projects / rustc.git / blame
| Commit | Line | Data |
|---|---|---|
| 17df50a5 XL |
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 | ||
| 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> { | |
| 50 | fn new(w: W) -> Self { | |
| 51 | Self { w, indent: 0 } | |
| 52 | } | |
| 53 | ||
| 54 | fn blank(&mut self) { | |
| 55 | writeln!(self.w).unwrap(); | |
| 56 | } | |
| 57 | ||
| 58 | fn print_indent(&mut self) { | |
| 59 | if self.indent != 0 { | |
| 60 | write!(self.w, "{:-1$}", " ", self.indent * 4).unwrap(); | |
| 61 | } | |
| 62 | } | |
| 63 | ||
| 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 | ||
| 72 | fn indent<F: FnOnce(&mut Self)>(&mut self, f: F) { | |
| 73 | self.indent += 1; | |
| 74 | f(self); | |
| 75 | self.indent -= 1; | |
| 76 | } | |
| 77 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 103 | fn field_bytes(&mut self, name: &str, value: &[u8]) { | |
| 104 | self.field_name(name); | |
| 105 | writeln!(self.w, "{:X?}", value).unwrap(); | |
| 106 | } | |
| 107 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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) { | |
| 136023e0 | 440 | dynstr = object::StringTable::new(data, 0, data.len() as u64); |
| 17df50a5 XL |
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 | ||
| 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), | |
| 136023e0 XL |
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), | |
| 17df50a5 | 548 | // TODO: |
| 17df50a5 XL |
549 | //SHT_DYNAMIC => |
| 550 | //SHT_SHLIB => | |
| 551 | //SHT_INIT_ARRAY => | |
| 552 | //SHT_FINI_ARRAY => | |
| 553 | //SHT_PREINIT_ARRAY => | |
| 554 | _ => {} | |
| 555 | } | |
| 556 | }); | |
| 557 | } | |
| 558 | } | |
| 559 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 136023e0 XL |
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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 17df50a5 XL |
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, | |
| 136023e0 XL |
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, | |
| 17df50a5 XL |
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 | ); | |
| 136023e0 XL |
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); | |
| 17df50a5 XL |
3346 | } |
| 3347 | ||
| 3348 | mod macho { | |
| 3349 | use super::*; | |
| 3350 | use object::macho::*; | |
| 3351 | use object::read::macho::*; | |
| 3352 | use object::BigEndian; | |
| 3353 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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 | ||
| 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, | |
| 136023e0 XL |
4831 | IMAGE_FILE_MACHINE_RISCV32, |
| 4832 | IMAGE_FILE_MACHINE_RISCV64, | |
| 4833 | IMAGE_FILE_MACHINE_RISCV128, | |
| 17df50a5 XL |
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 | } |