1 //! Example that uses the lower level read API.
2
3 use object::read::archive::ArchiveFile;
4 use object::read::macho::{FatArch, FatHeader};
5 use object::Endianness;
6 use std::convert::TryInto;
7 use std::io::Write;
8 use std::{env, fmt, fs, io, process, str};
9
main()10 fn main() {
11 let arg_len = env::args().len();
12 if arg_len <= 1 {
13 eprintln!("Usage: {} <file> ...", env::args().next().unwrap());
14 process::exit(1);
15 }
16
17 for file_path in env::args().skip(1) {
18 if arg_len > 2 {
19 println!();
20 println!("{}:", file_path);
21 }
22
23 let file = match fs::File::open(&file_path) {
24 Ok(file) => file,
25 Err(err) => {
26 println!("Failed to open file '{}': {}", file_path, err);
27 continue;
28 }
29 };
30 let file = match unsafe { memmap2::Mmap::map(&file) } {
31 Ok(mmap) => mmap,
32 Err(err) => {
33 println!("Failed to map file '{}': {}", file_path, err);
34 continue;
35 }
36 };
37
38 let stdout = io::stdout();
39 let mut printer = Printer::new(stdout.lock());
40 print_object(&mut printer, &*file);
41 }
42 }
43
44 struct Printer<W: Write> {
45 w: W,
46 indent: usize,
47 }
48
49 impl<W: Write> Printer<W> {
new(w: W) -> Self50 fn new(w: W) -> Self {
51 Self { w, indent: 0 }
52 }
53
blank(&mut self)54 fn blank(&mut self) {
55 writeln!(self.w).unwrap();
56 }
57
print_indent(&mut self)58 fn print_indent(&mut self) {
59 if self.indent != 0 {
60 write!(self.w, "{:-1$}", " ", self.indent * 4).unwrap();
61 }
62 }
63
print_string(&mut self, s: &[u8])64 fn print_string(&mut self, s: &[u8]) {
65 if let Ok(s) = str::from_utf8(s) {
66 write!(self.w, "\"{}\"", s).unwrap();
67 } else {
68 write!(self.w, "{:X?}", s).unwrap();
69 }
70 }
71
indent<F: FnOnce(&mut Self)>(&mut self, f: F)72 fn indent<F: FnOnce(&mut Self)>(&mut self, f: F) {
73 self.indent += 1;
74 f(self);
75 self.indent -= 1;
76 }
77
group<F: FnOnce(&mut Self)>(&mut self, name: &str, f: F)78 fn group<F: FnOnce(&mut Self)>(&mut self, name: &str, f: F) {
79 self.print_indent();
80 writeln!(self.w, "{} {{", name).unwrap();
81 self.indent(f);
82 self.print_indent();
83 writeln!(self.w, "}}").unwrap();
84 }
85
field_name(&mut self, name: &str)86 fn field_name(&mut self, name: &str) {
87 self.print_indent();
88 if !name.is_empty() {
89 write!(self.w, "{}: ", name).unwrap();
90 }
91 }
92
field<T: fmt::Display>(&mut self, name: &str, value: T)93 fn field<T: fmt::Display>(&mut self, name: &str, value: T) {
94 self.field_name(name);
95 writeln!(self.w, "{}", value).unwrap();
96 }
97
field_hex<T: fmt::UpperHex>(&mut self, name: &str, value: T)98 fn field_hex<T: fmt::UpperHex>(&mut self, name: &str, value: T) {
99 self.field_name(name);
100 writeln!(self.w, "0x{:X}", value).unwrap();
101 }
102
field_bytes(&mut self, name: &str, value: &[u8])103 fn field_bytes(&mut self, name: &str, value: &[u8]) {
104 self.field_name(name);
105 writeln!(self.w, "{:X?}", value).unwrap();
106 }
107
field_string<T: fmt::UpperHex>(&mut self, name: &str, value: T, s: Option<&[u8]>)108 fn field_string<T: fmt::UpperHex>(&mut self, name: &str, value: T, s: Option<&[u8]>) {
109 if let Some(s) = s {
110 self.field_name(name);
111 self.print_string(s);
112 writeln!(self.w, " (0x{:X})", value).unwrap();
113 } else {
114 self.field_hex(name, value);
115 }
116 }
117
field_inline_string(&mut self, name: &str, s: &[u8])118 fn field_inline_string(&mut self, name: &str, s: &[u8]) {
119 self.field_name(name);
120 self.print_string(s);
121 writeln!(self.w).unwrap();
122 }
123
field_enum<T: Eq + fmt::UpperHex>(&mut self, name: &str, value: T, flags: &[Flag<T>])124 fn field_enum<T: Eq + fmt::UpperHex>(&mut self, name: &str, value: T, flags: &[Flag<T>]) {
125 for flag in flags {
126 if value == flag.value {
127 self.field_name(name);
128 writeln!(self.w, "{} (0x{:X})", flag.name, value).unwrap();
129 return;
130 }
131 }
132 self.field_hex(name, value);
133 }
134
field_enums<T: Eq + fmt::UpperHex>(&mut self, name: &str, value: T, enums: &[&[Flag<T>]])135 fn field_enums<T: Eq + fmt::UpperHex>(&mut self, name: &str, value: T, enums: &[&[Flag<T>]]) {
136 for flags in enums {
137 for flag in *flags {
138 if value == flag.value {
139 self.field_name(name);
140 writeln!(self.w, "{} (0x{:X})", flag.name, value).unwrap();
141 return;
142 }
143 }
144 }
145 self.field_hex(name, value);
146 }
147
flags<T: Into<u64>, U: Copy + Into<u64>>(&mut self, value: T, mask: U, flags: &[Flag<U>])148 fn flags<T: Into<u64>, U: Copy + Into<u64>>(&mut self, value: T, mask: U, flags: &[Flag<U>]) {
149 let value = value.into();
150 let mask = mask.into();
151 self.indent(|p| {
152 if mask != 0 {
153 for flag in flags {
154 if value & mask == flag.value.into() {
155 p.print_indent();
156 writeln!(p.w, "{} (0x{:X})", flag.name, flag.value.into()).unwrap();
157 return;
158 }
159 }
160 p.print_indent();
161 writeln!(p.w, "<unknown> (0x{:X})", value & mask).unwrap();
162 } else {
163 for flag in flags {
164 if value & flag.value.into() == flag.value.into() {
165 p.print_indent();
166 writeln!(p.w, "{} (0x{:X})", flag.name, flag.value.into()).unwrap();
167 }
168 }
169 // TODO: display unknown flags (need to display all flags at once for this)
170 }
171 });
172 }
173 }
174
175 struct Flag<T> {
176 value: T,
177 name: &'static str,
178 }
179
180 macro_rules! flags {
181 ($($name:ident),+ $(,)?) => ( [ $(Flag { value: $name, name: stringify!($name), }),+ ] )
182 }
183
print_object(p: &mut Printer<impl Write>, data: &[u8])184 fn print_object(p: &mut Printer<impl Write>, data: &[u8]) {
185 let kind = match object::FileKind::parse(data) {
186 Ok(file) => file,
187 Err(err) => {
188 println!("Failed to parse file: {}", err);
189 return;
190 }
191 };
192 match kind {
193 object::FileKind::Archive => print_archive(p, data),
194 object::FileKind::Coff => pe::print_coff(p, data),
195 object::FileKind::DyldCache => macho::print_dyld_cache(p, data),
196 object::FileKind::Elf32 => elf::print_elf32(p, data),
197 object::FileKind::Elf64 => elf::print_elf64(p, data),
198 object::FileKind::MachO32 => macho::print_macho32(p, data, 0),
199 object::FileKind::MachO64 => macho::print_macho64(p, data, 0),
200 object::FileKind::MachOFat32 => macho::print_macho_fat32(p, data),
201 object::FileKind::MachOFat64 => macho::print_macho_fat64(p, data),
202 object::FileKind::Pe32 => pe::print_pe32(p, data),
203 object::FileKind::Pe64 => pe::print_pe64(p, data),
204 // TODO
205 _ => {}
206 }
207 }
208
print_object_at(p: &mut Printer<impl Write>, data: &[u8], offset: u64)209 fn print_object_at(p: &mut Printer<impl Write>, data: &[u8], offset: u64) {
210 let kind = match object::FileKind::parse_at(data, offset) {
211 Ok(file) => file,
212 Err(err) => {
213 println!("Failed to parse file: {}", err);
214 return;
215 }
216 };
217 match kind {
218 object::FileKind::MachO32 => macho::print_macho32(p, data, offset),
219 object::FileKind::MachO64 => macho::print_macho64(p, data, offset),
220 // TODO
221 _ => {}
222 }
223 }
224
print_archive(p: &mut Printer<impl Write>, data: &[u8])225 fn print_archive(p: &mut Printer<impl Write>, data: &[u8]) {
226 if let Ok(archive) = ArchiveFile::parse(data) {
227 p.field("Format", format!("Archive ({:?})", archive.kind()));
228 for member in archive.members() {
229 if let Ok(member) = member {
230 p.blank();
231 p.field("Member", String::from_utf8_lossy(member.name()));
232 if let Ok(data) = member.data(data) {
233 print_object(p, data);
234 }
235 }
236 }
237 }
238 }
239
240 mod elf {
241 use super::*;
242 use object::elf::*;
243 use object::read::elf::*;
244
print_elf32(p: &mut Printer<impl Write>, data: &[u8])245 pub(super) fn print_elf32(p: &mut Printer<impl Write>, data: &[u8]) {
246 if let Ok(elf) = FileHeader32::<Endianness>::parse(data) {
247 println!("Format: ELF 32-bit");
248 print_elf(p, elf, data);
249 }
250 }
251
print_elf64(p: &mut Printer<impl Write>, data: &[u8])252 pub(super) fn print_elf64(p: &mut Printer<impl Write>, data: &[u8]) {
253 if let Ok(elf) = FileHeader64::<Endianness>::parse(data) {
254 println!("Format: ELF 64-bit");
255 print_elf(p, elf, data);
256 }
257 }
258
print_elf<Elf: FileHeader<Endian = Endianness>>( p: &mut Printer<impl Write>, elf: &Elf, data: &[u8], )259 fn print_elf<Elf: FileHeader<Endian = Endianness>>(
260 p: &mut Printer<impl Write>,
261 elf: &Elf,
262 data: &[u8],
263 ) {
264 if let Ok(endian) = elf.endian() {
265 print_file_header(p, endian, elf);
266 if let Ok(segments) = elf.program_headers(endian, data) {
267 print_program_headers(p, endian, data, elf, segments);
268 }
269 if let Ok(sections) = elf.sections(endian, data) {
270 print_section_headers(p, endian, data, elf, §ions);
271 }
272 }
273 }
274
print_file_header<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, elf: &Elf, )275 fn print_file_header<Elf: FileHeader>(
276 p: &mut Printer<impl Write>,
277 endian: Elf::Endian,
278 elf: &Elf,
279 ) {
280 p.group("FileHeader", |p| {
281 p.group("Ident", |p| print_ident(p, elf.e_ident()));
282 p.field_enum("Type", elf.e_type(endian), &FLAGS_ET);
283 p.field_enum("Machine", elf.e_machine(endian), &FLAGS_EM);
284 let version = elf.e_version(endian);
285 if version < 256 {
286 p.field_enum("Version", version as u8, &FLAGS_EV);
287 } else {
288 p.field_hex("Version", version);
289 }
290 p.field_enum("Type", elf.e_type(endian), &FLAGS_ET);
291 p.field_hex("Entry", elf.e_entry(endian).into());
292 p.field_hex("ProgramHeaderOffset", elf.e_phoff(endian).into());
293 p.field_hex("SectionHeaderOffset", elf.e_shoff(endian).into());
294 let flags = elf.e_flags(endian);
295 p.field_hex("Flags", flags);
296 match elf.e_machine(endian) {
297 EM_SPARC => p.flags(flags, 0, &FLAGS_EF_SPARC),
298 EM_SPARCV9 => p.flags(flags, 0, &FLAGS_EF_SPARCV9),
299 EM_MIPS => {
300 p.flags(flags, 0, &FLAGS_EF_MIPS);
301 p.flags(flags, EF_MIPS_ARCH, &FLAGS_EF_MIPS_ARCH);
302 }
303 EM_PARISC => {
304 p.flags(flags, 0, &FLAGS_EF_PARISC);
305 p.flags(flags, EF_PARISC_ARCH, &FLAGS_EF_PARISC_ARCH);
306 }
307 EM_ALPHA => p.flags(flags, 0, &FLAGS_EF_ALPHA),
308 EM_PPC => p.flags(flags, 0, &FLAGS_EF_PPC),
309 EM_PPC64 => p.flags(flags, 0, &FLAGS_EF_PPC64),
310 EM_ARM => {
311 p.flags(flags, 0, &FLAGS_EF_ARM);
312 p.flags(flags, EF_ARM_EABIMASK, &FLAGS_EF_ARM_EABI);
313 }
314 EM_CSKY => p.flags(flags, EF_CSKY_ABIMASK, &FLAGS_EF_CSKY_ABI),
315 EM_IA_64 => p.flags(flags, 0, &FLAGS_EF_IA_64),
316 EM_SH => p.flags(flags, EF_SH_MACH_MASK, &FLAGS_EF_SH_MACH),
317 EM_S390 => p.flags(flags, 0, &FLAGS_EF_S390),
318 EM_RISCV => {
319 p.flags(flags, 0, &FLAGS_EF_RISCV);
320 p.flags(flags, EF_RISCV_FLOAT_ABI, &FLAGS_EF_RISCV_FLOAT_ABI);
321 }
322 _ => {}
323 };
324 p.field_hex("HeaderSize", elf.e_ehsize(endian));
325 p.field_hex("ProgramHeaderEntrySize", elf.e_phentsize(endian));
326 p.field("ProgramHeaderCount", elf.e_phnum(endian));
327 p.field_hex("SectionHeaderEntrySize", elf.e_shentsize(endian));
328 p.field("SectionHeaderCount", elf.e_shnum(endian));
329 p.field("SectionHeaderStringTableIndex", elf.e_shstrndx(endian));
330 });
331 }
332
print_ident(p: &mut Printer<impl Write>, ident: &Ident)333 fn print_ident(p: &mut Printer<impl Write>, ident: &Ident) {
334 p.field("Magic", format!("{:X?}", ident.magic));
335 p.field_enum("Class", ident.class, &FLAGS_EI_CLASS);
336 p.field_enum("Data", ident.data, &FLAGS_EI_DATA);
337 p.field_enum("Version", ident.version, &FLAGS_EV);
338 p.field_enum("OsAbi", ident.os_abi, &FLAGS_EI_OSABI);
339 p.field_hex("AbiVersion", ident.abi_version);
340 p.field("Unused", format!("{:X?}", ident.padding));
341 }
342
print_program_headers<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], elf: &Elf, segments: &[Elf::ProgramHeader], )343 fn print_program_headers<Elf: FileHeader>(
344 p: &mut Printer<impl Write>,
345 endian: Elf::Endian,
346 data: &[u8],
347 elf: &Elf,
348 segments: &[Elf::ProgramHeader],
349 ) {
350 for segment in segments {
351 p.group("ProgramHeader", |p| {
352 let proc = match elf.e_machine(endian) {
353 EM_MIPS => FLAGS_PT_MIPS,
354 EM_PARISC => FLAGS_PT_PARISC,
355 EM_ARM => FLAGS_PT_ARM,
356 EM_IA_64 => FLAGS_PT_IA_64,
357 _ => &[],
358 };
359 let os = match elf.e_ident().os_abi {
360 ELFOSABI_HPUX => FLAGS_PT_HP,
361 _ => &[],
362 };
363 p.field_enums("Type", segment.p_type(endian), &[FLAGS_PT, proc, os]);
364
365 p.field_hex("Offset", segment.p_offset(endian).into());
366 p.field_hex("VirtualAddress", segment.p_vaddr(endian).into());
367 p.field_hex("PhysicalAddress", segment.p_paddr(endian).into());
368 p.field_hex("FileSize", segment.p_filesz(endian).into());
369 p.field_hex("MemorySize", segment.p_memsz(endian).into());
370
371 let flags = segment.p_flags(endian);
372 p.field_hex("Flags", flags);
373 p.flags(flags, 0, FLAGS_PF);
374 match elf.e_ident().os_abi {
375 ELFOSABI_HPUX => p.flags(flags, 0, FLAGS_PF_HP),
376 _ => {}
377 };
378 match elf.e_machine(endian) {
379 EM_MIPS => p.flags(flags, 0, FLAGS_PF_MIPS),
380 EM_PARISC => p.flags(flags, 0, FLAGS_PF_PARISC),
381 EM_ARM => p.flags(flags, 0, FLAGS_PF_ARM),
382 EM_IA_64 => p.flags(flags, 0, FLAGS_PF_IA_64),
383 _ => {}
384 };
385
386 p.field_hex("Align", segment.p_align(endian).into());
387
388 match segment.p_type(endian) {
389 PT_NOTE => print_segment_notes(p, endian, data, elf, segment),
390 PT_DYNAMIC => print_segment_dynamic(p, endian, data, elf, segments, segment),
391 // TODO:
392 //PT_INTERP =>
393 //PT_SHLIB =>
394 //PT_PHDR =>
395 //PT_TLS =>
396 //PT_GNU_EH_FRAME =>
397 //PT_GNU_STACK =>
398 //PT_GNU_RELRO =>
399 _ => {}
400 }
401 });
402 }
403 }
404
print_segment_notes<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], _elf: &Elf, segment: &Elf::ProgramHeader, )405 fn print_segment_notes<Elf: FileHeader>(
406 p: &mut Printer<impl Write>,
407 endian: Elf::Endian,
408 data: &[u8],
409 _elf: &Elf,
410 segment: &Elf::ProgramHeader,
411 ) {
412 if let Ok(Some(notes)) = segment.notes(endian, data) {
413 print_notes(p, endian, notes);
414 }
415 }
416
print_segment_dynamic<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], elf: &Elf, segments: &[Elf::ProgramHeader], segment: &Elf::ProgramHeader, )417 fn print_segment_dynamic<Elf: FileHeader>(
418 p: &mut Printer<impl Write>,
419 endian: Elf::Endian,
420 data: &[u8],
421 elf: &Elf,
422 segments: &[Elf::ProgramHeader],
423 segment: &Elf::ProgramHeader,
424 ) {
425 if let Ok(Some(dynamic)) = segment.dynamic(endian, data) {
426 // TODO: add a helper API for this and the other mandatory tags?
427 let mut strtab = 0;
428 let mut strsz = 0;
429 for d in dynamic {
430 let tag = d.d_tag(endian).into();
431 if tag == DT_STRTAB.into() {
432 strtab = d.d_val(endian).into();
433 } else if tag == DT_STRSZ.into() {
434 strsz = d.d_val(endian).into();
435 }
436 }
437 let mut dynstr = object::StringTable::default();
438 for s in segments {
439 if let Ok(Some(data)) = s.data_range(endian, data, strtab, strsz) {
440 dynstr = object::StringTable::new(data, 0, data.len() as u64);
441 break;
442 }
443 }
444
445 let proc = match elf.e_machine(endian) {
446 EM_SPARC => FLAGS_DT_SPARC,
447 EM_MIPS => FLAGS_DT_MIPS,
448 EM_ALPHA => FLAGS_DT_ALPHA,
449 EM_PPC => FLAGS_DT_PPC,
450 EM_PPC64 => FLAGS_DT_PPC64,
451 EM_IA_64 => FLAGS_DT_IA_64,
452 EM_ALTERA_NIOS2 => FLAGS_DT_NIOS2,
453 _ => &[],
454 };
455 for d in dynamic {
456 let tag = d.d_tag(endian).into();
457 let val = d.d_val(endian).into();
458 p.group("Dynamic", |p| {
459 if let Ok(tag) = tag.try_into() {
460 p.field_enums("Tag", tag, &[FLAGS_DT, proc]);
461 if tag == DT_NEEDED {
462 p.field_string(
463 "Value",
464 val,
465 val.try_into().ok().and_then(|val| dynstr.get(val).ok()),
466 );
467 } else {
468 p.field_hex("Value", val);
469 if tag == DT_FLAGS {
470 p.flags(val, 0, FLAGS_DF);
471 } else if tag == DT_FLAGS_1 {
472 p.flags(val, 0, FLAGS_DF_1);
473 }
474 }
475 } else {
476 p.field_hex("Tag", tag);
477 p.field_hex("Value", val);
478 }
479 });
480 if tag == DT_NULL.into() {
481 break;
482 }
483 }
484 }
485 }
486
print_section_headers<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], elf: &Elf, sections: &SectionTable<Elf>, )487 fn print_section_headers<Elf: FileHeader>(
488 p: &mut Printer<impl Write>,
489 endian: Elf::Endian,
490 data: &[u8],
491 elf: &Elf,
492 sections: &SectionTable<Elf>,
493 ) {
494 for (index, section) in sections.iter().enumerate() {
495 p.group("SectionHeader", |p| {
496 p.field("Index", index);
497 p.field_string(
498 "Name",
499 section.sh_name(endian),
500 sections.section_name(endian, section).ok(),
501 );
502
503 let proc = match elf.e_machine(endian) {
504 EM_MIPS => FLAGS_SHT_MIPS,
505 EM_PARISC => FLAGS_SHT_PARISC,
506 EM_ALPHA => FLAGS_SHT_ALPHA,
507 EM_ARM => FLAGS_SHT_ARM,
508 EM_CSKY => FLAGS_SHT_CSKY,
509 EM_IA_64 => FLAGS_SHT_IA_64,
510 EM_X86_64 => FLAGS_SHT_X86_64,
511 _ => &[],
512 };
513 p.field_enums("Type", section.sh_type(endian), &[FLAGS_SHT, proc]);
514
515 let flags = section.sh_flags(endian).into();
516 p.field_hex("Flags", flags);
517 p.flags(flags, 0, FLAGS_SHF);
518 match elf.e_machine(endian) {
519 EM_MIPS => p.flags(flags, 0, FLAGS_SHF_MIPS),
520 EM_PARISC => p.flags(flags, 0, FLAGS_SHF_PARISC),
521 EM_ALPHA => p.flags(flags, 0, FLAGS_SHF_ALPHA),
522 EM_ARM => p.flags(flags, 0, FLAGS_SHF_ARM),
523 EM_IA_64 => p.flags(flags, 0, FLAGS_SHF_IA_64),
524 _ => {}
525 }
526
527 p.field_hex("Address", section.sh_addr(endian).into());
528 p.field_hex("Offset", section.sh_offset(endian).into());
529 p.field_hex("Size", section.sh_size(endian).into());
530 p.field("Link", section.sh_link(endian));
531 p.field("Info", section.sh_info(endian));
532 p.field_hex("AddressAlign", section.sh_addralign(endian).into());
533 p.field_hex("EntrySize", section.sh_entsize(endian).into());
534
535 match section.sh_type(endian) {
536 SHT_SYMTAB | SHT_DYNSYM => {
537 print_section_symbols(p, endian, data, elf, sections, index, section)
538 }
539 SHT_REL => print_section_rel(p, endian, data, elf, sections, section),
540 SHT_RELA => print_section_rela(p, endian, data, elf, sections, section),
541 SHT_NOTE => print_section_notes(p, endian, data, elf, section),
542 SHT_GROUP => print_section_group(p, endian, data, elf, sections, section),
543 SHT_HASH => print_hash(p, endian, data, elf, sections, section),
544 SHT_GNU_HASH => print_gnu_hash(p, endian, data, elf, sections, section),
545 SHT_GNU_VERDEF => print_gnu_verdef(p, endian, data, elf, sections, section),
546 SHT_GNU_VERNEED => print_gnu_verneed(p, endian, data, elf, sections, section),
547 SHT_GNU_VERSYM => print_gnu_versym(p, endian, data, elf, sections, section),
548 // TODO:
549 //SHT_DYNAMIC =>
550 //SHT_SHLIB =>
551 //SHT_INIT_ARRAY =>
552 //SHT_FINI_ARRAY =>
553 //SHT_PREINIT_ARRAY =>
554 _ => {}
555 }
556 });
557 }
558 }
559
print_section_symbols<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], elf: &Elf, sections: &SectionTable<Elf>, section_index: usize, section: &Elf::SectionHeader, )560 fn print_section_symbols<Elf: FileHeader>(
561 p: &mut Printer<impl Write>,
562 endian: Elf::Endian,
563 data: &[u8],
564 elf: &Elf,
565 sections: &SectionTable<Elf>,
566 section_index: usize,
567 section: &Elf::SectionHeader,
568 ) {
569 if let Ok(Some(symbols)) = section.symbols(endian, data, sections, section_index) {
570 let os_stt = match elf.e_ident().os_abi {
571 ELFOSABI_GNU => FLAGS_STT_GNU,
572 ELFOSABI_HPUX => FLAGS_STT_HP,
573 _ => &[],
574 };
575 let proc_stt = match elf.e_machine(endian) {
576 EM_SPARC => FLAGS_STT_SPARC,
577 EM_PARISC => FLAGS_STT_PARISC,
578 EM_ARM => FLAGS_STT_ARM,
579 _ => &[],
580 };
581 let os_stb = match elf.e_ident().os_abi {
582 ELFOSABI_GNU => FLAGS_STB_GNU,
583 _ => &[],
584 };
585 let proc_stb = match elf.e_machine(endian) {
586 EM_MIPS => FLAGS_STB_MIPS,
587 _ => &[],
588 };
589 let proc_shn = match elf.e_machine(endian) {
590 EM_MIPS => FLAGS_SHN_MIPS,
591 EM_PARISC => FLAGS_SHN_PARISC,
592 _ => &[],
593 };
594 for (index, symbol) in symbols.iter().enumerate() {
595 p.group("Symbol", |p| {
596 p.field("Index", index);
597 p.field_string(
598 "Name",
599 symbol.st_name(endian),
600 symbol.name(endian, symbols.strings()).ok(),
601 );
602 p.field_hex("Value", symbol.st_value(endian).into());
603 p.field_hex("Size", symbol.st_size(endian).into());
604 p.field_enums("Type", symbol.st_type(), &[FLAGS_STT, os_stt, proc_stt]);
605 p.field_enums("Bind", symbol.st_bind(), &[FLAGS_STB, os_stb, proc_stb]);
606
607 let other = symbol.st_other();
608 if other & !0x3 == 0 {
609 p.field_enum("Other", other, FLAGS_STV);
610 } else {
611 p.field_hex("Other", other);
612 p.flags(other, 0x3, FLAGS_STV);
613 match elf.e_machine(endian) {
614 EM_MIPS => p.flags(other, 0, FLAGS_STO_MIPS),
615 EM_ALPHA => p.flags(other, 0, FLAGS_STO_ALPHA),
616 EM_PPC64 => p.field_hex(
617 "Local",
618 (other & STO_PPC64_LOCAL_MASK) >> STO_PPC64_LOCAL_BIT,
619 ),
620 _ => {}
621 }
622 }
623
624 let shndx = symbol.st_shndx(endian);
625 if shndx == SHN_UNDEF || shndx >= SHN_LORESERVE {
626 p.field_enums("SectionIndex", shndx, &[FLAGS_SHN, proc_shn]);
627 } else {
628 p.field("SectionIndex", shndx);
629 }
630 if let Some(shndx) = symbols.shndx(index) {
631 p.field("ExtendedSectionIndex", shndx);
632 }
633 });
634 }
635 }
636 }
637
print_section_rel<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], elf: &Elf, sections: &SectionTable<Elf>, section: &Elf::SectionHeader, )638 fn print_section_rel<Elf: FileHeader>(
639 p: &mut Printer<impl Write>,
640 endian: Elf::Endian,
641 data: &[u8],
642 elf: &Elf,
643 sections: &SectionTable<Elf>,
644 section: &Elf::SectionHeader,
645 ) {
646 if let Ok(Some(relocations)) = section.rel(endian, data) {
647 let symbols = section.relocation_symbols(endian, data, sections).ok();
648 let proc = rel_flag_type(endian, elf);
649 for relocation in relocations {
650 p.group("Relocation", |p| {
651 p.field_hex("Offset", relocation.r_offset(endian).into());
652 p.field_enum("Type", relocation.r_type(endian), proc);
653 let sym = relocation.r_sym(endian);
654 p.field_string("Symbol", sym, rel_symbol(endian, symbols, sym as usize));
655 });
656 }
657 }
658 }
659
print_section_rela<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], elf: &Elf, sections: &SectionTable<Elf>, section: &Elf::SectionHeader, )660 fn print_section_rela<Elf: FileHeader>(
661 p: &mut Printer<impl Write>,
662 endian: Elf::Endian,
663 data: &[u8],
664 elf: &Elf,
665 sections: &SectionTable<Elf>,
666 section: &Elf::SectionHeader,
667 ) {
668 if let Ok(Some(relocations)) = section.rela(endian, data) {
669 let symbols = section.relocation_symbols(endian, data, sections).ok();
670 let proc = rel_flag_type(endian, elf);
671 for relocation in relocations {
672 p.group("Relocation", |p| {
673 p.field_hex("Offset", relocation.r_offset(endian).into());
674 p.field_enum(
675 "Type",
676 relocation.r_type(endian, elf.is_mips64el(endian)),
677 proc,
678 );
679 let sym = relocation.r_sym(endian, elf.is_mips64el(endian));
680 p.field_string("Symbol", sym, rel_symbol(endian, symbols, sym as usize));
681 let addend = relocation.r_addend(endian).into() as u64;
682 if addend != 0 {
683 p.field_hex("Addend", addend);
684 }
685 });
686 }
687 }
688 }
689
rel_symbol<'data, Elf: FileHeader>( endian: Elf::Endian, symbols: Option<SymbolTable<'data, Elf>>, sym: usize, ) -> Option<&'data [u8]>690 fn rel_symbol<'data, Elf: FileHeader>(
691 endian: Elf::Endian,
692 symbols: Option<SymbolTable<'data, Elf>>,
693 sym: usize,
694 ) -> Option<&'data [u8]> {
695 let symbols = symbols?;
696 let symbol = symbols.symbol(sym as usize).ok()?;
697 symbol.name(endian, symbols.strings()).ok()
698 }
699
rel_flag_type<Elf: FileHeader>(endian: Elf::Endian, elf: &Elf) -> &'static [Flag<u32>]700 fn rel_flag_type<Elf: FileHeader>(endian: Elf::Endian, elf: &Elf) -> &'static [Flag<u32>] {
701 match elf.e_machine(endian) {
702 EM_68K => FLAGS_R_68K,
703 EM_386 => FLAGS_R_386,
704 EM_SPARC => FLAGS_R_SPARC,
705 EM_MIPS => FLAGS_R_MIPS,
706 EM_PARISC => FLAGS_R_PARISC,
707 EM_ALPHA => FLAGS_R_ALPHA,
708 EM_PPC => FLAGS_R_PPC,
709 EM_PPC64 => FLAGS_R_PPC64,
710 EM_AARCH64 => FLAGS_R_AARCH64,
711 EM_ARM => FLAGS_R_ARM,
712 EM_CSKY => FLAGS_R_CKCORE,
713 EM_IA_64 => FLAGS_R_IA64,
714 EM_SH => FLAGS_R_SH,
715 EM_S390 => FLAGS_R_390,
716 EM_CRIS => FLAGS_R_CRIS,
717 EM_X86_64 => FLAGS_R_X86_64,
718 EM_MN10300 => FLAGS_R_MN10300,
719 EM_M32R => FLAGS_R_M32R,
720 EM_MICROBLAZE => FLAGS_R_MICROBLAZE,
721 EM_ALTERA_NIOS2 => FLAGS_R_NIOS2,
722 EM_TILEPRO => FLAGS_R_TILEPRO,
723 EM_TILEGX => FLAGS_R_TILEGX,
724 EM_RISCV => FLAGS_R_RISCV,
725 EM_BPF => FLAGS_R_BPF,
726 EM_METAG => FLAGS_R_METAG,
727 EM_NDS32 => FLAGS_R_NDS32,
728 _ => &[],
729 }
730 }
731
print_section_notes<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], _elf: &Elf, section: &Elf::SectionHeader, )732 fn print_section_notes<Elf: FileHeader>(
733 p: &mut Printer<impl Write>,
734 endian: Elf::Endian,
735 data: &[u8],
736 _elf: &Elf,
737 section: &Elf::SectionHeader,
738 ) {
739 if let Ok(Some(notes)) = section.notes(endian, data) {
740 print_notes(p, endian, notes);
741 }
742 }
743
print_section_group<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], _elf: &Elf, sections: &SectionTable<Elf>, section: &Elf::SectionHeader, )744 fn print_section_group<Elf: FileHeader>(
745 p: &mut Printer<impl Write>,
746 endian: Elf::Endian,
747 data: &[u8],
748 _elf: &Elf,
749 sections: &SectionTable<Elf>,
750 section: &Elf::SectionHeader,
751 ) {
752 if let Ok(Some((flag, members))) = section.group(endian, data) {
753 p.field_enum("GroupFlag", flag, FLAGS_GRP);
754 p.group("GroupSections", |p| {
755 for member in members {
756 let index = member.get(endian);
757 p.print_indent();
758 if let Ok(section) = sections.section(index as usize) {
759 if let Ok(name) = sections.section_name(endian, section) {
760 p.print_string(name);
761 writeln!(p.w, " ({})", index).unwrap();
762 } else {
763 writeln!(p.w, "{}", index).unwrap();
764 }
765 } else {
766 writeln!(p.w, "{}", index).unwrap();
767 }
768 }
769 });
770 }
771 }
772
print_notes<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, mut notes: NoteIterator<Elf>, )773 fn print_notes<Elf: FileHeader>(
774 p: &mut Printer<impl Write>,
775 endian: Elf::Endian,
776 mut notes: NoteIterator<Elf>,
777 ) {
778 while let Ok(Some(note)) = notes.next() {
779 p.group("Note", |p| {
780 let name = note.name();
781 p.field_string("Name", note.n_namesz(endian), Some(name));
782 let flags = if name == ELF_NOTE_CORE || name == ELF_NOTE_LINUX {
783 FLAGS_NT_CORE
784 } else if name == ELF_NOTE_SOLARIS {
785 FLAGS_NT_SOLARIS
786 } else if name == ELF_NOTE_GNU {
787 FLAGS_NT_GNU
788 } else {
789 // TODO: NT_VERSION
790 &[]
791 };
792 p.field_enum("Type", note.n_type(endian), flags);
793 // TODO: interpret desc
794 p.field_bytes("Desc", note.desc());
795 });
796 }
797 }
798
print_hash<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], _elf: &Elf, _sections: &SectionTable<Elf>, section: &Elf::SectionHeader, )799 fn print_hash<Elf: FileHeader>(
800 p: &mut Printer<impl Write>,
801 endian: Elf::Endian,
802 data: &[u8],
803 _elf: &Elf,
804 _sections: &SectionTable<Elf>,
805 section: &Elf::SectionHeader,
806 ) {
807 if let Ok(Some(hash)) = section.hash_header(endian, data) {
808 p.group("Hash", |p| {
809 p.field("BucketCount", hash.bucket_count.get(endian));
810 p.field("ChainCount", hash.chain_count.get(endian));
811 });
812 }
813 /* TODO: add this in a test somewhere
814 if let Ok(Some(hash_table)) = section.hash(endian, data) {
815 if let Ok(symbols) = _sections.symbols(endian, data, SHT_DYNSYM) {
816 for symbol in symbols.symbols() {
817 let name = symbols.symbol_name(endian, symbol).unwrap();
818 if !symbol.is_definition(endian) {
819 continue;
820 }
821 let hash = hash(name);
822 let hash_symbol = hash_table.find(endian, name, hash, &symbols).unwrap();
823 let hash_name = symbols.symbol_name(endian, hash_symbol).unwrap();
824 assert_eq!(name, hash_name);
825 }
826 }
827 }
828 */
829 }
830
print_gnu_hash<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], _elf: &Elf, _sections: &SectionTable<Elf>, section: &Elf::SectionHeader, )831 fn print_gnu_hash<Elf: FileHeader>(
832 p: &mut Printer<impl Write>,
833 endian: Elf::Endian,
834 data: &[u8],
835 _elf: &Elf,
836 _sections: &SectionTable<Elf>,
837 section: &Elf::SectionHeader,
838 ) {
839 if let Ok(Some(hash)) = section.gnu_hash_header(endian, data) {
840 p.group("GnuHash", |p| {
841 p.field("BucketCount", hash.bucket_count.get(endian));
842 p.field("SymbolBase", hash.symbol_base.get(endian));
843 p.field("BloomCount", hash.bloom_count.get(endian));
844 p.field("BloomShift", hash.bloom_shift.get(endian));
845 });
846 }
847 /* TODO: add this in a test somewhere
848 if let Ok(Some(hash_table)) = section.gnu_hash(endian, data) {
849 if let Ok(symbols) = _sections.symbols(endian, data, SHT_DYNSYM) {
850 for symbol in &symbols.symbols()[hash_table.symbol_base() as usize..] {
851 let name = symbols.symbol_name(endian, symbol).unwrap();
852 let hash = gnu_hash(name);
853 let hash_symbol = hash_table.find(endian, name, hash, &symbols).unwrap();
854 let hash_name = symbols.symbol_name(endian, hash_symbol).unwrap();
855 assert_eq!(name, hash_name);
856 }
857 }
858 }
859 */
860 }
861
print_gnu_verdef<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], _elf: &Elf, _sections: &SectionTable<Elf>, section: &Elf::SectionHeader, )862 fn print_gnu_verdef<Elf: FileHeader>(
863 p: &mut Printer<impl Write>,
864 endian: Elf::Endian,
865 data: &[u8],
866 _elf: &Elf,
867 _sections: &SectionTable<Elf>,
868 section: &Elf::SectionHeader,
869 ) {
870 if let Ok(Some(mut verdefs)) = section.gnu_verdef(endian, data) {
871 while let Ok(Some((verdef, mut verdauxs))) = verdefs.next() {
872 p.group("VersionDefinition", |p| {
873 // TODO: names
874 p.field("Version", verdef.vd_version.get(endian));
875 p.field_hex("Flags", verdef.vd_flags.get(endian));
876 p.flags(verdef.vd_flags.get(endian), 0, FLAGS_VER_FLG);
877 p.field("Index", verdef.vd_ndx.get(endian) & !VER_NDX_HIDDEN);
878 p.flags(verdef.vd_ndx.get(endian), 0, FLAGS_VER_NDX);
879 p.field("AuxCount", verdef.vd_cnt.get(endian));
880 p.field_hex("Hash", verdef.vd_hash.get(endian));
881 p.field("AuxOffset", verdef.vd_aux.get(endian));
882 p.field("NextOffset", verdef.vd_next.get(endian));
883 while let Ok(Some(verdaux)) = verdauxs.next() {
884 p.group("Aux", |p| {
885 p.field_hex("Name", verdaux.vda_name.get(endian));
886 p.field("NextOffset", verdaux.vda_next.get(endian));
887 });
888 }
889 });
890 }
891 }
892 }
893
print_gnu_verneed<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], _elf: &Elf, _sections: &SectionTable<Elf>, section: &Elf::SectionHeader, )894 fn print_gnu_verneed<Elf: FileHeader>(
895 p: &mut Printer<impl Write>,
896 endian: Elf::Endian,
897 data: &[u8],
898 _elf: &Elf,
899 _sections: &SectionTable<Elf>,
900 section: &Elf::SectionHeader,
901 ) {
902 if let Ok(Some(mut verneeds)) = section.gnu_verneed(endian, data) {
903 while let Ok(Some((verneed, mut vernauxs))) = verneeds.next() {
904 p.group("VersionNeed", |p| {
905 // TODO: names
906 p.field("Version", verneed.vn_version.get(endian));
907 p.field("AuxCount", verneed.vn_cnt.get(endian));
908 p.field_hex("Filename", verneed.vn_file.get(endian));
909 p.field("AuxOffset", verneed.vn_aux.get(endian));
910 p.field("NextOffset", verneed.vn_next.get(endian));
911 while let Ok(Some(vernaux)) = vernauxs.next() {
912 p.group("Aux", |p| {
913 p.field_hex("Hash", vernaux.vna_hash.get(endian));
914 p.field_hex("Flags", vernaux.vna_flags.get(endian));
915 p.flags(vernaux.vna_flags.get(endian), 0, FLAGS_VER_FLG);
916 p.field("Index", vernaux.vna_other.get(endian) & !VER_NDX_HIDDEN);
917 p.flags(vernaux.vna_other.get(endian), 0, FLAGS_VER_NDX);
918 p.field_hex("Name", vernaux.vna_name.get(endian));
919 p.field("NextOffset", vernaux.vna_next.get(endian));
920 });
921 }
922 });
923 }
924 }
925 }
926
print_gnu_versym<Elf: FileHeader>( p: &mut Printer<impl Write>, endian: Elf::Endian, data: &[u8], _elf: &Elf, _sections: &SectionTable<Elf>, section: &Elf::SectionHeader, )927 fn print_gnu_versym<Elf: FileHeader>(
928 p: &mut Printer<impl Write>,
929 endian: Elf::Endian,
930 data: &[u8],
931 _elf: &Elf,
932 _sections: &SectionTable<Elf>,
933 section: &Elf::SectionHeader,
934 ) {
935 if let Ok(Some(syms)) = section.gnu_versym(endian, data) {
936 for sym in syms {
937 p.group("VersionSymbol", |p| {
938 p.field("Version", sym.0.get(endian) & !VER_NDX_HIDDEN);
939 p.flags(sym.0.get(endian), 0, FLAGS_VER_NDX);
940 // TODO: version name
941 });
942 }
943 }
944 }
945
946 static FLAGS_EI_CLASS: &[Flag<u8>] = &flags!(ELFCLASSNONE, ELFCLASS32, ELFCLASS64);
947 static FLAGS_EI_DATA: &[Flag<u8>] = &flags!(ELFDATANONE, ELFDATA2LSB, ELFDATA2MSB);
948 static FLAGS_EV: &[Flag<u8>] = &flags!(EV_NONE, EV_CURRENT);
949 static FLAGS_EI_OSABI: &[Flag<u8>] = &flags!(
950 ELFOSABI_SYSV,
951 ELFOSABI_HPUX,
952 ELFOSABI_NETBSD,
953 ELFOSABI_GNU,
954 ELFOSABI_SOLARIS,
955 ELFOSABI_AIX,
956 ELFOSABI_IRIX,
957 ELFOSABI_FREEBSD,
958 ELFOSABI_TRU64,
959 ELFOSABI_MODESTO,
960 ELFOSABI_OPENBSD,
961 ELFOSABI_ARM_AEABI,
962 ELFOSABI_ARM,
963 ELFOSABI_STANDALONE,
964 );
965 static FLAGS_ET: &[Flag<u16>] = &flags!(ET_NONE, ET_REL, ET_EXEC, ET_DYN, ET_CORE);
966 static FLAGS_EM: &[Flag<u16>] = &flags!(
967 EM_NONE,
968 EM_M32,
969 EM_SPARC,
970 EM_386,
971 EM_68K,
972 EM_88K,
973 EM_IAMCU,
974 EM_860,
975 EM_MIPS,
976 EM_S370,
977 EM_MIPS_RS3_LE,
978 EM_PARISC,
979 EM_VPP500,
980 EM_SPARC32PLUS,
981 EM_960,
982 EM_PPC,
983 EM_PPC64,
984 EM_S390,
985 EM_SPU,
986 EM_V800,
987 EM_FR20,
988 EM_RH32,
989 EM_RCE,
990 EM_ARM,
991 EM_FAKE_ALPHA,
992 EM_SH,
993 EM_SPARCV9,
994 EM_TRICORE,
995 EM_ARC,
996 EM_H8_300,
997 EM_H8_300H,
998 EM_H8S,
999 EM_H8_500,
1000 EM_IA_64,
1001 EM_MIPS_X,
1002 EM_COLDFIRE,
1003 EM_68HC12,
1004 EM_MMA,
1005 EM_PCP,
1006 EM_NCPU,
1007 EM_NDR1,
1008 EM_STARCORE,
1009 EM_ME16,
1010 EM_ST100,
1011 EM_TINYJ,
1012 EM_X86_64,
1013 EM_PDSP,
1014 EM_PDP10,
1015 EM_PDP11,
1016 EM_FX66,
1017 EM_ST9PLUS,
1018 EM_ST7,
1019 EM_68HC16,
1020 EM_68HC11,
1021 EM_68HC08,
1022 EM_68HC05,
1023 EM_SVX,
1024 EM_ST19,
1025 EM_VAX,
1026 EM_CRIS,
1027 EM_JAVELIN,
1028 EM_FIREPATH,
1029 EM_ZSP,
1030 EM_MMIX,
1031 EM_HUANY,
1032 EM_PRISM,
1033 EM_AVR,
1034 EM_FR30,
1035 EM_D10V,
1036 EM_D30V,
1037 EM_V850,
1038 EM_M32R,
1039 EM_MN10300,
1040 EM_MN10200,
1041 EM_PJ,
1042 EM_OPENRISC,
1043 EM_ARC_COMPACT,
1044 EM_XTENSA,
1045 EM_VIDEOCORE,
1046 EM_TMM_GPP,
1047 EM_NS32K,
1048 EM_TPC,
1049 EM_SNP1K,
1050 EM_ST200,
1051 EM_IP2K,
1052 EM_MAX,
1053 EM_CR,
1054 EM_F2MC16,
1055 EM_MSP430,
1056 EM_BLACKFIN,
1057 EM_SE_C33,
1058 EM_SEP,
1059 EM_ARCA,
1060 EM_UNICORE,
1061 EM_EXCESS,
1062 EM_DXP,
1063 EM_ALTERA_NIOS2,
1064 EM_CRX,
1065 EM_XGATE,
1066 EM_C166,
1067 EM_M16C,
1068 EM_DSPIC30F,
1069 EM_CE,
1070 EM_M32C,
1071 EM_TSK3000,
1072 EM_RS08,
1073 EM_SHARC,
1074 EM_ECOG2,
1075 EM_SCORE7,
1076 EM_DSP24,
1077 EM_VIDEOCORE3,
1078 EM_LATTICEMICO32,
1079 EM_SE_C17,
1080 EM_TI_C6000,
1081 EM_TI_C2000,
1082 EM_TI_C5500,
1083 EM_TI_ARP32,
1084 EM_TI_PRU,
1085 EM_MMDSP_PLUS,
1086 EM_CYPRESS_M8C,
1087 EM_R32C,
1088 EM_TRIMEDIA,
1089 EM_HEXAGON,
1090 EM_8051,
1091 EM_STXP7X,
1092 EM_NDS32,
1093 EM_ECOG1X,
1094 EM_MAXQ30,
1095 EM_XIMO16,
1096 EM_MANIK,
1097 EM_CRAYNV2,
1098 EM_RX,
1099 EM_METAG,
1100 EM_MCST_ELBRUS,
1101 EM_ECOG16,
1102 EM_CR16,
1103 EM_ETPU,
1104 EM_SLE9X,
1105 EM_L10M,
1106 EM_K10M,
1107 EM_AARCH64,
1108 EM_AVR32,
1109 EM_STM8,
1110 EM_TILE64,
1111 EM_TILEPRO,
1112 EM_MICROBLAZE,
1113 EM_CUDA,
1114 EM_TILEGX,
1115 EM_CLOUDSHIELD,
1116 EM_COREA_1ST,
1117 EM_COREA_2ND,
1118 EM_ARC_COMPACT2,
1119 EM_OPEN8,
1120 EM_RL78,
1121 EM_VIDEOCORE5,
1122 EM_78KOR,
1123 EM_56800EX,
1124 EM_BA1,
1125 EM_BA2,
1126 EM_XCORE,
1127 EM_MCHP_PIC,
1128 EM_KM32,
1129 EM_KMX32,
1130 EM_EMX16,
1131 EM_EMX8,
1132 EM_KVARC,
1133 EM_CDP,
1134 EM_COGE,
1135 EM_COOL,
1136 EM_NORC,
1137 EM_CSR_KALIMBA,
1138 EM_Z80,
1139 EM_VISIUM,
1140 EM_FT32,
1141 EM_MOXIE,
1142 EM_AMDGPU,
1143 EM_RISCV,
1144 EM_BPF,
1145 EM_CSKY,
1146 EM_ALPHA,
1147 );
1148 static FLAGS_EF_SPARC: &[Flag<u32>] = &flags!(
1149 EF_SPARC_LEDATA,
1150 EF_SPARC_EXT_MASK,
1151 EF_SPARC_32PLUS,
1152 EF_SPARC_SUN_US1,
1153 EF_SPARC_HAL_R1,
1154 EF_SPARC_SUN_US3,
1155 );
1156 static FLAGS_EF_SPARCV9: &[Flag<u32>] = &flags!(
1157 EF_SPARCV9_MM,
1158 EF_SPARCV9_TSO,
1159 EF_SPARCV9_PSO,
1160 EF_SPARCV9_RMO,
1161 );
1162 static FLAGS_EF_MIPS: &[Flag<u32>] = &flags!(
1163 EF_MIPS_NOREORDER,
1164 EF_MIPS_PIC,
1165 EF_MIPS_CPIC,
1166 EF_MIPS_XGOT,
1167 EF_MIPS_64BIT_WHIRL,
1168 EF_MIPS_ABI2,
1169 EF_MIPS_ABI_ON32,
1170 EF_MIPS_FP64,
1171 EF_MIPS_NAN2008,
1172 );
1173 static FLAGS_EF_MIPS_ARCH: &[Flag<u32>] = &flags!(
1174 EF_MIPS_ARCH_1,
1175 EF_MIPS_ARCH_2,
1176 EF_MIPS_ARCH_3,
1177 EF_MIPS_ARCH_4,
1178 EF_MIPS_ARCH_5,
1179 EF_MIPS_ARCH_32,
1180 EF_MIPS_ARCH_64,
1181 EF_MIPS_ARCH_32R2,
1182 EF_MIPS_ARCH_64R2,
1183 );
1184 static FLAGS_EF_PARISC: &[Flag<u32>] = &flags!(
1185 EF_PARISC_TRAPNIL,
1186 EF_PARISC_EXT,
1187 EF_PARISC_LSB,
1188 EF_PARISC_WIDE,
1189 EF_PARISC_NO_KABP,
1190 EF_PARISC_LAZYSWAP,
1191 );
1192 static FLAGS_EF_PARISC_ARCH: &[Flag<u32>] =
1193 &flags!(EFA_PARISC_1_0, EFA_PARISC_1_1, EFA_PARISC_2_0);
1194 static FLAGS_EF_ALPHA: &[Flag<u32>] = &flags!(EF_ALPHA_32BIT, EF_ALPHA_CANRELAX);
1195 static FLAGS_EF_PPC: &[Flag<u32>] =
1196 &flags!(EF_PPC_EMB, EF_PPC_RELOCATABLE, EF_PPC_RELOCATABLE_LIB);
1197 static FLAGS_EF_PPC64: &[Flag<u32>] = &flags!(EF_PPC64_ABI);
1198 static FLAGS_EF_ARM: &[Flag<u32>] = &flags!(
1199 EF_ARM_RELEXEC,
1200 EF_ARM_HASENTRY,
1201 EF_ARM_INTERWORK,
1202 EF_ARM_APCS_26,
1203 EF_ARM_APCS_FLOAT,
1204 EF_ARM_PIC,
1205 EF_ARM_ALIGN8,
1206 EF_ARM_NEW_ABI,
1207 EF_ARM_OLD_ABI,
1208 EF_ARM_SOFT_FLOAT,
1209 EF_ARM_VFP_FLOAT,
1210 EF_ARM_MAVERICK_FLOAT,
1211 EF_ARM_BE8,
1212 EF_ARM_LE8,
1213 );
1214 static FLAGS_EF_ARM_EABI: &[Flag<u32>] = &flags!(
1215 EF_ARM_EABI_UNKNOWN,
1216 EF_ARM_EABI_VER1,
1217 EF_ARM_EABI_VER2,
1218 EF_ARM_EABI_VER3,
1219 EF_ARM_EABI_VER4,
1220 EF_ARM_EABI_VER5,
1221 );
1222 static FLAGS_EF_CSKY_ABI: &[Flag<u32>] = &flags!(EF_CSKY_ABIV1, EF_CSKY_ABIV2);
1223 static FLAGS_EF_IA_64: &[Flag<u32>] = &flags!(EF_IA_64_ABI64);
1224 static FLAGS_EF_SH_MACH: &[Flag<u32>] = &flags!(
1225 EF_SH_UNKNOWN,
1226 EF_SH1,
1227 EF_SH2,
1228 EF_SH3,
1229 EF_SH_DSP,
1230 EF_SH3_DSP,
1231 EF_SH4AL_DSP,
1232 EF_SH3E,
1233 EF_SH4,
1234 EF_SH2E,
1235 EF_SH4A,
1236 EF_SH2A,
1237 EF_SH4_NOFPU,
1238 EF_SH4A_NOFPU,
1239 EF_SH4_NOMMU_NOFPU,
1240 EF_SH2A_NOFPU,
1241 EF_SH3_NOMMU,
1242 EF_SH2A_SH4_NOFPU,
1243 EF_SH2A_SH3_NOFPU,
1244 EF_SH2A_SH4,
1245 EF_SH2A_SH3E,
1246 );
1247 static FLAGS_EF_S390: &[Flag<u32>] = &flags!(EF_S390_HIGH_GPRS);
1248 static FLAGS_EF_RISCV: &[Flag<u32>] = &flags!(EF_RISCV_RVC);
1249 static FLAGS_EF_RISCV_FLOAT_ABI: &[Flag<u32>] = &flags!(
1250 EF_RISCV_FLOAT_ABI_SOFT,
1251 EF_RISCV_FLOAT_ABI_SINGLE,
1252 EF_RISCV_FLOAT_ABI_DOUBLE,
1253 EF_RISCV_FLOAT_ABI_QUAD,
1254 );
1255 static FLAGS_PT: &[Flag<u32>] = &flags!(
1256 PT_NULL,
1257 PT_LOAD,
1258 PT_DYNAMIC,
1259 PT_INTERP,
1260 PT_NOTE,
1261 PT_SHLIB,
1262 PT_PHDR,
1263 PT_TLS,
1264 PT_LOOS,
1265 PT_GNU_EH_FRAME,
1266 PT_GNU_STACK,
1267 PT_GNU_RELRO,
1268 );
1269 static FLAGS_PT_HP: &[Flag<u32>] = &flags!(
1270 PT_HP_TLS,
1271 PT_HP_CORE_NONE,
1272 PT_HP_CORE_VERSION,
1273 PT_HP_CORE_KERNEL,
1274 PT_HP_CORE_COMM,
1275 PT_HP_CORE_PROC,
1276 PT_HP_CORE_LOADABLE,
1277 PT_HP_CORE_STACK,
1278 PT_HP_CORE_SHM,
1279 PT_HP_CORE_MMF,
1280 PT_HP_PARALLEL,
1281 PT_HP_FASTBIND,
1282 PT_HP_OPT_ANNOT,
1283 PT_HP_HSL_ANNOT,
1284 PT_HP_STACK,
1285 );
1286 static FLAGS_PT_MIPS: &[Flag<u32>] = &flags!(
1287 PT_MIPS_REGINFO,
1288 PT_MIPS_RTPROC,
1289 PT_MIPS_OPTIONS,
1290 PT_MIPS_ABIFLAGS,
1291 );
1292 static FLAGS_PT_PARISC: &[Flag<u32>] = &flags!(PT_PARISC_ARCHEXT, PT_PARISC_UNWIND);
1293 static FLAGS_PT_ARM: &[Flag<u32>] = &flags!(PT_ARM_EXIDX);
1294 static FLAGS_PT_IA_64: &[Flag<u32>] = &flags!(PT_IA_64_ARCHEXT, PT_IA_64_UNWIND);
1295 static FLAGS_PF: &[Flag<u32>] = &flags!(PF_X, PF_W, PF_R);
1296 static FLAGS_PF_HP: &[Flag<u32>] = &flags!(
1297 PF_HP_PAGE_SIZE,
1298 PF_HP_FAR_SHARED,
1299 PF_HP_NEAR_SHARED,
1300 PF_HP_CODE,
1301 PF_HP_MODIFY,
1302 PF_HP_LAZYSWAP,
1303 PF_HP_SBP,
1304 );
1305 static FLAGS_PF_MIPS: &[Flag<u32>] = &flags!(PF_MIPS_LOCAL);
1306 static FLAGS_PF_PARISC: &[Flag<u32>] = &flags!(PF_PARISC_SBP);
1307 static FLAGS_PF_ARM: &[Flag<u32>] = &flags!(PF_ARM_SB, PF_ARM_PI, PF_ARM_ABS);
1308 static FLAGS_PF_IA_64: &[Flag<u32>] = &flags!(PF_IA_64_NORECOV);
1309 static FLAGS_SHT: &[Flag<u32>] = &flags!(
1310 SHT_NULL,
1311 SHT_PROGBITS,
1312 SHT_SYMTAB,
1313 SHT_STRTAB,
1314 SHT_RELA,
1315 SHT_HASH,
1316 SHT_DYNAMIC,
1317 SHT_NOTE,
1318 SHT_NOBITS,
1319 SHT_REL,
1320 SHT_SHLIB,
1321 SHT_DYNSYM,
1322 SHT_INIT_ARRAY,
1323 SHT_FINI_ARRAY,
1324 SHT_PREINIT_ARRAY,
1325 SHT_GROUP,
1326 SHT_SYMTAB_SHNDX,
1327 SHT_GNU_ATTRIBUTES,
1328 SHT_GNU_HASH,
1329 SHT_GNU_LIBLIST,
1330 SHT_CHECKSUM,
1331 SHT_SUNW_move,
1332 SHT_SUNW_COMDAT,
1333 SHT_SUNW_syminfo,
1334 SHT_GNU_VERDEF,
1335 SHT_GNU_VERNEED,
1336 SHT_GNU_VERSYM,
1337 );
1338 static FLAGS_SHT_MIPS: &[Flag<u32>] = &flags!(
1339 SHT_MIPS_LIBLIST,
1340 SHT_MIPS_MSYM,
1341 SHT_MIPS_CONFLICT,
1342 SHT_MIPS_GPTAB,
1343 SHT_MIPS_UCODE,
1344 SHT_MIPS_DEBUG,
1345 SHT_MIPS_REGINFO,
1346 SHT_MIPS_PACKAGE,
1347 SHT_MIPS_PACKSYM,
1348 SHT_MIPS_RELD,
1349 SHT_MIPS_IFACE,
1350 SHT_MIPS_CONTENT,
1351 SHT_MIPS_OPTIONS,
1352 SHT_MIPS_SHDR,
1353 SHT_MIPS_FDESC,
1354 SHT_MIPS_EXTSYM,
1355 SHT_MIPS_DENSE,
1356 SHT_MIPS_PDESC,
1357 SHT_MIPS_LOCSYM,
1358 SHT_MIPS_AUXSYM,
1359 SHT_MIPS_OPTSYM,
1360 SHT_MIPS_LOCSTR,
1361 SHT_MIPS_LINE,
1362 SHT_MIPS_RFDESC,
1363 SHT_MIPS_DELTASYM,
1364 SHT_MIPS_DELTAINST,
1365 SHT_MIPS_DELTACLASS,
1366 SHT_MIPS_DWARF,
1367 SHT_MIPS_DELTADECL,
1368 SHT_MIPS_SYMBOL_LIB,
1369 SHT_MIPS_EVENTS,
1370 SHT_MIPS_TRANSLATE,
1371 SHT_MIPS_PIXIE,
1372 SHT_MIPS_XLATE,
1373 SHT_MIPS_XLATE_DEBUG,
1374 SHT_MIPS_WHIRL,
1375 SHT_MIPS_EH_REGION,
1376 SHT_MIPS_XLATE_OLD,
1377 SHT_MIPS_PDR_EXCEPTION,
1378 );
1379 static FLAGS_SHT_PARISC: &[Flag<u32>] =
1380 &flags!(SHT_PARISC_EXT, SHT_PARISC_UNWIND, SHT_PARISC_DOC);
1381 static FLAGS_SHT_ALPHA: &[Flag<u32>] = &flags!(SHT_ALPHA_DEBUG, SHT_ALPHA_REGINFO);
1382 static FLAGS_SHT_ARM: &[Flag<u32>] =
1383 &flags!(SHT_ARM_EXIDX, SHT_ARM_PREEMPTMAP, SHT_ARM_ATTRIBUTES);
1384 static FLAGS_SHT_CSKY: &[Flag<u32>] = &flags!(SHT_CSKY_ATTRIBUTES);
1385 static FLAGS_SHT_IA_64: &[Flag<u32>] = &flags!(SHT_IA_64_EXT, SHT_IA_64_UNWIND);
1386 static FLAGS_SHT_X86_64: &[Flag<u32>] = &flags!(SHT_X86_64_UNWIND);
1387 static FLAGS_SHF: &[Flag<u32>] = &flags!(
1388 SHF_WRITE,
1389 SHF_ALLOC,
1390 SHF_EXECINSTR,
1391 SHF_MERGE,
1392 SHF_STRINGS,
1393 SHF_INFO_LINK,
1394 SHF_LINK_ORDER,
1395 SHF_OS_NONCONFORMING,
1396 SHF_GROUP,
1397 SHF_TLS,
1398 SHF_COMPRESSED,
1399 );
1400 static FLAGS_SHF_MIPS: &[Flag<u32>] = &flags!(
1401 SHF_MIPS_GPREL,
1402 SHF_MIPS_MERGE,
1403 SHF_MIPS_ADDR,
1404 SHF_MIPS_STRINGS,
1405 SHF_MIPS_NOSTRIP,
1406 SHF_MIPS_LOCAL,
1407 SHF_MIPS_NAMES,
1408 SHF_MIPS_NODUPE,
1409 );
1410 static FLAGS_SHF_PARISC: &[Flag<u32>] =
1411 &flags!(SHF_PARISC_SHORT, SHF_PARISC_HUGE, SHF_PARISC_SBP);
1412 static FLAGS_SHF_ALPHA: &[Flag<u32>] = &flags!(SHF_ALPHA_GPREL);
1413 static FLAGS_SHF_ARM: &[Flag<u32>] = &flags!(SHF_ARM_ENTRYSECT, SHF_ARM_COMDEF);
1414 static FLAGS_SHF_IA_64: &[Flag<u32>] = &flags!(SHF_IA_64_SHORT, SHF_IA_64_NORECOV);
1415 static FLAGS_STT: &[Flag<u8>] = &flags!(
1416 STT_NOTYPE,
1417 STT_OBJECT,
1418 STT_FUNC,
1419 STT_SECTION,
1420 STT_FILE,
1421 STT_COMMON,
1422 STT_TLS,
1423 );
1424 static FLAGS_STT_GNU: &[Flag<u8>] = &flags!(STT_GNU_IFUNC);
1425 static FLAGS_STT_HP: &[Flag<u8>] = &flags!(STT_HP_OPAQUE, STT_HP_STUB);
1426 static FLAGS_STT_SPARC: &[Flag<u8>] = &flags!(STT_SPARC_REGISTER);
1427 static FLAGS_STT_PARISC: &[Flag<u8>] = &flags!(STT_PARISC_MILLICODE);
1428 static FLAGS_STT_ARM: &[Flag<u8>] = &flags!(STT_ARM_TFUNC, STT_ARM_16BIT);
1429 static FLAGS_STB: &[Flag<u8>] = &flags!(STB_LOCAL, STB_GLOBAL, STB_WEAK);
1430 static FLAGS_STB_GNU: &[Flag<u8>] = &flags!(STB_GNU_UNIQUE);
1431 static FLAGS_STB_MIPS: &[Flag<u8>] = &flags!(STB_MIPS_SPLIT_COMMON);
1432 static FLAGS_STV: &[Flag<u8>] = &flags!(STV_DEFAULT, STV_INTERNAL, STV_HIDDEN, STV_PROTECTED);
1433 static FLAGS_STO_MIPS: &[Flag<u8>] = &flags!(STO_MIPS_PLT);
1434 static FLAGS_STO_ALPHA: &[Flag<u8>] = &flags!(STO_ALPHA_NOPV, STO_ALPHA_STD_GPLOAD);
1435 static FLAGS_SHN: &[Flag<u16>] = &flags!(SHN_UNDEF, SHN_ABS, SHN_COMMON, SHN_XINDEX);
1436 static FLAGS_SHN_MIPS: &[Flag<u16>] = &flags!(
1437 SHN_MIPS_ACOMMON,
1438 SHN_MIPS_TEXT,
1439 SHN_MIPS_DATA,
1440 SHN_MIPS_SCOMMON,
1441 SHN_MIPS_SUNDEFINED,
1442 );
1443 static FLAGS_SHN_PARISC: &[Flag<u16>] = &flags!(SHN_PARISC_ANSI_COMMON, SHN_PARISC_HUGE_COMMON);
1444 static FLAGS_R_68K: &[Flag<u32>] = &flags!(
1445 R_68K_NONE,
1446 R_68K_32,
1447 R_68K_16,
1448 R_68K_8,
1449 R_68K_PC32,
1450 R_68K_PC16,
1451 R_68K_PC8,
1452 R_68K_GOT32,
1453 R_68K_GOT16,
1454 R_68K_GOT8,
1455 R_68K_GOT32O,
1456 R_68K_GOT16O,
1457 R_68K_GOT8O,
1458 R_68K_PLT32,
1459 R_68K_PLT16,
1460 R_68K_PLT8,
1461 R_68K_PLT32O,
1462 R_68K_PLT16O,
1463 R_68K_PLT8O,
1464 R_68K_COPY,
1465 R_68K_GLOB_DAT,
1466 R_68K_JMP_SLOT,
1467 R_68K_RELATIVE,
1468 R_68K_TLS_GD32,
1469 R_68K_TLS_GD16,
1470 R_68K_TLS_GD8,
1471 R_68K_TLS_LDM32,
1472 R_68K_TLS_LDM16,
1473 R_68K_TLS_LDM8,
1474 R_68K_TLS_LDO32,
1475 R_68K_TLS_LDO16,
1476 R_68K_TLS_LDO8,
1477 R_68K_TLS_IE32,
1478 R_68K_TLS_IE16,
1479 R_68K_TLS_IE8,
1480 R_68K_TLS_LE32,
1481 R_68K_TLS_LE16,
1482 R_68K_TLS_LE8,
1483 R_68K_TLS_DTPMOD32,
1484 R_68K_TLS_DTPREL32,
1485 R_68K_TLS_TPREL32,
1486 );
1487 static FLAGS_R_386: &[Flag<u32>] = &flags!(
1488 R_386_NONE,
1489 R_386_32,
1490 R_386_PC32,
1491 R_386_GOT32,
1492 R_386_PLT32,
1493 R_386_COPY,
1494 R_386_GLOB_DAT,
1495 R_386_JMP_SLOT,
1496 R_386_RELATIVE,
1497 R_386_GOTOFF,
1498 R_386_GOTPC,
1499 R_386_32PLT,
1500 R_386_TLS_TPOFF,
1501 R_386_TLS_IE,
1502 R_386_TLS_GOTIE,
1503 R_386_TLS_LE,
1504 R_386_TLS_GD,
1505 R_386_TLS_LDM,
1506 R_386_16,
1507 R_386_PC16,
1508 R_386_8,
1509 R_386_PC8,
1510 R_386_TLS_GD_32,
1511 R_386_TLS_GD_PUSH,
1512 R_386_TLS_GD_CALL,
1513 R_386_TLS_GD_POP,
1514 R_386_TLS_LDM_32,
1515 R_386_TLS_LDM_PUSH,
1516 R_386_TLS_LDM_CALL,
1517 R_386_TLS_LDM_POP,
1518 R_386_TLS_LDO_32,
1519 R_386_TLS_IE_32,
1520 R_386_TLS_LE_32,
1521 R_386_TLS_DTPMOD32,
1522 R_386_TLS_DTPOFF32,
1523 R_386_TLS_TPOFF32,
1524 R_386_SIZE32,
1525 R_386_TLS_GOTDESC,
1526 R_386_TLS_DESC_CALL,
1527 R_386_TLS_DESC,
1528 R_386_IRELATIVE,
1529 R_386_GOT32X,
1530 );
1531 static FLAGS_R_SPARC: &[Flag<u32>] = &flags!(
1532 R_SPARC_NONE,
1533 R_SPARC_8,
1534 R_SPARC_16,
1535 R_SPARC_32,
1536 R_SPARC_DISP8,
1537 R_SPARC_DISP16,
1538 R_SPARC_DISP32,
1539 R_SPARC_WDISP30,
1540 R_SPARC_WDISP22,
1541 R_SPARC_HI22,
1542 R_SPARC_22,
1543 R_SPARC_13,
1544 R_SPARC_LO10,
1545 R_SPARC_GOT10,
1546 R_SPARC_GOT13,
1547 R_SPARC_GOT22,
1548 R_SPARC_PC10,
1549 R_SPARC_PC22,
1550 R_SPARC_WPLT30,
1551 R_SPARC_COPY,
1552 R_SPARC_GLOB_DAT,
1553 R_SPARC_JMP_SLOT,
1554 R_SPARC_RELATIVE,
1555 R_SPARC_UA32,
1556 R_SPARC_PLT32,
1557 R_SPARC_HIPLT22,
1558 R_SPARC_LOPLT10,
1559 R_SPARC_PCPLT32,
1560 R_SPARC_PCPLT22,
1561 R_SPARC_PCPLT10,
1562 R_SPARC_10,
1563 R_SPARC_11,
1564 R_SPARC_64,
1565 R_SPARC_OLO10,
1566 R_SPARC_HH22,
1567 R_SPARC_HM10,
1568 R_SPARC_LM22,
1569 R_SPARC_PC_HH22,
1570 R_SPARC_PC_HM10,
1571 R_SPARC_PC_LM22,
1572 R_SPARC_WDISP16,
1573 R_SPARC_WDISP19,
1574 R_SPARC_GLOB_JMP,
1575 R_SPARC_7,
1576 R_SPARC_5,
1577 R_SPARC_6,
1578 R_SPARC_DISP64,
1579 R_SPARC_PLT64,
1580 R_SPARC_HIX22,
1581 R_SPARC_LOX10,
1582 R_SPARC_H44,
1583 R_SPARC_M44,
1584 R_SPARC_L44,
1585 R_SPARC_REGISTER,
1586 R_SPARC_UA64,
1587 R_SPARC_UA16,
1588 R_SPARC_TLS_GD_HI22,
1589 R_SPARC_TLS_GD_LO10,
1590 R_SPARC_TLS_GD_ADD,
1591 R_SPARC_TLS_GD_CALL,
1592 R_SPARC_TLS_LDM_HI22,
1593 R_SPARC_TLS_LDM_LO10,
1594 R_SPARC_TLS_LDM_ADD,
1595 R_SPARC_TLS_LDM_CALL,
1596 R_SPARC_TLS_LDO_HIX22,
1597 R_SPARC_TLS_LDO_LOX10,
1598 R_SPARC_TLS_LDO_ADD,
1599 R_SPARC_TLS_IE_HI22,
1600 R_SPARC_TLS_IE_LO10,
1601 R_SPARC_TLS_IE_LD,
1602 R_SPARC_TLS_IE_LDX,
1603 R_SPARC_TLS_IE_ADD,
1604 R_SPARC_TLS_LE_HIX22,
1605 R_SPARC_TLS_LE_LOX10,
1606 R_SPARC_TLS_DTPMOD32,
1607 R_SPARC_TLS_DTPMOD64,
1608 R_SPARC_TLS_DTPOFF32,
1609 R_SPARC_TLS_DTPOFF64,
1610 R_SPARC_TLS_TPOFF32,
1611 R_SPARC_TLS_TPOFF64,
1612 R_SPARC_GOTDATA_HIX22,
1613 R_SPARC_GOTDATA_LOX10,
1614 R_SPARC_GOTDATA_OP_HIX22,
1615 R_SPARC_GOTDATA_OP_LOX10,
1616 R_SPARC_GOTDATA_OP,
1617 R_SPARC_H34,
1618 R_SPARC_SIZE32,
1619 R_SPARC_SIZE64,
1620 R_SPARC_WDISP10,
1621 R_SPARC_JMP_IREL,
1622 R_SPARC_IRELATIVE,
1623 R_SPARC_GNU_VTINHERIT,
1624 R_SPARC_GNU_VTENTRY,
1625 R_SPARC_REV32,
1626 );
1627 static FLAGS_R_MIPS: &[Flag<u32>] = &flags!(
1628 R_MIPS_NONE,
1629 R_MIPS_16,
1630 R_MIPS_32,
1631 R_MIPS_REL32,
1632 R_MIPS_26,
1633 R_MIPS_HI16,
1634 R_MIPS_LO16,
1635 R_MIPS_GPREL16,
1636 R_MIPS_LITERAL,
1637 R_MIPS_GOT16,
1638 R_MIPS_PC16,
1639 R_MIPS_CALL16,
1640 R_MIPS_GPREL32,
1641 R_MIPS_SHIFT5,
1642 R_MIPS_SHIFT6,
1643 R_MIPS_64,
1644 R_MIPS_GOT_DISP,
1645 R_MIPS_GOT_PAGE,
1646 R_MIPS_GOT_OFST,
1647 R_MIPS_GOT_HI16,
1648 R_MIPS_GOT_LO16,
1649 R_MIPS_SUB,
1650 R_MIPS_INSERT_A,
1651 R_MIPS_INSERT_B,
1652 R_MIPS_DELETE,
1653 R_MIPS_HIGHER,
1654 R_MIPS_HIGHEST,
1655 R_MIPS_CALL_HI16,
1656 R_MIPS_CALL_LO16,
1657 R_MIPS_SCN_DISP,
1658 R_MIPS_REL16,
1659 R_MIPS_ADD_IMMEDIATE,
1660 R_MIPS_PJUMP,
1661 R_MIPS_RELGOT,
1662 R_MIPS_JALR,
1663 R_MIPS_TLS_DTPMOD32,
1664 R_MIPS_TLS_DTPREL32,
1665 R_MIPS_TLS_DTPMOD64,
1666 R_MIPS_TLS_DTPREL64,
1667 R_MIPS_TLS_GD,
1668 R_MIPS_TLS_LDM,
1669 R_MIPS_TLS_DTPREL_HI16,
1670 R_MIPS_TLS_DTPREL_LO16,
1671 R_MIPS_TLS_GOTTPREL,
1672 R_MIPS_TLS_TPREL32,
1673 R_MIPS_TLS_TPREL64,
1674 R_MIPS_TLS_TPREL_HI16,
1675 R_MIPS_TLS_TPREL_LO16,
1676 R_MIPS_GLOB_DAT,
1677 R_MIPS_COPY,
1678 R_MIPS_JUMP_SLOT,
1679 );
1680 static FLAGS_R_PARISC: &[Flag<u32>] = &flags!(
1681 R_PARISC_NONE,
1682 R_PARISC_DIR32,
1683 R_PARISC_DIR21L,
1684 R_PARISC_DIR17R,
1685 R_PARISC_DIR17F,
1686 R_PARISC_DIR14R,
1687 R_PARISC_PCREL32,
1688 R_PARISC_PCREL21L,
1689 R_PARISC_PCREL17R,
1690 R_PARISC_PCREL17F,
1691 R_PARISC_PCREL14R,
1692 R_PARISC_DPREL21L,
1693 R_PARISC_DPREL14R,
1694 R_PARISC_GPREL21L,
1695 R_PARISC_GPREL14R,
1696 R_PARISC_LTOFF21L,
1697 R_PARISC_LTOFF14R,
1698 R_PARISC_SECREL32,
1699 R_PARISC_SEGBASE,
1700 R_PARISC_SEGREL32,
1701 R_PARISC_PLTOFF21L,
1702 R_PARISC_PLTOFF14R,
1703 R_PARISC_LTOFF_FPTR32,
1704 R_PARISC_LTOFF_FPTR21L,
1705 R_PARISC_LTOFF_FPTR14R,
1706 R_PARISC_FPTR64,
1707 R_PARISC_PLABEL32,
1708 R_PARISC_PLABEL21L,
1709 R_PARISC_PLABEL14R,
1710 R_PARISC_PCREL64,
1711 R_PARISC_PCREL22F,
1712 R_PARISC_PCREL14WR,
1713 R_PARISC_PCREL14DR,
1714 R_PARISC_PCREL16F,
1715 R_PARISC_PCREL16WF,
1716 R_PARISC_PCREL16DF,
1717 R_PARISC_DIR64,
1718 R_PARISC_DIR14WR,
1719 R_PARISC_DIR14DR,
1720 R_PARISC_DIR16F,
1721 R_PARISC_DIR16WF,
1722 R_PARISC_DIR16DF,
1723 R_PARISC_GPREL64,
1724 R_PARISC_GPREL14WR,
1725 R_PARISC_GPREL14DR,
1726 R_PARISC_GPREL16F,
1727 R_PARISC_GPREL16WF,
1728 R_PARISC_GPREL16DF,
1729 R_PARISC_LTOFF64,
1730 R_PARISC_LTOFF14WR,
1731 R_PARISC_LTOFF14DR,
1732 R_PARISC_LTOFF16F,
1733 R_PARISC_LTOFF16WF,
1734 R_PARISC_LTOFF16DF,
1735 R_PARISC_SECREL64,
1736 R_PARISC_SEGREL64,
1737 R_PARISC_PLTOFF14WR,
1738 R_PARISC_PLTOFF14DR,
1739 R_PARISC_PLTOFF16F,
1740 R_PARISC_PLTOFF16WF,
1741 R_PARISC_PLTOFF16DF,
1742 R_PARISC_LTOFF_FPTR64,
1743 R_PARISC_LTOFF_FPTR14WR,
1744 R_PARISC_LTOFF_FPTR14DR,
1745 R_PARISC_LTOFF_FPTR16F,
1746 R_PARISC_LTOFF_FPTR16WF,
1747 R_PARISC_LTOFF_FPTR16DF,
1748 R_PARISC_COPY,
1749 R_PARISC_IPLT,
1750 R_PARISC_EPLT,
1751 R_PARISC_TPREL32,
1752 R_PARISC_TPREL21L,
1753 R_PARISC_TPREL14R,
1754 R_PARISC_LTOFF_TP21L,
1755 R_PARISC_LTOFF_TP14R,
1756 R_PARISC_LTOFF_TP14F,
1757 R_PARISC_TPREL64,
1758 R_PARISC_TPREL14WR,
1759 R_PARISC_TPREL14DR,
1760 R_PARISC_TPREL16F,
1761 R_PARISC_TPREL16WF,
1762 R_PARISC_TPREL16DF,
1763 R_PARISC_LTOFF_TP64,
1764 R_PARISC_LTOFF_TP14WR,
1765 R_PARISC_LTOFF_TP14DR,
1766 R_PARISC_LTOFF_TP16F,
1767 R_PARISC_LTOFF_TP16WF,
1768 R_PARISC_LTOFF_TP16DF,
1769 R_PARISC_GNU_VTENTRY,
1770 R_PARISC_GNU_VTINHERIT,
1771 R_PARISC_TLS_GD21L,
1772 R_PARISC_TLS_GD14R,
1773 R_PARISC_TLS_GDCALL,
1774 R_PARISC_TLS_LDM21L,
1775 R_PARISC_TLS_LDM14R,
1776 R_PARISC_TLS_LDMCALL,
1777 R_PARISC_TLS_LDO21L,
1778 R_PARISC_TLS_LDO14R,
1779 R_PARISC_TLS_DTPMOD32,
1780 R_PARISC_TLS_DTPMOD64,
1781 R_PARISC_TLS_DTPOFF32,
1782 R_PARISC_TLS_DTPOFF64,
1783 R_PARISC_TLS_LE21L,
1784 R_PARISC_TLS_LE14R,
1785 R_PARISC_TLS_IE21L,
1786 R_PARISC_TLS_IE14R,
1787 R_PARISC_TLS_TPREL32,
1788 R_PARISC_TLS_TPREL64,
1789 );
1790 static FLAGS_R_ALPHA: &[Flag<u32>] = &flags!(
1791 R_ALPHA_NONE,
1792 R_ALPHA_REFLONG,
1793 R_ALPHA_REFQUAD,
1794 R_ALPHA_GPREL32,
1795 R_ALPHA_LITERAL,
1796 R_ALPHA_LITUSE,
1797 R_ALPHA_GPDISP,
1798 R_ALPHA_BRADDR,
1799 R_ALPHA_HINT,
1800 R_ALPHA_SREL16,
1801 R_ALPHA_SREL32,
1802 R_ALPHA_SREL64,
1803 R_ALPHA_GPRELHIGH,
1804 R_ALPHA_GPRELLOW,
1805 R_ALPHA_GPREL16,
1806 R_ALPHA_COPY,
1807 R_ALPHA_GLOB_DAT,
1808 R_ALPHA_JMP_SLOT,
1809 R_ALPHA_RELATIVE,
1810 R_ALPHA_TLS_GD_HI,
1811 R_ALPHA_TLSGD,
1812 R_ALPHA_TLS_LDM,
1813 R_ALPHA_DTPMOD64,
1814 R_ALPHA_GOTDTPREL,
1815 R_ALPHA_DTPREL64,
1816 R_ALPHA_DTPRELHI,
1817 R_ALPHA_DTPRELLO,
1818 R_ALPHA_DTPREL16,
1819 R_ALPHA_GOTTPREL,
1820 R_ALPHA_TPREL64,
1821 R_ALPHA_TPRELHI,
1822 R_ALPHA_TPRELLO,
1823 R_ALPHA_TPREL16,
1824 );
1825 static FLAGS_R_PPC: &[Flag<u32>] = &flags!(
1826 R_PPC_NONE,
1827 R_PPC_ADDR32,
1828 R_PPC_ADDR24,
1829 R_PPC_ADDR16,
1830 R_PPC_ADDR16_LO,
1831 R_PPC_ADDR16_HI,
1832 R_PPC_ADDR16_HA,
1833 R_PPC_ADDR14,
1834 R_PPC_ADDR14_BRTAKEN,
1835 R_PPC_ADDR14_BRNTAKEN,
1836 R_PPC_REL24,
1837 R_PPC_REL14,
1838 R_PPC_REL14_BRTAKEN,
1839 R_PPC_REL14_BRNTAKEN,
1840 R_PPC_GOT16,
1841 R_PPC_GOT16_LO,
1842 R_PPC_GOT16_HI,
1843 R_PPC_GOT16_HA,
1844 R_PPC_PLTREL24,
1845 R_PPC_COPY,
1846 R_PPC_GLOB_DAT,
1847 R_PPC_JMP_SLOT,
1848 R_PPC_RELATIVE,
1849 R_PPC_LOCAL24PC,
1850 R_PPC_UADDR32,
1851 R_PPC_UADDR16,
1852 R_PPC_REL32,
1853 R_PPC_PLT32,
1854 R_PPC_PLTREL32,
1855 R_PPC_PLT16_LO,
1856 R_PPC_PLT16_HI,
1857 R_PPC_PLT16_HA,
1858 R_PPC_SDAREL16,
1859 R_PPC_SECTOFF,
1860 R_PPC_SECTOFF_LO,
1861 R_PPC_SECTOFF_HI,
1862 R_PPC_SECTOFF_HA,
1863 R_PPC_TLS,
1864 R_PPC_DTPMOD32,
1865 R_PPC_TPREL16,
1866 R_PPC_TPREL16_LO,
1867 R_PPC_TPREL16_HI,
1868 R_PPC_TPREL16_HA,
1869 R_PPC_TPREL32,
1870 R_PPC_DTPREL16,
1871 R_PPC_DTPREL16_LO,
1872 R_PPC_DTPREL16_HI,
1873 R_PPC_DTPREL16_HA,
1874 R_PPC_DTPREL32,
1875 R_PPC_GOT_TLSGD16,
1876 R_PPC_GOT_TLSGD16_LO,
1877 R_PPC_GOT_TLSGD16_HI,
1878 R_PPC_GOT_TLSGD16_HA,
1879 R_PPC_GOT_TLSLD16,
1880 R_PPC_GOT_TLSLD16_LO,
1881 R_PPC_GOT_TLSLD16_HI,
1882 R_PPC_GOT_TLSLD16_HA,
1883 R_PPC_GOT_TPREL16,
1884 R_PPC_GOT_TPREL16_LO,
1885 R_PPC_GOT_TPREL16_HI,
1886 R_PPC_GOT_TPREL16_HA,
1887 R_PPC_GOT_DTPREL16,
1888 R_PPC_GOT_DTPREL16_LO,
1889 R_PPC_GOT_DTPREL16_HI,
1890 R_PPC_GOT_DTPREL16_HA,
1891 R_PPC_TLSGD,
1892 R_PPC_TLSLD,
1893 R_PPC_EMB_NADDR32,
1894 R_PPC_EMB_NADDR16,
1895 R_PPC_EMB_NADDR16_LO,
1896 R_PPC_EMB_NADDR16_HI,
1897 R_PPC_EMB_NADDR16_HA,
1898 R_PPC_EMB_SDAI16,
1899 R_PPC_EMB_SDA2I16,
1900 R_PPC_EMB_SDA2REL,
1901 R_PPC_EMB_SDA21,
1902 R_PPC_EMB_MRKREF,
1903 R_PPC_EMB_RELSEC16,
1904 R_PPC_EMB_RELST_LO,
1905 R_PPC_EMB_RELST_HI,
1906 R_PPC_EMB_RELST_HA,
1907 R_PPC_EMB_BIT_FLD,
1908 R_PPC_EMB_RELSDA,
1909 R_PPC_DIAB_SDA21_LO,
1910 R_PPC_DIAB_SDA21_HI,
1911 R_PPC_DIAB_SDA21_HA,
1912 R_PPC_DIAB_RELSDA_LO,
1913 R_PPC_DIAB_RELSDA_HI,
1914 R_PPC_DIAB_RELSDA_HA,
1915 R_PPC_IRELATIVE,
1916 R_PPC_REL16,
1917 R_PPC_REL16_LO,
1918 R_PPC_REL16_HI,
1919 R_PPC_REL16_HA,
1920 R_PPC_TOC16,
1921 );
1922 static FLAGS_R_PPC64: &[Flag<u32>] = &flags!(
1923 R_PPC64_NONE,
1924 R_PPC64_ADDR32,
1925 R_PPC64_ADDR24,
1926 R_PPC64_ADDR16,
1927 R_PPC64_ADDR16_LO,
1928 R_PPC64_ADDR16_HI,
1929 R_PPC64_ADDR16_HA,
1930 R_PPC64_ADDR14,
1931 R_PPC64_ADDR14_BRTAKEN,
1932 R_PPC64_ADDR14_BRNTAKEN,
1933 R_PPC64_REL24,
1934 R_PPC64_REL14,
1935 R_PPC64_REL14_BRTAKEN,
1936 R_PPC64_REL14_BRNTAKEN,
1937 R_PPC64_GOT16,
1938 R_PPC64_GOT16_LO,
1939 R_PPC64_GOT16_HI,
1940 R_PPC64_GOT16_HA,
1941 R_PPC64_COPY,
1942 R_PPC64_GLOB_DAT,
1943 R_PPC64_JMP_SLOT,
1944 R_PPC64_RELATIVE,
1945 R_PPC64_UADDR32,
1946 R_PPC64_UADDR16,
1947 R_PPC64_REL32,
1948 R_PPC64_PLT32,
1949 R_PPC64_PLTREL32,
1950 R_PPC64_PLT16_LO,
1951 R_PPC64_PLT16_HI,
1952 R_PPC64_PLT16_HA,
1953 R_PPC64_SECTOFF,
1954 R_PPC64_SECTOFF_LO,
1955 R_PPC64_SECTOFF_HI,
1956 R_PPC64_SECTOFF_HA,
1957 R_PPC64_ADDR30,
1958 R_PPC64_ADDR64,
1959 R_PPC64_ADDR16_HIGHER,
1960 R_PPC64_ADDR16_HIGHERA,
1961 R_PPC64_ADDR16_HIGHEST,
1962 R_PPC64_ADDR16_HIGHESTA,
1963 R_PPC64_UADDR64,
1964 R_PPC64_REL64,
1965 R_PPC64_PLT64,
1966 R_PPC64_PLTREL64,
1967 R_PPC64_TOC16,
1968 R_PPC64_TOC16_LO,
1969 R_PPC64_TOC16_HI,
1970 R_PPC64_TOC16_HA,
1971 R_PPC64_TOC,
1972 R_PPC64_PLTGOT16,
1973 R_PPC64_PLTGOT16_LO,
1974 R_PPC64_PLTGOT16_HI,
1975 R_PPC64_PLTGOT16_HA,
1976 R_PPC64_ADDR16_DS,
1977 R_PPC64_ADDR16_LO_DS,
1978 R_PPC64_GOT16_DS,
1979 R_PPC64_GOT16_LO_DS,
1980 R_PPC64_PLT16_LO_DS,
1981 R_PPC64_SECTOFF_DS,
1982 R_PPC64_SECTOFF_LO_DS,
1983 R_PPC64_TOC16_DS,
1984 R_PPC64_TOC16_LO_DS,
1985 R_PPC64_PLTGOT16_DS,
1986 R_PPC64_PLTGOT16_LO_DS,
1987 R_PPC64_TLS,
1988 R_PPC64_DTPMOD64,
1989 R_PPC64_TPREL16,
1990 R_PPC64_TPREL16_LO,
1991 R_PPC64_TPREL16_HI,
1992 R_PPC64_TPREL16_HA,
1993 R_PPC64_TPREL64,
1994 R_PPC64_DTPREL16,
1995 R_PPC64_DTPREL16_LO,
1996 R_PPC64_DTPREL16_HI,
1997 R_PPC64_DTPREL16_HA,
1998 R_PPC64_DTPREL64,
1999 R_PPC64_GOT_TLSGD16,
2000 R_PPC64_GOT_TLSGD16_LO,
2001 R_PPC64_GOT_TLSGD16_HI,
2002 R_PPC64_GOT_TLSGD16_HA,
2003 R_PPC64_GOT_TLSLD16,
2004 R_PPC64_GOT_TLSLD16_LO,
2005 R_PPC64_GOT_TLSLD16_HI,
2006 R_PPC64_GOT_TLSLD16_HA,
2007 R_PPC64_GOT_TPREL16_DS,
2008 R_PPC64_GOT_TPREL16_LO_DS,
2009 R_PPC64_GOT_TPREL16_HI,
2010 R_PPC64_GOT_TPREL16_HA,
2011 R_PPC64_GOT_DTPREL16_DS,
2012 R_PPC64_GOT_DTPREL16_LO_DS,
2013 R_PPC64_GOT_DTPREL16_HI,
2014 R_PPC64_GOT_DTPREL16_HA,
2015 R_PPC64_TPREL16_DS,
2016 R_PPC64_TPREL16_LO_DS,
2017 R_PPC64_TPREL16_HIGHER,
2018 R_PPC64_TPREL16_HIGHERA,
2019 R_PPC64_TPREL16_HIGHEST,
2020 R_PPC64_TPREL16_HIGHESTA,
2021 R_PPC64_DTPREL16_DS,
2022 R_PPC64_DTPREL16_LO_DS,
2023 R_PPC64_DTPREL16_HIGHER,
2024 R_PPC64_DTPREL16_HIGHERA,
2025 R_PPC64_DTPREL16_HIGHEST,
2026 R_PPC64_DTPREL16_HIGHESTA,
2027 R_PPC64_TLSGD,
2028 R_PPC64_TLSLD,
2029 R_PPC64_TOCSAVE,
2030 R_PPC64_ADDR16_HIGH,
2031 R_PPC64_ADDR16_HIGHA,
2032 R_PPC64_TPREL16_HIGH,
2033 R_PPC64_TPREL16_HIGHA,
2034 R_PPC64_DTPREL16_HIGH,
2035 R_PPC64_DTPREL16_HIGHA,
2036 R_PPC64_JMP_IREL,
2037 R_PPC64_IRELATIVE,
2038 R_PPC64_REL16,
2039 R_PPC64_REL16_LO,
2040 R_PPC64_REL16_HI,
2041 R_PPC64_REL16_HA,
2042 );
2043 static FLAGS_R_AARCH64: &[Flag<u32>] = &flags!(
2044 R_AARCH64_NONE,
2045 R_AARCH64_P32_ABS32,
2046 R_AARCH64_P32_COPY,
2047 R_AARCH64_P32_GLOB_DAT,
2048 R_AARCH64_P32_JUMP_SLOT,
2049 R_AARCH64_P32_RELATIVE,
2050 R_AARCH64_P32_TLS_DTPMOD,
2051 R_AARCH64_P32_TLS_DTPREL,
2052 R_AARCH64_P32_TLS_TPREL,
2053 R_AARCH64_P32_TLSDESC,
2054 R_AARCH64_P32_IRELATIVE,
2055 R_AARCH64_ABS64,
2056 R_AARCH64_ABS32,
2057 R_AARCH64_ABS16,
2058 R_AARCH64_PREL64,
2059 R_AARCH64_PREL32,
2060 R_AARCH64_PREL16,
2061 R_AARCH64_MOVW_UABS_G0,
2062 R_AARCH64_MOVW_UABS_G0_NC,
2063 R_AARCH64_MOVW_UABS_G1,
2064 R_AARCH64_MOVW_UABS_G1_NC,
2065 R_AARCH64_MOVW_UABS_G2,
2066 R_AARCH64_MOVW_UABS_G2_NC,
2067 R_AARCH64_MOVW_UABS_G3,
2068 R_AARCH64_MOVW_SABS_G0,
2069 R_AARCH64_MOVW_SABS_G1,
2070 R_AARCH64_MOVW_SABS_G2,
2071 R_AARCH64_LD_PREL_LO19,
2072 R_AARCH64_ADR_PREL_LO21,
2073 R_AARCH64_ADR_PREL_PG_HI21,
2074 R_AARCH64_ADR_PREL_PG_HI21_NC,
2075 R_AARCH64_ADD_ABS_LO12_NC,
2076 R_AARCH64_LDST8_ABS_LO12_NC,
2077 R_AARCH64_TSTBR14,
2078 R_AARCH64_CONDBR19,
2079 R_AARCH64_JUMP26,
2080 R_AARCH64_CALL26,
2081 R_AARCH64_LDST16_ABS_LO12_NC,
2082 R_AARCH64_LDST32_ABS_LO12_NC,
2083 R_AARCH64_LDST64_ABS_LO12_NC,
2084 R_AARCH64_MOVW_PREL_G0,
2085 R_AARCH64_MOVW_PREL_G0_NC,
2086 R_AARCH64_MOVW_PREL_G1,
2087 R_AARCH64_MOVW_PREL_G1_NC,
2088 R_AARCH64_MOVW_PREL_G2,
2089 R_AARCH64_MOVW_PREL_G2_NC,
2090 R_AARCH64_MOVW_PREL_G3,
2091 R_AARCH64_LDST128_ABS_LO12_NC,
2092 R_AARCH64_MOVW_GOTOFF_G0,
2093 R_AARCH64_MOVW_GOTOFF_G0_NC,
2094 R_AARCH64_MOVW_GOTOFF_G1,
2095 R_AARCH64_MOVW_GOTOFF_G1_NC,
2096 R_AARCH64_MOVW_GOTOFF_G2,
2097 R_AARCH64_MOVW_GOTOFF_G2_NC,
2098 R_AARCH64_MOVW_GOTOFF_G3,
2099 R_AARCH64_GOTREL64,
2100 R_AARCH64_GOTREL32,
2101 R_AARCH64_GOT_LD_PREL19,
2102 R_AARCH64_LD64_GOTOFF_LO15,
2103 R_AARCH64_ADR_GOT_PAGE,
2104 R_AARCH64_LD64_GOT_LO12_NC,
2105 R_AARCH64_LD64_GOTPAGE_LO15,
2106 R_AARCH64_TLSGD_ADR_PREL21,
2107 R_AARCH64_TLSGD_ADR_PAGE21,
2108 R_AARCH64_TLSGD_ADD_LO12_NC,
2109 R_AARCH64_TLSGD_MOVW_G1,
2110 R_AARCH64_TLSGD_MOVW_G0_NC,
2111 R_AARCH64_TLSLD_ADR_PREL21,
2112 R_AARCH64_TLSLD_ADR_PAGE21,
2113 R_AARCH64_TLSLD_ADD_LO12_NC,
2114 R_AARCH64_TLSLD_MOVW_G1,
2115 R_AARCH64_TLSLD_MOVW_G0_NC,
2116 R_AARCH64_TLSLD_LD_PREL19,
2117 R_AARCH64_TLSLD_MOVW_DTPREL_G2,
2118 R_AARCH64_TLSLD_MOVW_DTPREL_G1,
2119 R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC,
2120 R_AARCH64_TLSLD_MOVW_DTPREL_G0,
2121 R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC,
2122 R_AARCH64_TLSLD_ADD_DTPREL_HI12,
2123 R_AARCH64_TLSLD_ADD_DTPREL_LO12,
2124 R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC,
2125 R_AARCH64_TLSLD_LDST8_DTPREL_LO12,
2126 R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC,
2127 R_AARCH64_TLSLD_LDST16_DTPREL_LO12,
2128 R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC,
2129 R_AARCH64_TLSLD_LDST32_DTPREL_LO12,
2130 R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC,
2131 R_AARCH64_TLSLD_LDST64_DTPREL_LO12,
2132 R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC,
2133 R_AARCH64_TLSIE_MOVW_GOTTPREL_G1,
2134 R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC,
2135 R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21,
2136 R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC,
2137 R_AARCH64_TLSIE_LD_GOTTPREL_PREL19,
2138 R_AARCH64_TLSLE_MOVW_TPREL_G2,
2139 R_AARCH64_TLSLE_MOVW_TPREL_G1,
2140 R_AARCH64_TLSLE_MOVW_TPREL_G1_NC,
2141 R_AARCH64_TLSLE_MOVW_TPREL_G0,
2142 R_AARCH64_TLSLE_MOVW_TPREL_G0_NC,
2143 R_AARCH64_TLSLE_ADD_TPREL_HI12,
2144 R_AARCH64_TLSLE_ADD_TPREL_LO12,
2145 R_AARCH64_TLSLE_ADD_TPREL_LO12_NC,
2146 R_AARCH64_TLSLE_LDST8_TPREL_LO12,
2147 R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC,
2148 R_AARCH64_TLSLE_LDST16_TPREL_LO12,
2149 R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC,
2150 R_AARCH64_TLSLE_LDST32_TPREL_LO12,
2151 R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC,
2152 R_AARCH64_TLSLE_LDST64_TPREL_LO12,
2153 R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC,
2154 R_AARCH64_TLSDESC_LD_PREL19,
2155 R_AARCH64_TLSDESC_ADR_PREL21,
2156 R_AARCH64_TLSDESC_ADR_PAGE21,
2157 R_AARCH64_TLSDESC_LD64_LO12,
2158 R_AARCH64_TLSDESC_ADD_LO12,
2159 R_AARCH64_TLSDESC_OFF_G1,
2160 R_AARCH64_TLSDESC_OFF_G0_NC,
2161 R_AARCH64_TLSDESC_LDR,
2162 R_AARCH64_TLSDESC_ADD,
2163 R_AARCH64_TLSDESC_CALL,
2164 R_AARCH64_TLSLE_LDST128_TPREL_LO12,
2165 R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC,
2166 R_AARCH64_TLSLD_LDST128_DTPREL_LO12,
2167 R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC,
2168 R_AARCH64_COPY,
2169 R_AARCH64_GLOB_DAT,
2170 R_AARCH64_JUMP_SLOT,
2171 R_AARCH64_RELATIVE,
2172 R_AARCH64_TLS_DTPMOD,
2173 R_AARCH64_TLS_DTPREL,
2174 R_AARCH64_TLS_TPREL,
2175 R_AARCH64_TLSDESC,
2176 R_AARCH64_IRELATIVE,
2177 );
2178 static FLAGS_R_ARM: &[Flag<u32>] = &flags!(
2179 R_ARM_NONE,
2180 R_ARM_PC24,
2181 R_ARM_ABS32,
2182 R_ARM_REL32,
2183 R_ARM_PC13,
2184 R_ARM_ABS16,
2185 R_ARM_ABS12,
2186 R_ARM_THM_ABS5,
2187 R_ARM_ABS8,
2188 R_ARM_SBREL32,
2189 R_ARM_THM_PC22,
2190 R_ARM_THM_PC8,
2191 R_ARM_AMP_VCALL9,
2192 R_ARM_SWI24,
2193 R_ARM_TLS_DESC,
2194 R_ARM_THM_SWI8,
2195 R_ARM_XPC25,
2196 R_ARM_THM_XPC22,
2197 R_ARM_TLS_DTPMOD32,
2198 R_ARM_TLS_DTPOFF32,
2199 R_ARM_TLS_TPOFF32,
2200 R_ARM_COPY,
2201 R_ARM_GLOB_DAT,
2202 R_ARM_JUMP_SLOT,
2203 R_ARM_RELATIVE,
2204 R_ARM_GOTOFF,
2205 R_ARM_GOTPC,
2206 R_ARM_GOT32,
2207 R_ARM_PLT32,
2208 R_ARM_CALL,
2209 R_ARM_JUMP24,
2210 R_ARM_THM_JUMP24,
2211 R_ARM_BASE_ABS,
2212 R_ARM_ALU_PCREL_7_0,
2213 R_ARM_ALU_PCREL_15_8,
2214 R_ARM_ALU_PCREL_23_15,
2215 R_ARM_LDR_SBREL_11_0,
2216 R_ARM_ALU_SBREL_19_12,
2217 R_ARM_ALU_SBREL_27_20,
2218 R_ARM_TARGET1,
2219 R_ARM_SBREL31,
2220 R_ARM_V4BX,
2221 R_ARM_TARGET2,
2222 R_ARM_PREL31,
2223 R_ARM_MOVW_ABS_NC,
2224 R_ARM_MOVT_ABS,
2225 R_ARM_MOVW_PREL_NC,
2226 R_ARM_MOVT_PREL,
2227 R_ARM_THM_MOVW_ABS_NC,
2228 R_ARM_THM_MOVT_ABS,
2229 R_ARM_THM_MOVW_PREL_NC,
2230 R_ARM_THM_MOVT_PREL,
2231 R_ARM_THM_JUMP19,
2232 R_ARM_THM_JUMP6,
2233 R_ARM_THM_ALU_PREL_11_0,
2234 R_ARM_THM_PC12,
2235 R_ARM_ABS32_NOI,
2236 R_ARM_REL32_NOI,
2237 R_ARM_ALU_PC_G0_NC,
2238 R_ARM_ALU_PC_G0,
2239 R_ARM_ALU_PC_G1_NC,
2240 R_ARM_ALU_PC_G1,
2241 R_ARM_ALU_PC_G2,
2242 R_ARM_LDR_PC_G1,
2243 R_ARM_LDR_PC_G2,
2244 R_ARM_LDRS_PC_G0,
2245 R_ARM_LDRS_PC_G1,
2246 R_ARM_LDRS_PC_G2,
2247 R_ARM_LDC_PC_G0,
2248 R_ARM_LDC_PC_G1,
2249 R_ARM_LDC_PC_G2,
2250 R_ARM_ALU_SB_G0_NC,
2251 R_ARM_ALU_SB_G0,
2252 R_ARM_ALU_SB_G1_NC,
2253 R_ARM_ALU_SB_G1,
2254 R_ARM_ALU_SB_G2,
2255 R_ARM_LDR_SB_G0,
2256 R_ARM_LDR_SB_G1,
2257 R_ARM_LDR_SB_G2,
2258 R_ARM_LDRS_SB_G0,
2259 R_ARM_LDRS_SB_G1,
2260 R_ARM_LDRS_SB_G2,
2261 R_ARM_LDC_SB_G0,
2262 R_ARM_LDC_SB_G1,
2263 R_ARM_LDC_SB_G2,
2264 R_ARM_MOVW_BREL_NC,
2265 R_ARM_MOVT_BREL,
2266 R_ARM_MOVW_BREL,
2267 R_ARM_THM_MOVW_BREL_NC,
2268 R_ARM_THM_MOVT_BREL,
2269 R_ARM_THM_MOVW_BREL,
2270 R_ARM_TLS_GOTDESC,
2271 R_ARM_TLS_CALL,
2272 R_ARM_TLS_DESCSEQ,
2273 R_ARM_THM_TLS_CALL,
2274 R_ARM_PLT32_ABS,
2275 R_ARM_GOT_ABS,
2276 R_ARM_GOT_PREL,
2277 R_ARM_GOT_BREL12,
2278 R_ARM_GOTOFF12,
2279 R_ARM_GOTRELAX,
2280 R_ARM_GNU_VTENTRY,
2281 R_ARM_GNU_VTINHERIT,
2282 R_ARM_THM_PC11,
2283 R_ARM_THM_PC9,
2284 R_ARM_TLS_GD32,
2285 R_ARM_TLS_LDM32,
2286 R_ARM_TLS_LDO32,
2287 R_ARM_TLS_IE32,
2288 R_ARM_TLS_LE32,
2289 R_ARM_TLS_LDO12,
2290 R_ARM_TLS_LE12,
2291 R_ARM_TLS_IE12GP,
2292 R_ARM_ME_TOO,
2293 R_ARM_THM_TLS_DESCSEQ,
2294 R_ARM_THM_TLS_DESCSEQ16,
2295 R_ARM_THM_TLS_DESCSEQ32,
2296 R_ARM_THM_GOT_BREL12,
2297 R_ARM_IRELATIVE,
2298 R_ARM_RXPC25,
2299 R_ARM_RSBREL32,
2300 R_ARM_THM_RPC22,
2301 R_ARM_RREL32,
2302 R_ARM_RABS22,
2303 R_ARM_RPC24,
2304 R_ARM_RBASE,
2305 );
2306 static FLAGS_R_CKCORE: &[Flag<u32>] = &flags!(
2307 R_CKCORE_NONE,
2308 R_CKCORE_ADDR32,
2309 R_CKCORE_PCRELIMM8BY4,
2310 R_CKCORE_PCRELIMM11BY2,
2311 R_CKCORE_PCREL32,
2312 R_CKCORE_PCRELJSR_IMM11BY2,
2313 R_CKCORE_RELATIVE,
2314 R_CKCORE_COPY,
2315 R_CKCORE_GLOB_DAT,
2316 R_CKCORE_JUMP_SLOT,
2317 R_CKCORE_GOTOFF,
2318 R_CKCORE_GOTPC,
2319 R_CKCORE_GOT32,
2320 R_CKCORE_PLT32,
2321 R_CKCORE_ADDRGOT,
2322 R_CKCORE_ADDRPLT,
2323 R_CKCORE_PCREL_IMM26BY2,
2324 R_CKCORE_PCREL_IMM16BY2,
2325 R_CKCORE_PCREL_IMM16BY4,
2326 R_CKCORE_PCREL_IMM10BY2,
2327 R_CKCORE_PCREL_IMM10BY4,
2328 R_CKCORE_ADDR_HI16,
2329 R_CKCORE_ADDR_LO16,
2330 R_CKCORE_GOTPC_HI16,
2331 R_CKCORE_GOTPC_LO16,
2332 R_CKCORE_GOTOFF_HI16,
2333 R_CKCORE_GOTOFF_LO16,
2334 R_CKCORE_GOT12,
2335 R_CKCORE_GOT_HI16,
2336 R_CKCORE_GOT_LO16,
2337 R_CKCORE_PLT12,
2338 R_CKCORE_PLT_HI16,
2339 R_CKCORE_PLT_LO16,
2340 R_CKCORE_ADDRGOT_HI16,
2341 R_CKCORE_ADDRGOT_LO16,
2342 R_CKCORE_ADDRPLT_HI16,
2343 R_CKCORE_ADDRPLT_LO16,
2344 R_CKCORE_PCREL_JSR_IMM26BY2,
2345 R_CKCORE_TOFFSET_LO16,
2346 R_CKCORE_DOFFSET_LO16,
2347 R_CKCORE_PCREL_IMM18BY2,
2348 R_CKCORE_DOFFSET_IMM18,
2349 R_CKCORE_DOFFSET_IMM18BY2,
2350 R_CKCORE_DOFFSET_IMM18BY4,
2351 R_CKCORE_GOT_IMM18BY4,
2352 R_CKCORE_PLT_IMM18BY4,
2353 R_CKCORE_PCREL_IMM7BY4,
2354 R_CKCORE_TLS_LE32,
2355 R_CKCORE_TLS_IE32,
2356 R_CKCORE_TLS_GD32,
2357 R_CKCORE_TLS_LDM32,
2358 R_CKCORE_TLS_LDO32,
2359 R_CKCORE_TLS_DTPMOD32,
2360 R_CKCORE_TLS_DTPOFF32,
2361 R_CKCORE_TLS_TPOFF32,
2362 );
2363 static FLAGS_R_IA64: &[Flag<u32>] = &flags!(
2364 R_IA64_NONE,
2365 R_IA64_IMM14,
2366 R_IA64_IMM22,
2367 R_IA64_IMM64,
2368 R_IA64_DIR32MSB,
2369 R_IA64_DIR32LSB,
2370 R_IA64_DIR64MSB,
2371 R_IA64_DIR64LSB,
2372 R_IA64_GPREL22,
2373 R_IA64_GPREL64I,
2374 R_IA64_GPREL32MSB,
2375 R_IA64_GPREL32LSB,
2376 R_IA64_GPREL64MSB,
2377 R_IA64_GPREL64LSB,
2378 R_IA64_LTOFF22,
2379 R_IA64_LTOFF64I,
2380 R_IA64_PLTOFF22,
2381 R_IA64_PLTOFF64I,
2382 R_IA64_PLTOFF64MSB,
2383 R_IA64_PLTOFF64LSB,
2384 R_IA64_FPTR64I,
2385 R_IA64_FPTR32MSB,
2386 R_IA64_FPTR32LSB,
2387 R_IA64_FPTR64MSB,
2388 R_IA64_FPTR64LSB,
2389 R_IA64_PCREL60B,
2390 R_IA64_PCREL21B,
2391 R_IA64_PCREL21M,
2392 R_IA64_PCREL21F,
2393 R_IA64_PCREL32MSB,
2394 R_IA64_PCREL32LSB,
2395 R_IA64_PCREL64MSB,
2396 R_IA64_PCREL64LSB,
2397 R_IA64_LTOFF_FPTR22,
2398 R_IA64_LTOFF_FPTR64I,
2399 R_IA64_LTOFF_FPTR32MSB,
2400 R_IA64_LTOFF_FPTR32LSB,
2401 R_IA64_LTOFF_FPTR64MSB,
2402 R_IA64_LTOFF_FPTR64LSB,
2403 R_IA64_SEGREL32MSB,
2404 R_IA64_SEGREL32LSB,
2405 R_IA64_SEGREL64MSB,
2406 R_IA64_SEGREL64LSB,
2407 R_IA64_SECREL32MSB,
2408 R_IA64_SECREL32LSB,
2409 R_IA64_SECREL64MSB,
2410 R_IA64_SECREL64LSB,
2411 R_IA64_REL32MSB,
2412 R_IA64_REL32LSB,
2413 R_IA64_REL64MSB,
2414 R_IA64_REL64LSB,
2415 R_IA64_LTV32MSB,
2416 R_IA64_LTV32LSB,
2417 R_IA64_LTV64MSB,
2418 R_IA64_LTV64LSB,
2419 R_IA64_PCREL21BI,
2420 R_IA64_PCREL22,
2421 R_IA64_PCREL64I,
2422 R_IA64_IPLTMSB,
2423 R_IA64_IPLTLSB,
2424 R_IA64_COPY,
2425 R_IA64_SUB,
2426 R_IA64_LTOFF22X,
2427 R_IA64_LDXMOV,
2428 R_IA64_TPREL14,
2429 R_IA64_TPREL22,
2430 R_IA64_TPREL64I,
2431 R_IA64_TPREL64MSB,
2432 R_IA64_TPREL64LSB,
2433 R_IA64_LTOFF_TPREL22,
2434 R_IA64_DTPMOD64MSB,
2435 R_IA64_DTPMOD64LSB,
2436 R_IA64_LTOFF_DTPMOD22,
2437 R_IA64_DTPREL14,
2438 R_IA64_DTPREL22,
2439 R_IA64_DTPREL64I,
2440 R_IA64_DTPREL32MSB,
2441 R_IA64_DTPREL32LSB,
2442 R_IA64_DTPREL64MSB,
2443 R_IA64_DTPREL64LSB,
2444 R_IA64_LTOFF_DTPREL22,
2445 );
2446 static FLAGS_R_SH: &[Flag<u32>] = &flags!(
2447 R_SH_NONE,
2448 R_SH_DIR32,
2449 R_SH_REL32,
2450 R_SH_DIR8WPN,
2451 R_SH_IND12W,
2452 R_SH_DIR8WPL,
2453 R_SH_DIR8WPZ,
2454 R_SH_DIR8BP,
2455 R_SH_DIR8W,
2456 R_SH_DIR8L,
2457 R_SH_SWITCH16,
2458 R_SH_SWITCH32,
2459 R_SH_USES,
2460 R_SH_COUNT,
2461 R_SH_ALIGN,
2462 R_SH_CODE,
2463 R_SH_DATA,
2464 R_SH_LABEL,
2465 R_SH_SWITCH8,
2466 R_SH_GNU_VTINHERIT,
2467 R_SH_GNU_VTENTRY,
2468 R_SH_TLS_GD_32,
2469 R_SH_TLS_LD_32,
2470 R_SH_TLS_LDO_32,
2471 R_SH_TLS_IE_32,
2472 R_SH_TLS_LE_32,
2473 R_SH_TLS_DTPMOD32,
2474 R_SH_TLS_DTPOFF32,
2475 R_SH_TLS_TPOFF32,
2476 R_SH_GOT32,
2477 R_SH_PLT32,
2478 R_SH_COPY,
2479 R_SH_GLOB_DAT,
2480 R_SH_JMP_SLOT,
2481 R_SH_RELATIVE,
2482 R_SH_GOTOFF,
2483 R_SH_GOTPC,
2484 );
2485 static FLAGS_R_390: &[Flag<u32>] = &flags!(
2486 R_390_NONE,
2487 R_390_8,
2488 R_390_12,
2489 R_390_16,
2490 R_390_32,
2491 R_390_PC32,
2492 R_390_GOT12,
2493 R_390_GOT32,
2494 R_390_PLT32,
2495 R_390_COPY,
2496 R_390_GLOB_DAT,
2497 R_390_JMP_SLOT,
2498 R_390_RELATIVE,
2499 R_390_GOTOFF32,
2500 R_390_GOTPC,
2501 R_390_GOT16,
2502 R_390_PC16,
2503 R_390_PC16DBL,
2504 R_390_PLT16DBL,
2505 R_390_PC32DBL,
2506 R_390_PLT32DBL,
2507 R_390_GOTPCDBL,
2508 R_390_64,
2509 R_390_PC64,
2510 R_390_GOT64,
2511 R_390_PLT64,
2512 R_390_GOTENT,
2513 R_390_GOTOFF16,
2514 R_390_GOTOFF64,
2515 R_390_GOTPLT12,
2516 R_390_GOTPLT16,
2517 R_390_GOTPLT32,
2518 R_390_GOTPLT64,
2519 R_390_GOTPLTENT,
2520 R_390_PLTOFF16,
2521 R_390_PLTOFF32,
2522 R_390_PLTOFF64,
2523 R_390_TLS_LOAD,
2524 R_390_TLS_GDCALL,
2525 R_390_TLS_LDCALL,
2526 R_390_TLS_GD32,
2527 R_390_TLS_GD64,
2528 R_390_TLS_GOTIE12,
2529 R_390_TLS_GOTIE32,
2530 R_390_TLS_GOTIE64,
2531 R_390_TLS_LDM32,
2532 R_390_TLS_LDM64,
2533 R_390_TLS_IE32,
2534 R_390_TLS_IE64,
2535 R_390_TLS_IEENT,
2536 R_390_TLS_LE32,
2537 R_390_TLS_LE64,
2538 R_390_TLS_LDO32,
2539 R_390_TLS_LDO64,
2540 R_390_TLS_DTPMOD,
2541 R_390_TLS_DTPOFF,
2542 R_390_TLS_TPOFF,
2543 R_390_20,
2544 R_390_GOT20,
2545 R_390_GOTPLT20,
2546 R_390_TLS_GOTIE20,
2547 R_390_IRELATIVE,
2548 );
2549 static FLAGS_R_CRIS: &[Flag<u32>] = &flags!(
2550 R_CRIS_NONE,
2551 R_CRIS_8,
2552 R_CRIS_16,
2553 R_CRIS_32,
2554 R_CRIS_8_PCREL,
2555 R_CRIS_16_PCREL,
2556 R_CRIS_32_PCREL,
2557 R_CRIS_GNU_VTINHERIT,
2558 R_CRIS_GNU_VTENTRY,
2559 R_CRIS_COPY,
2560 R_CRIS_GLOB_DAT,
2561 R_CRIS_JUMP_SLOT,
2562 R_CRIS_RELATIVE,
2563 R_CRIS_16_GOT,
2564 R_CRIS_32_GOT,
2565 R_CRIS_16_GOTPLT,
2566 R_CRIS_32_GOTPLT,
2567 R_CRIS_32_GOTREL,
2568 R_CRIS_32_PLT_GOTREL,
2569 R_CRIS_32_PLT_PCREL,
2570 );
2571 static FLAGS_R_X86_64: &[Flag<u32>] = &flags!(
2572 R_X86_64_NONE,
2573 R_X86_64_64,
2574 R_X86_64_PC32,
2575 R_X86_64_GOT32,
2576 R_X86_64_PLT32,
2577 R_X86_64_COPY,
2578 R_X86_64_GLOB_DAT,
2579 R_X86_64_JUMP_SLOT,
2580 R_X86_64_RELATIVE,
2581 R_X86_64_GOTPCREL,
2582 R_X86_64_32,
2583 R_X86_64_32S,
2584 R_X86_64_16,
2585 R_X86_64_PC16,
2586 R_X86_64_8,
2587 R_X86_64_PC8,
2588 R_X86_64_DTPMOD64,
2589 R_X86_64_DTPOFF64,
2590 R_X86_64_TPOFF64,
2591 R_X86_64_TLSGD,
2592 R_X86_64_TLSLD,
2593 R_X86_64_DTPOFF32,
2594 R_X86_64_GOTTPOFF,
2595 R_X86_64_TPOFF32,
2596 R_X86_64_PC64,
2597 R_X86_64_GOTOFF64,
2598 R_X86_64_GOTPC32,
2599 R_X86_64_GOT64,
2600 R_X86_64_GOTPCREL64,
2601 R_X86_64_GOTPC64,
2602 R_X86_64_GOTPLT64,
2603 R_X86_64_PLTOFF64,
2604 R_X86_64_SIZE32,
2605 R_X86_64_SIZE64,
2606 R_X86_64_GOTPC32_TLSDESC,
2607 R_X86_64_TLSDESC_CALL,
2608 R_X86_64_TLSDESC,
2609 R_X86_64_IRELATIVE,
2610 R_X86_64_RELATIVE64,
2611 R_X86_64_GOTPCRELX,
2612 R_X86_64_REX_GOTPCRELX,
2613 );
2614 static FLAGS_R_MN10300: &[Flag<u32>] = &flags!(
2615 R_MN10300_NONE,
2616 R_MN10300_32,
2617 R_MN10300_16,
2618 R_MN10300_8,
2619 R_MN10300_PCREL32,
2620 R_MN10300_PCREL16,
2621 R_MN10300_PCREL8,
2622 R_MN10300_GNU_VTINHERIT,
2623 R_MN10300_GNU_VTENTRY,
2624 R_MN10300_24,
2625 R_MN10300_GOTPC32,
2626 R_MN10300_GOTPC16,
2627 R_MN10300_GOTOFF32,
2628 R_MN10300_GOTOFF24,
2629 R_MN10300_GOTOFF16,
2630 R_MN10300_PLT32,
2631 R_MN10300_PLT16,
2632 R_MN10300_GOT32,
2633 R_MN10300_GOT24,
2634 R_MN10300_GOT16,
2635 R_MN10300_COPY,
2636 R_MN10300_GLOB_DAT,
2637 R_MN10300_JMP_SLOT,
2638 R_MN10300_RELATIVE,
2639 R_MN10300_TLS_GD,
2640 R_MN10300_TLS_LD,
2641 R_MN10300_TLS_LDO,
2642 R_MN10300_TLS_GOTIE,
2643 R_MN10300_TLS_IE,
2644 R_MN10300_TLS_LE,
2645 R_MN10300_TLS_DTPMOD,
2646 R_MN10300_TLS_DTPOFF,
2647 R_MN10300_TLS_TPOFF,
2648 R_MN10300_SYM_DIFF,
2649 R_MN10300_ALIGN,
2650 );
2651 static FLAGS_R_M32R: &[Flag<u32>] = &flags!(
2652 R_M32R_NONE,
2653 R_M32R_16,
2654 R_M32R_32,
2655 R_M32R_24,
2656 R_M32R_10_PCREL,
2657 R_M32R_18_PCREL,
2658 R_M32R_26_PCREL,
2659 R_M32R_HI16_ULO,
2660 R_M32R_HI16_SLO,
2661 R_M32R_LO16,
2662 R_M32R_SDA16,
2663 R_M32R_GNU_VTINHERIT,
2664 R_M32R_GNU_VTENTRY,
2665 R_M32R_16_RELA,
2666 R_M32R_32_RELA,
2667 R_M32R_24_RELA,
2668 R_M32R_10_PCREL_RELA,
2669 R_M32R_18_PCREL_RELA,
2670 R_M32R_26_PCREL_RELA,
2671 R_M32R_HI16_ULO_RELA,
2672 R_M32R_HI16_SLO_RELA,
2673 R_M32R_LO16_RELA,
2674 R_M32R_SDA16_RELA,
2675 R_M32R_RELA_GNU_VTINHERIT,
2676 R_M32R_RELA_GNU_VTENTRY,
2677 R_M32R_REL32,
2678 R_M32R_GOT24,
2679 R_M32R_26_PLTREL,
2680 R_M32R_COPY,
2681 R_M32R_GLOB_DAT,
2682 R_M32R_JMP_SLOT,
2683 R_M32R_RELATIVE,
2684 R_M32R_GOTOFF,
2685 R_M32R_GOTPC24,
2686 R_M32R_GOT16_HI_ULO,
2687 R_M32R_GOT16_HI_SLO,
2688 R_M32R_GOT16_LO,
2689 R_M32R_GOTPC_HI_ULO,
2690 R_M32R_GOTPC_HI_SLO,
2691 R_M32R_GOTPC_LO,
2692 R_M32R_GOTOFF_HI_ULO,
2693 R_M32R_GOTOFF_HI_SLO,
2694 R_M32R_GOTOFF_LO,
2695 R_M32R_NUM,
2696 );
2697 static FLAGS_R_MICROBLAZE: &[Flag<u32>] = &flags!(
2698 R_MICROBLAZE_NONE,
2699 R_MICROBLAZE_32,
2700 R_MICROBLAZE_32_PCREL,
2701 R_MICROBLAZE_64_PCREL,
2702 R_MICROBLAZE_32_PCREL_LO,
2703 R_MICROBLAZE_64,
2704 R_MICROBLAZE_32_LO,
2705 R_MICROBLAZE_SRO32,
2706 R_MICROBLAZE_SRW32,
2707 R_MICROBLAZE_64_NONE,
2708 R_MICROBLAZE_32_SYM_OP_SYM,
2709 R_MICROBLAZE_GNU_VTINHERIT,
2710 R_MICROBLAZE_GNU_VTENTRY,
2711 R_MICROBLAZE_GOTPC_64,
2712 R_MICROBLAZE_GOT_64,
2713 R_MICROBLAZE_PLT_64,
2714 R_MICROBLAZE_REL,
2715 R_MICROBLAZE_JUMP_SLOT,
2716 R_MICROBLAZE_GLOB_DAT,
2717 R_MICROBLAZE_GOTOFF_64,
2718 R_MICROBLAZE_GOTOFF_32,
2719 R_MICROBLAZE_COPY,
2720 R_MICROBLAZE_TLS,
2721 R_MICROBLAZE_TLSGD,
2722 R_MICROBLAZE_TLSLD,
2723 R_MICROBLAZE_TLSDTPMOD32,
2724 R_MICROBLAZE_TLSDTPREL32,
2725 R_MICROBLAZE_TLSDTPREL64,
2726 R_MICROBLAZE_TLSGOTTPREL32,
2727 R_MICROBLAZE_TLSTPREL32,
2728 );
2729 static FLAGS_R_NIOS2: &[Flag<u32>] = &flags!(
2730 R_NIOS2_NONE,
2731 R_NIOS2_S16,
2732 R_NIOS2_U16,
2733 R_NIOS2_PCREL16,
2734 R_NIOS2_CALL26,
2735 R_NIOS2_IMM5,
2736 R_NIOS2_CACHE_OPX,
2737 R_NIOS2_IMM6,
2738 R_NIOS2_IMM8,
2739 R_NIOS2_HI16,
2740 R_NIOS2_LO16,
2741 R_NIOS2_HIADJ16,
2742 R_NIOS2_BFD_RELOC_32,
2743 R_NIOS2_BFD_RELOC_16,
2744 R_NIOS2_BFD_RELOC_8,
2745 R_NIOS2_GPREL,
2746 R_NIOS2_GNU_VTINHERIT,
2747 R_NIOS2_GNU_VTENTRY,
2748 R_NIOS2_UJMP,
2749 R_NIOS2_CJMP,
2750 R_NIOS2_CALLR,
2751 R_NIOS2_ALIGN,
2752 R_NIOS2_GOT16,
2753 R_NIOS2_CALL16,
2754 R_NIOS2_GOTOFF_LO,
2755 R_NIOS2_GOTOFF_HA,
2756 R_NIOS2_PCREL_LO,
2757 R_NIOS2_PCREL_HA,
2758 R_NIOS2_TLS_GD16,
2759 R_NIOS2_TLS_LDM16,
2760 R_NIOS2_TLS_LDO16,
2761 R_NIOS2_TLS_IE16,
2762 R_NIOS2_TLS_LE16,
2763 R_NIOS2_TLS_DTPMOD,
2764 R_NIOS2_TLS_DTPREL,
2765 R_NIOS2_TLS_TPREL,
2766 R_NIOS2_COPY,
2767 R_NIOS2_GLOB_DAT,
2768 R_NIOS2_JUMP_SLOT,
2769 R_NIOS2_RELATIVE,
2770 R_NIOS2_GOTOFF,
2771 R_NIOS2_CALL26_NOAT,
2772 R_NIOS2_GOT_LO,
2773 R_NIOS2_GOT_HA,
2774 R_NIOS2_CALL_LO,
2775 R_NIOS2_CALL_HA,
2776 );
2777 static FLAGS_R_TILEPRO: &[Flag<u32>] = &flags!(
2778 R_TILEPRO_NONE,
2779 R_TILEPRO_32,
2780 R_TILEPRO_16,
2781 R_TILEPRO_8,
2782 R_TILEPRO_32_PCREL,
2783 R_TILEPRO_16_PCREL,
2784 R_TILEPRO_8_PCREL,
2785 R_TILEPRO_LO16,
2786 R_TILEPRO_HI16,
2787 R_TILEPRO_HA16,
2788 R_TILEPRO_COPY,
2789 R_TILEPRO_GLOB_DAT,
2790 R_TILEPRO_JMP_SLOT,
2791 R_TILEPRO_RELATIVE,
2792 R_TILEPRO_BROFF_X1,
2793 R_TILEPRO_JOFFLONG_X1,
2794 R_TILEPRO_JOFFLONG_X1_PLT,
2795 R_TILEPRO_IMM8_X0,
2796 R_TILEPRO_IMM8_Y0,
2797 R_TILEPRO_IMM8_X1,
2798 R_TILEPRO_IMM8_Y1,
2799 R_TILEPRO_MT_IMM15_X1,
2800 R_TILEPRO_MF_IMM15_X1,
2801 R_TILEPRO_IMM16_X0,
2802 R_TILEPRO_IMM16_X1,
2803 R_TILEPRO_IMM16_X0_LO,
2804 R_TILEPRO_IMM16_X1_LO,
2805 R_TILEPRO_IMM16_X0_HI,
2806 R_TILEPRO_IMM16_X1_HI,
2807 R_TILEPRO_IMM16_X0_HA,
2808 R_TILEPRO_IMM16_X1_HA,
2809 R_TILEPRO_IMM16_X0_PCREL,
2810 R_TILEPRO_IMM16_X1_PCREL,
2811 R_TILEPRO_IMM16_X0_LO_PCREL,
2812 R_TILEPRO_IMM16_X1_LO_PCREL,
2813 R_TILEPRO_IMM16_X0_HI_PCREL,
2814 R_TILEPRO_IMM16_X1_HI_PCREL,
2815 R_TILEPRO_IMM16_X0_HA_PCREL,
2816 R_TILEPRO_IMM16_X1_HA_PCREL,
2817 R_TILEPRO_IMM16_X0_GOT,
2818 R_TILEPRO_IMM16_X1_GOT,
2819 R_TILEPRO_IMM16_X0_GOT_LO,
2820 R_TILEPRO_IMM16_X1_GOT_LO,
2821 R_TILEPRO_IMM16_X0_GOT_HI,
2822 R_TILEPRO_IMM16_X1_GOT_HI,
2823 R_TILEPRO_IMM16_X0_GOT_HA,
2824 R_TILEPRO_IMM16_X1_GOT_HA,
2825 R_TILEPRO_MMSTART_X0,
2826 R_TILEPRO_MMEND_X0,
2827 R_TILEPRO_MMSTART_X1,
2828 R_TILEPRO_MMEND_X1,
2829 R_TILEPRO_SHAMT_X0,
2830 R_TILEPRO_SHAMT_X1,
2831 R_TILEPRO_SHAMT_Y0,
2832 R_TILEPRO_SHAMT_Y1,
2833 R_TILEPRO_DEST_IMM8_X1,
2834 R_TILEPRO_TLS_GD_CALL,
2835 R_TILEPRO_IMM8_X0_TLS_GD_ADD,
2836 R_TILEPRO_IMM8_X1_TLS_GD_ADD,
2837 R_TILEPRO_IMM8_Y0_TLS_GD_ADD,
2838 R_TILEPRO_IMM8_Y1_TLS_GD_ADD,
2839 R_TILEPRO_TLS_IE_LOAD,
2840 R_TILEPRO_IMM16_X0_TLS_GD,
2841 R_TILEPRO_IMM16_X1_TLS_GD,
2842 R_TILEPRO_IMM16_X0_TLS_GD_LO,
2843 R_TILEPRO_IMM16_X1_TLS_GD_LO,
2844 R_TILEPRO_IMM16_X0_TLS_GD_HI,
2845 R_TILEPRO_IMM16_X1_TLS_GD_HI,
2846 R_TILEPRO_IMM16_X0_TLS_GD_HA,
2847 R_TILEPRO_IMM16_X1_TLS_GD_HA,
2848 R_TILEPRO_IMM16_X0_TLS_IE,
2849 R_TILEPRO_IMM16_X1_TLS_IE,
2850 R_TILEPRO_IMM16_X0_TLS_IE_LO,
2851 R_TILEPRO_IMM16_X1_TLS_IE_LO,
2852 R_TILEPRO_IMM16_X0_TLS_IE_HI,
2853 R_TILEPRO_IMM16_X1_TLS_IE_HI,
2854 R_TILEPRO_IMM16_X0_TLS_IE_HA,
2855 R_TILEPRO_IMM16_X1_TLS_IE_HA,
2856 R_TILEPRO_TLS_DTPMOD32,
2857 R_TILEPRO_TLS_DTPOFF32,
2858 R_TILEPRO_TLS_TPOFF32,
2859 R_TILEPRO_IMM16_X0_TLS_LE,
2860 R_TILEPRO_IMM16_X1_TLS_LE,
2861 R_TILEPRO_IMM16_X0_TLS_LE_LO,
2862 R_TILEPRO_IMM16_X1_TLS_LE_LO,
2863 R_TILEPRO_IMM16_X0_TLS_LE_HI,
2864 R_TILEPRO_IMM16_X1_TLS_LE_HI,
2865 R_TILEPRO_IMM16_X0_TLS_LE_HA,
2866 R_TILEPRO_IMM16_X1_TLS_LE_HA,
2867 R_TILEPRO_GNU_VTINHERIT,
2868 R_TILEPRO_GNU_VTENTRY,
2869 );
2870 static FLAGS_R_TILEGX: &[Flag<u32>] = &flags!(
2871 R_TILEGX_NONE,
2872 R_TILEGX_64,
2873 R_TILEGX_32,
2874 R_TILEGX_16,
2875 R_TILEGX_8,
2876 R_TILEGX_64_PCREL,
2877 R_TILEGX_32_PCREL,
2878 R_TILEGX_16_PCREL,
2879 R_TILEGX_8_PCREL,
2880 R_TILEGX_HW0,
2881 R_TILEGX_HW1,
2882 R_TILEGX_HW2,
2883 R_TILEGX_HW3,
2884 R_TILEGX_HW0_LAST,
2885 R_TILEGX_HW1_LAST,
2886 R_TILEGX_HW2_LAST,
2887 R_TILEGX_COPY,
2888 R_TILEGX_GLOB_DAT,
2889 R_TILEGX_JMP_SLOT,
2890 R_TILEGX_RELATIVE,
2891 R_TILEGX_BROFF_X1,
2892 R_TILEGX_JUMPOFF_X1,
2893 R_TILEGX_JUMPOFF_X1_PLT,
2894 R_TILEGX_IMM8_X0,
2895 R_TILEGX_IMM8_Y0,
2896 R_TILEGX_IMM8_X1,
2897 R_TILEGX_IMM8_Y1,
2898 R_TILEGX_DEST_IMM8_X1,
2899 R_TILEGX_MT_IMM14_X1,
2900 R_TILEGX_MF_IMM14_X1,
2901 R_TILEGX_MMSTART_X0,
2902 R_TILEGX_MMEND_X0,
2903 R_TILEGX_SHAMT_X0,
2904 R_TILEGX_SHAMT_X1,
2905 R_TILEGX_SHAMT_Y0,
2906 R_TILEGX_SHAMT_Y1,
2907 R_TILEGX_IMM16_X0_HW0,
2908 R_TILEGX_IMM16_X1_HW0,
2909 R_TILEGX_IMM16_X0_HW1,
2910 R_TILEGX_IMM16_X1_HW1,
2911 R_TILEGX_IMM16_X0_HW2,
2912 R_TILEGX_IMM16_X1_HW2,
2913 R_TILEGX_IMM16_X0_HW3,
2914 R_TILEGX_IMM16_X1_HW3,
2915 R_TILEGX_IMM16_X0_HW0_LAST,
2916 R_TILEGX_IMM16_X1_HW0_LAST,
2917 R_TILEGX_IMM16_X0_HW1_LAST,
2918 R_TILEGX_IMM16_X1_HW1_LAST,
2919 R_TILEGX_IMM16_X0_HW2_LAST,
2920 R_TILEGX_IMM16_X1_HW2_LAST,
2921 R_TILEGX_IMM16_X0_HW0_PCREL,
2922 R_TILEGX_IMM16_X1_HW0_PCREL,
2923 R_TILEGX_IMM16_X0_HW1_PCREL,
2924 R_TILEGX_IMM16_X1_HW1_PCREL,
2925 R_TILEGX_IMM16_X0_HW2_PCREL,
2926 R_TILEGX_IMM16_X1_HW2_PCREL,
2927 R_TILEGX_IMM16_X0_HW3_PCREL,
2928 R_TILEGX_IMM16_X1_HW3_PCREL,
2929 R_TILEGX_IMM16_X0_HW0_LAST_PCREL,
2930 R_TILEGX_IMM16_X1_HW0_LAST_PCREL,
2931 R_TILEGX_IMM16_X0_HW1_LAST_PCREL,
2932 R_TILEGX_IMM16_X1_HW1_LAST_PCREL,
2933 R_TILEGX_IMM16_X0_HW2_LAST_PCREL,
2934 R_TILEGX_IMM16_X1_HW2_LAST_PCREL,
2935 R_TILEGX_IMM16_X0_HW0_GOT,
2936 R_TILEGX_IMM16_X1_HW0_GOT,
2937 R_TILEGX_IMM16_X0_HW0_PLT_PCREL,
2938 R_TILEGX_IMM16_X1_HW0_PLT_PCREL,
2939 R_TILEGX_IMM16_X0_HW1_PLT_PCREL,
2940 R_TILEGX_IMM16_X1_HW1_PLT_PCREL,
2941 R_TILEGX_IMM16_X0_HW2_PLT_PCREL,
2942 R_TILEGX_IMM16_X1_HW2_PLT_PCREL,
2943 R_TILEGX_IMM16_X0_HW0_LAST_GOT,
2944 R_TILEGX_IMM16_X1_HW0_LAST_GOT,
2945 R_TILEGX_IMM16_X0_HW1_LAST_GOT,
2946 R_TILEGX_IMM16_X1_HW1_LAST_GOT,
2947 R_TILEGX_IMM16_X0_HW3_PLT_PCREL,
2948 R_TILEGX_IMM16_X1_HW3_PLT_PCREL,
2949 R_TILEGX_IMM16_X0_HW0_TLS_GD,
2950 R_TILEGX_IMM16_X1_HW0_TLS_GD,
2951 R_TILEGX_IMM16_X0_HW0_TLS_LE,
2952 R_TILEGX_IMM16_X1_HW0_TLS_LE,
2953 R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE,
2954 R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE,
2955 R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE,
2956 R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE,
2957 R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD,
2958 R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD,
2959 R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD,
2960 R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD,
2961 R_TILEGX_IMM16_X0_HW0_TLS_IE,
2962 R_TILEGX_IMM16_X1_HW0_TLS_IE,
2963 R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL,
2964 R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL,
2965 R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL,
2966 R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL,
2967 R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL,
2968 R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL,
2969 R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE,
2970 R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE,
2971 R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE,
2972 R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE,
2973 R_TILEGX_TLS_DTPMOD64,
2974 R_TILEGX_TLS_DTPOFF64,
2975 R_TILEGX_TLS_TPOFF64,
2976 R_TILEGX_TLS_DTPMOD32,
2977 R_TILEGX_TLS_DTPOFF32,
2978 R_TILEGX_TLS_TPOFF32,
2979 R_TILEGX_TLS_GD_CALL,
2980 R_TILEGX_IMM8_X0_TLS_GD_ADD,
2981 R_TILEGX_IMM8_X1_TLS_GD_ADD,
2982 R_TILEGX_IMM8_Y0_TLS_GD_ADD,
2983 R_TILEGX_IMM8_Y1_TLS_GD_ADD,
2984 R_TILEGX_TLS_IE_LOAD,
2985 R_TILEGX_IMM8_X0_TLS_ADD,
2986 R_TILEGX_IMM8_X1_TLS_ADD,
2987 R_TILEGX_IMM8_Y0_TLS_ADD,
2988 R_TILEGX_IMM8_Y1_TLS_ADD,
2989 R_TILEGX_GNU_VTINHERIT,
2990 R_TILEGX_GNU_VTENTRY,
2991 );
2992 static FLAGS_R_RISCV: &[Flag<u32>] = &flags!(
2993 R_RISCV_NONE,
2994 R_RISCV_32,
2995 R_RISCV_64,
2996 R_RISCV_RELATIVE,
2997 R_RISCV_COPY,
2998 R_RISCV_JUMP_SLOT,
2999 R_RISCV_TLS_DTPMOD32,
3000 R_RISCV_TLS_DTPMOD64,
3001 R_RISCV_TLS_DTPREL32,
3002 R_RISCV_TLS_DTPREL64,
3003 R_RISCV_TLS_TPREL32,
3004 R_RISCV_TLS_TPREL64,
3005 R_RISCV_BRANCH,
3006 R_RISCV_JAL,
3007 R_RISCV_CALL,
3008 R_RISCV_CALL_PLT,
3009 R_RISCV_GOT_HI20,
3010 R_RISCV_TLS_GOT_HI20,
3011 R_RISCV_TLS_GD_HI20,
3012 R_RISCV_PCREL_HI20,
3013 R_RISCV_PCREL_LO12_I,
3014 R_RISCV_PCREL_LO12_S,
3015 R_RISCV_HI20,
3016 R_RISCV_LO12_I,
3017 R_RISCV_LO12_S,
3018 R_RISCV_TPREL_HI20,
3019 R_RISCV_TPREL_LO12_I,
3020 R_RISCV_TPREL_LO12_S,
3021 R_RISCV_TPREL_ADD,
3022 R_RISCV_ADD8,
3023 R_RISCV_ADD16,
3024 R_RISCV_ADD32,
3025 R_RISCV_ADD64,
3026 R_RISCV_SUB8,
3027 R_RISCV_SUB16,
3028 R_RISCV_SUB32,
3029 R_RISCV_SUB64,
3030 R_RISCV_GNU_VTINHERIT,
3031 R_RISCV_GNU_VTENTRY,
3032 R_RISCV_ALIGN,
3033 R_RISCV_RVC_BRANCH,
3034 R_RISCV_RVC_JUMP,
3035 R_RISCV_RVC_LUI,
3036 R_RISCV_GPREL_I,
3037 R_RISCV_GPREL_S,
3038 R_RISCV_TPREL_I,
3039 R_RISCV_TPREL_S,
3040 R_RISCV_RELAX,
3041 R_RISCV_SUB6,
3042 R_RISCV_SET6,
3043 R_RISCV_SET8,
3044 R_RISCV_SET16,
3045 R_RISCV_SET32,
3046 R_RISCV_32_PCREL,
3047 );
3048 static FLAGS_R_BPF: &[Flag<u32>] = &flags!(R_BPF_NONE, R_BPF_64_64, R_BPF_64_32);
3049 static FLAGS_R_METAG: &[Flag<u32>] = &flags!(
3050 R_METAG_HIADDR16,
3051 R_METAG_LOADDR16,
3052 R_METAG_ADDR32,
3053 R_METAG_NONE,
3054 R_METAG_RELBRANCH,
3055 R_METAG_GETSETOFF,
3056 R_METAG_REG32OP1,
3057 R_METAG_REG32OP2,
3058 R_METAG_REG32OP3,
3059 R_METAG_REG16OP1,
3060 R_METAG_REG16OP2,
3061 R_METAG_REG16OP3,
3062 R_METAG_REG32OP4,
3063 R_METAG_HIOG,
3064 R_METAG_LOOG,
3065 R_METAG_REL8,
3066 R_METAG_REL16,
3067 R_METAG_GNU_VTINHERIT,
3068 R_METAG_GNU_VTENTRY,
3069 R_METAG_HI16_GOTOFF,
3070 R_METAG_LO16_GOTOFF,
3071 R_METAG_GETSET_GOTOFF,
3072 R_METAG_GETSET_GOT,
3073 R_METAG_HI16_GOTPC,
3074 R_METAG_LO16_GOTPC,
3075 R_METAG_HI16_PLT,
3076 R_METAG_LO16_PLT,
3077 R_METAG_RELBRANCH_PLT,
3078 R_METAG_GOTOFF,
3079 R_METAG_PLT,
3080 R_METAG_COPY,
3081 R_METAG_JMP_SLOT,
3082 R_METAG_RELATIVE,
3083 R_METAG_GLOB_DAT,
3084 R_METAG_TLS_GD,
3085 R_METAG_TLS_LDM,
3086 R_METAG_TLS_LDO_HI16,
3087 R_METAG_TLS_LDO_LO16,
3088 R_METAG_TLS_LDO,
3089 R_METAG_TLS_IE,
3090 R_METAG_TLS_IENONPIC,
3091 R_METAG_TLS_IENONPIC_HI16,
3092 R_METAG_TLS_IENONPIC_LO16,
3093 R_METAG_TLS_TPOFF,
3094 R_METAG_TLS_DTPMOD,
3095 R_METAG_TLS_DTPOFF,
3096 R_METAG_TLS_LE,
3097 R_METAG_TLS_LE_HI16,
3098 R_METAG_TLS_LE_LO16,
3099 );
3100 static FLAGS_R_NDS32: &[Flag<u32>] = &flags!(
3101 R_NDS32_NONE,
3102 R_NDS32_32_RELA,
3103 R_NDS32_COPY,
3104 R_NDS32_GLOB_DAT,
3105 R_NDS32_JMP_SLOT,
3106 R_NDS32_RELATIVE,
3107 R_NDS32_TLS_TPOFF,
3108 R_NDS32_TLS_DESC,
3109 );
3110 static FLAGS_NT_CORE: &[Flag<u32>] = &flags!(
3111 NT_PRSTATUS,
3112 NT_PRFPREG,
3113 NT_FPREGSET,
3114 NT_PRPSINFO,
3115 NT_PRXREG,
3116 NT_TASKSTRUCT,
3117 NT_PLATFORM,
3118 NT_AUXV,
3119 NT_GWINDOWS,
3120 NT_ASRS,
3121 NT_PSTATUS,
3122 NT_PSINFO,
3123 NT_PRCRED,
3124 NT_UTSNAME,
3125 NT_LWPSTATUS,
3126 NT_LWPSINFO,
3127 NT_PRFPXREG,
3128 NT_SIGINFO,
3129 NT_FILE,
3130 NT_PRXFPREG,
3131 NT_PPC_VMX,
3132 NT_PPC_SPE,
3133 NT_PPC_VSX,
3134 NT_PPC_TAR,
3135 NT_PPC_PPR,
3136 NT_PPC_DSCR,
3137 NT_PPC_EBB,
3138 NT_PPC_PMU,
3139 NT_PPC_TM_CGPR,
3140 NT_PPC_TM_CFPR,
3141 NT_PPC_TM_CVMX,
3142 NT_PPC_TM_CVSX,
3143 NT_PPC_TM_SPR,
3144 NT_PPC_TM_CTAR,
3145 NT_PPC_TM_CPPR,
3146 NT_PPC_TM_CDSCR,
3147 NT_PPC_PKEY,
3148 NT_386_TLS,
3149 NT_386_IOPERM,
3150 NT_X86_XSTATE,
3151 NT_S390_HIGH_GPRS,
3152 NT_S390_TIMER,
3153 NT_S390_TODCMP,
3154 NT_S390_TODPREG,
3155 NT_S390_CTRS,
3156 NT_S390_PREFIX,
3157 NT_S390_LAST_BREAK,
3158 NT_S390_SYSTEM_CALL,
3159 NT_S390_TDB,
3160 NT_S390_VXRS_LOW,
3161 NT_S390_VXRS_HIGH,
3162 NT_S390_GS_CB,
3163 NT_S390_GS_BC,
3164 NT_S390_RI_CB,
3165 NT_ARM_VFP,
3166 NT_ARM_TLS,
3167 NT_ARM_HW_BREAK,
3168 NT_ARM_HW_WATCH,
3169 NT_ARM_SYSTEM_CALL,
3170 NT_ARM_SVE,
3171 NT_VMCOREDD,
3172 NT_MIPS_DSP,
3173 NT_MIPS_FP_MODE,
3174 );
3175 static FLAGS_NT_SOLARIS: &[Flag<u32>] = &flags!(NT_SOLARIS_PAGESIZE_HINT);
3176 static FLAGS_NT_GNU: &[Flag<u32>] = &flags!(
3177 NT_GNU_ABI_TAG,
3178 NT_GNU_HWCAP,
3179 NT_GNU_BUILD_ID,
3180 NT_GNU_GOLD_VERSION,
3181 NT_GNU_PROPERTY_TYPE_0,
3182 );
3183 static FLAGS_GRP: &[Flag<u32>] = &flags!(GRP_COMDAT);
3184 static FLAGS_DT: &[Flag<u32>] = &flags!(
3185 DT_NULL,
3186 DT_NEEDED,
3187 DT_PLTRELSZ,
3188 DT_PLTGOT,
3189 DT_HASH,
3190 DT_STRTAB,
3191 DT_SYMTAB,
3192 DT_RELA,
3193 DT_RELASZ,
3194 DT_RELAENT,
3195 DT_STRSZ,
3196 DT_SYMENT,
3197 DT_INIT,
3198 DT_FINI,
3199 DT_SONAME,
3200 DT_RPATH,
3201 DT_SYMBOLIC,
3202 DT_REL,
3203 DT_RELSZ,
3204 DT_RELENT,
3205 DT_PLTREL,
3206 DT_DEBUG,
3207 DT_TEXTREL,
3208 DT_JMPREL,
3209 DT_BIND_NOW,
3210 DT_INIT_ARRAY,
3211 DT_FINI_ARRAY,
3212 DT_INIT_ARRAYSZ,
3213 DT_FINI_ARRAYSZ,
3214 DT_RUNPATH,
3215 DT_FLAGS,
3216 DT_PREINIT_ARRAY,
3217 DT_PREINIT_ARRAYSZ,
3218 DT_SYMTAB_SHNDX,
3219 DT_GNU_PRELINKED,
3220 DT_GNU_CONFLICTSZ,
3221 DT_GNU_LIBLISTSZ,
3222 DT_CHECKSUM,
3223 DT_PLTPADSZ,
3224 DT_MOVEENT,
3225 DT_MOVESZ,
3226 DT_FEATURE_1,
3227 DT_POSFLAG_1,
3228 DT_SYMINSZ,
3229 DT_SYMINENT,
3230 DT_GNU_HASH,
3231 DT_TLSDESC_PLT,
3232 DT_TLSDESC_GOT,
3233 DT_GNU_CONFLICT,
3234 DT_GNU_LIBLIST,
3235 DT_CONFIG,
3236 DT_DEPAUDIT,
3237 DT_AUDIT,
3238 DT_PLTPAD,
3239 DT_MOVETAB,
3240 DT_SYMINFO,
3241 DT_VERSYM,
3242 DT_RELACOUNT,
3243 DT_RELCOUNT,
3244 DT_FLAGS_1,
3245 DT_VERDEF,
3246 DT_VERDEFNUM,
3247 DT_VERNEED,
3248 DT_VERNEEDNUM,
3249 DT_AUXILIARY,
3250 DT_FILTER,
3251 );
3252 static FLAGS_DT_SPARC: &[Flag<u32>] = &flags!(DT_SPARC_REGISTER);
3253 static FLAGS_DT_MIPS: &[Flag<u32>] = &flags!(
3254 DT_MIPS_RLD_VERSION,
3255 DT_MIPS_TIME_STAMP,
3256 DT_MIPS_ICHECKSUM,
3257 DT_MIPS_IVERSION,
3258 DT_MIPS_FLAGS,
3259 DT_MIPS_BASE_ADDRESS,
3260 DT_MIPS_MSYM,
3261 DT_MIPS_CONFLICT,
3262 DT_MIPS_LIBLIST,
3263 DT_MIPS_LOCAL_GOTNO,
3264 DT_MIPS_CONFLICTNO,
3265 DT_MIPS_LIBLISTNO,
3266 DT_MIPS_SYMTABNO,
3267 DT_MIPS_UNREFEXTNO,
3268 DT_MIPS_GOTSYM,
3269 DT_MIPS_HIPAGENO,
3270 DT_MIPS_RLD_MAP,
3271 DT_MIPS_DELTA_CLASS,
3272 DT_MIPS_DELTA_CLASS_NO,
3273 DT_MIPS_DELTA_INSTANCE,
3274 DT_MIPS_DELTA_INSTANCE_NO,
3275 DT_MIPS_DELTA_RELOC,
3276 DT_MIPS_DELTA_RELOC_NO,
3277 DT_MIPS_DELTA_SYM,
3278 DT_MIPS_DELTA_SYM_NO,
3279 DT_MIPS_DELTA_CLASSSYM,
3280 DT_MIPS_DELTA_CLASSSYM_NO,
3281 DT_MIPS_CXX_FLAGS,
3282 DT_MIPS_PIXIE_INIT,
3283 DT_MIPS_SYMBOL_LIB,
3284 DT_MIPS_LOCALPAGE_GOTIDX,
3285 DT_MIPS_LOCAL_GOTIDX,
3286 DT_MIPS_HIDDEN_GOTIDX,
3287 DT_MIPS_PROTECTED_GOTIDX,
3288 DT_MIPS_OPTIONS,
3289 DT_MIPS_INTERFACE,
3290 DT_MIPS_DYNSTR_ALIGN,
3291 DT_MIPS_INTERFACE_SIZE,
3292 DT_MIPS_RLD_TEXT_RESOLVE_ADDR,
3293 DT_MIPS_PERF_SUFFIX,
3294 DT_MIPS_COMPACT_SIZE,
3295 DT_MIPS_GP_VALUE,
3296 DT_MIPS_AUX_DYNAMIC,
3297 DT_MIPS_PLTGOT,
3298 DT_MIPS_RWPLT,
3299 DT_MIPS_RLD_MAP_REL,
3300 );
3301 static FLAGS_DT_ALPHA: &[Flag<u32>] = &flags!(DT_ALPHA_PLTRO);
3302 static FLAGS_DT_PPC: &[Flag<u32>] = &flags!(DT_PPC_GOT, DT_PPC_OPT);
3303 static FLAGS_DT_PPC64: &[Flag<u32>] =
3304 &flags!(DT_PPC64_GLINK, DT_PPC64_OPD, DT_PPC64_OPDSZ, DT_PPC64_OPT);
3305 static FLAGS_DT_IA_64: &[Flag<u32>] = &flags!(DT_IA_64_PLT_RESERVE);
3306 static FLAGS_DT_NIOS2: &[Flag<u32>] = &flags!(DT_NIOS2_GP);
3307 static FLAGS_DF: &[Flag<u32>] = &flags!(
3308 DF_ORIGIN,
3309 DF_SYMBOLIC,
3310 DF_TEXTREL,
3311 DF_BIND_NOW,
3312 DF_STATIC_TLS,
3313 );
3314 static FLAGS_DF_1: &[Flag<u32>] = &flags!(
3315 DF_1_NOW,
3316 DF_1_GLOBAL,
3317 DF_1_GROUP,
3318 DF_1_NODELETE,
3319 DF_1_LOADFLTR,
3320 DF_1_INITFIRST,
3321 DF_1_NOOPEN,
3322 DF_1_ORIGIN,
3323 DF_1_DIRECT,
3324 DF_1_TRANS,
3325 DF_1_INTERPOSE,
3326 DF_1_NODEFLIB,
3327 DF_1_NODUMP,
3328 DF_1_CONFALT,
3329 DF_1_ENDFILTEE,
3330 DF_1_DISPRELDNE,
3331 DF_1_DISPRELPND,
3332 DF_1_NODIRECT,
3333 DF_1_IGNMULDEF,
3334 DF_1_NOKSYMS,
3335 DF_1_NOHDR,
3336 DF_1_EDITED,
3337 DF_1_NORELOC,
3338 DF_1_SYMINTPOSE,
3339 DF_1_GLOBAUDIT,
3340 DF_1_SINGLETON,
3341 DF_1_STUB,
3342 DF_1_PIE,
3343 );
3344 static FLAGS_VER_FLG: &[Flag<u16>] = &flags!(VER_FLG_BASE, VER_FLG_WEAK);
3345 static FLAGS_VER_NDX: &[Flag<u16>] = &flags!(VER_NDX_HIDDEN);
3346 }
3347
3348 mod macho {
3349 use super::*;
3350 use object::macho::*;
3351 use object::read::macho::*;
3352 use object::BigEndian;
3353
print_dyld_cache(p: &mut Printer<impl Write>, data: &[u8])3354 pub(super) fn print_dyld_cache(p: &mut Printer<impl Write>, data: &[u8]) {
3355 if let Ok(header) = DyldCacheHeader::<Endianness>::parse(data) {
3356 if let Ok((_, endian)) = header.parse_magic() {
3357 print_dyld_cache_header(p, endian, header);
3358 let mappings = header.mappings(endian, data).ok();
3359 if let Some(mappings) = mappings {
3360 print_dyld_cache_mappings(p, endian, mappings);
3361 }
3362 if let Ok(images) = header.images(endian, data) {
3363 print_dyld_cache_images(p, endian, data, mappings, images);
3364 }
3365 }
3366 }
3367 }
3368
print_dyld_cache_header( p: &mut Printer<impl Write>, endian: Endianness, header: &DyldCacheHeader<Endianness>, )3369 pub(super) fn print_dyld_cache_header(
3370 p: &mut Printer<impl Write>,
3371 endian: Endianness,
3372 header: &DyldCacheHeader<Endianness>,
3373 ) {
3374 p.group("DyldCacheHeader", |p| {
3375 p.field_bytes("Magic", &header.magic);
3376 p.field_hex("MappingOffset", header.mapping_offset.get(endian));
3377 p.field("MappingCount", header.mapping_count.get(endian));
3378 p.field_hex("ImagesOffset", header.images_offset.get(endian));
3379 p.field("ImagesCount", header.images_count.get(endian));
3380 p.field_hex("DyldBaseAddress", header.dyld_base_address.get(endian));
3381 });
3382 }
3383
print_dyld_cache_mappings( p: &mut Printer<impl Write>, endian: Endianness, mappings: &[DyldCacheMappingInfo<Endianness>], )3384 pub(super) fn print_dyld_cache_mappings(
3385 p: &mut Printer<impl Write>,
3386 endian: Endianness,
3387 mappings: &[DyldCacheMappingInfo<Endianness>],
3388 ) {
3389 for mapping in mappings {
3390 p.group("DyldCacheMappingInfo", |p| {
3391 p.field_hex("Address", mapping.address.get(endian));
3392 p.field_hex("Size", mapping.size.get(endian));
3393 p.field_hex("FileOffset", mapping.file_offset.get(endian));
3394 p.field_hex("MaxProt", mapping.max_prot.get(endian));
3395 p.flags(mapping.max_prot.get(endian), 0, FLAGS_VM);
3396 p.field_hex("InitProt", mapping.init_prot.get(endian));
3397 p.flags(mapping.init_prot.get(endian), 0, FLAGS_VM);
3398 });
3399 }
3400 }
3401
print_dyld_cache_images( p: &mut Printer<impl Write>, endian: Endianness, data: &[u8], mappings: Option<&[DyldCacheMappingInfo<Endianness>]>, images: &[DyldCacheImageInfo<Endianness>], )3402 pub(super) fn print_dyld_cache_images(
3403 p: &mut Printer<impl Write>,
3404 endian: Endianness,
3405 data: &[u8],
3406 mappings: Option<&[DyldCacheMappingInfo<Endianness>]>,
3407 images: &[DyldCacheImageInfo<Endianness>],
3408 ) {
3409 for image in images {
3410 p.group("DyldCacheImageInfo", |p| {
3411 p.field_hex("Address", image.address.get(endian));
3412 p.field_hex("ModTime", image.mod_time.get(endian));
3413 p.field_hex("Inode", image.inode.get(endian));
3414 p.field_string(
3415 "Path",
3416 image.path_file_offset.get(endian),
3417 image.path(endian, data).ok(),
3418 );
3419 p.field_hex("Pad", image.pad.get(endian));
3420 });
3421 if let Some(offset) =
3422 mappings.and_then(|mappings| image.file_offset(endian, mappings).ok())
3423 {
3424 p.blank();
3425 print_object_at(p, data, offset);
3426 p.blank();
3427 }
3428 }
3429 }
3430
print_macho_fat32(p: &mut Printer<impl Write>, data: &[u8])3431 pub(super) fn print_macho_fat32(p: &mut Printer<impl Write>, data: &[u8]) {
3432 if let Ok(arches) = FatHeader::parse_arch32(data) {
3433 println!("Format: Mach-O Fat 32-bit");
3434 print_fat_header(p, data);
3435 for arch in arches {
3436 print_fat_arch(p, arch);
3437 }
3438 for arch in arches {
3439 if let Ok(data) = arch.data(data) {
3440 p.blank();
3441 print_object(p, data);
3442 }
3443 }
3444 }
3445 }
3446
print_macho_fat64(p: &mut Printer<impl Write>, data: &[u8])3447 pub(super) fn print_macho_fat64(p: &mut Printer<impl Write>, data: &[u8]) {
3448 if let Ok(arches) = FatHeader::parse_arch64(data) {
3449 println!("Format: Mach-O Fat 64-bit");
3450 print_fat_header(p, data);
3451 for arch in arches {
3452 print_fat_arch(p, arch);
3453 }
3454 for arch in arches {
3455 if let Ok(data) = arch.data(data) {
3456 p.blank();
3457 print_object(p, data);
3458 }
3459 }
3460 }
3461 }
3462
print_fat_header(p: &mut Printer<impl Write>, data: &[u8])3463 pub(super) fn print_fat_header(p: &mut Printer<impl Write>, data: &[u8]) {
3464 if let Ok(header) = FatHeader::parse(data) {
3465 p.group("FatHeader", |p| {
3466 p.field_hex("Magic", header.magic.get(BigEndian));
3467 p.field("NumberOfFatArch", header.nfat_arch.get(BigEndian));
3468 });
3469 }
3470 }
3471
print_fat_arch<Arch: FatArch>(p: &mut Printer<impl Write>, arch: &Arch)3472 pub(super) fn print_fat_arch<Arch: FatArch>(p: &mut Printer<impl Write>, arch: &Arch) {
3473 p.group("FatArch", |p| {
3474 print_cputype(p, arch.cputype(), arch.cpusubtype());
3475 p.field_hex("Offset", arch.offset().into());
3476 p.field_hex("Size", arch.size().into());
3477 p.field("Align", arch.align());
3478 });
3479 }
3480
print_macho32(p: &mut Printer<impl Write>, data: &[u8], offset: u64)3481 pub(super) fn print_macho32(p: &mut Printer<impl Write>, data: &[u8], offset: u64) {
3482 if let Ok(header) = MachHeader32::parse(data, offset) {
3483 println!("Format: Mach-O 32-bit");
3484 print_macho(p, header, data, offset);
3485 }
3486 }
3487
print_macho64(p: &mut Printer<impl Write>, data: &[u8], offset: u64)3488 pub(super) fn print_macho64(p: &mut Printer<impl Write>, data: &[u8], offset: u64) {
3489 if let Ok(header) = MachHeader64::parse(data, offset) {
3490 println!("Format: Mach-O 64-bit");
3491 print_macho(p, header, data, offset);
3492 }
3493 }
3494
3495 #[derive(Default)]
3496 struct MachState {
3497 section_index: usize,
3498 }
3499
print_macho<Mach: MachHeader<Endian = Endianness>>( p: &mut Printer<impl Write>, header: &Mach, data: &[u8], offset: u64, )3500 fn print_macho<Mach: MachHeader<Endian = Endianness>>(
3501 p: &mut Printer<impl Write>,
3502 header: &Mach,
3503 data: &[u8],
3504 offset: u64,
3505 ) {
3506 if let Ok(endian) = header.endian() {
3507 let mut state = MachState::default();
3508 print_mach_header(p, endian, header);
3509 if let Ok(mut commands) = header.load_commands(endian, data, offset) {
3510 while let Ok(Some(command)) = commands.next() {
3511 print_load_command(p, endian, data, header, command, &mut state);
3512 }
3513 }
3514 }
3515 }
3516
print_mach_header<Mach: MachHeader>( p: &mut Printer<impl Write>, endian: Mach::Endian, header: &Mach, )3517 fn print_mach_header<Mach: MachHeader>(
3518 p: &mut Printer<impl Write>,
3519 endian: Mach::Endian,
3520 header: &Mach,
3521 ) {
3522 p.group("MachHeader", |p| {
3523 p.field_hex("Magic", header.magic().to_be());
3524 print_cputype(p, header.cputype(endian), header.cpusubtype(endian));
3525 p.field_enum("FileType", header.filetype(endian), FLAGS_MH_FILETYPE);
3526 p.field("NumberOfCmds", header.ncmds(endian));
3527 p.field_hex("SizeOfCmds", header.sizeofcmds(endian));
3528 p.field_enum("Flags", header.flags(endian), FLAGS_MH);
3529 });
3530 }
3531
print_load_command<Mach: MachHeader>( p: &mut Printer<impl Write>, endian: Mach::Endian, data: &[u8], header: &Mach, command: LoadCommandData<Mach::Endian>, state: &mut MachState, )3532 fn print_load_command<Mach: MachHeader>(
3533 p: &mut Printer<impl Write>,
3534 endian: Mach::Endian,
3535 data: &[u8],
3536 header: &Mach,
3537 command: LoadCommandData<Mach::Endian>,
3538 state: &mut MachState,
3539 ) {
3540 if let Ok(variant) = command.variant() {
3541 match variant {
3542 LoadCommandVariant::Segment32(segment, section_data) => {
3543 print_segment(
3544 p,
3545 endian,
3546 data,
3547 header.cputype(endian),
3548 segment,
3549 section_data,
3550 state,
3551 );
3552 }
3553 LoadCommandVariant::Segment64(segment, section_data) => {
3554 print_segment(
3555 p,
3556 endian,
3557 data,
3558 header.cputype(endian),
3559 segment,
3560 section_data,
3561 state,
3562 );
3563 }
3564 LoadCommandVariant::Symtab(symtab) => {
3565 print_symtab::<Mach, _>(p, endian, data, symtab);
3566 }
3567 LoadCommandVariant::Thread(x, _thread_data) => {
3568 p.group("ThreadCommand", |p| {
3569 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3570 p.field_hex("CmdSize", x.cmdsize.get(endian));
3571 // TODO: thread_data
3572 });
3573 }
3574 LoadCommandVariant::Dysymtab(x) => {
3575 p.group("DysymtabCommand", |p| {
3576 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3577 p.field_hex("CmdSize", x.cmdsize.get(endian));
3578 // TODO: dump the tables these are all pointing to
3579 p.field("IndexOfLocalSymbols", x.ilocalsym.get(endian));
3580 p.field("NumberOfLocalSymbols", x.nlocalsym.get(endian));
3581 p.field("IndexOfExternallyDefinedSymbols", x.iextdefsym.get(endian));
3582 p.field("NumberOfExternallyDefinedSymbols", x.nextdefsym.get(endian));
3583 p.field("IndexOfUndefinedSymbols", x.iundefsym.get(endian));
3584 p.field("NumberOfUndefinedSymbols", x.nundefsym.get(endian));
3585 p.field_hex("TocOffset", x.tocoff.get(endian));
3586 p.field("NumberOfTocEntries", x.ntoc.get(endian));
3587 p.field_hex("ModuleTableOffset", x.modtaboff.get(endian));
3588 p.field("NumberOfModuleTableEntries", x.nmodtab.get(endian));
3589 p.field_hex("ExternalRefSymbolOffset", x.extrefsymoff.get(endian));
3590 p.field("NumberOfExternalRefSymbols", x.nextrefsyms.get(endian));
3591 p.field_hex("IndirectSymbolOffset", x.indirectsymoff.get(endian));
3592 p.field("NumberOfIndirectSymbols", x.nindirectsyms.get(endian));
3593 p.field_hex("ExternalRelocationOffset", x.extreloff.get(endian));
3594 p.field("NumberOfExternalRelocations", x.nextrel.get(endian));
3595 p.field_hex("LocalRelocationOffset", x.locreloff.get(endian));
3596 p.field("NumberOfLocalRelocations", x.nlocrel.get(endian));
3597 });
3598 }
3599 LoadCommandVariant::Dylib(x) | LoadCommandVariant::IdDylib(x) => {
3600 p.group("DylibCommand", |p| {
3601 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3602 p.field_hex("CmdSize", x.cmdsize.get(endian));
3603 p.group("Dylib", |p| {
3604 p.field_string(
3605 "Name",
3606 x.dylib.name.offset.get(endian),
3607 command.string(endian, x.dylib.name).ok(),
3608 );
3609 p.field("Timestamp", x.dylib.timestamp.get(endian));
3610 p.field_hex("CurrentVersion", x.dylib.current_version.get(endian));
3611 p.field_hex(
3612 "CompatibilityVersion",
3613 x.dylib.compatibility_version.get(endian),
3614 );
3615 });
3616 });
3617 }
3618 LoadCommandVariant::LoadDylinker(x)
3619 | LoadCommandVariant::IdDylinker(x)
3620 | LoadCommandVariant::DyldEnvironment(x) => {
3621 p.group("DylinkerCommand", |p| {
3622 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3623 p.field_hex("CmdSize", x.cmdsize.get(endian));
3624 p.field_string(
3625 "Name",
3626 x.name.offset.get(endian),
3627 command.string(endian, x.name).ok(),
3628 );
3629 });
3630 }
3631 LoadCommandVariant::PreboundDylib(x) => {
3632 p.group("PreboundDylibCommand", |p| {
3633 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3634 p.field_hex("CmdSize", x.cmdsize.get(endian));
3635 p.field_string(
3636 "Name",
3637 x.name.offset.get(endian),
3638 command.string(endian, x.name).ok(),
3639 );
3640 p.field("NumberOfModules", x.nmodules.get(endian));
3641 // TODO: display bit vector
3642 p.field_hex("LinkedModules", x.linked_modules.offset.get(endian));
3643 });
3644 }
3645 LoadCommandVariant::Routines32(x) => {
3646 p.group("RoutinesCommand32", |p| {
3647 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3648 p.field_hex("CmdSize", x.cmdsize.get(endian));
3649 p.field_hex("InitAddress", x.init_address.get(endian));
3650 p.field_hex("InitModule", x.init_module.get(endian));
3651 p.field_hex("Reserved1", x.reserved1.get(endian));
3652 p.field_hex("Reserved2", x.reserved2.get(endian));
3653 p.field_hex("Reserved3", x.reserved3.get(endian));
3654 p.field_hex("Reserved4", x.reserved4.get(endian));
3655 p.field_hex("Reserved5", x.reserved5.get(endian));
3656 p.field_hex("Reserved6", x.reserved6.get(endian));
3657 });
3658 }
3659 LoadCommandVariant::Routines64(x) => {
3660 p.group("RoutinesCommand64", |p| {
3661 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3662 p.field_hex("CmdSize", x.cmdsize.get(endian));
3663 p.field_hex("InitAddress", x.init_address.get(endian));
3664 p.field_hex("InitModule", x.init_module.get(endian));
3665 p.field_hex("Reserved1", x.reserved1.get(endian));
3666 p.field_hex("Reserved2", x.reserved2.get(endian));
3667 p.field_hex("Reserved3", x.reserved3.get(endian));
3668 p.field_hex("Reserved4", x.reserved4.get(endian));
3669 p.field_hex("Reserved5", x.reserved5.get(endian));
3670 p.field_hex("Reserved6", x.reserved6.get(endian));
3671 });
3672 }
3673 LoadCommandVariant::SubFramework(x) => {
3674 p.group("SubFrameworkCommand", |p| {
3675 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3676 p.field_hex("CmdSize", x.cmdsize.get(endian));
3677 p.field_string(
3678 "Umbrella",
3679 x.umbrella.offset.get(endian),
3680 command.string(endian, x.umbrella).ok(),
3681 );
3682 });
3683 }
3684 LoadCommandVariant::SubUmbrella(x) => {
3685 p.group("SubUmbrellaCommand", |p| {
3686 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3687 p.field_hex("CmdSize", x.cmdsize.get(endian));
3688 p.field_string(
3689 "SubUmbrella",
3690 x.sub_umbrella.offset.get(endian),
3691 command.string(endian, x.sub_umbrella).ok(),
3692 );
3693 });
3694 }
3695 LoadCommandVariant::SubClient(x) => {
3696 p.group("SubClientCommand", |p| {
3697 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3698 p.field_hex("CmdSize", x.cmdsize.get(endian));
3699 p.field_string(
3700 "Client",
3701 x.client.offset.get(endian),
3702 command.string(endian, x.client).ok(),
3703 );
3704 });
3705 }
3706 LoadCommandVariant::SubLibrary(x) => {
3707 p.group("SubLibraryCommand", |p| {
3708 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3709 p.field_hex("CmdSize", x.cmdsize.get(endian));
3710 p.field_string(
3711 "SubLibrary",
3712 x.sub_library.offset.get(endian),
3713 command.string(endian, x.sub_library).ok(),
3714 );
3715 });
3716 }
3717 LoadCommandVariant::TwolevelHints(x) => {
3718 p.group("TwolevelHintsCommand", |p| {
3719 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3720 p.field_hex("CmdSize", x.cmdsize.get(endian));
3721 p.field_hex("Offset", x.offset.get(endian));
3722 p.field_hex("NumberOfHints", x.nhints.get(endian));
3723 // TODO: display hints
3724 });
3725 }
3726 LoadCommandVariant::PrebindCksum(x) => {
3727 p.group("PrebindCksumCommand", |p| {
3728 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3729 p.field_hex("CmdSize", x.cmdsize.get(endian));
3730 p.field_hex("Cksum", x.cksum.get(endian));
3731 });
3732 }
3733 LoadCommandVariant::Uuid(x) => {
3734 p.group("UuidCommand", |p| {
3735 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3736 p.field_hex("CmdSize", x.cmdsize.get(endian));
3737 p.field("Uuid", format!("{:X?}", x.uuid));
3738 });
3739 }
3740 LoadCommandVariant::Rpath(x) => {
3741 p.group("RpathCommand", |p| {
3742 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3743 p.field_hex("CmdSize", x.cmdsize.get(endian));
3744 p.field_string(
3745 "Path",
3746 x.path.offset.get(endian),
3747 command.string(endian, x.path).ok(),
3748 );
3749 });
3750 }
3751 LoadCommandVariant::LinkeditData(x) => {
3752 p.group("LinkeditDataCommand", |p| {
3753 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3754 p.field_hex("CmdSize", x.cmdsize.get(endian));
3755 p.field_hex("DataOffset", x.dataoff.get(endian));
3756 p.field_hex("DataSize", x.datasize.get(endian));
3757 });
3758 }
3759 LoadCommandVariant::EncryptionInfo32(x) => {
3760 p.group("EncryptionInfoCommand32", |p| {
3761 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3762 p.field_hex("CmdSize", x.cmdsize.get(endian));
3763 p.field_hex("CryptOffset", x.cryptoff.get(endian));
3764 p.field_hex("CryptSize", x.cryptsize.get(endian));
3765 p.field_hex("CryptId", x.cryptid.get(endian));
3766 });
3767 }
3768 LoadCommandVariant::EncryptionInfo64(x) => {
3769 p.group("EncryptionInfoCommand64", |p| {
3770 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3771 p.field_hex("CmdSize", x.cmdsize.get(endian));
3772 p.field_hex("CryptOffset", x.cryptoff.get(endian));
3773 p.field_hex("CryptSize", x.cryptsize.get(endian));
3774 p.field_hex("CryptId", x.cryptid.get(endian));
3775 p.field_hex("Pad", x.pad.get(endian));
3776 });
3777 }
3778 LoadCommandVariant::DyldInfo(x) => {
3779 p.group("DyldInfoCommand", |p| {
3780 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3781 p.field_hex("CmdSize", x.cmdsize.get(endian));
3782 // TODO: dump the tables these are all pointing to
3783 p.field_hex("RebaseOffset", x.rebase_off.get(endian));
3784 p.field_hex("RebaseSize", x.rebase_size.get(endian));
3785 p.field_hex("BindOffset", x.bind_off.get(endian));
3786 p.field_hex("BindSize", x.bind_size.get(endian));
3787 p.field_hex("WeakBindOffset", x.weak_bind_off.get(endian));
3788 p.field_hex("WeakBindSize", x.weak_bind_size.get(endian));
3789 p.field_hex("LazyBindOffset", x.lazy_bind_off.get(endian));
3790 p.field_hex("LazyBindSize", x.lazy_bind_size.get(endian));
3791 p.field_hex("ExportOffset", x.export_off.get(endian));
3792 p.field_hex("ExportSize", x.export_size.get(endian));
3793 });
3794 }
3795 LoadCommandVariant::VersionMin(x) => {
3796 p.group("VersionMinCommand", |p| {
3797 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3798 p.field_hex("CmdSize", x.cmdsize.get(endian));
3799 p.field_hex("Version", x.version.get(endian));
3800 p.field_hex("Sdk", x.sdk.get(endian));
3801 });
3802 }
3803 LoadCommandVariant::EntryPoint(x) => {
3804 p.group("EntryPointCommand", |p| {
3805 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3806 p.field_hex("CmdSize", x.cmdsize.get(endian));
3807 p.field_hex("EntryOffset", x.entryoff.get(endian));
3808 p.field_hex("StackSize", x.stacksize.get(endian));
3809 });
3810 }
3811 LoadCommandVariant::SourceVersion(x) => {
3812 p.group("SourceVersionCommand", |p| {
3813 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3814 p.field_hex("CmdSize", x.cmdsize.get(endian));
3815 p.field_hex("Version", x.version.get(endian));
3816 });
3817 }
3818 LoadCommandVariant::LinkerOption(x) => {
3819 p.group("LinkerOptionCommand", |p| {
3820 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3821 p.field_hex("CmdSize", x.cmdsize.get(endian));
3822 p.field_hex("Count", x.count.get(endian));
3823 // TODO: dump strings
3824 });
3825 }
3826 LoadCommandVariant::Note(x) => {
3827 p.group("NoteCommand", |p| {
3828 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3829 p.field_hex("CmdSize", x.cmdsize.get(endian));
3830 // TODO: string?
3831 p.field("DataOwner", format!("{:X?}", x.data_owner));
3832 p.field_hex("Offset", x.offset.get(endian));
3833 p.field_hex("Size", x.size.get(endian));
3834 });
3835 }
3836 LoadCommandVariant::BuildVersion(x) => {
3837 p.group("BuildVersionCommand", |p| {
3838 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3839 p.field_hex("CmdSize", x.cmdsize.get(endian));
3840 p.field_enum("Platform", x.platform.get(endian), FLAGS_PLATFORM);
3841 p.field_hex("MinOs", x.minos.get(endian));
3842 p.field_hex("Sdk", x.sdk.get(endian));
3843 p.field_hex("NumberOfTools", x.ntools.get(endian));
3844 // TODO: dump tools
3845 });
3846 }
3847 LoadCommandVariant::FilesetEntry(x) => {
3848 p.group("FilesetEntryCommand", |p| {
3849 p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
3850 p.field_hex("CmdSize", x.cmdsize.get(endian));
3851 p.field_hex("VmAddress", x.vmaddr.get(endian));
3852 p.field_hex("FileOffset", x.fileoff.get(endian));
3853 p.field_string(
3854 "EntryId",
3855 x.entry_id.offset.get(endian),
3856 command.string(endian, x.entry_id).ok(),
3857 );
3858 p.field_hex("Reserved", x.reserved.get(endian));
3859 });
3860 }
3861 _ => {
3862 p.group("LoadCommand", |p| {
3863 p.field_enum("Cmd", command.cmd(), FLAGS_LC);
3864 p.field_hex("CmdSize", command.cmdsize());
3865 });
3866 }
3867 }
3868 } else {
3869 p.group("LoadCommand", |p| {
3870 p.field_enum("Cmd", command.cmd(), FLAGS_LC);
3871 p.field_hex("CmdSize", command.cmdsize());
3872 });
3873 }
3874 }
3875
print_segment<S: Segment>( p: &mut Printer<impl Write>, endian: S::Endian, data: &[u8], cputype: u32, segment: &S, section_data: &[u8], state: &mut MachState, )3876 fn print_segment<S: Segment>(
3877 p: &mut Printer<impl Write>,
3878 endian: S::Endian,
3879 data: &[u8],
3880 cputype: u32,
3881 segment: &S,
3882 section_data: &[u8],
3883 state: &mut MachState,
3884 ) {
3885 p.group("SegmentCommand", |p| {
3886 p.field_enum("Cmd", segment.cmd(endian), FLAGS_LC);
3887 p.field_hex("CmdSize", segment.cmdsize(endian));
3888 p.field_inline_string("SegmentName", segment.name());
3889 p.field_hex("VmAddress", segment.vmaddr(endian).into());
3890 p.field_hex("VmSize", segment.vmsize(endian).into());
3891 p.field_hex("FileOffset", segment.fileoff(endian).into());
3892 p.field_hex("FileSize", segment.filesize(endian).into());
3893 p.field_hex("MaxProt", segment.maxprot(endian));
3894 p.flags(segment.maxprot(endian), 0, FLAGS_VM);
3895 p.field_hex("InitProt", segment.initprot(endian));
3896 p.flags(segment.initprot(endian), 0, FLAGS_VM);
3897 p.field("NumberOfSections", segment.nsects(endian));
3898 p.field_hex("Flags", segment.flags(endian));
3899 p.flags(segment.flags(endian), 0, FLAGS_SG);
3900 if let Ok(sections) = segment.sections(endian, section_data) {
3901 for section in sections {
3902 print_section(p, endian, data, cputype, section, state);
3903 }
3904 }
3905 });
3906 }
3907
print_section<S: Section>( p: &mut Printer<impl Write>, endian: S::Endian, data: &[u8], cputype: u32, section: &S, state: &mut MachState, )3908 fn print_section<S: Section>(
3909 p: &mut Printer<impl Write>,
3910 endian: S::Endian,
3911 data: &[u8],
3912 cputype: u32,
3913 section: &S,
3914 state: &mut MachState,
3915 ) {
3916 p.group("Section", |p| {
3917 p.field("Index", state.section_index);
3918 state.section_index += 1;
3919 p.field_inline_string("SectionName", section.name());
3920 p.field_inline_string("SegmentName", section.segment_name());
3921 p.field_hex("Address", section.addr(endian).into());
3922 p.field_hex("Size", section.size(endian).into());
3923 p.field_hex("Offset", section.offset(endian));
3924 p.field_hex("Align", section.align(endian));
3925 p.field_hex("RelocationOffset", section.reloff(endian));
3926 p.field_hex("NumberOfRelocations", section.nreloc(endian));
3927 let flags = section.flags(endian);
3928 if flags & SECTION_TYPE == flags {
3929 p.field_enum("Flags", flags, FLAGS_S_TYPE);
3930 } else {
3931 p.field_hex("Flags", section.flags(endian));
3932 p.flags(flags, SECTION_TYPE, FLAGS_S_TYPE);
3933 p.flags(flags, 0, FLAGS_S_ATTR);
3934 }
3935 if let Ok(relocations) = section.relocations(endian, data) {
3936 let proc = match cputype {
3937 CPU_TYPE_X86 => FLAGS_GENERIC_RELOC,
3938 CPU_TYPE_X86_64 => FLAGS_X86_64_RELOC,
3939 CPU_TYPE_ARM => FLAGS_ARM_RELOC,
3940 CPU_TYPE_ARM64 | CPU_TYPE_ARM64_32 => FLAGS_ARM64_RELOC,
3941 CPU_TYPE_POWERPC | CPU_TYPE_POWERPC64 => FLAGS_PPC_RELOC,
3942 _ => &[],
3943 };
3944 for relocation in relocations {
3945 if relocation.r_scattered(endian, cputype) {
3946 let info = relocation.scattered_info(endian);
3947 p.group("ScatteredRelocationInfo", |p| {
3948 p.field_hex("Address", info.r_address);
3949 p.field("PcRel", if info.r_pcrel { "yes" } else { "no" });
3950 p.field("Length", info.r_length);
3951 p.field_enum("Type", info.r_type, proc);
3952 p.field_hex("Value", info.r_value);
3953 });
3954 } else {
3955 let info = relocation.info(endian);
3956 p.group("RelocationInfo", |p| {
3957 p.field_hex("Address", info.r_address);
3958 if info.r_extern {
3959 // TODO: symbol name
3960 p.field("Symbol", info.r_symbolnum);
3961 } else {
3962 p.field("Section", info.r_symbolnum);
3963 }
3964 p.field("PcRel", if info.r_pcrel { "yes" } else { "no" });
3965 p.field("Length", info.r_length);
3966 p.field("Extern", if info.r_extern { "yes" } else { "no" });
3967 p.field_enum("Type", info.r_type, proc);
3968 });
3969 }
3970 }
3971 }
3972 });
3973 }
3974
print_symtab<Mach: MachHeader, W: Write>( p: &mut Printer<W>, endian: Mach::Endian, data: &[u8], symtab: &SymtabCommand<Mach::Endian>, )3975 fn print_symtab<Mach: MachHeader, W: Write>(
3976 p: &mut Printer<W>,
3977 endian: Mach::Endian,
3978 data: &[u8],
3979 symtab: &SymtabCommand<Mach::Endian>,
3980 ) {
3981 p.group("SymtabCommand", |p| {
3982 p.field_enum("Cmd", symtab.cmd.get(endian), FLAGS_LC);
3983 p.field_hex("CmdSize", symtab.cmdsize.get(endian));
3984 p.field_hex("SymbolOffset", symtab.symoff.get(endian));
3985 p.field_hex("NumberOfSymbols", symtab.nsyms.get(endian));
3986 p.field_hex("StringOffset", symtab.stroff.get(endian));
3987 p.field_hex("StringSize", symtab.strsize.get(endian));
3988 if let Ok(symbols) = symtab.symbols::<Mach, _>(endian, data) {
3989 for (index, nlist) in symbols.iter().enumerate() {
3990 p.group("Nlist", |p| {
3991 p.field("Index", index);
3992 p.field_string(
3993 "String",
3994 nlist.n_strx(endian),
3995 nlist.name(endian, symbols.strings()).ok(),
3996 );
3997 let n_type = nlist.n_type();
3998 if nlist.is_stab() {
3999 p.field_enum("Type", n_type, FLAGS_N_STAB);
4000 } else if n_type & N_TYPE == n_type {
4001 // Avoid an extra line if no flags.
4002 p.field_enum("Type", n_type, FLAGS_N_TYPE);
4003 } else {
4004 p.field_hex("Type", n_type);
4005 p.flags(n_type, N_TYPE, FLAGS_N_TYPE);
4006 p.flags(n_type, 0, FLAGS_N_EXT);
4007 }
4008 p.field("Section", nlist.n_sect());
4009 let n_desc = nlist.n_desc(endian);
4010 p.field_hex("Desc", n_desc);
4011 if nlist.is_undefined() {
4012 p.flags(n_desc, REFERENCE_TYPE, FLAGS_REFERENCE);
4013 }
4014 if !nlist.is_stab() {
4015 p.flags(n_desc, 0, FLAGS_N_DESC);
4016 }
4017 p.field_hex("Value", nlist.n_value(endian).into());
4018 });
4019 }
4020 }
4021 });
4022 }
4023
print_cputype(p: &mut Printer<impl Write>, cputype: u32, cpusubtype: u32)4024 fn print_cputype(p: &mut Printer<impl Write>, cputype: u32, cpusubtype: u32) {
4025 let proc = match cputype {
4026 CPU_TYPE_ANY => FLAGS_CPU_SUBTYPE_ANY,
4027 CPU_TYPE_VAX => FLAGS_CPU_SUBTYPE_VAX,
4028 CPU_TYPE_MC680X0 => FLAGS_CPU_SUBTYPE_MC680X0,
4029 CPU_TYPE_X86 => FLAGS_CPU_SUBTYPE_X86,
4030 CPU_TYPE_X86_64 => FLAGS_CPU_SUBTYPE_X86_64,
4031 CPU_TYPE_MIPS => FLAGS_CPU_SUBTYPE_MIPS,
4032 CPU_TYPE_MC98000 => FLAGS_CPU_SUBTYPE_MC98000,
4033 CPU_TYPE_HPPA => FLAGS_CPU_SUBTYPE_HPPA,
4034 CPU_TYPE_ARM => FLAGS_CPU_SUBTYPE_ARM,
4035 CPU_TYPE_ARM64 => FLAGS_CPU_SUBTYPE_ARM64,
4036 CPU_TYPE_ARM64_32 => FLAGS_CPU_SUBTYPE_ARM64_32,
4037 CPU_TYPE_MC88000 => FLAGS_CPU_SUBTYPE_MC88000,
4038 CPU_TYPE_SPARC => FLAGS_CPU_SUBTYPE_SPARC,
4039 CPU_TYPE_I860 => FLAGS_CPU_SUBTYPE_I860,
4040 CPU_TYPE_POWERPC | CPU_TYPE_POWERPC64 => FLAGS_CPU_SUBTYPE_POWERPC,
4041 _ => &[],
4042 };
4043 p.field_enum("CpuType", cputype, FLAGS_CPU_TYPE);
4044 p.field_hex("CpuSubtype", cpusubtype);
4045 p.flags(cpusubtype, !CPU_SUBTYPE_MASK, proc);
4046 p.flags(cpusubtype, 0, FLAGS_CPU_SUBTYPE);
4047 }
4048
4049 static FLAGS_CPU_TYPE: &[Flag<u32>] = &flags!(
4050 CPU_TYPE_ANY,
4051 CPU_TYPE_VAX,
4052 CPU_TYPE_MC680X0,
4053 CPU_TYPE_X86,
4054 CPU_TYPE_X86_64,
4055 CPU_TYPE_MIPS,
4056 CPU_TYPE_MC98000,
4057 CPU_TYPE_HPPA,
4058 CPU_TYPE_ARM,
4059 CPU_TYPE_ARM64,
4060 CPU_TYPE_ARM64_32,
4061 CPU_TYPE_MC88000,
4062 CPU_TYPE_SPARC,
4063 CPU_TYPE_I860,
4064 CPU_TYPE_ALPHA,
4065 CPU_TYPE_POWERPC,
4066 CPU_TYPE_POWERPC64,
4067 );
4068 static FLAGS_CPU_SUBTYPE: &[Flag<u32>] = &flags!(CPU_SUBTYPE_LIB64);
4069 static FLAGS_CPU_SUBTYPE_ANY: &[Flag<u32>] = &flags!(
4070 CPU_SUBTYPE_MULTIPLE,
4071 CPU_SUBTYPE_LITTLE_ENDIAN,
4072 CPU_SUBTYPE_BIG_ENDIAN,
4073 );
4074 static FLAGS_CPU_SUBTYPE_VAX: &[Flag<u32>] = &flags!(
4075 CPU_SUBTYPE_VAX_ALL,
4076 CPU_SUBTYPE_VAX780,
4077 CPU_SUBTYPE_VAX785,
4078 CPU_SUBTYPE_VAX750,
4079 CPU_SUBTYPE_VAX730,
4080 CPU_SUBTYPE_UVAXI,
4081 CPU_SUBTYPE_UVAXII,
4082 CPU_SUBTYPE_VAX8200,
4083 CPU_SUBTYPE_VAX8500,
4084 CPU_SUBTYPE_VAX8600,
4085 CPU_SUBTYPE_VAX8650,
4086 CPU_SUBTYPE_VAX8800,
4087 CPU_SUBTYPE_UVAXIII,
4088 );
4089 static FLAGS_CPU_SUBTYPE_MC680X0: &[Flag<u32>] = &flags!(
4090 CPU_SUBTYPE_MC680X0_ALL,
4091 CPU_SUBTYPE_MC68040,
4092 CPU_SUBTYPE_MC68030_ONLY,
4093 );
4094 static FLAGS_CPU_SUBTYPE_X86: &[Flag<u32>] = &flags!(
4095 CPU_SUBTYPE_I386_ALL,
4096 CPU_SUBTYPE_386,
4097 CPU_SUBTYPE_486,
4098 CPU_SUBTYPE_486SX,
4099 CPU_SUBTYPE_586,
4100 CPU_SUBTYPE_PENT,
4101 CPU_SUBTYPE_PENTPRO,
4102 CPU_SUBTYPE_PENTII_M3,
4103 CPU_SUBTYPE_PENTII_M5,
4104 CPU_SUBTYPE_CELERON,
4105 CPU_SUBTYPE_CELERON_MOBILE,
4106 CPU_SUBTYPE_PENTIUM_3,
4107 CPU_SUBTYPE_PENTIUM_3_M,
4108 CPU_SUBTYPE_PENTIUM_3_XEON,
4109 CPU_SUBTYPE_PENTIUM_M,
4110 CPU_SUBTYPE_PENTIUM_4,
4111 CPU_SUBTYPE_PENTIUM_4_M,
4112 CPU_SUBTYPE_ITANIUM,
4113 CPU_SUBTYPE_ITANIUM_2,
4114 CPU_SUBTYPE_XEON,
4115 CPU_SUBTYPE_XEON_MP,
4116 );
4117 static FLAGS_CPU_SUBTYPE_X86_64: &[Flag<u32>] = &flags!(
4118 CPU_SUBTYPE_X86_64_ALL,
4119 CPU_SUBTYPE_X86_ARCH1,
4120 CPU_SUBTYPE_X86_64_H,
4121 );
4122 static FLAGS_CPU_SUBTYPE_MIPS: &[Flag<u32>] = &flags!(
4123 CPU_SUBTYPE_MIPS_ALL,
4124 CPU_SUBTYPE_MIPS_R2300,
4125 CPU_SUBTYPE_MIPS_R2600,
4126 CPU_SUBTYPE_MIPS_R2800,
4127 CPU_SUBTYPE_MIPS_R2000A,
4128 CPU_SUBTYPE_MIPS_R2000,
4129 CPU_SUBTYPE_MIPS_R3000A,
4130 CPU_SUBTYPE_MIPS_R3000,
4131 );
4132 static FLAGS_CPU_SUBTYPE_MC98000: &[Flag<u32>] =
4133 &flags!(CPU_SUBTYPE_MC98000_ALL, CPU_SUBTYPE_MC98601);
4134 static FLAGS_CPU_SUBTYPE_HPPA: &[Flag<u32>] =
4135 &flags!(CPU_SUBTYPE_HPPA_ALL, CPU_SUBTYPE_HPPA_7100LC);
4136 static FLAGS_CPU_SUBTYPE_MC88000: &[Flag<u32>] = &flags!(
4137 CPU_SUBTYPE_MC88000_ALL,
4138 CPU_SUBTYPE_MC88100,
4139 CPU_SUBTYPE_MC88110,
4140 );
4141 static FLAGS_CPU_SUBTYPE_SPARC: &[Flag<u32>] = &flags!(CPU_SUBTYPE_SPARC_ALL);
4142 static FLAGS_CPU_SUBTYPE_I860: &[Flag<u32>] =
4143 &flags!(CPU_SUBTYPE_I860_ALL, CPU_SUBTYPE_I860_860);
4144 static FLAGS_CPU_SUBTYPE_POWERPC: &[Flag<u32>] = &flags!(
4145 CPU_SUBTYPE_POWERPC_ALL,
4146 CPU_SUBTYPE_POWERPC_601,
4147 CPU_SUBTYPE_POWERPC_602,
4148 CPU_SUBTYPE_POWERPC_603,
4149 CPU_SUBTYPE_POWERPC_603E,
4150 CPU_SUBTYPE_POWERPC_603EV,
4151 CPU_SUBTYPE_POWERPC_604,
4152 CPU_SUBTYPE_POWERPC_604E,
4153 CPU_SUBTYPE_POWERPC_620,
4154 CPU_SUBTYPE_POWERPC_750,
4155 CPU_SUBTYPE_POWERPC_7400,
4156 CPU_SUBTYPE_POWERPC_7450,
4157 CPU_SUBTYPE_POWERPC_970,
4158 );
4159 static FLAGS_CPU_SUBTYPE_ARM: &[Flag<u32>] = &flags!(
4160 CPU_SUBTYPE_ARM_ALL,
4161 CPU_SUBTYPE_ARM_V4T,
4162 CPU_SUBTYPE_ARM_V6,
4163 CPU_SUBTYPE_ARM_V5TEJ,
4164 CPU_SUBTYPE_ARM_XSCALE,
4165 CPU_SUBTYPE_ARM_V7,
4166 CPU_SUBTYPE_ARM_V7F,
4167 CPU_SUBTYPE_ARM_V7S,
4168 CPU_SUBTYPE_ARM_V7K,
4169 CPU_SUBTYPE_ARM_V8,
4170 CPU_SUBTYPE_ARM_V6M,
4171 CPU_SUBTYPE_ARM_V7M,
4172 CPU_SUBTYPE_ARM_V7EM,
4173 CPU_SUBTYPE_ARM_V8M,
4174 );
4175 static FLAGS_CPU_SUBTYPE_ARM64: &[Flag<u32>] = &flags!(
4176 CPU_SUBTYPE_ARM64_ALL,
4177 CPU_SUBTYPE_ARM64_V8,
4178 CPU_SUBTYPE_ARM64E,
4179 );
4180 static FLAGS_CPU_SUBTYPE_ARM64_32: &[Flag<u32>] =
4181 &flags!(CPU_SUBTYPE_ARM64_32_ALL, CPU_SUBTYPE_ARM64_32_V8);
4182 static FLAGS_MH_FILETYPE: &[Flag<u32>] = &flags!(
4183 MH_OBJECT,
4184 MH_EXECUTE,
4185 MH_FVMLIB,
4186 MH_CORE,
4187 MH_PRELOAD,
4188 MH_DYLIB,
4189 MH_DYLINKER,
4190 MH_BUNDLE,
4191 MH_DYLIB_STUB,
4192 MH_DSYM,
4193 MH_KEXT_BUNDLE,
4194 MH_FILESET,
4195 );
4196 static FLAGS_MH: &[Flag<u32>] = &flags!(
4197 MH_NOUNDEFS,
4198 MH_INCRLINK,
4199 MH_DYLDLINK,
4200 MH_BINDATLOAD,
4201 MH_PREBOUND,
4202 MH_SPLIT_SEGS,
4203 MH_LAZY_INIT,
4204 MH_TWOLEVEL,
4205 MH_FORCE_FLAT,
4206 MH_NOMULTIDEFS,
4207 MH_NOFIXPREBINDING,
4208 MH_PREBINDABLE,
4209 MH_ALLMODSBOUND,
4210 MH_SUBSECTIONS_VIA_SYMBOLS,
4211 MH_CANONICAL,
4212 MH_WEAK_DEFINES,
4213 MH_BINDS_TO_WEAK,
4214 MH_ALLOW_STACK_EXECUTION,
4215 MH_ROOT_SAFE,
4216 MH_SETUID_SAFE,
4217 MH_NO_REEXPORTED_DYLIBS,
4218 MH_PIE,
4219 MH_DEAD_STRIPPABLE_DYLIB,
4220 MH_HAS_TLV_DESCRIPTORS,
4221 MH_NO_HEAP_EXECUTION,
4222 MH_APP_EXTENSION_SAFE,
4223 MH_NLIST_OUTOFSYNC_WITH_DYLDINFO,
4224 MH_SIM_SUPPORT,
4225 MH_DYLIB_IN_CACHE,
4226 );
4227 static FLAGS_LC: &[Flag<u32>] = &flags!(
4228 LC_SEGMENT,
4229 LC_SYMTAB,
4230 LC_SYMSEG,
4231 LC_THREAD,
4232 LC_UNIXTHREAD,
4233 LC_LOADFVMLIB,
4234 LC_IDFVMLIB,
4235 LC_IDENT,
4236 LC_FVMFILE,
4237 LC_PREPAGE,
4238 LC_DYSYMTAB,
4239 LC_LOAD_DYLIB,
4240 LC_ID_DYLIB,
4241 LC_LOAD_DYLINKER,
4242 LC_ID_DYLINKER,
4243 LC_PREBOUND_DYLIB,
4244 LC_ROUTINES,
4245 LC_SUB_FRAMEWORK,
4246 LC_SUB_UMBRELLA,
4247 LC_SUB_CLIENT,
4248 LC_SUB_LIBRARY,
4249 LC_TWOLEVEL_HINTS,
4250 LC_PREBIND_CKSUM,
4251 LC_LOAD_WEAK_DYLIB,
4252 LC_SEGMENT_64,
4253 LC_ROUTINES_64,
4254 LC_UUID,
4255 LC_RPATH,
4256 LC_CODE_SIGNATURE,
4257 LC_SEGMENT_SPLIT_INFO,
4258 LC_REEXPORT_DYLIB,
4259 LC_LAZY_LOAD_DYLIB,
4260 LC_ENCRYPTION_INFO,
4261 LC_DYLD_INFO,
4262 LC_DYLD_INFO_ONLY,
4263 LC_LOAD_UPWARD_DYLIB,
4264 LC_VERSION_MIN_MACOSX,
4265 LC_VERSION_MIN_IPHONEOS,
4266 LC_FUNCTION_STARTS,
4267 LC_DYLD_ENVIRONMENT,
4268 LC_MAIN,
4269 LC_DATA_IN_CODE,
4270 LC_SOURCE_VERSION,
4271 LC_DYLIB_CODE_SIGN_DRS,
4272 LC_ENCRYPTION_INFO_64,
4273 LC_LINKER_OPTION,
4274 LC_LINKER_OPTIMIZATION_HINT,
4275 LC_VERSION_MIN_TVOS,
4276 LC_VERSION_MIN_WATCHOS,
4277 LC_NOTE,
4278 LC_BUILD_VERSION,
4279 LC_DYLD_EXPORTS_TRIE,
4280 LC_DYLD_CHAINED_FIXUPS,
4281 LC_FILESET_ENTRY,
4282 );
4283 static FLAGS_VM: &[Flag<u32>] = &flags!(VM_PROT_READ, VM_PROT_WRITE, VM_PROT_EXECUTE);
4284 static FLAGS_SG: &[Flag<u32>] = &flags!(
4285 SG_HIGHVM,
4286 SG_FVMLIB,
4287 SG_NORELOC,
4288 SG_PROTECTED_VERSION_1,
4289 SG_READ_ONLY,
4290 );
4291 static FLAGS_S_TYPE: &[Flag<u32>] = &flags!(
4292 S_REGULAR,
4293 S_ZEROFILL,
4294 S_CSTRING_LITERALS,
4295 S_4BYTE_LITERALS,
4296 S_8BYTE_LITERALS,
4297 S_LITERAL_POINTERS,
4298 S_NON_LAZY_SYMBOL_POINTERS,
4299 S_LAZY_SYMBOL_POINTERS,
4300 S_SYMBOL_STUBS,
4301 S_MOD_INIT_FUNC_POINTERS,
4302 S_MOD_TERM_FUNC_POINTERS,
4303 S_COALESCED,
4304 S_GB_ZEROFILL,
4305 S_INTERPOSING,
4306 S_16BYTE_LITERALS,
4307 S_DTRACE_DOF,
4308 S_LAZY_DYLIB_SYMBOL_POINTERS,
4309 S_THREAD_LOCAL_REGULAR,
4310 S_THREAD_LOCAL_ZEROFILL,
4311 S_THREAD_LOCAL_VARIABLES,
4312 S_THREAD_LOCAL_VARIABLE_POINTERS,
4313 S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
4314 S_INIT_FUNC_OFFSETS,
4315 );
4316 static FLAGS_S_ATTR: &[Flag<u32>] = &flags!(
4317 S_ATTR_PURE_INSTRUCTIONS,
4318 S_ATTR_NO_TOC,
4319 S_ATTR_STRIP_STATIC_SYMS,
4320 S_ATTR_NO_DEAD_STRIP,
4321 S_ATTR_LIVE_SUPPORT,
4322 S_ATTR_SELF_MODIFYING_CODE,
4323 S_ATTR_DEBUG,
4324 S_ATTR_SOME_INSTRUCTIONS,
4325 S_ATTR_EXT_RELOC,
4326 S_ATTR_LOC_RELOC,
4327 );
4328 static FLAGS_PLATFORM: &[Flag<u32>] = &flags!(
4329 PLATFORM_MACOS,
4330 PLATFORM_IOS,
4331 PLATFORM_TVOS,
4332 PLATFORM_WATCHOS,
4333 PLATFORM_BRIDGEOS,
4334 PLATFORM_MACCATALYST,
4335 PLATFORM_IOSSIMULATOR,
4336 PLATFORM_TVOSSIMULATOR,
4337 PLATFORM_WATCHOSSIMULATOR,
4338 PLATFORM_DRIVERKIT,
4339 );
4340 static FLAGS_N_EXT: &[Flag<u8>] = &flags!(N_PEXT, N_EXT);
4341 static FLAGS_N_TYPE: &[Flag<u8>] = &flags!(N_UNDF, N_ABS, N_SECT, N_PBUD, N_INDR);
4342 static FLAGS_N_STAB: &[Flag<u8>] = &flags!(
4343 N_GSYM, N_FNAME, N_FUN, N_STSYM, N_LCSYM, N_BNSYM, N_AST, N_OPT, N_RSYM, N_SLINE, N_ENSYM,
4344 N_SSYM, N_SO, N_OSO, N_LSYM, N_BINCL, N_SOL, N_PARAMS, N_VERSION, N_OLEVEL, N_PSYM,
4345 N_EINCL, N_ENTRY, N_LBRAC, N_EXCL, N_RBRAC, N_BCOMM, N_ECOMM, N_ECOML, N_LENG, N_PC,
4346 );
4347 static FLAGS_REFERENCE: &[Flag<u16>] = &flags!(
4348 REFERENCE_FLAG_UNDEFINED_NON_LAZY,
4349 REFERENCE_FLAG_UNDEFINED_LAZY,
4350 REFERENCE_FLAG_DEFINED,
4351 REFERENCE_FLAG_PRIVATE_DEFINED,
4352 REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY,
4353 REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY,
4354 );
4355 static FLAGS_N_DESC: &[Flag<u16>] = &flags!(
4356 REFERENCED_DYNAMICALLY,
4357 N_NO_DEAD_STRIP,
4358 N_DESC_DISCARDED,
4359 N_WEAK_REF,
4360 N_WEAK_DEF,
4361 N_REF_TO_WEAK,
4362 N_ARM_THUMB_DEF,
4363 N_SYMBOL_RESOLVER,
4364 N_ALT_ENTRY,
4365 );
4366 static FLAGS_GENERIC_RELOC: &[Flag<u8>] = &flags!(
4367 GENERIC_RELOC_VANILLA,
4368 GENERIC_RELOC_PAIR,
4369 GENERIC_RELOC_SECTDIFF,
4370 GENERIC_RELOC_PB_LA_PTR,
4371 GENERIC_RELOC_LOCAL_SECTDIFF,
4372 GENERIC_RELOC_TLV,
4373 );
4374 static FLAGS_ARM_RELOC: &[Flag<u8>] = &flags!(
4375 ARM_RELOC_VANILLA,
4376 ARM_RELOC_PAIR,
4377 ARM_RELOC_SECTDIFF,
4378 ARM_RELOC_LOCAL_SECTDIFF,
4379 ARM_RELOC_PB_LA_PTR,
4380 ARM_RELOC_BR24,
4381 ARM_THUMB_RELOC_BR22,
4382 ARM_THUMB_32BIT_BRANCH,
4383 ARM_RELOC_HALF,
4384 ARM_RELOC_HALF_SECTDIFF,
4385 );
4386 static FLAGS_ARM64_RELOC: &[Flag<u8>] = &flags!(
4387 ARM64_RELOC_UNSIGNED,
4388 ARM64_RELOC_SUBTRACTOR,
4389 ARM64_RELOC_BRANCH26,
4390 ARM64_RELOC_PAGE21,
4391 ARM64_RELOC_PAGEOFF12,
4392 ARM64_RELOC_GOT_LOAD_PAGE21,
4393 ARM64_RELOC_GOT_LOAD_PAGEOFF12,
4394 ARM64_RELOC_POINTER_TO_GOT,
4395 ARM64_RELOC_TLVP_LOAD_PAGE21,
4396 ARM64_RELOC_TLVP_LOAD_PAGEOFF12,
4397 ARM64_RELOC_ADDEND,
4398 ARM64_RELOC_AUTHENTICATED_POINTER,
4399 );
4400 static FLAGS_PPC_RELOC: &[Flag<u8>] = &flags!(
4401 PPC_RELOC_VANILLA,
4402 PPC_RELOC_PAIR,
4403 PPC_RELOC_BR14,
4404 PPC_RELOC_BR24,
4405 PPC_RELOC_HI16,
4406 PPC_RELOC_LO16,
4407 PPC_RELOC_HA16,
4408 PPC_RELOC_LO14,
4409 PPC_RELOC_SECTDIFF,
4410 PPC_RELOC_PB_LA_PTR,
4411 PPC_RELOC_HI16_SECTDIFF,
4412 PPC_RELOC_LO16_SECTDIFF,
4413 PPC_RELOC_HA16_SECTDIFF,
4414 PPC_RELOC_JBSR,
4415 PPC_RELOC_LO14_SECTDIFF,
4416 PPC_RELOC_LOCAL_SECTDIFF,
4417 );
4418 static FLAGS_X86_64_RELOC: &[Flag<u8>] = &flags!(
4419 X86_64_RELOC_UNSIGNED,
4420 X86_64_RELOC_SIGNED,
4421 X86_64_RELOC_BRANCH,
4422 X86_64_RELOC_GOT_LOAD,
4423 X86_64_RELOC_GOT,
4424 X86_64_RELOC_SUBTRACTOR,
4425 X86_64_RELOC_SIGNED_1,
4426 X86_64_RELOC_SIGNED_2,
4427 X86_64_RELOC_SIGNED_4,
4428 X86_64_RELOC_TLV,
4429 );
4430 }
4431
4432 mod pe {
4433 use super::*;
4434 use object::pe::*;
4435 use object::read::pe::*;
4436 use object::LittleEndian as LE;
4437
print_coff(p: &mut Printer<impl Write>, data: &[u8])4438 pub(super) fn print_coff(p: &mut Printer<impl Write>, data: &[u8]) {
4439 let mut offset = 0;
4440 if let Ok(header) = ImageFileHeader::parse(data, &mut offset) {
4441 println!("Format: COFF");
4442 print_file(p, header);
4443 let sections = header.sections(data, offset).ok();
4444 let symbols = header.symbols(data).ok();
4445 if let Some(ref sections) = sections {
4446 print_sections(p, data, header.machine.get(LE), symbols.as_ref(), §ions);
4447 }
4448 if let Some(ref symbols) = symbols {
4449 print_symbols(p, sections.as_ref(), &symbols);
4450 }
4451 }
4452 }
4453
print_pe32(p: &mut Printer<impl Write>, data: &[u8])4454 pub(super) fn print_pe32(p: &mut Printer<impl Write>, data: &[u8]) {
4455 println!("Format: PE 32-bit");
4456 print_pe::<ImageNtHeaders32, _>(p, data);
4457 }
4458
print_pe64(p: &mut Printer<impl Write>, data: &[u8])4459 pub(super) fn print_pe64(p: &mut Printer<impl Write>, data: &[u8]) {
4460 println!("Format: PE 64-bit");
4461 print_pe::<ImageNtHeaders64, _>(p, data);
4462 }
4463
print_pe<Pe: ImageNtHeaders, W: Write>(p: &mut Printer<W>, data: &[u8])4464 fn print_pe<Pe: ImageNtHeaders, W: Write>(p: &mut Printer<W>, data: &[u8]) {
4465 if let Ok(dos_header) = ImageDosHeader::parse(data) {
4466 p.group("ImageDosHeader", |p| {
4467 p.field_hex("Magic", dos_header.e_magic.get(LE));
4468 p.field_hex("CountBytesLastPage", dos_header.e_cblp.get(LE));
4469 p.field_hex("CountPages", dos_header.e_cp.get(LE));
4470 p.field_hex("CountRelocations", dos_header.e_crlc.get(LE));
4471 p.field_hex("CountHeaderParagraphs", dos_header.e_cparhdr.get(LE));
4472 p.field_hex("MinAllocParagraphs", dos_header.e_minalloc.get(LE));
4473 p.field_hex("MaxAllocParagraphs", dos_header.e_maxalloc.get(LE));
4474 p.field_hex("StackSegment", dos_header.e_ss.get(LE));
4475 p.field_hex("StackPointer", dos_header.e_sp.get(LE));
4476 p.field_hex("Checksum", dos_header.e_csum.get(LE));
4477 p.field_hex("InstructionPointer", dos_header.e_ip.get(LE));
4478 p.field_hex("CodeSegment", dos_header.e_cs.get(LE));
4479 p.field_hex("AddressOfRelocations", dos_header.e_lfarlc.get(LE));
4480 p.field_hex("OverlayNumber", dos_header.e_ovno.get(LE));
4481 p.field_hex("OemId", dos_header.e_oemid.get(LE));
4482 p.field_hex("OemInfo", dos_header.e_oeminfo.get(LE));
4483 p.field_hex("AddressOfNewHeader", dos_header.e_lfanew.get(LE));
4484 });
4485 let mut offset = dos_header.nt_headers_offset().into();
4486 if let Ok((nt_headers, data_directories)) = Pe::parse(data, &mut offset) {
4487 p.group("ImageNtHeaders", |p| {
4488 p.field_hex("Signature", nt_headers.signature());
4489 });
4490 let header = nt_headers.file_header();
4491 let sections = header.sections(data, offset).ok();
4492 let symbols = header.symbols(data).ok();
4493 print_file(p, header);
4494 print_optional(p, nt_headers.optional_header());
4495 for (index, dir) in data_directories.iter().enumerate() {
4496 p.group("ImageDataDirectory", |p| {
4497 p.field_enum("Index", index, FLAGS_IMAGE_DIRECTORY_ENTRY);
4498 p.field_hex("VirtualAddress", dir.virtual_address.get(LE));
4499 p.field_hex("Size", dir.size.get(LE));
4500 if let Some(dir_data) = sections
4501 .as_ref()
4502 .and_then(|sections| dir.data(data, sections).ok())
4503 {
4504 match index {
4505 IMAGE_DIRECTORY_ENTRY_EXPORT => print_export_dir(p, dir, dir_data),
4506 // TODO
4507 _ => {}
4508 }
4509 }
4510 });
4511 }
4512 if let Some(ref sections) = sections {
4513 print_sections(p, data, header.machine.get(LE), symbols.as_ref(), §ions);
4514 }
4515 if let Some(ref symbols) = symbols {
4516 print_symbols(p, sections.as_ref(), &symbols);
4517 }
4518 }
4519 }
4520 }
4521
print_file(p: &mut Printer<impl Write>, header: &ImageFileHeader)4522 fn print_file(p: &mut Printer<impl Write>, header: &ImageFileHeader) {
4523 p.group("ImageFileHeader", |p| {
4524 p.field_enum("Machine", header.machine.get(LE), FLAGS_IMAGE_FILE_MACHINE);
4525 p.field("NumberOfSections", header.number_of_sections.get(LE));
4526 p.field("TimeDateStamp", header.time_date_stamp.get(LE));
4527 p.field_hex(
4528 "PointerToSymbolTable",
4529 header.pointer_to_symbol_table.get(LE),
4530 );
4531 p.field("NumberOfSymbols", header.number_of_symbols.get(LE));
4532 p.field_hex(
4533 "SizeOfOptionalHeader",
4534 header.size_of_optional_header.get(LE),
4535 );
4536 p.field_hex("Characteristics", header.characteristics.get(LE));
4537 p.flags(header.characteristics.get(LE), 0, FLAGS_IMAGE_FILE);
4538 });
4539 }
4540
print_optional(p: &mut Printer<impl Write>, header: &impl ImageOptionalHeader)4541 fn print_optional(p: &mut Printer<impl Write>, header: &impl ImageOptionalHeader) {
4542 p.group("ImageOptionalHeader", |p| {
4543 p.field_hex("Magic", header.magic());
4544 p.field("MajorLinkerVersion", header.major_linker_version());
4545 p.field("MinorLinkerVersion", header.minor_linker_version());
4546 p.field_hex("SizeOfCode", header.size_of_code());
4547 p.field_hex("SizeOfInitializedData", header.size_of_initialized_data());
4548 p.field_hex(
4549 "SizeOfUninitializedData",
4550 header.size_of_uninitialized_data(),
4551 );
4552 p.field_hex("AddressOfEntryPoint", header.address_of_entry_point());
4553 p.field_hex("BaseOfCode", header.base_of_code());
4554 p.field_hex("ImageBase", header.image_base());
4555 p.field_hex("SectionAlignment", header.section_alignment());
4556 p.field(
4557 "MajorOperatingSystemVersion",
4558 header.major_operating_system_version(),
4559 );
4560 p.field(
4561 "MinorOperatingSystemVersion",
4562 header.minor_operating_system_version(),
4563 );
4564 p.field("MajorImageVersion", header.major_image_version());
4565 p.field("MinorImageVersion", header.minor_image_version());
4566 p.field("MajorSubsystemVersion", header.major_subsystem_version());
4567 p.field("MinorSubsystemVersion", header.minor_subsystem_version());
4568 p.field("Win32VersionValue", header.win32_version_value());
4569 p.field_hex("SizeOfImage", header.size_of_image());
4570 p.field_hex("SizeOfHeaders", header.size_of_headers());
4571 p.field_hex("CheckSum", header.check_sum());
4572 p.field_enum("Subsystem", header.subsystem(), FLAGS_IMAGE_SUBSYSTEM);
4573 p.field_hex("DllCharacteristics", header.dll_characteristics());
4574 p.flags(
4575 header.dll_characteristics(),
4576 0,
4577 FLAGS_IMAGE_DLLCHARACTERISTICS,
4578 );
4579 p.field_hex("SizeOfStackReserve", header.size_of_stack_reserve());
4580 p.field_hex("SizeOfStackCommit", header.size_of_stack_commit());
4581 p.field_hex("SizeOfHeapReserve", header.size_of_heap_reserve());
4582 p.field_hex("SizeOfHeapCommit", header.size_of_heap_commit());
4583 p.field_hex("LoaderFlags", header.loader_flags());
4584 p.field_hex("NumberOfRvaAndSizes", header.number_of_rva_and_sizes());
4585 });
4586 }
4587
print_export_dir(p: &mut Printer<impl Write>, _dir: &ImageDataDirectory, dir_data: &[u8])4588 fn print_export_dir(p: &mut Printer<impl Write>, _dir: &ImageDataDirectory, dir_data: &[u8]) {
4589 if let Ok((export_dir, _)) = object::from_bytes::<pe::ImageExportDirectory>(dir_data) {
4590 p.group("ImageExportDirectory", |p| {
4591 p.field_hex("Characteristics", export_dir.characteristics.get(LE));
4592 p.field_hex("TimeDateStamp", export_dir.time_date_stamp.get(LE));
4593 p.field("MajorVersion", export_dir.major_version.get(LE));
4594 p.field("MinorVersion", export_dir.minor_version.get(LE));
4595 p.field_hex("Name", export_dir.name.get(LE));
4596 p.field("Base", export_dir.base.get(LE));
4597 p.field("NumberOfFunctions", export_dir.number_of_functions.get(LE));
4598 p.field("NumberOfNames", export_dir.number_of_names.get(LE));
4599 p.field_hex(
4600 "AddressOfFunctions",
4601 export_dir.address_of_functions.get(LE),
4602 );
4603 p.field_hex("AddressOfNames", export_dir.address_of_names.get(LE));
4604 p.field_hex(
4605 "AddressOfNameOrdinals",
4606 export_dir.address_of_name_ordinals.get(LE),
4607 );
4608 // TODO: display tables
4609 });
4610 }
4611 }
4612
print_sections( p: &mut Printer<impl Write>, data: &[u8], machine: u16, symbols: Option<&SymbolTable>, sections: &SectionTable, )4613 fn print_sections(
4614 p: &mut Printer<impl Write>,
4615 data: &[u8],
4616 machine: u16,
4617 symbols: Option<&SymbolTable>,
4618 sections: &SectionTable,
4619 ) {
4620 for (index, section) in sections.iter().enumerate() {
4621 p.group("ImageSectionHeader", |p| {
4622 p.field("Index", index + 1);
4623 if let Some(name) = symbols.and_then(|symbols| section.name(symbols.strings()).ok())
4624 {
4625 p.field_inline_string("Name", name);
4626 } else {
4627 p.field_inline_string("Name", section.raw_name());
4628 }
4629 p.field_hex("VirtualSize", section.virtual_size.get(LE));
4630 p.field_hex("VirtualAddress", section.virtual_address.get(LE));
4631 p.field_hex("SizeOfRawData", section.size_of_raw_data.get(LE));
4632 p.field_hex("PointerToRawData", section.pointer_to_raw_data.get(LE));
4633 p.field_hex(
4634 "PointerToRelocations",
4635 section.pointer_to_relocations.get(LE),
4636 );
4637 p.field_hex(
4638 "PointerToLinenumbers",
4639 section.pointer_to_linenumbers.get(LE),
4640 );
4641 p.field("NumberOfRelocations", section.number_of_relocations.get(LE));
4642 p.field("NumberOfLinenumbers", section.number_of_linenumbers.get(LE));
4643 p.field_hex("Characteristics", section.characteristics.get(LE));
4644 p.flags(section.characteristics.get(LE), 0, FLAGS_IMAGE_SCN);
4645 p.flags(
4646 section.characteristics.get(LE),
4647 IMAGE_SCN_ALIGN_MASK,
4648 FLAGS_IMAGE_SCN_ALIGN,
4649 );
4650 if let Ok(relocations) = section.coff_relocations(data) {
4651 for relocation in relocations {
4652 p.group("ImageRelocation", |p| {
4653 p.field_hex("VirtualAddress", relocation.virtual_address.get(LE));
4654 let index = relocation.symbol_table_index.get(LE);
4655 let name = symbols.and_then(|symbols| {
4656 symbols
4657 .symbol(index as usize)
4658 .and_then(|symbol| symbol.name(symbols.strings()))
4659 .ok()
4660 });
4661 p.field_string("Symbol", index, name);
4662 let proc = match machine {
4663 IMAGE_FILE_MACHINE_I386 => FLAGS_IMAGE_REL_I386,
4664 IMAGE_FILE_MACHINE_MIPS16
4665 | IMAGE_FILE_MACHINE_MIPSFPU
4666 | IMAGE_FILE_MACHINE_MIPSFPU16 => FLAGS_IMAGE_REL_MIPS,
4667 IMAGE_FILE_MACHINE_ALPHA | IMAGE_FILE_MACHINE_ALPHA64 => {
4668 FLAGS_IMAGE_REL_ALPHA
4669 }
4670 IMAGE_FILE_MACHINE_POWERPC | IMAGE_FILE_MACHINE_POWERPCFP => {
4671 FLAGS_IMAGE_REL_PPC
4672 }
4673 IMAGE_FILE_MACHINE_SH3
4674 | IMAGE_FILE_MACHINE_SH3DSP
4675 | IMAGE_FILE_MACHINE_SH3E
4676 | IMAGE_FILE_MACHINE_SH4
4677 | IMAGE_FILE_MACHINE_SH5 => FLAGS_IMAGE_REL_SH,
4678 IMAGE_FILE_MACHINE_ARM => FLAGS_IMAGE_REL_ARM,
4679 IMAGE_FILE_MACHINE_AM33 => FLAGS_IMAGE_REL_AM,
4680 IMAGE_FILE_MACHINE_ARM64 => FLAGS_IMAGE_REL_ARM64,
4681 IMAGE_FILE_MACHINE_AMD64 => FLAGS_IMAGE_REL_AMD64,
4682 IMAGE_FILE_MACHINE_IA64 => FLAGS_IMAGE_REL_IA64,
4683 IMAGE_FILE_MACHINE_CEF => FLAGS_IMAGE_REL_CEF,
4684 IMAGE_FILE_MACHINE_CEE => FLAGS_IMAGE_REL_CEE,
4685 IMAGE_FILE_MACHINE_M32R => FLAGS_IMAGE_REL_M32R,
4686 IMAGE_FILE_MACHINE_EBC => FLAGS_IMAGE_REL_EBC,
4687 _ => &[],
4688 };
4689 let typ = relocation.typ.get(LE);
4690 p.field_enum("Type", typ, proc);
4691 match machine {
4692 IMAGE_FILE_MACHINE_POWERPC | IMAGE_FILE_MACHINE_POWERPCFP => {
4693 p.flags(typ, 0, FLAGS_IMAGE_REL_PPC_BITS)
4694 }
4695 IMAGE_FILE_MACHINE_SH3
4696 | IMAGE_FILE_MACHINE_SH3DSP
4697 | IMAGE_FILE_MACHINE_SH3E
4698 | IMAGE_FILE_MACHINE_SH4
4699 | IMAGE_FILE_MACHINE_SH5 => {
4700 p.flags(typ, 0, FLAGS_IMAGE_REL_SH_BITS)
4701 }
4702 _ => {}
4703 }
4704 });
4705 }
4706 }
4707 });
4708 }
4709 }
4710
print_symbols( p: &mut Printer<impl Write>, sections: Option<&SectionTable>, symbols: &SymbolTable, )4711 fn print_symbols(
4712 p: &mut Printer<impl Write>,
4713 sections: Option<&SectionTable>,
4714 symbols: &SymbolTable,
4715 ) {
4716 for (index, symbol) in symbols.iter() {
4717 p.group("ImageSymbol", |p| {
4718 p.field("Index", index);
4719 if let Ok(name) = symbol.name(symbols.strings()) {
4720 p.field_inline_string("Name", name);
4721 } else {
4722 p.field("Name", format!("{:X?}", symbol.name));
4723 }
4724 p.field_hex("Value", symbol.value.get(LE));
4725 let section = symbol.section_number.get(LE);
4726 if section == 0 || section >= IMAGE_SYM_SECTION_MAX {
4727 p.field_enum("Section", section, FLAGS_IMAGE_SYM);
4728 } else {
4729 let section_name = sections.and_then(|sections| {
4730 sections
4731 .section(section.into())
4732 .and_then(|section| section.name(symbols.strings()))
4733 .ok()
4734 });
4735 p.field_string("Section", section, section_name);
4736 }
4737 p.field_hex("Type", symbol.typ.get(LE));
4738 p.field_enum("BaseType", symbol.base_type(), FLAGS_IMAGE_SYM_TYPE);
4739 p.field_enum("DerivedType", symbol.derived_type(), FLAGS_IMAGE_SYM_DTYPE);
4740 p.field_enum("StorageClass", symbol.storage_class, FLAGS_IMAGE_SYM_CLASS);
4741 p.field_hex("NumberOfAuxSymbols", symbol.number_of_aux_symbols);
4742 if symbol.has_aux_file_name() {
4743 if let Ok(name) = symbols.aux_file_name(index, symbol.number_of_aux_symbols) {
4744 p.group("ImageAuxSymbolFile", |p| {
4745 p.field_inline_string("Name", name);
4746 });
4747 }
4748 } else if symbol.has_aux_function() {
4749 if let Ok(aux) = symbols.aux_function(index) {
4750 p.group("ImageAuxSymbolFunction", |p| {
4751 p.field("TagIndex", aux.tag_index.get(LE));
4752 p.field("TotalSize", aux.total_size.get(LE));
4753 p.field_hex("PointerToLinenumber", aux.pointer_to_linenumber.get(LE));
4754 p.field(
4755 "PointerToNextFunction",
4756 aux.pointer_to_next_function.get(LE),
4757 );
4758 p.field("Unused", format!("{:X?}", aux.unused));
4759 });
4760 }
4761 } else if symbol.has_aux_section() {
4762 if let Ok(aux) = symbols.aux_section(index) {
4763 p.group("ImageAuxSymbolSection", |p| {
4764 p.field_hex("Length", aux.length.get(LE));
4765 p.field("NumberOfRelocations", aux.number_of_relocations.get(LE));
4766 p.field("NumberOfLinenumbers", aux.number_of_linenumbers.get(LE));
4767 p.field_hex("CheckSum", aux.check_sum.get(LE));
4768 p.field("Number", aux.number.get(LE));
4769 p.field_enum("Selection", aux.selection, FLAGS_IMAGE_COMDAT_SELECT);
4770 p.field_hex("Reserved", aux.reserved);
4771 p.field("HighNumber", aux.high_number.get(LE));
4772 });
4773 }
4774 }
4775 // TODO: ImageAuxSymbolFunctionBeginEnd
4776 // TODO: ImageAuxSymbolWeak
4777 });
4778 }
4779 }
4780
4781 static FLAGS_IMAGE_FILE: &[Flag<u16>] = &flags!(
4782 IMAGE_FILE_RELOCS_STRIPPED,
4783 IMAGE_FILE_EXECUTABLE_IMAGE,
4784 IMAGE_FILE_LINE_NUMS_STRIPPED,
4785 IMAGE_FILE_LOCAL_SYMS_STRIPPED,
4786 IMAGE_FILE_AGGRESIVE_WS_TRIM,
4787 IMAGE_FILE_LARGE_ADDRESS_AWARE,
4788 IMAGE_FILE_BYTES_REVERSED_LO,
4789 IMAGE_FILE_32BIT_MACHINE,
4790 IMAGE_FILE_DEBUG_STRIPPED,
4791 IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP,
4792 IMAGE_FILE_NET_RUN_FROM_SWAP,
4793 IMAGE_FILE_SYSTEM,
4794 IMAGE_FILE_DLL,
4795 IMAGE_FILE_UP_SYSTEM_ONLY,
4796 IMAGE_FILE_BYTES_REVERSED_HI,
4797 );
4798 static FLAGS_IMAGE_FILE_MACHINE: &[Flag<u16>] = &flags!(
4799 IMAGE_FILE_MACHINE_UNKNOWN,
4800 IMAGE_FILE_MACHINE_TARGET_HOST,
4801 IMAGE_FILE_MACHINE_I386,
4802 IMAGE_FILE_MACHINE_R3000,
4803 IMAGE_FILE_MACHINE_R4000,
4804 IMAGE_FILE_MACHINE_R10000,
4805 IMAGE_FILE_MACHINE_WCEMIPSV2,
4806 IMAGE_FILE_MACHINE_ALPHA,
4807 IMAGE_FILE_MACHINE_SH3,
4808 IMAGE_FILE_MACHINE_SH3DSP,
4809 IMAGE_FILE_MACHINE_SH3E,
4810 IMAGE_FILE_MACHINE_SH4,
4811 IMAGE_FILE_MACHINE_SH5,
4812 IMAGE_FILE_MACHINE_ARM,
4813 IMAGE_FILE_MACHINE_THUMB,
4814 IMAGE_FILE_MACHINE_ARMNT,
4815 IMAGE_FILE_MACHINE_AM33,
4816 IMAGE_FILE_MACHINE_POWERPC,
4817 IMAGE_FILE_MACHINE_POWERPCFP,
4818 IMAGE_FILE_MACHINE_IA64,
4819 IMAGE_FILE_MACHINE_MIPS16,
4820 IMAGE_FILE_MACHINE_ALPHA64,
4821 IMAGE_FILE_MACHINE_MIPSFPU,
4822 IMAGE_FILE_MACHINE_MIPSFPU16,
4823 IMAGE_FILE_MACHINE_AXP64,
4824 IMAGE_FILE_MACHINE_TRICORE,
4825 IMAGE_FILE_MACHINE_CEF,
4826 IMAGE_FILE_MACHINE_EBC,
4827 IMAGE_FILE_MACHINE_AMD64,
4828 IMAGE_FILE_MACHINE_M32R,
4829 IMAGE_FILE_MACHINE_ARM64,
4830 IMAGE_FILE_MACHINE_CEE,
4831 IMAGE_FILE_MACHINE_RISCV32,
4832 IMAGE_FILE_MACHINE_RISCV64,
4833 IMAGE_FILE_MACHINE_RISCV128,
4834 );
4835 static FLAGS_IMAGE_SCN: &[Flag<u32>] = &flags!(
4836 IMAGE_SCN_TYPE_NO_PAD,
4837 IMAGE_SCN_CNT_CODE,
4838 IMAGE_SCN_CNT_INITIALIZED_DATA,
4839 IMAGE_SCN_CNT_UNINITIALIZED_DATA,
4840 IMAGE_SCN_LNK_OTHER,
4841 IMAGE_SCN_LNK_INFO,
4842 IMAGE_SCN_LNK_REMOVE,
4843 IMAGE_SCN_LNK_COMDAT,
4844 IMAGE_SCN_NO_DEFER_SPEC_EXC,
4845 IMAGE_SCN_GPREL,
4846 IMAGE_SCN_MEM_FARDATA,
4847 IMAGE_SCN_MEM_PURGEABLE,
4848 IMAGE_SCN_MEM_16BIT,
4849 IMAGE_SCN_MEM_LOCKED,
4850 IMAGE_SCN_MEM_PRELOAD,
4851 IMAGE_SCN_LNK_NRELOC_OVFL,
4852 IMAGE_SCN_MEM_DISCARDABLE,
4853 IMAGE_SCN_MEM_NOT_CACHED,
4854 IMAGE_SCN_MEM_NOT_PAGED,
4855 IMAGE_SCN_MEM_SHARED,
4856 IMAGE_SCN_MEM_EXECUTE,
4857 IMAGE_SCN_MEM_READ,
4858 IMAGE_SCN_MEM_WRITE,
4859 );
4860 static FLAGS_IMAGE_SCN_ALIGN: &[Flag<u32>] = &flags!(
4861 IMAGE_SCN_ALIGN_1BYTES,
4862 IMAGE_SCN_ALIGN_2BYTES,
4863 IMAGE_SCN_ALIGN_4BYTES,
4864 IMAGE_SCN_ALIGN_8BYTES,
4865 IMAGE_SCN_ALIGN_16BYTES,
4866 IMAGE_SCN_ALIGN_32BYTES,
4867 IMAGE_SCN_ALIGN_64BYTES,
4868 IMAGE_SCN_ALIGN_128BYTES,
4869 IMAGE_SCN_ALIGN_256BYTES,
4870 IMAGE_SCN_ALIGN_512BYTES,
4871 IMAGE_SCN_ALIGN_1024BYTES,
4872 IMAGE_SCN_ALIGN_2048BYTES,
4873 IMAGE_SCN_ALIGN_4096BYTES,
4874 IMAGE_SCN_ALIGN_8192BYTES,
4875 );
4876 static FLAGS_IMAGE_REL_I386: &[Flag<u16>] = &flags!(
4877 IMAGE_REL_I386_ABSOLUTE,
4878 IMAGE_REL_I386_DIR16,
4879 IMAGE_REL_I386_REL16,
4880 IMAGE_REL_I386_DIR32,
4881 IMAGE_REL_I386_DIR32NB,
4882 IMAGE_REL_I386_SEG12,
4883 IMAGE_REL_I386_SECTION,
4884 IMAGE_REL_I386_SECREL,
4885 IMAGE_REL_I386_TOKEN,
4886 IMAGE_REL_I386_SECREL7,
4887 IMAGE_REL_I386_REL32,
4888 );
4889 static FLAGS_IMAGE_REL_MIPS: &[Flag<u16>] = &flags!(
4890 IMAGE_REL_MIPS_ABSOLUTE,
4891 IMAGE_REL_MIPS_REFHALF,
4892 IMAGE_REL_MIPS_REFWORD,
4893 IMAGE_REL_MIPS_JMPADDR,
4894 IMAGE_REL_MIPS_REFHI,
4895 IMAGE_REL_MIPS_REFLO,
4896 IMAGE_REL_MIPS_GPREL,
4897 IMAGE_REL_MIPS_LITERAL,
4898 IMAGE_REL_MIPS_SECTION,
4899 IMAGE_REL_MIPS_SECREL,
4900 IMAGE_REL_MIPS_SECRELLO,
4901 IMAGE_REL_MIPS_SECRELHI,
4902 IMAGE_REL_MIPS_TOKEN,
4903 IMAGE_REL_MIPS_JMPADDR16,
4904 IMAGE_REL_MIPS_REFWORDNB,
4905 IMAGE_REL_MIPS_PAIR,
4906 );
4907 static FLAGS_IMAGE_REL_ALPHA: &[Flag<u16>] = &flags!(
4908 IMAGE_REL_ALPHA_ABSOLUTE,
4909 IMAGE_REL_ALPHA_REFLONG,
4910 IMAGE_REL_ALPHA_REFQUAD,
4911 IMAGE_REL_ALPHA_GPREL32,
4912 IMAGE_REL_ALPHA_LITERAL,
4913 IMAGE_REL_ALPHA_LITUSE,
4914 IMAGE_REL_ALPHA_GPDISP,
4915 IMAGE_REL_ALPHA_BRADDR,
4916 IMAGE_REL_ALPHA_HINT,
4917 IMAGE_REL_ALPHA_INLINE_REFLONG,
4918 IMAGE_REL_ALPHA_REFHI,
4919 IMAGE_REL_ALPHA_REFLO,
4920 IMAGE_REL_ALPHA_PAIR,
4921 IMAGE_REL_ALPHA_MATCH,
4922 IMAGE_REL_ALPHA_SECTION,
4923 IMAGE_REL_ALPHA_SECREL,
4924 IMAGE_REL_ALPHA_REFLONGNB,
4925 IMAGE_REL_ALPHA_SECRELLO,
4926 IMAGE_REL_ALPHA_SECRELHI,
4927 IMAGE_REL_ALPHA_REFQ3,
4928 IMAGE_REL_ALPHA_REFQ2,
4929 IMAGE_REL_ALPHA_REFQ1,
4930 IMAGE_REL_ALPHA_GPRELLO,
4931 IMAGE_REL_ALPHA_GPRELHI,
4932 );
4933 static FLAGS_IMAGE_REL_PPC: &[Flag<u16>] = &flags!(
4934 IMAGE_REL_PPC_ABSOLUTE,
4935 IMAGE_REL_PPC_ADDR64,
4936 IMAGE_REL_PPC_ADDR32,
4937 IMAGE_REL_PPC_ADDR24,
4938 IMAGE_REL_PPC_ADDR16,
4939 IMAGE_REL_PPC_ADDR14,
4940 IMAGE_REL_PPC_REL24,
4941 IMAGE_REL_PPC_REL14,
4942 IMAGE_REL_PPC_TOCREL16,
4943 IMAGE_REL_PPC_TOCREL14,
4944 IMAGE_REL_PPC_ADDR32NB,
4945 IMAGE_REL_PPC_SECREL,
4946 IMAGE_REL_PPC_SECTION,
4947 IMAGE_REL_PPC_IFGLUE,
4948 IMAGE_REL_PPC_IMGLUE,
4949 IMAGE_REL_PPC_SECREL16,
4950 IMAGE_REL_PPC_REFHI,
4951 IMAGE_REL_PPC_REFLO,
4952 IMAGE_REL_PPC_PAIR,
4953 IMAGE_REL_PPC_SECRELLO,
4954 IMAGE_REL_PPC_SECRELHI,
4955 IMAGE_REL_PPC_GPREL,
4956 IMAGE_REL_PPC_TOKEN,
4957 );
4958 static FLAGS_IMAGE_REL_PPC_BITS: &[Flag<u16>] = &flags!(
4959 IMAGE_REL_PPC_NEG,
4960 IMAGE_REL_PPC_BRTAKEN,
4961 IMAGE_REL_PPC_BRNTAKEN,
4962 IMAGE_REL_PPC_TOCDEFN,
4963 );
4964 static FLAGS_IMAGE_REL_SH: &[Flag<u16>] = &flags!(
4965 IMAGE_REL_SH3_ABSOLUTE,
4966 IMAGE_REL_SH3_DIRECT16,
4967 IMAGE_REL_SH3_DIRECT32,
4968 IMAGE_REL_SH3_DIRECT8,
4969 IMAGE_REL_SH3_DIRECT8_WORD,
4970 IMAGE_REL_SH3_DIRECT8_LONG,
4971 IMAGE_REL_SH3_DIRECT4,
4972 IMAGE_REL_SH3_DIRECT4_WORD,
4973 IMAGE_REL_SH3_DIRECT4_LONG,
4974 IMAGE_REL_SH3_PCREL8_WORD,
4975 IMAGE_REL_SH3_PCREL8_LONG,
4976 IMAGE_REL_SH3_PCREL12_WORD,
4977 IMAGE_REL_SH3_STARTOF_SECTION,
4978 IMAGE_REL_SH3_SIZEOF_SECTION,
4979 IMAGE_REL_SH3_SECTION,
4980 IMAGE_REL_SH3_SECREL,
4981 IMAGE_REL_SH3_DIRECT32_NB,
4982 IMAGE_REL_SH3_GPREL4_LONG,
4983 IMAGE_REL_SH3_TOKEN,
4984 IMAGE_REL_SHM_PCRELPT,
4985 IMAGE_REL_SHM_REFLO,
4986 IMAGE_REL_SHM_REFHALF,
4987 IMAGE_REL_SHM_RELLO,
4988 IMAGE_REL_SHM_RELHALF,
4989 IMAGE_REL_SHM_PAIR,
4990 );
4991 static FLAGS_IMAGE_REL_SH_BITS: &[Flag<u16>] = &flags!(IMAGE_REL_SH_NOMODE,);
4992 static FLAGS_IMAGE_REL_ARM: &[Flag<u16>] = &flags!(
4993 IMAGE_REL_ARM_ABSOLUTE,
4994 IMAGE_REL_ARM_ADDR32,
4995 IMAGE_REL_ARM_ADDR32NB,
4996 IMAGE_REL_ARM_BRANCH24,
4997 IMAGE_REL_ARM_BRANCH11,
4998 IMAGE_REL_ARM_TOKEN,
4999 IMAGE_REL_ARM_GPREL12,
5000 IMAGE_REL_ARM_GPREL7,
5001 IMAGE_REL_ARM_BLX24,
5002 IMAGE_REL_ARM_BLX11,
5003 IMAGE_REL_ARM_SECTION,
5004 IMAGE_REL_ARM_SECREL,
5005 IMAGE_REL_ARM_MOV32A,
5006 IMAGE_REL_ARM_MOV32T,
5007 IMAGE_REL_ARM_BRANCH20T,
5008 IMAGE_REL_ARM_BRANCH24T,
5009 IMAGE_REL_ARM_BLX23T,
5010 );
5011 static FLAGS_IMAGE_REL_AM: &[Flag<u16>] = &flags!(
5012 IMAGE_REL_AM_ABSOLUTE,
5013 IMAGE_REL_AM_ADDR32,
5014 IMAGE_REL_AM_ADDR32NB,
5015 IMAGE_REL_AM_CALL32,
5016 IMAGE_REL_AM_FUNCINFO,
5017 IMAGE_REL_AM_REL32_1,
5018 IMAGE_REL_AM_REL32_2,
5019 IMAGE_REL_AM_SECREL,
5020 IMAGE_REL_AM_SECTION,
5021 IMAGE_REL_AM_TOKEN,
5022 );
5023 static FLAGS_IMAGE_REL_ARM64: &[Flag<u16>] = &flags!(
5024 IMAGE_REL_ARM64_ABSOLUTE,
5025 IMAGE_REL_ARM64_ADDR32,
5026 IMAGE_REL_ARM64_ADDR32NB,
5027 IMAGE_REL_ARM64_BRANCH26,
5028 IMAGE_REL_ARM64_PAGEBASE_REL21,
5029 IMAGE_REL_ARM64_REL21,
5030 IMAGE_REL_ARM64_PAGEOFFSET_12A,
5031 IMAGE_REL_ARM64_PAGEOFFSET_12L,
5032 IMAGE_REL_ARM64_SECREL,
5033 IMAGE_REL_ARM64_SECREL_LOW12A,
5034 IMAGE_REL_ARM64_SECREL_HIGH12A,
5035 IMAGE_REL_ARM64_SECREL_LOW12L,
5036 IMAGE_REL_ARM64_TOKEN,
5037 IMAGE_REL_ARM64_SECTION,
5038 IMAGE_REL_ARM64_ADDR64,
5039 IMAGE_REL_ARM64_BRANCH19,
5040 );
5041 static FLAGS_IMAGE_REL_AMD64: &[Flag<u16>] = &flags!(
5042 IMAGE_REL_AMD64_ABSOLUTE,
5043 IMAGE_REL_AMD64_ADDR64,
5044 IMAGE_REL_AMD64_ADDR32,
5045 IMAGE_REL_AMD64_ADDR32NB,
5046 IMAGE_REL_AMD64_REL32,
5047 IMAGE_REL_AMD64_REL32_1,
5048 IMAGE_REL_AMD64_REL32_2,
5049 IMAGE_REL_AMD64_REL32_3,
5050 IMAGE_REL_AMD64_REL32_4,
5051 IMAGE_REL_AMD64_REL32_5,
5052 IMAGE_REL_AMD64_SECTION,
5053 IMAGE_REL_AMD64_SECREL,
5054 IMAGE_REL_AMD64_SECREL7,
5055 IMAGE_REL_AMD64_TOKEN,
5056 IMAGE_REL_AMD64_SREL32,
5057 IMAGE_REL_AMD64_PAIR,
5058 IMAGE_REL_AMD64_SSPAN32,
5059 IMAGE_REL_AMD64_EHANDLER,
5060 IMAGE_REL_AMD64_IMPORT_BR,
5061 IMAGE_REL_AMD64_IMPORT_CALL,
5062 IMAGE_REL_AMD64_CFG_BR,
5063 IMAGE_REL_AMD64_CFG_BR_REX,
5064 IMAGE_REL_AMD64_CFG_CALL,
5065 IMAGE_REL_AMD64_INDIR_BR,
5066 IMAGE_REL_AMD64_INDIR_BR_REX,
5067 IMAGE_REL_AMD64_INDIR_CALL,
5068 IMAGE_REL_AMD64_INDIR_BR_SWITCHTABLE_FIRST,
5069 IMAGE_REL_AMD64_INDIR_BR_SWITCHTABLE_LAST,
5070 );
5071 static FLAGS_IMAGE_REL_IA64: &[Flag<u16>] = &flags!(
5072 IMAGE_REL_IA64_ABSOLUTE,
5073 IMAGE_REL_IA64_IMM14,
5074 IMAGE_REL_IA64_IMM22,
5075 IMAGE_REL_IA64_IMM64,
5076 IMAGE_REL_IA64_DIR32,
5077 IMAGE_REL_IA64_DIR64,
5078 IMAGE_REL_IA64_PCREL21B,
5079 IMAGE_REL_IA64_PCREL21M,
5080 IMAGE_REL_IA64_PCREL21F,
5081 IMAGE_REL_IA64_GPREL22,
5082 IMAGE_REL_IA64_LTOFF22,
5083 IMAGE_REL_IA64_SECTION,
5084 IMAGE_REL_IA64_SECREL22,
5085 IMAGE_REL_IA64_SECREL64I,
5086 IMAGE_REL_IA64_SECREL32,
5087 IMAGE_REL_IA64_DIR32NB,
5088 IMAGE_REL_IA64_SREL14,
5089 IMAGE_REL_IA64_SREL22,
5090 IMAGE_REL_IA64_SREL32,
5091 IMAGE_REL_IA64_UREL32,
5092 IMAGE_REL_IA64_PCREL60X,
5093 IMAGE_REL_IA64_PCREL60B,
5094 IMAGE_REL_IA64_PCREL60F,
5095 IMAGE_REL_IA64_PCREL60I,
5096 IMAGE_REL_IA64_PCREL60M,
5097 IMAGE_REL_IA64_IMMGPREL64,
5098 IMAGE_REL_IA64_TOKEN,
5099 IMAGE_REL_IA64_GPREL32,
5100 IMAGE_REL_IA64_ADDEND,
5101 );
5102 static FLAGS_IMAGE_REL_CEF: &[Flag<u16>] = &flags!(
5103 IMAGE_REL_CEF_ABSOLUTE,
5104 IMAGE_REL_CEF_ADDR32,
5105 IMAGE_REL_CEF_ADDR64,
5106 IMAGE_REL_CEF_ADDR32NB,
5107 IMAGE_REL_CEF_SECTION,
5108 IMAGE_REL_CEF_SECREL,
5109 IMAGE_REL_CEF_TOKEN,
5110 );
5111 static FLAGS_IMAGE_REL_CEE: &[Flag<u16>] = &flags!(
5112 IMAGE_REL_CEE_ABSOLUTE,
5113 IMAGE_REL_CEE_ADDR32,
5114 IMAGE_REL_CEE_ADDR64,
5115 IMAGE_REL_CEE_ADDR32NB,
5116 IMAGE_REL_CEE_SECTION,
5117 IMAGE_REL_CEE_SECREL,
5118 IMAGE_REL_CEE_TOKEN,
5119 );
5120 static FLAGS_IMAGE_REL_M32R: &[Flag<u16>] = &flags!(
5121 IMAGE_REL_M32R_ABSOLUTE,
5122 IMAGE_REL_M32R_ADDR32,
5123 IMAGE_REL_M32R_ADDR32NB,
5124 IMAGE_REL_M32R_ADDR24,
5125 IMAGE_REL_M32R_GPREL16,
5126 IMAGE_REL_M32R_PCREL24,
5127 IMAGE_REL_M32R_PCREL16,
5128 IMAGE_REL_M32R_PCREL8,
5129 IMAGE_REL_M32R_REFHALF,
5130 IMAGE_REL_M32R_REFHI,
5131 IMAGE_REL_M32R_REFLO,
5132 IMAGE_REL_M32R_PAIR,
5133 IMAGE_REL_M32R_SECTION,
5134 IMAGE_REL_M32R_SECREL32,
5135 IMAGE_REL_M32R_TOKEN,
5136 );
5137 static FLAGS_IMAGE_REL_EBC: &[Flag<u16>] = &flags!(
5138 IMAGE_REL_EBC_ABSOLUTE,
5139 IMAGE_REL_EBC_ADDR32NB,
5140 IMAGE_REL_EBC_REL32,
5141 IMAGE_REL_EBC_SECTION,
5142 IMAGE_REL_EBC_SECREL,
5143 );
5144 static FLAGS_IMAGE_SYM: &[Flag<u16>] =
5145 &flags!(IMAGE_SYM_UNDEFINED, IMAGE_SYM_ABSOLUTE, IMAGE_SYM_DEBUG,);
5146 static FLAGS_IMAGE_SYM_TYPE: &[Flag<u16>] = &flags!(
5147 IMAGE_SYM_TYPE_NULL,
5148 IMAGE_SYM_TYPE_VOID,
5149 IMAGE_SYM_TYPE_CHAR,
5150 IMAGE_SYM_TYPE_SHORT,
5151 IMAGE_SYM_TYPE_INT,
5152 IMAGE_SYM_TYPE_LONG,
5153 IMAGE_SYM_TYPE_FLOAT,
5154 IMAGE_SYM_TYPE_DOUBLE,
5155 IMAGE_SYM_TYPE_STRUCT,
5156 IMAGE_SYM_TYPE_UNION,
5157 IMAGE_SYM_TYPE_ENUM,
5158 IMAGE_SYM_TYPE_MOE,
5159 IMAGE_SYM_TYPE_BYTE,
5160 IMAGE_SYM_TYPE_WORD,
5161 IMAGE_SYM_TYPE_UINT,
5162 IMAGE_SYM_TYPE_DWORD,
5163 IMAGE_SYM_TYPE_PCODE,
5164 );
5165 static FLAGS_IMAGE_SYM_DTYPE: &[Flag<u16>] = &flags!(
5166 IMAGE_SYM_DTYPE_NULL,
5167 IMAGE_SYM_DTYPE_POINTER,
5168 IMAGE_SYM_DTYPE_FUNCTION,
5169 IMAGE_SYM_DTYPE_ARRAY,
5170 );
5171 static FLAGS_IMAGE_SYM_CLASS: &[Flag<u8>] = &flags!(
5172 IMAGE_SYM_CLASS_END_OF_FUNCTION,
5173 IMAGE_SYM_CLASS_NULL,
5174 IMAGE_SYM_CLASS_AUTOMATIC,
5175 IMAGE_SYM_CLASS_EXTERNAL,
5176 IMAGE_SYM_CLASS_STATIC,
5177 IMAGE_SYM_CLASS_REGISTER,
5178 IMAGE_SYM_CLASS_EXTERNAL_DEF,
5179 IMAGE_SYM_CLASS_LABEL,
5180 IMAGE_SYM_CLASS_UNDEFINED_LABEL,
5181 IMAGE_SYM_CLASS_MEMBER_OF_STRUCT,
5182 IMAGE_SYM_CLASS_ARGUMENT,
5183 IMAGE_SYM_CLASS_STRUCT_TAG,
5184 IMAGE_SYM_CLASS_MEMBER_OF_UNION,
5185 IMAGE_SYM_CLASS_UNION_TAG,
5186 IMAGE_SYM_CLASS_TYPE_DEFINITION,
5187 IMAGE_SYM_CLASS_UNDEFINED_STATIC,
5188 IMAGE_SYM_CLASS_ENUM_TAG,
5189 IMAGE_SYM_CLASS_MEMBER_OF_ENUM,
5190 IMAGE_SYM_CLASS_REGISTER_PARAM,
5191 IMAGE_SYM_CLASS_BIT_FIELD,
5192 IMAGE_SYM_CLASS_FAR_EXTERNAL,
5193 IMAGE_SYM_CLASS_BLOCK,
5194 IMAGE_SYM_CLASS_FUNCTION,
5195 IMAGE_SYM_CLASS_END_OF_STRUCT,
5196 IMAGE_SYM_CLASS_FILE,
5197 IMAGE_SYM_CLASS_SECTION,
5198 IMAGE_SYM_CLASS_WEAK_EXTERNAL,
5199 IMAGE_SYM_CLASS_CLR_TOKEN,
5200 );
5201 static FLAGS_IMAGE_COMDAT_SELECT: &[Flag<u8>] = &flags!(
5202 IMAGE_COMDAT_SELECT_NODUPLICATES,
5203 IMAGE_COMDAT_SELECT_ANY,
5204 IMAGE_COMDAT_SELECT_SAME_SIZE,
5205 IMAGE_COMDAT_SELECT_EXACT_MATCH,
5206 IMAGE_COMDAT_SELECT_ASSOCIATIVE,
5207 IMAGE_COMDAT_SELECT_LARGEST,
5208 IMAGE_COMDAT_SELECT_NEWEST,
5209 );
5210 static FLAGS_IMAGE_SUBSYSTEM: &[Flag<u16>] = &flags!(
5211 IMAGE_SUBSYSTEM_UNKNOWN,
5212 IMAGE_SUBSYSTEM_NATIVE,
5213 IMAGE_SUBSYSTEM_WINDOWS_GUI,
5214 IMAGE_SUBSYSTEM_WINDOWS_CUI,
5215 IMAGE_SUBSYSTEM_OS2_CUI,
5216 IMAGE_SUBSYSTEM_POSIX_CUI,
5217 IMAGE_SUBSYSTEM_NATIVE_WINDOWS,
5218 IMAGE_SUBSYSTEM_WINDOWS_CE_GUI,
5219 IMAGE_SUBSYSTEM_EFI_APPLICATION,
5220 IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER,
5221 IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER,
5222 IMAGE_SUBSYSTEM_EFI_ROM,
5223 IMAGE_SUBSYSTEM_XBOX,
5224 IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION,
5225 IMAGE_SUBSYSTEM_XBOX_CODE_CATALOG,
5226 );
5227 static FLAGS_IMAGE_DLLCHARACTERISTICS: &[Flag<u16>] = &flags!(
5228 IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA,
5229 IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE,
5230 IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY,
5231 IMAGE_DLLCHARACTERISTICS_NX_COMPAT,
5232 IMAGE_DLLCHARACTERISTICS_NO_ISOLATION,
5233 IMAGE_DLLCHARACTERISTICS_NO_SEH,
5234 IMAGE_DLLCHARACTERISTICS_NO_BIND,
5235 IMAGE_DLLCHARACTERISTICS_APPCONTAINER,
5236 IMAGE_DLLCHARACTERISTICS_WDM_DRIVER,
5237 IMAGE_DLLCHARACTERISTICS_GUARD_CF,
5238 IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE,
5239 );
5240 static FLAGS_IMAGE_DIRECTORY_ENTRY: &[Flag<usize>] = &flags!(
5241 IMAGE_DIRECTORY_ENTRY_EXPORT,
5242 IMAGE_DIRECTORY_ENTRY_IMPORT,
5243 IMAGE_DIRECTORY_ENTRY_RESOURCE,
5244 IMAGE_DIRECTORY_ENTRY_EXCEPTION,
5245 IMAGE_DIRECTORY_ENTRY_SECURITY,
5246 IMAGE_DIRECTORY_ENTRY_BASERELOC,
5247 IMAGE_DIRECTORY_ENTRY_DEBUG,
5248 IMAGE_DIRECTORY_ENTRY_ARCHITECTURE,
5249 IMAGE_DIRECTORY_ENTRY_GLOBALPTR,
5250 IMAGE_DIRECTORY_ENTRY_TLS,
5251 IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG,
5252 IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT,
5253 IMAGE_DIRECTORY_ENTRY_IAT,
5254 IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT,
5255 IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR,
5256 );
5257 }
5258