summaryrefslogtreecommitdiffstats
path: root/vendor/object-0.26.2
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/object-0.26.2')
-rw-r--r--vendor/object-0.26.2/.cargo-checksum.json1
-rw-r--r--vendor/object-0.26.2/CHANGELOG.md164
-rw-r--r--vendor/object-0.26.2/Cargo.lock132
-rw-r--r--vendor/object-0.26.2/Cargo.toml101
-rw-r--r--vendor/object-0.26.2/LICENSE-APACHE201
-rw-r--r--vendor/object-0.26.2/LICENSE-MIT25
-rw-r--r--vendor/object-0.26.2/README.md48
-rw-r--r--vendor/object-0.26.2/clippy.toml1
-rw-r--r--vendor/object-0.26.2/examples/ar.rs46
-rw-r--r--vendor/object-0.26.2/examples/dyldcachedump.rs50
-rw-r--r--vendor/object-0.26.2/examples/nm.rs95
-rw-r--r--vendor/object-0.26.2/examples/objcopy.rs174
-rw-r--r--vendor/object-0.26.2/examples/objdump.rs230
-rw-r--r--vendor/object-0.26.2/examples/objectmap.rs67
-rw-r--r--vendor/object-0.26.2/examples/readobj.rs5257
-rw-r--r--vendor/object-0.26.2/src/archive.rs39
-rw-r--r--vendor/object-0.26.2/src/common.rs417
-rw-r--r--vendor/object-0.26.2/src/elf.rs6248
-rw-r--r--vendor/object-0.26.2/src/endian.rs771
-rw-r--r--vendor/object-0.26.2/src/lib.rs103
-rw-r--r--vendor/object-0.26.2/src/macho.rs3254
-rw-r--r--vendor/object-0.26.2/src/pe.rs2958
-rw-r--r--vendor/object-0.26.2/src/pod.rs238
-rw-r--r--vendor/object-0.26.2/src/read/any.rs1225
-rw-r--r--vendor/object-0.26.2/src/read/archive.rs502
-rw-r--r--vendor/object-0.26.2/src/read/coff/comdat.rs162
-rw-r--r--vendor/object-0.26.2/src/read/coff/file.rs241
-rw-r--r--vendor/object-0.26.2/src/read/coff/mod.rs18
-rw-r--r--vendor/object-0.26.2/src/read/coff/relocation.rs85
-rw-r--r--vendor/object-0.26.2/src/read/coff/section.rs420
-rw-r--r--vendor/object-0.26.2/src/read/coff/symbol.rs505
-rw-r--r--vendor/object-0.26.2/src/read/elf/comdat.rs161
-rw-r--r--vendor/object-0.26.2/src/read/elf/compression.rs56
-rw-r--r--vendor/object-0.26.2/src/read/elf/dynamic.rs45
-rw-r--r--vendor/object-0.26.2/src/read/elf/file.rs859
-rw-r--r--vendor/object-0.26.2/src/read/elf/hash.rs211
-rw-r--r--vendor/object-0.26.2/src/read/elf/mod.rs39
-rw-r--r--vendor/object-0.26.2/src/read/elf/note.rs185
-rw-r--r--vendor/object-0.26.2/src/read/elf/relocation.rs534
-rw-r--r--vendor/object-0.26.2/src/read/elf/section.rs970
-rw-r--r--vendor/object-0.26.2/src/read/elf/segment.rs322
-rw-r--r--vendor/object-0.26.2/src/read/elf/symbol.rs545
-rw-r--r--vendor/object-0.26.2/src/read/elf/version.rs175
-rw-r--r--vendor/object-0.26.2/src/read/macho/dyld_cache.rs218
-rw-r--r--vendor/object-0.26.2/src/read/macho/fat.rs120
-rw-r--r--vendor/object-0.26.2/src/read/macho/file.rs648
-rw-r--r--vendor/object-0.26.2/src/read/macho/load_command.rs348
-rw-r--r--vendor/object-0.26.2/src/read/macho/mod.rs30
-rw-r--r--vendor/object-0.26.2/src/read/macho/relocation.rs126
-rw-r--r--vendor/object-0.26.2/src/read/macho/section.rs366
-rw-r--r--vendor/object-0.26.2/src/read/macho/segment.rs284
-rw-r--r--vendor/object-0.26.2/src/read/macho/symbol.rs486
-rw-r--r--vendor/object-0.26.2/src/read/mod.rs694
-rw-r--r--vendor/object-0.26.2/src/read/pe/file.rs1057
-rw-r--r--vendor/object-0.26.2/src/read/pe/mod.rs16
-rw-r--r--vendor/object-0.26.2/src/read/pe/section.rs343
-rw-r--r--vendor/object-0.26.2/src/read/read_cache.rs185
-rw-r--r--vendor/object-0.26.2/src/read/read_ref.rs137
-rw-r--r--vendor/object-0.26.2/src/read/traits.rs429
-rw-r--r--vendor/object-0.26.2/src/read/util.rs383
-rw-r--r--vendor/object-0.26.2/src/read/wasm.rs859
-rw-r--r--vendor/object-0.26.2/src/write/coff.rs626
-rw-r--r--vendor/object-0.26.2/src/write/elf.rs1314
-rw-r--r--vendor/object-0.26.2/src/write/macho.rs844
-rw-r--r--vendor/object-0.26.2/src/write/mod.rs858
-rw-r--r--vendor/object-0.26.2/src/write/string.rs139
-rw-r--r--vendor/object-0.26.2/src/write/util.rs129
-rw-r--r--vendor/object-0.26.2/tests/integration.rs1
-rw-r--r--vendor/object-0.26.2/tests/parse_self.rs25
-rw-r--r--vendor/object-0.26.2/tests/round_trip/bss.rs255
-rw-r--r--vendor/object-0.26.2/tests/round_trip/comdat.rs225
-rw-r--r--vendor/object-0.26.2/tests/round_trip/common.rs245
-rw-r--r--vendor/object-0.26.2/tests/round_trip/elf.rs218
-rw-r--r--vendor/object-0.26.2/tests/round_trip/macho.rs24
-rw-r--r--vendor/object-0.26.2/tests/round_trip/mod.rs445
-rw-r--r--vendor/object-0.26.2/tests/round_trip/tls.rs316
76 files changed, 40273 insertions, 0 deletions
diff --git a/vendor/object-0.26.2/.cargo-checksum.json b/vendor/object-0.26.2/.cargo-checksum.json
new file mode 100644
index 000000000..1f76cb1fc
--- /dev/null
+++ b/vendor/object-0.26.2/.cargo-checksum.json
@@ -0,0 +1 @@
+{"files":{"CHANGELOG.md":"52a47c66164f368e5a167f1732525583ec574cd7de8be91fac29d52997b1c632","Cargo.lock":"a1190887088da0ebf768d172d97a9c21519fe4adb72860e4c9d3826307a57ce6","Cargo.toml":"2481b73a96029b6409d582b026d901d04f5ef12c12ccb27f3c997fa567ce18a7","LICENSE-APACHE":"a60eea817514531668d7e00765731449fe14d059d3249e0bc93b36de45f759f2","LICENSE-MIT":"0b74dfa0bcee5c420c6b7f67b4b2658f9ab8388c97b8e733975f2cecbdd668a6","README.md":"283c8881f81e647191130eea41b94fe877214e492fd35dd02a10c0698aaedcdf","clippy.toml":"50fd0cdaae995561b1d688c9410fe99335fc7ac3916a400dafd25ff63f8215f7","examples/ar.rs":"9846b618c70acfcb869895f1e1829a3b3824c04afd685ee7af289c91fcf0e420","examples/dyldcachedump.rs":"d30974ade7acbb13843ab5ffe74e825316f533b4bf7a6431799277d2340aad01","examples/nm.rs":"07b8dd510ad51640ffedba74ef3d05b290922d1a5ccf78237693e527124deb2d","examples/objcopy.rs":"e4e3a080733e877bd8024b3bd98dbf607e3ad9611db4f417a156c0f144f6b663","examples/objdump.rs":"1e0a27b2c3ac4dd85df9fc9a4463644de5f4762b3428e9b0d4f542c7084ff793","examples/objectmap.rs":"d36457d5334551a8d82880847a563ca619e022746e8ef3fd79f3a16193a5dd95","examples/readobj.rs":"49feba2fd34a6fb76e18763348e6ccf5a0c4ccf3779e5bc622df4d8ed14e82bf","src/archive.rs":"7ca11076759d4b87b42657f866b0d2b1dd07d2536b19645da0a5da5dd713b77d","src/common.rs":"9a16e67c321a6b35d35ce9d0611281f8f30b2c475cde68479d6a0fdd2b997a5e","src/elf.rs":"78df96810cb379e1dd8b4872ab90d2337855fa4d4d98fb09697d0750154dc40b","src/endian.rs":"ceaad1b651627ad9e6218a168f87353ae651f5d76c9f61bc8099dff25007405e","src/lib.rs":"fccca74e1e79d5d4dbb090a0103d91b5a0b4f71983d5e3ee3b139b13a9c7990d","src/macho.rs":"ef938fbfd5913711493ef4347a1b426b7ee661a2eb2038681552d7d8b7282e7a","src/pe.rs":"7a1b57131f43ed01472f4924f37657896880b82b127a153795388eb4577a640a","src/pod.rs":"9643a698e1388ad98d1e9ea074ca5b0b35599a2491a82e67a62ebcdc8cb19218","src/read/any.rs":"696a956935e7f1babb621ff71dec23154ca4bf906a8adfa5c02aac7a50117c69","src/read/archive.rs":"987eaf577ec47f5b4ac4e91c697abad31c00ead02f3241dde4f74ce24a884b20","src/read/coff/comdat.rs":"f4198dcdd2c270c9f1ba9efa30c6fb291913984079a45c02e6b6f57dce2700da","src/read/coff/file.rs":"3b15e43d5db9e3af025cda166dd731a5a10293c8d6a6a6f82e7ff4541a4b04a8","src/read/coff/mod.rs":"5eed1c0ca7cf044b3173223b06afacc4961a0515ef2478fffa35641f4ee364ee","src/read/coff/relocation.rs":"a9406980b89a33a16b4fa4f41f01d6db63096c46ff61bb8bd590f86f1d5ed5cf","src/read/coff/section.rs":"721e4f96c2de16f85192db0ad53ee34745bcbe8d551ad297d4f44ab13205ec06","src/read/coff/symbol.rs":"01a11c8f77c1b80d354d9437439cf4685b99bf254cc9eeadd19da2a394fc3c57","src/read/elf/comdat.rs":"340cccdea68c7ed77406ee45c4baa5f179588d77d90bb88b0cd9749d0d725cb1","src/read/elf/compression.rs":"097ff8bdc78d01a1532b11c1c0cae3b35905128c7d98b471de188d46da3ff970","src/read/elf/dynamic.rs":"2454551eb67757622b3d6660bc13ed39341be91f382eb8b1910095f58cf2bae2","src/read/elf/file.rs":"9d5958552ac3f590249c45795d40d8ffce0d41a6e4d9ae2f38f356ad4e46c05e","src/read/elf/hash.rs":"3a08046c78a6fd79bccfd1a0d4cc113da8d0664164576f290885b51d8110acca","src/read/elf/mod.rs":"98b5bd46778d3c33e9d19dee2d294f61677dec16b28f22aa73340008c241fe09","src/read/elf/note.rs":"33bf89a85bb7927fd0123cd6c2919f0b9b0f8935db1ae7b446b75ea2717a476d","src/read/elf/relocation.rs":"62b27c79964f7b037f4fb0b952afacd14790751828e82b67ed5890f143e2b2dc","src/read/elf/section.rs":"d692093ad195ccd0e4857c2f9c638543aa38a8179180e68d27a1f0784aa5e09a","src/read/elf/segment.rs":"d3cbb86cc9ca6eca93f9c17f36823dae0bd72ab2761f2b784dadd8f5b5c9dd9f","src/read/elf/symbol.rs":"9582039f44e82a3bbf225db12ddab9a3b3d5f4b0536d4125c18bb693da3c6db7","src/read/elf/version.rs":"c665034c90cb17e7bd1a6ba836966534fb2527698979908a704cf3b716c0dbdc","src/read/macho/dyld_cache.rs":"37330ba249226231b2e6ae7de80d60845c2eb7db854fd588c52fc706e13e49b8","src/read/macho/fat.rs":"05e84f0a10958ef4e3828f388cd5d2fea95481ea89aeb80b76a2784c4208e4a1","src/read/macho/file.rs":"c524be5be3447afb5aa9c68673f495de05e652687790397f6bf5617b9beea21a","src/read/macho/load_command.rs":"df976715bbc7699f7fdb8e9d388ba3e96a6d40c6a03b96c2696bd7c19786695a","src/read/macho/mod.rs":"23b353da3b7e076c68a067776e6a5b346a746116ac42c2c90bafd95ad54a90b3","src/read/macho/relocation.rs":"77fa3e65ccf5884433c96cdc39c457b8a0c430432e5ff9cad22a8becf13f0183","src/read/macho/section.rs":"59e70336d50f757d8d8daf44f23acca77de87cffcf2d62326e3b17c2ff9f672f","src/read/macho/segment.rs":"659b61a8cb563504f533c390fb901883b72c298f7bea037100a677cc9e4face4","src/read/macho/symbol.rs":"c0a615079779bf83bc3a6ae6d816f8d853099591f0b72e8646a624955bc5069e","src/read/mod.rs":"18ccc63d7acfc1af561d413738cafb1882368179257d36d2dc2496e21095bf7c","src/read/pe/file.rs":"f17836ac757dfd198323a2df1289b02dbb3ba85f2ceff0fdb7e565d30d555da3","src/read/pe/mod.rs":"05d9f3320596f9e567cbd791b68982d50a31e8d18f60c2c401c4a40eb50f1d94","src/read/pe/section.rs":"befd3c82fe6d9186b5802945853da9653649779989fd36cd2a835e3264156281","src/read/read_cache.rs":"939b66cfc11fc022c4e4b78fcad63b375516967da2274da78fb200271d934a53","src/read/read_ref.rs":"5fe6f717c79b07fecac9ee8ba15740c7a9581c36f1e356119e99dd669af6c39c","src/read/traits.rs":"5f29ae16bcf078c7089b22d7bd3ca9c6bc2eb637900a3b1cc70f9a45e5f8be09","src/read/util.rs":"c329a240689b177613049e00faf7928e6cd6aad021542cd708cc06b598c6900e","src/read/wasm.rs":"936ac6b218d23d7bb9ca6869f17cd8dafbed80ee0b267254c7a3ffe05bd46948","src/write/coff.rs":"16f52497fd18ec893c8f72903e9ea0bde6901e75acdfbc8be6a7305e13bccb8c","src/write/elf.rs":"2d6d3c4b014e9df7dd09e3ecf926a7d8fbac6e3cf3ab768e672b7c8ac1d38485","src/write/macho.rs":"fa058f9e7aa1e9895a3c4575fa527c3d5dbac186d994c9ba48801348a8428f35","src/write/mod.rs":"970620fba6e7b851981cda09929d93667a51d0c0be2c1491fdd8002d530515df","src/write/string.rs":"920d71223a5a146ef516b6d5fb6d22bc86a7e456da369ae8a4d1ca6b63d59892","src/write/util.rs":"3bf18004fd5cd25229e480856f36b3410f23b12c096de4c52ab13e11da75b2e3","tests/integration.rs":"d491a0ae0d50c3194cd7b81720262f55ccb234251346f188284ce29729823dc2","tests/parse_self.rs":"81b44b2dd1de9a5d8c18d9bd8926156e39fb83931837afa8ca344da0d309aeee","tests/round_trip/bss.rs":"849d69b063fd757fed02219dd81e9d13b82068a2025d2cc5cfd40cf557e31bda","tests/round_trip/comdat.rs":"2e3ef1aef466911646e5cbfe0b1a8c1543530baf8ca6102394519e701a1e2747","tests/round_trip/common.rs":"ced08ff559ca4d343ceef54bb4c581a3405cd96d6a1628ba43b7aab82070800b","tests/round_trip/elf.rs":"a1ff40266998321c75023cf76384f8ad03828c6d487421ea8b7774fce8173039","tests/round_trip/macho.rs":"b23931f506345b26ce3b4908dc2ce02f704603c622d39f5e9e7c8529f2882818","tests/round_trip/mod.rs":"b741ba432fdee2156699743962c64aaf2d1e9629c432e40953ac4d410688ea5a","tests/round_trip/tls.rs":"23a49a1036b9173ece82a3080745930e5925e745280ab38866c9d3c29f463e63"},"package":"39f37e50073ccad23b6d09bcb5b263f4e76d3bb6038e4a3c08e52162ffa8abc2"} \ No newline at end of file
diff --git a/vendor/object-0.26.2/CHANGELOG.md b/vendor/object-0.26.2/CHANGELOG.md
new file mode 100644
index 000000000..429585bbf
--- /dev/null
+++ b/vendor/object-0.26.2/CHANGELOG.md
@@ -0,0 +1,164 @@
+# `object` Change Log
+
+--------------------------------------------------------------------------------
+
+## 0.26.2
+
+Released 2021/08/28.
+
+### Added
+
+* Added support for 64-bit symbol table names to `read::archive`.
+ [#366](https://github.com/gimli-rs/object/pull/366)
+
+--------------------------------------------------------------------------------
+
+## 0.26.1
+
+Released 2021/08/19.
+
+### Changed
+
+* Activate `memchr`'s `rustc-dep-of-std` feature
+ [#356](https://github.com/gimli-rs/object/pull/356)
+
+--------------------------------------------------------------------------------
+
+## 0.26.0
+
+Released 2021/07/26.
+
+### Breaking changes
+
+* Changed `ReadRef::read_bytes_at_until` to accept a range parameter.
+ [#326](https://github.com/gimli-rs/object/pull/326)
+
+* Added `ReadRef` type parameter to `read::StringTable` and types that
+ contain it. String table entries are now only read as required.
+ [#326](https://github.com/gimli-rs/object/pull/326)
+
+* Changed result type of `read::elf::SectionHeader::data` and `data_as_array`.
+ [#332](https://github.com/gimli-rs/object/pull/332)
+
+* Moved `pod::WritableBuffer` to `write::WritableBuffer`.
+ Renamed `WritableBuffer::extend` to `write_bytes`.
+ Added more provided methods to `WritableBuffer`.
+ [#335](https://github.com/gimli-rs/object/pull/335)
+
+* Moved `pod::Bytes` to `read::Bytes`.
+ [#336](https://github.com/gimli-rs/object/pull/336)
+
+* Added `is_mips64el` parameter to `elf::Rela64::r_info/set_r_info`.
+ [#337](https://github.com/gimli-rs/object/pull/337)
+
+### Changed
+
+* Removed `alloc` dependency when no features are enabled.
+ [#336](https://github.com/gimli-rs/object/pull/336)
+
+### Added
+
+* Added `read::pe::PeFile` methods: `section_table`, `data_directory`, and `data`.
+ [#324](https://github.com/gimli-rs/object/pull/324)
+
+* Added more ELF definitions.
+ [#332](https://github.com/gimli-rs/object/pull/332)
+
+* Added `read::elf::SectionTable` methods for hash tables and symbol version
+ information.
+ [#332](https://github.com/gimli-rs/object/pull/332)
+
+* Added PE RISC-V definitions.
+ [#333](https://github.com/gimli-rs/object/pull/333)
+
+* Added `WritableBuffer` implementation for `Vec`.
+ [#335](https://github.com/gimli-rs/object/pull/335)
+
+--------------------------------------------------------------------------------
+
+## 0.25.3
+
+Released 2021/06/12.
+
+### Added
+
+* Added `RelocationEncoding::AArch64Call`.
+ [#322](https://github.com/gimli-rs/object/pull/322)
+
+--------------------------------------------------------------------------------
+
+## 0.25.2
+
+Released 2021/06/04.
+
+### Added
+
+* Added `Architecture::X86_64_X32`.
+ [#320](https://github.com/gimli-rs/object/pull/320)
+
+--------------------------------------------------------------------------------
+
+## 0.25.1
+
+Released 2021/06/03.
+
+### Changed
+
+* write: Fix choice of `SHT_REL` or `SHT_RELA` for most architectures.
+ [#318](https://github.com/gimli-rs/object/pull/318)
+
+* write: Fix relocation encoding for MIPS64EL.
+ [#318](https://github.com/gimli-rs/object/pull/318)
+
+--------------------------------------------------------------------------------
+
+## 0.25.0
+
+Released 2021/06/02.
+
+### Breaking changes
+
+* Added `non_exhaustive` to most public enums.
+ [#306](https://github.com/gimli-rs/object/pull/306)
+
+* `MachHeader::parse` and `MachHeader::load_commands` now require a header offset.
+ [#304](https://github.com/gimli-rs/object/pull/304)
+
+* Added `ReadRef::read_bytes_at_until`.
+ [#308](https://github.com/gimli-rs/object/pull/308)
+
+* `PeFile::entry`, `PeSection::address` and `PeSegment::address` now return a
+ virtual address instead of a RVA.
+ [#315](https://github.com/gimli-rs/object/pull/315)
+
+### Added
+
+* Added `pod::from_bytes_mut`, `pod::slice_from_bytes_mut`, `pod::bytes_of_mut`,
+ and `pod::bytes_of_slice_mut`.
+ [#296](https://github.com/gimli-rs/object/pull/296)
+ [#297](https://github.com/gimli-rs/object/pull/297)
+
+* Added `Object::pdb_info`.
+ [#298](https://github.com/gimli-rs/object/pull/298)
+
+* Added `read::macho::DyldCache`, other associated definitions,
+ and support for these in the examples.
+ [#308](https://github.com/gimli-rs/object/pull/308)
+
+* Added more architecture support.
+ [#303](https://github.com/gimli-rs/object/pull/303)
+ [#309](https://github.com/gimli-rs/object/pull/309)
+
+* Derive more traits for enums.
+ [#311](https://github.com/gimli-rs/object/pull/311)
+
+* Added `Object::relative_address_base`.
+ [#315](https://github.com/gimli-rs/object/pull/315)
+
+### Changed
+
+* Improved performance for string parsing.
+ [#302](https://github.com/gimli-rs/object/pull/302)
+
+* `objdump` example allows selecting container members.
+ [#308](https://github.com/gimli-rs/object/pull/308)
diff --git a/vendor/object-0.26.2/Cargo.lock b/vendor/object-0.26.2/Cargo.lock
new file mode 100644
index 000000000..b42e1b04b
--- /dev/null
+++ b/vendor/object-0.26.2/Cargo.lock
@@ -0,0 +1,132 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "autocfg"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cdb031dd78e28731d87d56cc8ffef4a8f36ca26c38fe2de700543e627f8a464a"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "compiler_builtins"
+version = "0.1.49"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "20b1438ef42c655665a8ab2c1c6d605a305f031d38d9be689ddfef41a20f3aa2"
+
+[[package]]
+name = "crc32fast"
+version = "1.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "81156fece84ab6a9f2afdb109ce3ae577e42b1228441eded99bd77f627953b1a"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "flate2"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cd3aec53de10fe96d7d8c565eb17f2c687bb5518a2ec453b5b1252964526abe0"
+dependencies = [
+ "cfg-if",
+ "crc32fast",
+ "libc",
+ "miniz_oxide",
+]
+
+[[package]]
+name = "hashbrown"
+version = "0.11.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e"
+
+[[package]]
+name = "indexmap"
+version = "1.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc633605454125dec4b66843673f01c7df2b89479b32e0ed634e43a91cff62a5"
+dependencies = [
+ "autocfg",
+ "hashbrown",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.99"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a7f823d141fe0a24df1e23b4af4e3c7ba9e5966ec514ea068c93024aa7deb765"
+
+[[package]]
+name = "memchr"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "308cc39be01b73d0d18f82a0e7b2a3df85245f84af96fdddc5d202d27e47b86a"
+dependencies = [
+ "compiler_builtins",
+ "rustc-std-workspace-core",
+]
+
+[[package]]
+name = "memmap2"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "00b6c2ebff6180198788f5db08d7ce3bc1d0b617176678831a7510825973e357"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "miniz_oxide"
+version = "0.4.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a92518e98c078586bc6c934028adcca4c92a53d6a958196de835170a01d84e4b"
+dependencies = [
+ "adler",
+ "autocfg",
+]
+
+[[package]]
+name = "object"
+version = "0.26.2"
+dependencies = [
+ "compiler_builtins",
+ "crc32fast",
+ "flate2",
+ "indexmap",
+ "memchr",
+ "memmap2",
+ "rustc-std-workspace-alloc",
+ "rustc-std-workspace-core",
+ "wasmparser",
+]
+
+[[package]]
+name = "rustc-std-workspace-alloc"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ff66d57013a5686e1917ed6a025d54dd591fcda71a41fe07edf4d16726aefa86"
+
+[[package]]
+name = "rustc-std-workspace-core"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1956f5517128a2b6f23ab2dadf1a976f4f5b27962e7724c2bf3d45e539ec098c"
+
+[[package]]
+name = "wasmparser"
+version = "0.57.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32fddd575d477c6e9702484139cf9f23dcd554b06d185ed0f56c857dd3a47aa6"
diff --git a/vendor/object-0.26.2/Cargo.toml b/vendor/object-0.26.2/Cargo.toml
new file mode 100644
index 000000000..7ce7bdffd
--- /dev/null
+++ b/vendor/object-0.26.2/Cargo.toml
@@ -0,0 +1,101 @@
+# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO
+#
+# When uploading crates to the registry Cargo will automatically
+# "normalize" Cargo.toml files for maximal compatibility
+# with all versions of Cargo and also rewrite `path` dependencies
+# to registry (e.g., crates.io) dependencies
+#
+# If you believe there's an error in this file please file an
+# issue against the rust-lang/cargo repository. If you're
+# editing this file be aware that the upstream Cargo.toml
+# will likely look very different (and much more reasonable)
+
+[package]
+edition = "2018"
+name = "object"
+version = "0.26.2"
+exclude = ["/.coveralls.yml", "/.travis.yml"]
+description = "A unified interface for reading and writing object file formats."
+keywords = ["object", "elf", "mach-o", "pe", "coff"]
+license = "Apache-2.0/MIT"
+repository = "https://github.com/gimli-rs/object"
+[package.metadata.docs.rs]
+features = ["all"]
+
+[[example]]
+name = "ar"
+required-features = ["read_core", "archive"]
+
+[[example]]
+name = "objcopy"
+required-features = ["read", "write"]
+
+[[example]]
+name = "objdump"
+required-features = ["read"]
+
+[[example]]
+name = "objectmap"
+required-features = ["read_core"]
+
+[[example]]
+name = "nm"
+required-features = ["read"]
+
+[[example]]
+name = "readobj"
+required-features = ["read"]
+[dependencies.alloc]
+version = "1.0.0"
+optional = true
+package = "rustc-std-workspace-alloc"
+
+[dependencies.compiler_builtins]
+version = "0.1.2"
+optional = true
+
+[dependencies.core]
+version = "1.0.0"
+optional = true
+package = "rustc-std-workspace-core"
+
+[dependencies.crc32fast]
+version = "1.2"
+optional = true
+
+[dependencies.flate2]
+version = "1"
+optional = true
+
+[dependencies.indexmap]
+version = "1.1"
+optional = true
+
+[dependencies.memchr]
+version = "2.4.1"
+default-features = false
+
+[dependencies.wasmparser]
+version = "0.57"
+optional = true
+[dev-dependencies.memmap2]
+version = "0.3"
+
+[features]
+all = ["read", "write", "std", "compression", "wasm"]
+archive = []
+cargo-all = []
+coff = []
+compression = ["flate2", "std"]
+default = ["read", "compression"]
+elf = []
+macho = []
+pe = ["coff"]
+read = ["read_core", "archive", "coff", "elf", "macho", "pe", "unaligned"]
+read_core = []
+rustc-dep-of-std = ["core", "compiler_builtins", "alloc", "memchr/rustc-dep-of-std"]
+std = ["memchr/std"]
+unaligned = []
+wasm = ["wasmparser"]
+write = ["write_core", "coff", "elf", "macho"]
+write_core = ["crc32fast", "indexmap", "std"]
diff --git a/vendor/object-0.26.2/LICENSE-APACHE b/vendor/object-0.26.2/LICENSE-APACHE
new file mode 100644
index 000000000..16fe87b06
--- /dev/null
+++ b/vendor/object-0.26.2/LICENSE-APACHE
@@ -0,0 +1,201 @@
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/vendor/object-0.26.2/LICENSE-MIT b/vendor/object-0.26.2/LICENSE-MIT
new file mode 100644
index 000000000..8440c7e95
--- /dev/null
+++ b/vendor/object-0.26.2/LICENSE-MIT
@@ -0,0 +1,25 @@
+Copyright (c) 2015 The Gimli Developers
+
+Permission is hereby granted, free of charge, to any
+person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the
+Software without restriction, including without
+limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software
+is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice
+shall be included in all copies or substantial portions
+of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
+IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
diff --git a/vendor/object-0.26.2/README.md b/vendor/object-0.26.2/README.md
new file mode 100644
index 000000000..b6c753c3c
--- /dev/null
+++ b/vendor/object-0.26.2/README.md
@@ -0,0 +1,48 @@
+# `object`
+
+The `object` crate provides a unified interface to working with object files
+across platforms. It supports reading object files and executable files,
+and writing object files.
+
+For reading files, it provides multiple levels of support:
+
+* raw struct definitions suitable for zero copy access
+* low level APIs for accessing the raw structs
+* a higher level unified API for accessing common features of object files, such
+ as sections and symbols
+
+Supported file formats: ELF, Mach-O, Windows PE/COFF, Wasm, and Unix archive.
+
+## Example for unified read API
+```rust
+use object::{Object, ObjectSection};
+use std::error::Error;
+use std::fs;
+
+/// Reads a file and displays the content of the ".boot" section.
+fn main() -> Result<(), Box<dyn Error>> {
+ let bin_data = fs::read("./multiboot2-binary.elf")?;
+ let obj_file = object::File::parse(&*bin_data)?;
+ if let Some(section) = obj_file.section_by_name(".boot") {
+ println!("{:#x?}", section.data()?);
+ } else {
+ eprintln!("section not available");
+ }
+ Ok(())
+}
+```
+
+## License
+
+Licensed under either of
+
+ * Apache License, Version 2.0 ([`LICENSE-APACHE`](./LICENSE-APACHE) or http://www.apache.org/licenses/LICENSE-2.0)
+ * MIT license ([`LICENSE-MIT`](./LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+## Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in the work by you, as defined in the Apache-2.0 license, shall be
+dual licensed as above, without any additional terms or conditions.
diff --git a/vendor/object-0.26.2/clippy.toml b/vendor/object-0.26.2/clippy.toml
new file mode 100644
index 000000000..f97e544b6
--- /dev/null
+++ b/vendor/object-0.26.2/clippy.toml
@@ -0,0 +1 @@
+msrv = "1.42.0"
diff --git a/vendor/object-0.26.2/examples/ar.rs b/vendor/object-0.26.2/examples/ar.rs
new file mode 100644
index 000000000..a3170437d
--- /dev/null
+++ b/vendor/object-0.26.2/examples/ar.rs
@@ -0,0 +1,46 @@
+use std::{env, fs, process};
+
+fn main() {
+ let mut args = env::args().skip(1);
+ if args.len() < 2 {
+ eprintln!(
+ "Usage: {} <op> <archive> [<member>...]",
+ env::args().next().unwrap()
+ );
+ process::exit(1);
+ }
+
+ let op = args.next().unwrap();
+ let file_path = args.next().unwrap();
+
+ let file = match fs::File::open(&file_path) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to open file '{}': {}", file_path, err,);
+ return;
+ }
+ };
+ let file = match unsafe { memmap2::Mmap::map(&file) } {
+ Ok(mmap) => mmap,
+ Err(err) => {
+ println!("Failed to map file '{}': {}", file_path, err,);
+ return;
+ }
+ };
+ let archive = match object::read::archive::ArchiveFile::parse(&*file) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to parse file '{}': {}", file_path, err);
+ return;
+ }
+ };
+ match op.chars().next().unwrap() {
+ 't' => {
+ for member in archive.members() {
+ let member = member.unwrap();
+ println!("{}", String::from_utf8_lossy(member.name()));
+ }
+ }
+ op => println!("Invalid operation: {}", op),
+ }
+}
diff --git a/vendor/object-0.26.2/examples/dyldcachedump.rs b/vendor/object-0.26.2/examples/dyldcachedump.rs
new file mode 100644
index 000000000..bb2df6981
--- /dev/null
+++ b/vendor/object-0.26.2/examples/dyldcachedump.rs
@@ -0,0 +1,50 @@
+use object::read::macho::DyldCache;
+use object::Endianness;
+use std::{env, fs, process};
+
+fn main() {
+ let arg_len = env::args().len();
+ if arg_len <= 1 {
+ eprintln!("Usage: {} <file> ...", env::args().next().unwrap());
+ process::exit(1);
+ }
+
+ for file_path in env::args().skip(1) {
+ if arg_len > 2 {
+ println!();
+ println!("{}:", file_path);
+ }
+
+ let file = match fs::File::open(&file_path) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to open file '{}': {}", file_path, err,);
+ continue;
+ }
+ };
+ let file = match unsafe { memmap2::Mmap::map(&file) } {
+ Ok(mmap) => mmap,
+ Err(err) => {
+ println!("Failed to map file '{}': {}", file_path, err,);
+ continue;
+ }
+ };
+ let cache = match DyldCache::<Endianness>::parse(&*file) {
+ Ok(cache) => cache,
+ Err(err) => {
+ println!(
+ "Failed to parse Dyld shared cache file '{}': {}",
+ file_path, err,
+ );
+ continue;
+ }
+ };
+
+ // Print the list of image paths in this file.
+ for image in cache.images() {
+ if let Ok(path) = image.path() {
+ println!("{}", path);
+ }
+ }
+ }
+}
diff --git a/vendor/object-0.26.2/examples/nm.rs b/vendor/object-0.26.2/examples/nm.rs
new file mode 100644
index 000000000..a7bae51f2
--- /dev/null
+++ b/vendor/object-0.26.2/examples/nm.rs
@@ -0,0 +1,95 @@
+use object::{
+ Object, ObjectSection, ObjectSymbol, SectionIndex, SectionKind, Symbol, SymbolKind,
+ SymbolSection,
+};
+use std::collections::HashMap;
+use std::{env, fs, process};
+
+fn main() {
+ let arg_len = env::args().len();
+ if arg_len <= 1 {
+ eprintln!("Usage: {} <file> ...", env::args().next().unwrap());
+ process::exit(1);
+ }
+
+ for file_path in env::args().skip(1) {
+ if arg_len > 2 {
+ println!();
+ println!("{}:", file_path);
+ }
+
+ let file = match fs::File::open(&file_path) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to open file '{}': {}", file_path, err,);
+ continue;
+ }
+ };
+ let file = match unsafe { memmap2::Mmap::map(&file) } {
+ Ok(mmap) => mmap,
+ Err(err) => {
+ println!("Failed to map file '{}': {}", file_path, err,);
+ continue;
+ }
+ };
+ let file = match object::File::parse(&*file) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to parse file '{}': {}", file_path, err);
+ continue;
+ }
+ };
+
+ let section_kinds = file.sections().map(|s| (s.index(), s.kind())).collect();
+
+ println!("Debugging symbols:");
+ for symbol in file.symbols() {
+ print_symbol(&symbol, &section_kinds);
+ }
+ println!();
+
+ println!("Dynamic symbols:");
+ for symbol in file.dynamic_symbols() {
+ print_symbol(&symbol, &section_kinds);
+ }
+ }
+}
+
+fn print_symbol(symbol: &Symbol<'_, '_>, section_kinds: &HashMap<SectionIndex, SectionKind>) {
+ if let SymbolKind::Section | SymbolKind::File = symbol.kind() {
+ return;
+ }
+
+ let mut kind = match symbol.section() {
+ SymbolSection::Undefined => 'U',
+ SymbolSection::Absolute => 'A',
+ SymbolSection::Common => 'C',
+ SymbolSection::Section(index) => match section_kinds.get(&index) {
+ Some(SectionKind::Text) => 't',
+ Some(SectionKind::Data) | Some(SectionKind::Tls) | Some(SectionKind::TlsVariables) => {
+ 'd'
+ }
+ Some(SectionKind::ReadOnlyData) | Some(SectionKind::ReadOnlyString) => 'r',
+ Some(SectionKind::UninitializedData) | Some(SectionKind::UninitializedTls) => 'b',
+ Some(SectionKind::Common) => 'C',
+ _ => '?',
+ },
+ _ => '?',
+ };
+
+ if symbol.is_global() {
+ kind = kind.to_ascii_uppercase();
+ }
+
+ if symbol.is_undefined() {
+ print!("{:16} ", "");
+ } else {
+ print!("{:016x} ", symbol.address());
+ }
+ println!(
+ "{:016x} {} {}",
+ symbol.size(),
+ kind,
+ symbol.name().unwrap_or("<unknown>"),
+ );
+}
diff --git a/vendor/object-0.26.2/examples/objcopy.rs b/vendor/object-0.26.2/examples/objcopy.rs
new file mode 100644
index 000000000..54b43c8b6
--- /dev/null
+++ b/vendor/object-0.26.2/examples/objcopy.rs
@@ -0,0 +1,174 @@
+use std::collections::HashMap;
+use std::{env, fs, process};
+
+use object::{
+ write, Object, ObjectComdat, ObjectSection, ObjectSymbol, RelocationTarget, SectionKind,
+ SymbolFlags, SymbolKind, SymbolSection,
+};
+
+fn main() {
+ let mut args = env::args();
+ if args.len() != 3 {
+ eprintln!("Usage: {} <infile> <outfile>", args.next().unwrap());
+ process::exit(1);
+ }
+
+ args.next();
+ let in_file_path = args.next().unwrap();
+ let out_file_path = args.next().unwrap();
+
+ let in_file = match fs::File::open(&in_file_path) {
+ Ok(file) => file,
+ Err(err) => {
+ eprintln!("Failed to open file '{}': {}", in_file_path, err,);
+ process::exit(1);
+ }
+ };
+ let in_file = match unsafe { memmap2::Mmap::map(&in_file) } {
+ Ok(mmap) => mmap,
+ Err(err) => {
+ eprintln!("Failed to map file '{}': {}", in_file_path, err,);
+ process::exit(1);
+ }
+ };
+ let in_object = match object::File::parse(&*in_file) {
+ Ok(object) => object,
+ Err(err) => {
+ eprintln!("Failed to parse file '{}': {}", in_file_path, err);
+ process::exit(1);
+ }
+ };
+
+ let mut out_object = write::Object::new(
+ in_object.format(),
+ in_object.architecture(),
+ in_object.endianness(),
+ );
+ out_object.mangling = write::Mangling::None;
+ out_object.flags = in_object.flags();
+
+ let mut out_sections = HashMap::new();
+ for in_section in in_object.sections() {
+ if in_section.kind() == SectionKind::Metadata {
+ continue;
+ }
+ let section_id = out_object.add_section(
+ in_section
+ .segment_name()
+ .unwrap()
+ .unwrap_or("")
+ .as_bytes()
+ .to_vec(),
+ in_section.name().unwrap().as_bytes().to_vec(),
+ in_section.kind(),
+ );
+ let out_section = out_object.section_mut(section_id);
+ if out_section.is_bss() {
+ out_section.append_bss(in_section.size(), in_section.align());
+ } else {
+ out_section.set_data(in_section.data().unwrap().into(), in_section.align());
+ }
+ out_section.flags = in_section.flags();
+ out_sections.insert(in_section.index(), section_id);
+ }
+
+ let mut out_symbols = HashMap::new();
+ for in_symbol in in_object.symbols() {
+ if in_symbol.kind() == SymbolKind::Null {
+ continue;
+ }
+ let (section, value) = match in_symbol.section() {
+ SymbolSection::None => (write::SymbolSection::None, in_symbol.address()),
+ SymbolSection::Undefined => (write::SymbolSection::Undefined, in_symbol.address()),
+ SymbolSection::Absolute => (write::SymbolSection::Absolute, in_symbol.address()),
+ SymbolSection::Common => (write::SymbolSection::Common, in_symbol.address()),
+ SymbolSection::Section(index) => {
+ if let Some(out_section) = out_sections.get(&index) {
+ (
+ write::SymbolSection::Section(*out_section),
+ in_symbol.address() - in_object.section_by_index(index).unwrap().address(),
+ )
+ } else {
+ // Ignore symbols for sections that we have skipped.
+ assert_eq!(in_symbol.kind(), SymbolKind::Section);
+ continue;
+ }
+ }
+ _ => panic!("unknown symbol section for {:?}", in_symbol),
+ };
+ let flags = match in_symbol.flags() {
+ SymbolFlags::None => SymbolFlags::None,
+ SymbolFlags::Elf { st_info, st_other } => SymbolFlags::Elf { st_info, st_other },
+ SymbolFlags::MachO { n_desc } => SymbolFlags::MachO { n_desc },
+ SymbolFlags::CoffSection {
+ selection,
+ associative_section,
+ } => {
+ let associative_section =
+ associative_section.map(|index| *out_sections.get(&index).unwrap());
+ SymbolFlags::CoffSection {
+ selection,
+ associative_section,
+ }
+ }
+ _ => panic!("unknown symbol flags for {:?}", in_symbol),
+ };
+ let out_symbol = write::Symbol {
+ name: in_symbol.name().unwrap_or("").as_bytes().to_vec(),
+ value,
+ size: in_symbol.size(),
+ kind: in_symbol.kind(),
+ scope: in_symbol.scope(),
+ weak: in_symbol.is_weak(),
+ section,
+ flags,
+ };
+ let symbol_id = out_object.add_symbol(out_symbol);
+ out_symbols.insert(in_symbol.index(), symbol_id);
+ }
+
+ for in_section in in_object.sections() {
+ if in_section.kind() == SectionKind::Metadata {
+ continue;
+ }
+ let out_section = *out_sections.get(&in_section.index()).unwrap();
+ for (offset, in_relocation) in in_section.relocations() {
+ let symbol = match in_relocation.target() {
+ RelocationTarget::Symbol(symbol) => *out_symbols.get(&symbol).unwrap(),
+ RelocationTarget::Section(section) => {
+ out_object.section_symbol(*out_sections.get(&section).unwrap())
+ }
+ _ => panic!("unknown relocation target for {:?}", in_relocation),
+ };
+ let out_relocation = write::Relocation {
+ offset,
+ size: in_relocation.size(),
+ kind: in_relocation.kind(),
+ encoding: in_relocation.encoding(),
+ symbol,
+ addend: in_relocation.addend(),
+ };
+ out_object
+ .add_relocation(out_section, out_relocation)
+ .unwrap();
+ }
+ }
+
+ for in_comdat in in_object.comdats() {
+ let mut sections = Vec::new();
+ for in_section in in_comdat.sections() {
+ sections.push(*out_sections.get(&in_section).unwrap());
+ }
+ out_object.add_comdat(write::Comdat {
+ kind: in_comdat.kind(),
+ symbol: *out_symbols.get(&in_comdat.symbol()).unwrap(),
+ sections,
+ });
+ }
+
+ let out_data = out_object.write().unwrap();
+ if let Err(err) = fs::write(&out_file_path, out_data) {
+ eprintln!("Failed to write file '{}': {}", out_file_path, err);
+ process::exit(1);
+ }
+}
diff --git a/vendor/object-0.26.2/examples/objdump.rs b/vendor/object-0.26.2/examples/objdump.rs
new file mode 100644
index 000000000..b6eb0003f
--- /dev/null
+++ b/vendor/object-0.26.2/examples/objdump.rs
@@ -0,0 +1,230 @@
+use object::read::archive::ArchiveFile;
+use object::read::macho::{DyldCache, FatArch, FatHeader};
+use object::{Endianness, Object, ObjectComdat, ObjectSection, ObjectSymbol};
+use std::{env, fs, process};
+
+fn main() {
+ let mut args = env::args();
+ let cmd = args.next().unwrap();
+ if args.len() == 0 {
+ eprintln!("Usage: {} <file> [<member>...]", cmd);
+ process::exit(1);
+ }
+ let file_path = args.next().unwrap();
+ let mut member_names: Vec<_> = args.map(|name| (name, false)).collect();
+
+ let file = match fs::File::open(&file_path) {
+ Ok(file) => file,
+ Err(err) => {
+ eprintln!("Failed to open file '{}': {}", file_path, err,);
+ process::exit(1);
+ }
+ };
+ let file = match unsafe { memmap2::Mmap::map(&file) } {
+ Ok(mmap) => mmap,
+ Err(err) => {
+ eprintln!("Failed to map file '{}': {}", file_path, err,);
+ process::exit(1);
+ }
+ };
+
+ if let Ok(archive) = ArchiveFile::parse(&*file) {
+ eprintln!("Format: Archive (kind: {:?})", archive.kind());
+ for member in archive.members() {
+ if let Ok(member) = member {
+ if find_member(&mut member_names, member.name()) {
+ println!();
+ println!("{}:", String::from_utf8_lossy(member.name()));
+ if let Ok(data) = member.data(&*file) {
+ dump_object(data);
+ }
+ }
+ }
+ }
+ } else if let Ok(arches) = FatHeader::parse_arch32(&*file) {
+ println!("Format: Mach-O Fat 32");
+ for arch in arches {
+ println!();
+ println!("Fat Arch: {:?}", arch.architecture());
+ if let Ok(data) = arch.data(&*file) {
+ dump_object(data);
+ }
+ }
+ } else if let Ok(arches) = FatHeader::parse_arch64(&*file) {
+ println!("Format: Mach-O Fat 64");
+ for arch in arches {
+ println!();
+ println!("Fat Arch: {:?}", arch.architecture());
+ if let Ok(data) = arch.data(&*file) {
+ dump_object(data);
+ }
+ }
+ } else if let Ok(cache) = DyldCache::<Endianness>::parse(&*file) {
+ println!("Format: dyld cache {:?}-endian", cache.endianness());
+ println!("Architecture: {:?}", cache.architecture());
+ for image in cache.images() {
+ if let Ok(path) = image.path() {
+ if find_member(&mut member_names, path.as_bytes()) {
+ println!();
+ println!("{}:", path);
+ let file = match image.parse_object() {
+ Ok(file) => file,
+ Err(err) => {
+ eprintln!("Failed to parse file: {}", err);
+ continue;
+ }
+ };
+ dump_parsed_object(&file);
+ }
+ }
+ }
+ } else {
+ dump_object(&*file);
+ }
+
+ for (name, found) in member_names {
+ if !found {
+ eprintln!("Failed to find member '{}", name);
+ }
+ }
+}
+
+fn find_member(member_names: &mut [(String, bool)], name: &[u8]) -> bool {
+ if member_names.is_empty() {
+ return true;
+ }
+ match member_names.iter().position(|x| x.0.as_bytes() == name) {
+ Some(i) => {
+ member_names[i].1 = true;
+ true
+ }
+ None => false,
+ }
+}
+
+fn dump_object(data: &[u8]) {
+ let file = match object::File::parse(data) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to parse file: {}", err);
+ return;
+ }
+ };
+ dump_parsed_object(&file);
+}
+
+fn dump_parsed_object(file: &object::File) {
+ println!(
+ "Format: {:?} {:?}-endian {}-bit",
+ file.format(),
+ file.endianness(),
+ if file.is_64() { "64" } else { "32" }
+ );
+ println!("Architecture: {:?}", file.architecture());
+ println!("Flags: {:x?}", file.flags());
+ println!("Relative Address Base: {:x?}", file.relative_address_base());
+ println!("Entry Address: {:x?}", file.entry());
+
+ match file.mach_uuid() {
+ Ok(Some(uuid)) => println!("Mach UUID: {:x?}", uuid),
+ Ok(None) => {}
+ Err(e) => println!("Failed to parse Mach UUID: {}", e),
+ }
+ match file.build_id() {
+ Ok(Some(build_id)) => println!("Build ID: {:x?}", build_id),
+ Ok(None) => {}
+ Err(e) => println!("Failed to parse build ID: {}", e),
+ }
+ match file.gnu_debuglink() {
+ Ok(Some((filename, crc))) => println!(
+ "GNU debug link: {} CRC: {:08x}",
+ String::from_utf8_lossy(filename),
+ crc,
+ ),
+ Ok(None) => {}
+ Err(e) => println!("Failed to parse GNU debug link: {}", e),
+ }
+ match file.gnu_debugaltlink() {
+ Ok(Some((filename, build_id))) => println!(
+ "GNU debug alt link: {}, build ID: {:x?}",
+ String::from_utf8_lossy(filename),
+ build_id,
+ ),
+ Ok(None) => {}
+ Err(e) => println!("Failed to parse GNU debug alt link: {}", e),
+ }
+ match file.pdb_info() {
+ Ok(Some(info)) => println!(
+ "PDB file: {}, GUID: {:x?}, Age: {}",
+ String::from_utf8_lossy(info.path()),
+ info.guid(),
+ info.age()
+ ),
+ Ok(None) => {}
+ Err(e) => println!("Failed to parse PE CodeView info: {}", e),
+ }
+
+ for segment in file.segments() {
+ println!("{:x?}", segment);
+ }
+
+ for section in file.sections() {
+ println!("{}: {:x?}", section.index().0, section);
+ }
+
+ for comdat in file.comdats() {
+ print!("{:?} Sections:", comdat);
+ for section in comdat.sections() {
+ print!(" {}", section.0);
+ }
+ println!();
+ }
+
+ println!();
+ println!("Symbols");
+ for symbol in file.symbols() {
+ println!("{}: {:x?}", symbol.index().0, symbol);
+ }
+
+ for section in file.sections() {
+ if section.relocations().next().is_some() {
+ println!(
+ "\n{} relocations",
+ section.name().unwrap_or("<invalid name>")
+ );
+ for relocation in section.relocations() {
+ println!("{:x?}", relocation);
+ }
+ }
+ }
+
+ println!();
+ println!("Dynamic symbols");
+ for symbol in file.dynamic_symbols() {
+ println!("{}: {:x?}", symbol.index().0, symbol);
+ }
+
+ if let Some(relocations) = file.dynamic_relocations() {
+ println!();
+ println!("Dynamic relocations");
+ for relocation in relocations {
+ println!("{:x?}", relocation);
+ }
+ }
+
+ let imports = file.imports().unwrap();
+ if !imports.is_empty() {
+ println!();
+ for import in imports {
+ println!("{:?}", import);
+ }
+ }
+
+ let exports = file.exports().unwrap();
+ if !exports.is_empty() {
+ println!();
+ for export in exports {
+ println!("{:x?}", export);
+ }
+ }
+}
diff --git a/vendor/object-0.26.2/examples/objectmap.rs b/vendor/object-0.26.2/examples/objectmap.rs
new file mode 100644
index 000000000..de8d8a002
--- /dev/null
+++ b/vendor/object-0.26.2/examples/objectmap.rs
@@ -0,0 +1,67 @@
+use object::Object;
+use std::{env, fs, process};
+
+fn main() {
+ let mut args = env::args().skip(1);
+ if args.len() == 0 {
+ eprintln!(
+ "Usage: {} <file> [address] ...",
+ env::args().next().unwrap()
+ );
+ process::exit(1);
+ }
+
+ let file_path = args.next().unwrap();
+ let file = match fs::File::open(&file_path) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to open file '{}': {}", file_path, err,);
+ process::exit(1);
+ }
+ };
+ let file = match unsafe { memmap2::Mmap::map(&file) } {
+ Ok(mmap) => mmap,
+ Err(err) => {
+ println!("Failed to map file '{}': {}", file_path, err,);
+ process::exit(1);
+ }
+ };
+ let file = match object::File::parse(&*file) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to parse file '{}': {}", file_path, err);
+ process::exit(1);
+ }
+ };
+
+ let map = file.object_map();
+
+ if args.len() == 0 {
+ for symbol in map.symbols() {
+ print_symbol(symbol, &map);
+ }
+ } else {
+ for arg in args {
+ let mut arg = &arg[..];
+ if arg.starts_with("0x") {
+ arg = &arg[2..];
+ }
+ let address = u64::from_str_radix(arg, 16).expect("Failed to parse address");
+ if let Some(symbol) = map.get(address) {
+ print_symbol(symbol, &map);
+ } else {
+ println!("{:} not found", address);
+ }
+ }
+ }
+}
+
+fn print_symbol(symbol: &object::ObjectMapEntry<'_>, map: &object::ObjectMap<'_>) {
+ println!(
+ "{:x} {:x} {} {}",
+ symbol.address(),
+ symbol.size(),
+ String::from_utf8_lossy(symbol.name()),
+ String::from_utf8_lossy(symbol.object(map)),
+ );
+}
diff --git a/vendor/object-0.26.2/examples/readobj.rs b/vendor/object-0.26.2/examples/readobj.rs
new file mode 100644
index 000000000..bbcab143a
--- /dev/null
+++ b/vendor/object-0.26.2/examples/readobj.rs
@@ -0,0 +1,5257 @@
+//! Example that uses the lower level read API.
+
+use object::read::archive::ArchiveFile;
+use object::read::macho::{FatArch, FatHeader};
+use object::Endianness;
+use std::convert::TryInto;
+use std::io::Write;
+use std::{env, fmt, fs, io, process, str};
+
+fn main() {
+ let arg_len = env::args().len();
+ if arg_len <= 1 {
+ eprintln!("Usage: {} <file> ...", env::args().next().unwrap());
+ process::exit(1);
+ }
+
+ for file_path in env::args().skip(1) {
+ if arg_len > 2 {
+ println!();
+ println!("{}:", file_path);
+ }
+
+ let file = match fs::File::open(&file_path) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to open file '{}': {}", file_path, err);
+ continue;
+ }
+ };
+ let file = match unsafe { memmap2::Mmap::map(&file) } {
+ Ok(mmap) => mmap,
+ Err(err) => {
+ println!("Failed to map file '{}': {}", file_path, err);
+ continue;
+ }
+ };
+
+ let stdout = io::stdout();
+ let mut printer = Printer::new(stdout.lock());
+ print_object(&mut printer, &*file);
+ }
+}
+
+struct Printer<W: Write> {
+ w: W,
+ indent: usize,
+}
+
+impl<W: Write> Printer<W> {
+ fn new(w: W) -> Self {
+ Self { w, indent: 0 }
+ }
+
+ fn blank(&mut self) {
+ writeln!(self.w).unwrap();
+ }
+
+ fn print_indent(&mut self) {
+ if self.indent != 0 {
+ write!(self.w, "{:-1$}", " ", self.indent * 4).unwrap();
+ }
+ }
+
+ fn print_string(&mut self, s: &[u8]) {
+ if let Ok(s) = str::from_utf8(s) {
+ write!(self.w, "\"{}\"", s).unwrap();
+ } else {
+ write!(self.w, "{:X?}", s).unwrap();
+ }
+ }
+
+ fn indent<F: FnOnce(&mut Self)>(&mut self, f: F) {
+ self.indent += 1;
+ f(self);
+ self.indent -= 1;
+ }
+
+ fn group<F: FnOnce(&mut Self)>(&mut self, name: &str, f: F) {
+ self.print_indent();
+ writeln!(self.w, "{} {{", name).unwrap();
+ self.indent(f);
+ self.print_indent();
+ writeln!(self.w, "}}").unwrap();
+ }
+
+ fn field_name(&mut self, name: &str) {
+ self.print_indent();
+ if !name.is_empty() {
+ write!(self.w, "{}: ", name).unwrap();
+ }
+ }
+
+ fn field<T: fmt::Display>(&mut self, name: &str, value: T) {
+ self.field_name(name);
+ writeln!(self.w, "{}", value).unwrap();
+ }
+
+ fn field_hex<T: fmt::UpperHex>(&mut self, name: &str, value: T) {
+ self.field_name(name);
+ writeln!(self.w, "0x{:X}", value).unwrap();
+ }
+
+ fn field_bytes(&mut self, name: &str, value: &[u8]) {
+ self.field_name(name);
+ writeln!(self.w, "{:X?}", value).unwrap();
+ }
+
+ fn field_string<T: fmt::UpperHex>(&mut self, name: &str, value: T, s: Option<&[u8]>) {
+ if let Some(s) = s {
+ self.field_name(name);
+ self.print_string(s);
+ writeln!(self.w, " (0x{:X})", value).unwrap();
+ } else {
+ self.field_hex(name, value);
+ }
+ }
+
+ fn field_inline_string(&mut self, name: &str, s: &[u8]) {
+ self.field_name(name);
+ self.print_string(s);
+ writeln!(self.w).unwrap();
+ }
+
+ fn field_enum<T: Eq + fmt::UpperHex>(&mut self, name: &str, value: T, flags: &[Flag<T>]) {
+ for flag in flags {
+ if value == flag.value {
+ self.field_name(name);
+ writeln!(self.w, "{} (0x{:X})", flag.name, value).unwrap();
+ return;
+ }
+ }
+ self.field_hex(name, value);
+ }
+
+ fn field_enums<T: Eq + fmt::UpperHex>(&mut self, name: &str, value: T, enums: &[&[Flag<T>]]) {
+ for flags in enums {
+ for flag in *flags {
+ if value == flag.value {
+ self.field_name(name);
+ writeln!(self.w, "{} (0x{:X})", flag.name, value).unwrap();
+ return;
+ }
+ }
+ }
+ self.field_hex(name, value);
+ }
+
+ fn flags<T: Into<u64>, U: Copy + Into<u64>>(&mut self, value: T, mask: U, flags: &[Flag<U>]) {
+ let value = value.into();
+ let mask = mask.into();
+ self.indent(|p| {
+ if mask != 0 {
+ for flag in flags {
+ if value & mask == flag.value.into() {
+ p.print_indent();
+ writeln!(p.w, "{} (0x{:X})", flag.name, flag.value.into()).unwrap();
+ return;
+ }
+ }
+ p.print_indent();
+ writeln!(p.w, "<unknown> (0x{:X})", value & mask).unwrap();
+ } else {
+ for flag in flags {
+ if value & flag.value.into() == flag.value.into() {
+ p.print_indent();
+ writeln!(p.w, "{} (0x{:X})", flag.name, flag.value.into()).unwrap();
+ }
+ }
+ // TODO: display unknown flags (need to display all flags at once for this)
+ }
+ });
+ }
+}
+
+struct Flag<T> {
+ value: T,
+ name: &'static str,
+}
+
+macro_rules! flags {
+ ($($name:ident),+ $(,)?) => ( [ $(Flag { value: $name, name: stringify!($name), }),+ ] )
+}
+
+fn print_object(p: &mut Printer<impl Write>, data: &[u8]) {
+ let kind = match object::FileKind::parse(data) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to parse file: {}", err);
+ return;
+ }
+ };
+ match kind {
+ object::FileKind::Archive => print_archive(p, data),
+ object::FileKind::Coff => pe::print_coff(p, data),
+ object::FileKind::DyldCache => macho::print_dyld_cache(p, data),
+ object::FileKind::Elf32 => elf::print_elf32(p, data),
+ object::FileKind::Elf64 => elf::print_elf64(p, data),
+ object::FileKind::MachO32 => macho::print_macho32(p, data, 0),
+ object::FileKind::MachO64 => macho::print_macho64(p, data, 0),
+ object::FileKind::MachOFat32 => macho::print_macho_fat32(p, data),
+ object::FileKind::MachOFat64 => macho::print_macho_fat64(p, data),
+ object::FileKind::Pe32 => pe::print_pe32(p, data),
+ object::FileKind::Pe64 => pe::print_pe64(p, data),
+ // TODO
+ _ => {}
+ }
+}
+
+fn print_object_at(p: &mut Printer<impl Write>, data: &[u8], offset: u64) {
+ let kind = match object::FileKind::parse_at(data, offset) {
+ Ok(file) => file,
+ Err(err) => {
+ println!("Failed to parse file: {}", err);
+ return;
+ }
+ };
+ match kind {
+ object::FileKind::MachO32 => macho::print_macho32(p, data, offset),
+ object::FileKind::MachO64 => macho::print_macho64(p, data, offset),
+ // TODO
+ _ => {}
+ }
+}
+
+fn print_archive(p: &mut Printer<impl Write>, data: &[u8]) {
+ if let Ok(archive) = ArchiveFile::parse(data) {
+ p.field("Format", format!("Archive ({:?})", archive.kind()));
+ for member in archive.members() {
+ if let Ok(member) = member {
+ p.blank();
+ p.field("Member", String::from_utf8_lossy(member.name()));
+ if let Ok(data) = member.data(data) {
+ print_object(p, data);
+ }
+ }
+ }
+ }
+}
+
+mod elf {
+ use super::*;
+ use object::elf::*;
+ use object::read::elf::*;
+
+ pub(super) fn print_elf32(p: &mut Printer<impl Write>, data: &[u8]) {
+ if let Ok(elf) = FileHeader32::<Endianness>::parse(data) {
+ println!("Format: ELF 32-bit");
+ print_elf(p, elf, data);
+ }
+ }
+
+ pub(super) fn print_elf64(p: &mut Printer<impl Write>, data: &[u8]) {
+ if let Ok(elf) = FileHeader64::<Endianness>::parse(data) {
+ println!("Format: ELF 64-bit");
+ print_elf(p, elf, data);
+ }
+ }
+
+ fn print_elf<Elf: FileHeader<Endian = Endianness>>(
+ p: &mut Printer<impl Write>,
+ elf: &Elf,
+ data: &[u8],
+ ) {
+ if let Ok(endian) = elf.endian() {
+ print_file_header(p, endian, elf);
+ if let Ok(segments) = elf.program_headers(endian, data) {
+ print_program_headers(p, endian, data, elf, segments);
+ }
+ if let Ok(sections) = elf.sections(endian, data) {
+ print_section_headers(p, endian, data, elf, &sections);
+ }
+ }
+ }
+
+ fn print_file_header<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ elf: &Elf,
+ ) {
+ p.group("FileHeader", |p| {
+ p.group("Ident", |p| print_ident(p, elf.e_ident()));
+ p.field_enum("Type", elf.e_type(endian), &FLAGS_ET);
+ p.field_enum("Machine", elf.e_machine(endian), &FLAGS_EM);
+ let version = elf.e_version(endian);
+ if version < 256 {
+ p.field_enum("Version", version as u8, &FLAGS_EV);
+ } else {
+ p.field_hex("Version", version);
+ }
+ p.field_enum("Type", elf.e_type(endian), &FLAGS_ET);
+ p.field_hex("Entry", elf.e_entry(endian).into());
+ p.field_hex("ProgramHeaderOffset", elf.e_phoff(endian).into());
+ p.field_hex("SectionHeaderOffset", elf.e_shoff(endian).into());
+ let flags = elf.e_flags(endian);
+ p.field_hex("Flags", flags);
+ match elf.e_machine(endian) {
+ EM_SPARC => p.flags(flags, 0, &FLAGS_EF_SPARC),
+ EM_SPARCV9 => p.flags(flags, 0, &FLAGS_EF_SPARCV9),
+ EM_MIPS => {
+ p.flags(flags, 0, &FLAGS_EF_MIPS);
+ p.flags(flags, EF_MIPS_ARCH, &FLAGS_EF_MIPS_ARCH);
+ }
+ EM_PARISC => {
+ p.flags(flags, 0, &FLAGS_EF_PARISC);
+ p.flags(flags, EF_PARISC_ARCH, &FLAGS_EF_PARISC_ARCH);
+ }
+ EM_ALPHA => p.flags(flags, 0, &FLAGS_EF_ALPHA),
+ EM_PPC => p.flags(flags, 0, &FLAGS_EF_PPC),
+ EM_PPC64 => p.flags(flags, 0, &FLAGS_EF_PPC64),
+ EM_ARM => {
+ p.flags(flags, 0, &FLAGS_EF_ARM);
+ p.flags(flags, EF_ARM_EABIMASK, &FLAGS_EF_ARM_EABI);
+ }
+ EM_CSKY => p.flags(flags, EF_CSKY_ABIMASK, &FLAGS_EF_CSKY_ABI),
+ EM_IA_64 => p.flags(flags, 0, &FLAGS_EF_IA_64),
+ EM_SH => p.flags(flags, EF_SH_MACH_MASK, &FLAGS_EF_SH_MACH),
+ EM_S390 => p.flags(flags, 0, &FLAGS_EF_S390),
+ EM_RISCV => {
+ p.flags(flags, 0, &FLAGS_EF_RISCV);
+ p.flags(flags, EF_RISCV_FLOAT_ABI, &FLAGS_EF_RISCV_FLOAT_ABI);
+ }
+ _ => {}
+ };
+ p.field_hex("HeaderSize", elf.e_ehsize(endian));
+ p.field_hex("ProgramHeaderEntrySize", elf.e_phentsize(endian));
+ p.field("ProgramHeaderCount", elf.e_phnum(endian));
+ p.field_hex("SectionHeaderEntrySize", elf.e_shentsize(endian));
+ p.field("SectionHeaderCount", elf.e_shnum(endian));
+ p.field("SectionHeaderStringTableIndex", elf.e_shstrndx(endian));
+ });
+ }
+
+ fn print_ident(p: &mut Printer<impl Write>, ident: &Ident) {
+ p.field("Magic", format!("{:X?}", ident.magic));
+ p.field_enum("Class", ident.class, &FLAGS_EI_CLASS);
+ p.field_enum("Data", ident.data, &FLAGS_EI_DATA);
+ p.field_enum("Version", ident.version, &FLAGS_EV);
+ p.field_enum("OsAbi", ident.os_abi, &FLAGS_EI_OSABI);
+ p.field_hex("AbiVersion", ident.abi_version);
+ p.field("Unused", format!("{:X?}", ident.padding));
+ }
+
+ fn print_program_headers<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ elf: &Elf,
+ segments: &[Elf::ProgramHeader],
+ ) {
+ for segment in segments {
+ p.group("ProgramHeader", |p| {
+ let proc = match elf.e_machine(endian) {
+ EM_MIPS => FLAGS_PT_MIPS,
+ EM_PARISC => FLAGS_PT_PARISC,
+ EM_ARM => FLAGS_PT_ARM,
+ EM_IA_64 => FLAGS_PT_IA_64,
+ _ => &[],
+ };
+ let os = match elf.e_ident().os_abi {
+ ELFOSABI_HPUX => FLAGS_PT_HP,
+ _ => &[],
+ };
+ p.field_enums("Type", segment.p_type(endian), &[FLAGS_PT, proc, os]);
+
+ p.field_hex("Offset", segment.p_offset(endian).into());
+ p.field_hex("VirtualAddress", segment.p_vaddr(endian).into());
+ p.field_hex("PhysicalAddress", segment.p_paddr(endian).into());
+ p.field_hex("FileSize", segment.p_filesz(endian).into());
+ p.field_hex("MemorySize", segment.p_memsz(endian).into());
+
+ let flags = segment.p_flags(endian);
+ p.field_hex("Flags", flags);
+ p.flags(flags, 0, FLAGS_PF);
+ match elf.e_ident().os_abi {
+ ELFOSABI_HPUX => p.flags(flags, 0, FLAGS_PF_HP),
+ _ => {}
+ };
+ match elf.e_machine(endian) {
+ EM_MIPS => p.flags(flags, 0, FLAGS_PF_MIPS),
+ EM_PARISC => p.flags(flags, 0, FLAGS_PF_PARISC),
+ EM_ARM => p.flags(flags, 0, FLAGS_PF_ARM),
+ EM_IA_64 => p.flags(flags, 0, FLAGS_PF_IA_64),
+ _ => {}
+ };
+
+ p.field_hex("Align", segment.p_align(endian).into());
+
+ match segment.p_type(endian) {
+ PT_NOTE => print_segment_notes(p, endian, data, elf, segment),
+ PT_DYNAMIC => print_segment_dynamic(p, endian, data, elf, segments, segment),
+ // TODO:
+ //PT_INTERP =>
+ //PT_SHLIB =>
+ //PT_PHDR =>
+ //PT_TLS =>
+ //PT_GNU_EH_FRAME =>
+ //PT_GNU_STACK =>
+ //PT_GNU_RELRO =>
+ _ => {}
+ }
+ });
+ }
+ }
+
+ fn print_segment_notes<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ _elf: &Elf,
+ segment: &Elf::ProgramHeader,
+ ) {
+ if let Ok(Some(notes)) = segment.notes(endian, data) {
+ print_notes(p, endian, notes);
+ }
+ }
+
+ fn print_segment_dynamic<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ elf: &Elf,
+ segments: &[Elf::ProgramHeader],
+ segment: &Elf::ProgramHeader,
+ ) {
+ if let Ok(Some(dynamic)) = segment.dynamic(endian, data) {
+ // TODO: add a helper API for this and the other mandatory tags?
+ let mut strtab = 0;
+ let mut strsz = 0;
+ for d in dynamic {
+ let tag = d.d_tag(endian).into();
+ if tag == DT_STRTAB.into() {
+ strtab = d.d_val(endian).into();
+ } else if tag == DT_STRSZ.into() {
+ strsz = d.d_val(endian).into();
+ }
+ }
+ let mut dynstr = object::StringTable::default();
+ for s in segments {
+ if let Ok(Some(data)) = s.data_range(endian, data, strtab, strsz) {
+ dynstr = object::StringTable::new(data, 0, data.len() as u64);
+ break;
+ }
+ }
+
+ let proc = match elf.e_machine(endian) {
+ EM_SPARC => FLAGS_DT_SPARC,
+ EM_MIPS => FLAGS_DT_MIPS,
+ EM_ALPHA => FLAGS_DT_ALPHA,
+ EM_PPC => FLAGS_DT_PPC,
+ EM_PPC64 => FLAGS_DT_PPC64,
+ EM_IA_64 => FLAGS_DT_IA_64,
+ EM_ALTERA_NIOS2 => FLAGS_DT_NIOS2,
+ _ => &[],
+ };
+ for d in dynamic {
+ let tag = d.d_tag(endian).into();
+ let val = d.d_val(endian).into();
+ p.group("Dynamic", |p| {
+ if let Ok(tag) = tag.try_into() {
+ p.field_enums("Tag", tag, &[FLAGS_DT, proc]);
+ if tag == DT_NEEDED {
+ p.field_string(
+ "Value",
+ val,
+ val.try_into().ok().and_then(|val| dynstr.get(val).ok()),
+ );
+ } else {
+ p.field_hex("Value", val);
+ if tag == DT_FLAGS {
+ p.flags(val, 0, FLAGS_DF);
+ } else if tag == DT_FLAGS_1 {
+ p.flags(val, 0, FLAGS_DF_1);
+ }
+ }
+ } else {
+ p.field_hex("Tag", tag);
+ p.field_hex("Value", val);
+ }
+ });
+ if tag == DT_NULL.into() {
+ break;
+ }
+ }
+ }
+ }
+
+ fn print_section_headers<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ elf: &Elf,
+ sections: &SectionTable<Elf>,
+ ) {
+ for (index, section) in sections.iter().enumerate() {
+ p.group("SectionHeader", |p| {
+ p.field("Index", index);
+ p.field_string(
+ "Name",
+ section.sh_name(endian),
+ sections.section_name(endian, section).ok(),
+ );
+
+ let proc = match elf.e_machine(endian) {
+ EM_MIPS => FLAGS_SHT_MIPS,
+ EM_PARISC => FLAGS_SHT_PARISC,
+ EM_ALPHA => FLAGS_SHT_ALPHA,
+ EM_ARM => FLAGS_SHT_ARM,
+ EM_CSKY => FLAGS_SHT_CSKY,
+ EM_IA_64 => FLAGS_SHT_IA_64,
+ EM_X86_64 => FLAGS_SHT_X86_64,
+ _ => &[],
+ };
+ p.field_enums("Type", section.sh_type(endian), &[FLAGS_SHT, proc]);
+
+ let flags = section.sh_flags(endian).into();
+ p.field_hex("Flags", flags);
+ p.flags(flags, 0, FLAGS_SHF);
+ match elf.e_machine(endian) {
+ EM_MIPS => p.flags(flags, 0, FLAGS_SHF_MIPS),
+ EM_PARISC => p.flags(flags, 0, FLAGS_SHF_PARISC),
+ EM_ALPHA => p.flags(flags, 0, FLAGS_SHF_ALPHA),
+ EM_ARM => p.flags(flags, 0, FLAGS_SHF_ARM),
+ EM_IA_64 => p.flags(flags, 0, FLAGS_SHF_IA_64),
+ _ => {}
+ }
+
+ p.field_hex("Address", section.sh_addr(endian).into());
+ p.field_hex("Offset", section.sh_offset(endian).into());
+ p.field_hex("Size", section.sh_size(endian).into());
+ p.field("Link", section.sh_link(endian));
+ p.field("Info", section.sh_info(endian));
+ p.field_hex("AddressAlign", section.sh_addralign(endian).into());
+ p.field_hex("EntrySize", section.sh_entsize(endian).into());
+
+ match section.sh_type(endian) {
+ SHT_SYMTAB | SHT_DYNSYM => {
+ print_section_symbols(p, endian, data, elf, sections, index, section)
+ }
+ SHT_REL => print_section_rel(p, endian, data, elf, sections, section),
+ SHT_RELA => print_section_rela(p, endian, data, elf, sections, section),
+ SHT_NOTE => print_section_notes(p, endian, data, elf, section),
+ SHT_GROUP => print_section_group(p, endian, data, elf, sections, section),
+ SHT_HASH => print_hash(p, endian, data, elf, sections, section),
+ SHT_GNU_HASH => print_gnu_hash(p, endian, data, elf, sections, section),
+ SHT_GNU_VERDEF => print_gnu_verdef(p, endian, data, elf, sections, section),
+ SHT_GNU_VERNEED => print_gnu_verneed(p, endian, data, elf, sections, section),
+ SHT_GNU_VERSYM => print_gnu_versym(p, endian, data, elf, sections, section),
+ // TODO:
+ //SHT_DYNAMIC =>
+ //SHT_SHLIB =>
+ //SHT_INIT_ARRAY =>
+ //SHT_FINI_ARRAY =>
+ //SHT_PREINIT_ARRAY =>
+ _ => {}
+ }
+ });
+ }
+ }
+
+ fn print_section_symbols<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ elf: &Elf,
+ sections: &SectionTable<Elf>,
+ section_index: usize,
+ section: &Elf::SectionHeader,
+ ) {
+ if let Ok(Some(symbols)) = section.symbols(endian, data, sections, section_index) {
+ let os_stt = match elf.e_ident().os_abi {
+ ELFOSABI_GNU => FLAGS_STT_GNU,
+ ELFOSABI_HPUX => FLAGS_STT_HP,
+ _ => &[],
+ };
+ let proc_stt = match elf.e_machine(endian) {
+ EM_SPARC => FLAGS_STT_SPARC,
+ EM_PARISC => FLAGS_STT_PARISC,
+ EM_ARM => FLAGS_STT_ARM,
+ _ => &[],
+ };
+ let os_stb = match elf.e_ident().os_abi {
+ ELFOSABI_GNU => FLAGS_STB_GNU,
+ _ => &[],
+ };
+ let proc_stb = match elf.e_machine(endian) {
+ EM_MIPS => FLAGS_STB_MIPS,
+ _ => &[],
+ };
+ let proc_shn = match elf.e_machine(endian) {
+ EM_MIPS => FLAGS_SHN_MIPS,
+ EM_PARISC => FLAGS_SHN_PARISC,
+ _ => &[],
+ };
+ for (index, symbol) in symbols.iter().enumerate() {
+ p.group("Symbol", |p| {
+ p.field("Index", index);
+ p.field_string(
+ "Name",
+ symbol.st_name(endian),
+ symbol.name(endian, symbols.strings()).ok(),
+ );
+ p.field_hex("Value", symbol.st_value(endian).into());
+ p.field_hex("Size", symbol.st_size(endian).into());
+ p.field_enums("Type", symbol.st_type(), &[FLAGS_STT, os_stt, proc_stt]);
+ p.field_enums("Bind", symbol.st_bind(), &[FLAGS_STB, os_stb, proc_stb]);
+
+ let other = symbol.st_other();
+ if other & !0x3 == 0 {
+ p.field_enum("Other", other, FLAGS_STV);
+ } else {
+ p.field_hex("Other", other);
+ p.flags(other, 0x3, FLAGS_STV);
+ match elf.e_machine(endian) {
+ EM_MIPS => p.flags(other, 0, FLAGS_STO_MIPS),
+ EM_ALPHA => p.flags(other, 0, FLAGS_STO_ALPHA),
+ EM_PPC64 => p.field_hex(
+ "Local",
+ (other & STO_PPC64_LOCAL_MASK) >> STO_PPC64_LOCAL_BIT,
+ ),
+ _ => {}
+ }
+ }
+
+ let shndx = symbol.st_shndx(endian);
+ if shndx == SHN_UNDEF || shndx >= SHN_LORESERVE {
+ p.field_enums("SectionIndex", shndx, &[FLAGS_SHN, proc_shn]);
+ } else {
+ p.field("SectionIndex", shndx);
+ }
+ if let Some(shndx) = symbols.shndx(index) {
+ p.field("ExtendedSectionIndex", shndx);
+ }
+ });
+ }
+ }
+ }
+
+ fn print_section_rel<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ elf: &Elf,
+ sections: &SectionTable<Elf>,
+ section: &Elf::SectionHeader,
+ ) {
+ if let Ok(Some(relocations)) = section.rel(endian, data) {
+ let symbols = section.relocation_symbols(endian, data, sections).ok();
+ let proc = rel_flag_type(endian, elf);
+ for relocation in relocations {
+ p.group("Relocation", |p| {
+ p.field_hex("Offset", relocation.r_offset(endian).into());
+ p.field_enum("Type", relocation.r_type(endian), proc);
+ let sym = relocation.r_sym(endian);
+ p.field_string("Symbol", sym, rel_symbol(endian, symbols, sym as usize));
+ });
+ }
+ }
+ }
+
+ fn print_section_rela<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ elf: &Elf,
+ sections: &SectionTable<Elf>,
+ section: &Elf::SectionHeader,
+ ) {
+ if let Ok(Some(relocations)) = section.rela(endian, data) {
+ let symbols = section.relocation_symbols(endian, data, sections).ok();
+ let proc = rel_flag_type(endian, elf);
+ for relocation in relocations {
+ p.group("Relocation", |p| {
+ p.field_hex("Offset", relocation.r_offset(endian).into());
+ p.field_enum(
+ "Type",
+ relocation.r_type(endian, elf.is_mips64el(endian)),
+ proc,
+ );
+ let sym = relocation.r_sym(endian, elf.is_mips64el(endian));
+ p.field_string("Symbol", sym, rel_symbol(endian, symbols, sym as usize));
+ let addend = relocation.r_addend(endian).into() as u64;
+ if addend != 0 {
+ p.field_hex("Addend", addend);
+ }
+ });
+ }
+ }
+ }
+
+ fn rel_symbol<'data, Elf: FileHeader>(
+ endian: Elf::Endian,
+ symbols: Option<SymbolTable<'data, Elf>>,
+ sym: usize,
+ ) -> Option<&'data [u8]> {
+ let symbols = symbols?;
+ let symbol = symbols.symbol(sym as usize).ok()?;
+ symbol.name(endian, symbols.strings()).ok()
+ }
+
+ fn rel_flag_type<Elf: FileHeader>(endian: Elf::Endian, elf: &Elf) -> &'static [Flag<u32>] {
+ match elf.e_machine(endian) {
+ EM_68K => FLAGS_R_68K,
+ EM_386 => FLAGS_R_386,
+ EM_SPARC => FLAGS_R_SPARC,
+ EM_MIPS => FLAGS_R_MIPS,
+ EM_PARISC => FLAGS_R_PARISC,
+ EM_ALPHA => FLAGS_R_ALPHA,
+ EM_PPC => FLAGS_R_PPC,
+ EM_PPC64 => FLAGS_R_PPC64,
+ EM_AARCH64 => FLAGS_R_AARCH64,
+ EM_ARM => FLAGS_R_ARM,
+ EM_CSKY => FLAGS_R_CKCORE,
+ EM_IA_64 => FLAGS_R_IA64,
+ EM_SH => FLAGS_R_SH,
+ EM_S390 => FLAGS_R_390,
+ EM_CRIS => FLAGS_R_CRIS,
+ EM_X86_64 => FLAGS_R_X86_64,
+ EM_MN10300 => FLAGS_R_MN10300,
+ EM_M32R => FLAGS_R_M32R,
+ EM_MICROBLAZE => FLAGS_R_MICROBLAZE,
+ EM_ALTERA_NIOS2 => FLAGS_R_NIOS2,
+ EM_TILEPRO => FLAGS_R_TILEPRO,
+ EM_TILEGX => FLAGS_R_TILEGX,
+ EM_RISCV => FLAGS_R_RISCV,
+ EM_BPF => FLAGS_R_BPF,
+ EM_METAG => FLAGS_R_METAG,
+ EM_NDS32 => FLAGS_R_NDS32,
+ _ => &[],
+ }
+ }
+
+ fn print_section_notes<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ _elf: &Elf,
+ section: &Elf::SectionHeader,
+ ) {
+ if let Ok(Some(notes)) = section.notes(endian, data) {
+ print_notes(p, endian, notes);
+ }
+ }
+
+ fn print_section_group<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ _elf: &Elf,
+ sections: &SectionTable<Elf>,
+ section: &Elf::SectionHeader,
+ ) {
+ if let Ok(Some((flag, members))) = section.group(endian, data) {
+ p.field_enum("GroupFlag", flag, FLAGS_GRP);
+ p.group("GroupSections", |p| {
+ for member in members {
+ let index = member.get(endian);
+ p.print_indent();
+ if let Ok(section) = sections.section(index as usize) {
+ if let Ok(name) = sections.section_name(endian, section) {
+ p.print_string(name);
+ writeln!(p.w, " ({})", index).unwrap();
+ } else {
+ writeln!(p.w, "{}", index).unwrap();
+ }
+ } else {
+ writeln!(p.w, "{}", index).unwrap();
+ }
+ }
+ });
+ }
+ }
+
+ fn print_notes<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ mut notes: NoteIterator<Elf>,
+ ) {
+ while let Ok(Some(note)) = notes.next() {
+ p.group("Note", |p| {
+ let name = note.name();
+ p.field_string("Name", note.n_namesz(endian), Some(name));
+ let flags = if name == ELF_NOTE_CORE || name == ELF_NOTE_LINUX {
+ FLAGS_NT_CORE
+ } else if name == ELF_NOTE_SOLARIS {
+ FLAGS_NT_SOLARIS
+ } else if name == ELF_NOTE_GNU {
+ FLAGS_NT_GNU
+ } else {
+ // TODO: NT_VERSION
+ &[]
+ };
+ p.field_enum("Type", note.n_type(endian), flags);
+ // TODO: interpret desc
+ p.field_bytes("Desc", note.desc());
+ });
+ }
+ }
+
+ fn print_hash<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ _elf: &Elf,
+ _sections: &SectionTable<Elf>,
+ section: &Elf::SectionHeader,
+ ) {
+ if let Ok(Some(hash)) = section.hash_header(endian, data) {
+ p.group("Hash", |p| {
+ p.field("BucketCount", hash.bucket_count.get(endian));
+ p.field("ChainCount", hash.chain_count.get(endian));
+ });
+ }
+ /* TODO: add this in a test somewhere
+ if let Ok(Some(hash_table)) = section.hash(endian, data) {
+ if let Ok(symbols) = _sections.symbols(endian, data, SHT_DYNSYM) {
+ for symbol in symbols.symbols() {
+ let name = symbols.symbol_name(endian, symbol).unwrap();
+ if !symbol.is_definition(endian) {
+ continue;
+ }
+ let hash = hash(name);
+ let hash_symbol = hash_table.find(endian, name, hash, &symbols).unwrap();
+ let hash_name = symbols.symbol_name(endian, hash_symbol).unwrap();
+ assert_eq!(name, hash_name);
+ }
+ }
+ }
+ */
+ }
+
+ fn print_gnu_hash<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ _elf: &Elf,
+ _sections: &SectionTable<Elf>,
+ section: &Elf::SectionHeader,
+ ) {
+ if let Ok(Some(hash)) = section.gnu_hash_header(endian, data) {
+ p.group("GnuHash", |p| {
+ p.field("BucketCount", hash.bucket_count.get(endian));
+ p.field("SymbolBase", hash.symbol_base.get(endian));
+ p.field("BloomCount", hash.bloom_count.get(endian));
+ p.field("BloomShift", hash.bloom_shift.get(endian));
+ });
+ }
+ /* TODO: add this in a test somewhere
+ if let Ok(Some(hash_table)) = section.gnu_hash(endian, data) {
+ if let Ok(symbols) = _sections.symbols(endian, data, SHT_DYNSYM) {
+ for symbol in &symbols.symbols()[hash_table.symbol_base() as usize..] {
+ let name = symbols.symbol_name(endian, symbol).unwrap();
+ let hash = gnu_hash(name);
+ let hash_symbol = hash_table.find(endian, name, hash, &symbols).unwrap();
+ let hash_name = symbols.symbol_name(endian, hash_symbol).unwrap();
+ assert_eq!(name, hash_name);
+ }
+ }
+ }
+ */
+ }
+
+ fn print_gnu_verdef<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ _elf: &Elf,
+ _sections: &SectionTable<Elf>,
+ section: &Elf::SectionHeader,
+ ) {
+ if let Ok(Some(mut verdefs)) = section.gnu_verdef(endian, data) {
+ while let Ok(Some((verdef, mut verdauxs))) = verdefs.next() {
+ p.group("VersionDefinition", |p| {
+ // TODO: names
+ p.field("Version", verdef.vd_version.get(endian));
+ p.field_hex("Flags", verdef.vd_flags.get(endian));
+ p.flags(verdef.vd_flags.get(endian), 0, FLAGS_VER_FLG);
+ p.field("Index", verdef.vd_ndx.get(endian) & !VER_NDX_HIDDEN);
+ p.flags(verdef.vd_ndx.get(endian), 0, FLAGS_VER_NDX);
+ p.field("AuxCount", verdef.vd_cnt.get(endian));
+ p.field_hex("Hash", verdef.vd_hash.get(endian));
+ p.field("AuxOffset", verdef.vd_aux.get(endian));
+ p.field("NextOffset", verdef.vd_next.get(endian));
+ while let Ok(Some(verdaux)) = verdauxs.next() {
+ p.group("Aux", |p| {
+ p.field_hex("Name", verdaux.vda_name.get(endian));
+ p.field("NextOffset", verdaux.vda_next.get(endian));
+ });
+ }
+ });
+ }
+ }
+ }
+
+ fn print_gnu_verneed<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ _elf: &Elf,
+ _sections: &SectionTable<Elf>,
+ section: &Elf::SectionHeader,
+ ) {
+ if let Ok(Some(mut verneeds)) = section.gnu_verneed(endian, data) {
+ while let Ok(Some((verneed, mut vernauxs))) = verneeds.next() {
+ p.group("VersionNeed", |p| {
+ // TODO: names
+ p.field("Version", verneed.vn_version.get(endian));
+ p.field("AuxCount", verneed.vn_cnt.get(endian));
+ p.field_hex("Filename", verneed.vn_file.get(endian));
+ p.field("AuxOffset", verneed.vn_aux.get(endian));
+ p.field("NextOffset", verneed.vn_next.get(endian));
+ while let Ok(Some(vernaux)) = vernauxs.next() {
+ p.group("Aux", |p| {
+ p.field_hex("Hash", vernaux.vna_hash.get(endian));
+ p.field_hex("Flags", vernaux.vna_flags.get(endian));
+ p.flags(vernaux.vna_flags.get(endian), 0, FLAGS_VER_FLG);
+ p.field("Index", vernaux.vna_other.get(endian) & !VER_NDX_HIDDEN);
+ p.flags(vernaux.vna_other.get(endian), 0, FLAGS_VER_NDX);
+ p.field_hex("Name", vernaux.vna_name.get(endian));
+ p.field("NextOffset", vernaux.vna_next.get(endian));
+ });
+ }
+ });
+ }
+ }
+ }
+
+ fn print_gnu_versym<Elf: FileHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Elf::Endian,
+ data: &[u8],
+ _elf: &Elf,
+ _sections: &SectionTable<Elf>,
+ section: &Elf::SectionHeader,
+ ) {
+ if let Ok(Some(syms)) = section.gnu_versym(endian, data) {
+ for sym in syms {
+ p.group("VersionSymbol", |p| {
+ p.field("Version", sym.0.get(endian) & !VER_NDX_HIDDEN);
+ p.flags(sym.0.get(endian), 0, FLAGS_VER_NDX);
+ // TODO: version name
+ });
+ }
+ }
+ }
+
+ static FLAGS_EI_CLASS: &[Flag<u8>] = &flags!(ELFCLASSNONE, ELFCLASS32, ELFCLASS64);
+ static FLAGS_EI_DATA: &[Flag<u8>] = &flags!(ELFDATANONE, ELFDATA2LSB, ELFDATA2MSB);
+ static FLAGS_EV: &[Flag<u8>] = &flags!(EV_NONE, EV_CURRENT);
+ static FLAGS_EI_OSABI: &[Flag<u8>] = &flags!(
+ ELFOSABI_SYSV,
+ ELFOSABI_HPUX,
+ ELFOSABI_NETBSD,
+ ELFOSABI_GNU,
+ ELFOSABI_SOLARIS,
+ ELFOSABI_AIX,
+ ELFOSABI_IRIX,
+ ELFOSABI_FREEBSD,
+ ELFOSABI_TRU64,
+ ELFOSABI_MODESTO,
+ ELFOSABI_OPENBSD,
+ ELFOSABI_ARM_AEABI,
+ ELFOSABI_ARM,
+ ELFOSABI_STANDALONE,
+ );
+ static FLAGS_ET: &[Flag<u16>] = &flags!(ET_NONE, ET_REL, ET_EXEC, ET_DYN, ET_CORE);
+ static FLAGS_EM: &[Flag<u16>] = &flags!(
+ EM_NONE,
+ EM_M32,
+ EM_SPARC,
+ EM_386,
+ EM_68K,
+ EM_88K,
+ EM_IAMCU,
+ EM_860,
+ EM_MIPS,
+ EM_S370,
+ EM_MIPS_RS3_LE,
+ EM_PARISC,
+ EM_VPP500,
+ EM_SPARC32PLUS,
+ EM_960,
+ EM_PPC,
+ EM_PPC64,
+ EM_S390,
+ EM_SPU,
+ EM_V800,
+ EM_FR20,
+ EM_RH32,
+ EM_RCE,
+ EM_ARM,
+ EM_FAKE_ALPHA,
+ EM_SH,
+ EM_SPARCV9,
+ EM_TRICORE,
+ EM_ARC,
+ EM_H8_300,
+ EM_H8_300H,
+ EM_H8S,
+ EM_H8_500,
+ EM_IA_64,
+ EM_MIPS_X,
+ EM_COLDFIRE,
+ EM_68HC12,
+ EM_MMA,
+ EM_PCP,
+ EM_NCPU,
+ EM_NDR1,
+ EM_STARCORE,
+ EM_ME16,
+ EM_ST100,
+ EM_TINYJ,
+ EM_X86_64,
+ EM_PDSP,
+ EM_PDP10,
+ EM_PDP11,
+ EM_FX66,
+ EM_ST9PLUS,
+ EM_ST7,
+ EM_68HC16,
+ EM_68HC11,
+ EM_68HC08,
+ EM_68HC05,
+ EM_SVX,
+ EM_ST19,
+ EM_VAX,
+ EM_CRIS,
+ EM_JAVELIN,
+ EM_FIREPATH,
+ EM_ZSP,
+ EM_MMIX,
+ EM_HUANY,
+ EM_PRISM,
+ EM_AVR,
+ EM_FR30,
+ EM_D10V,
+ EM_D30V,
+ EM_V850,
+ EM_M32R,
+ EM_MN10300,
+ EM_MN10200,
+ EM_PJ,
+ EM_OPENRISC,
+ EM_ARC_COMPACT,
+ EM_XTENSA,
+ EM_VIDEOCORE,
+ EM_TMM_GPP,
+ EM_NS32K,
+ EM_TPC,
+ EM_SNP1K,
+ EM_ST200,
+ EM_IP2K,
+ EM_MAX,
+ EM_CR,
+ EM_F2MC16,
+ EM_MSP430,
+ EM_BLACKFIN,
+ EM_SE_C33,
+ EM_SEP,
+ EM_ARCA,
+ EM_UNICORE,
+ EM_EXCESS,
+ EM_DXP,
+ EM_ALTERA_NIOS2,
+ EM_CRX,
+ EM_XGATE,
+ EM_C166,
+ EM_M16C,
+ EM_DSPIC30F,
+ EM_CE,
+ EM_M32C,
+ EM_TSK3000,
+ EM_RS08,
+ EM_SHARC,
+ EM_ECOG2,
+ EM_SCORE7,
+ EM_DSP24,
+ EM_VIDEOCORE3,
+ EM_LATTICEMICO32,
+ EM_SE_C17,
+ EM_TI_C6000,
+ EM_TI_C2000,
+ EM_TI_C5500,
+ EM_TI_ARP32,
+ EM_TI_PRU,
+ EM_MMDSP_PLUS,
+ EM_CYPRESS_M8C,
+ EM_R32C,
+ EM_TRIMEDIA,
+ EM_HEXAGON,
+ EM_8051,
+ EM_STXP7X,
+ EM_NDS32,
+ EM_ECOG1X,
+ EM_MAXQ30,
+ EM_XIMO16,
+ EM_MANIK,
+ EM_CRAYNV2,
+ EM_RX,
+ EM_METAG,
+ EM_MCST_ELBRUS,
+ EM_ECOG16,
+ EM_CR16,
+ EM_ETPU,
+ EM_SLE9X,
+ EM_L10M,
+ EM_K10M,
+ EM_AARCH64,
+ EM_AVR32,
+ EM_STM8,
+ EM_TILE64,
+ EM_TILEPRO,
+ EM_MICROBLAZE,
+ EM_CUDA,
+ EM_TILEGX,
+ EM_CLOUDSHIELD,
+ EM_COREA_1ST,
+ EM_COREA_2ND,
+ EM_ARC_COMPACT2,
+ EM_OPEN8,
+ EM_RL78,
+ EM_VIDEOCORE5,
+ EM_78KOR,
+ EM_56800EX,
+ EM_BA1,
+ EM_BA2,
+ EM_XCORE,
+ EM_MCHP_PIC,
+ EM_KM32,
+ EM_KMX32,
+ EM_EMX16,
+ EM_EMX8,
+ EM_KVARC,
+ EM_CDP,
+ EM_COGE,
+ EM_COOL,
+ EM_NORC,
+ EM_CSR_KALIMBA,
+ EM_Z80,
+ EM_VISIUM,
+ EM_FT32,
+ EM_MOXIE,
+ EM_AMDGPU,
+ EM_RISCV,
+ EM_BPF,
+ EM_CSKY,
+ EM_ALPHA,
+ );
+ static FLAGS_EF_SPARC: &[Flag<u32>] = &flags!(
+ EF_SPARC_LEDATA,
+ EF_SPARC_EXT_MASK,
+ EF_SPARC_32PLUS,
+ EF_SPARC_SUN_US1,
+ EF_SPARC_HAL_R1,
+ EF_SPARC_SUN_US3,
+ );
+ static FLAGS_EF_SPARCV9: &[Flag<u32>] = &flags!(
+ EF_SPARCV9_MM,
+ EF_SPARCV9_TSO,
+ EF_SPARCV9_PSO,
+ EF_SPARCV9_RMO,
+ );
+ static FLAGS_EF_MIPS: &[Flag<u32>] = &flags!(
+ EF_MIPS_NOREORDER,
+ EF_MIPS_PIC,
+ EF_MIPS_CPIC,
+ EF_MIPS_XGOT,
+ EF_MIPS_64BIT_WHIRL,
+ EF_MIPS_ABI2,
+ EF_MIPS_ABI_ON32,
+ EF_MIPS_FP64,
+ EF_MIPS_NAN2008,
+ );
+ static FLAGS_EF_MIPS_ARCH: &[Flag<u32>] = &flags!(
+ EF_MIPS_ARCH_1,
+ EF_MIPS_ARCH_2,
+ EF_MIPS_ARCH_3,
+ EF_MIPS_ARCH_4,
+ EF_MIPS_ARCH_5,
+ EF_MIPS_ARCH_32,
+ EF_MIPS_ARCH_64,
+ EF_MIPS_ARCH_32R2,
+ EF_MIPS_ARCH_64R2,
+ );
+ static FLAGS_EF_PARISC: &[Flag<u32>] = &flags!(
+ EF_PARISC_TRAPNIL,
+ EF_PARISC_EXT,
+ EF_PARISC_LSB,
+ EF_PARISC_WIDE,
+ EF_PARISC_NO_KABP,
+ EF_PARISC_LAZYSWAP,
+ );
+ static FLAGS_EF_PARISC_ARCH: &[Flag<u32>] =
+ &flags!(EFA_PARISC_1_0, EFA_PARISC_1_1, EFA_PARISC_2_0);
+ static FLAGS_EF_ALPHA: &[Flag<u32>] = &flags!(EF_ALPHA_32BIT, EF_ALPHA_CANRELAX);
+ static FLAGS_EF_PPC: &[Flag<u32>] =
+ &flags!(EF_PPC_EMB, EF_PPC_RELOCATABLE, EF_PPC_RELOCATABLE_LIB);
+ static FLAGS_EF_PPC64: &[Flag<u32>] = &flags!(EF_PPC64_ABI);
+ static FLAGS_EF_ARM: &[Flag<u32>] = &flags!(
+ EF_ARM_RELEXEC,
+ EF_ARM_HASENTRY,
+ EF_ARM_INTERWORK,
+ EF_ARM_APCS_26,
+ EF_ARM_APCS_FLOAT,
+ EF_ARM_PIC,
+ EF_ARM_ALIGN8,
+ EF_ARM_NEW_ABI,
+ EF_ARM_OLD_ABI,
+ EF_ARM_SOFT_FLOAT,
+ EF_ARM_VFP_FLOAT,
+ EF_ARM_MAVERICK_FLOAT,
+ EF_ARM_BE8,
+ EF_ARM_LE8,
+ );
+ static FLAGS_EF_ARM_EABI: &[Flag<u32>] = &flags!(
+ EF_ARM_EABI_UNKNOWN,
+ EF_ARM_EABI_VER1,
+ EF_ARM_EABI_VER2,
+ EF_ARM_EABI_VER3,
+ EF_ARM_EABI_VER4,
+ EF_ARM_EABI_VER5,
+ );
+ static FLAGS_EF_CSKY_ABI: &[Flag<u32>] = &flags!(EF_CSKY_ABIV1, EF_CSKY_ABIV2);
+ static FLAGS_EF_IA_64: &[Flag<u32>] = &flags!(EF_IA_64_ABI64);
+ static FLAGS_EF_SH_MACH: &[Flag<u32>] = &flags!(
+ EF_SH_UNKNOWN,
+ EF_SH1,
+ EF_SH2,
+ EF_SH3,
+ EF_SH_DSP,
+ EF_SH3_DSP,
+ EF_SH4AL_DSP,
+ EF_SH3E,
+ EF_SH4,
+ EF_SH2E,
+ EF_SH4A,
+ EF_SH2A,
+ EF_SH4_NOFPU,
+ EF_SH4A_NOFPU,
+ EF_SH4_NOMMU_NOFPU,
+ EF_SH2A_NOFPU,
+ EF_SH3_NOMMU,
+ EF_SH2A_SH4_NOFPU,
+ EF_SH2A_SH3_NOFPU,
+ EF_SH2A_SH4,
+ EF_SH2A_SH3E,
+ );
+ static FLAGS_EF_S390: &[Flag<u32>] = &flags!(EF_S390_HIGH_GPRS);
+ static FLAGS_EF_RISCV: &[Flag<u32>] = &flags!(EF_RISCV_RVC);
+ static FLAGS_EF_RISCV_FLOAT_ABI: &[Flag<u32>] = &flags!(
+ EF_RISCV_FLOAT_ABI_SOFT,
+ EF_RISCV_FLOAT_ABI_SINGLE,
+ EF_RISCV_FLOAT_ABI_DOUBLE,
+ EF_RISCV_FLOAT_ABI_QUAD,
+ );
+ static FLAGS_PT: &[Flag<u32>] = &flags!(
+ PT_NULL,
+ PT_LOAD,
+ PT_DYNAMIC,
+ PT_INTERP,
+ PT_NOTE,
+ PT_SHLIB,
+ PT_PHDR,
+ PT_TLS,
+ PT_LOOS,
+ PT_GNU_EH_FRAME,
+ PT_GNU_STACK,
+ PT_GNU_RELRO,
+ );
+ static FLAGS_PT_HP: &[Flag<u32>] = &flags!(
+ PT_HP_TLS,
+ PT_HP_CORE_NONE,
+ PT_HP_CORE_VERSION,
+ PT_HP_CORE_KERNEL,
+ PT_HP_CORE_COMM,
+ PT_HP_CORE_PROC,
+ PT_HP_CORE_LOADABLE,
+ PT_HP_CORE_STACK,
+ PT_HP_CORE_SHM,
+ PT_HP_CORE_MMF,
+ PT_HP_PARALLEL,
+ PT_HP_FASTBIND,
+ PT_HP_OPT_ANNOT,
+ PT_HP_HSL_ANNOT,
+ PT_HP_STACK,
+ );
+ static FLAGS_PT_MIPS: &[Flag<u32>] = &flags!(
+ PT_MIPS_REGINFO,
+ PT_MIPS_RTPROC,
+ PT_MIPS_OPTIONS,
+ PT_MIPS_ABIFLAGS,
+ );
+ static FLAGS_PT_PARISC: &[Flag<u32>] = &flags!(PT_PARISC_ARCHEXT, PT_PARISC_UNWIND);
+ static FLAGS_PT_ARM: &[Flag<u32>] = &flags!(PT_ARM_EXIDX);
+ static FLAGS_PT_IA_64: &[Flag<u32>] = &flags!(PT_IA_64_ARCHEXT, PT_IA_64_UNWIND);
+ static FLAGS_PF: &[Flag<u32>] = &flags!(PF_X, PF_W, PF_R);
+ static FLAGS_PF_HP: &[Flag<u32>] = &flags!(
+ PF_HP_PAGE_SIZE,
+ PF_HP_FAR_SHARED,
+ PF_HP_NEAR_SHARED,
+ PF_HP_CODE,
+ PF_HP_MODIFY,
+ PF_HP_LAZYSWAP,
+ PF_HP_SBP,
+ );
+ static FLAGS_PF_MIPS: &[Flag<u32>] = &flags!(PF_MIPS_LOCAL);
+ static FLAGS_PF_PARISC: &[Flag<u32>] = &flags!(PF_PARISC_SBP);
+ static FLAGS_PF_ARM: &[Flag<u32>] = &flags!(PF_ARM_SB, PF_ARM_PI, PF_ARM_ABS);
+ static FLAGS_PF_IA_64: &[Flag<u32>] = &flags!(PF_IA_64_NORECOV);
+ static FLAGS_SHT: &[Flag<u32>] = &flags!(
+ SHT_NULL,
+ SHT_PROGBITS,
+ SHT_SYMTAB,
+ SHT_STRTAB,
+ SHT_RELA,
+ SHT_HASH,
+ SHT_DYNAMIC,
+ SHT_NOTE,
+ SHT_NOBITS,
+ SHT_REL,
+ SHT_SHLIB,
+ SHT_DYNSYM,
+ SHT_INIT_ARRAY,
+ SHT_FINI_ARRAY,
+ SHT_PREINIT_ARRAY,
+ SHT_GROUP,
+ SHT_SYMTAB_SHNDX,
+ SHT_GNU_ATTRIBUTES,
+ SHT_GNU_HASH,
+ SHT_GNU_LIBLIST,
+ SHT_CHECKSUM,
+ SHT_SUNW_move,
+ SHT_SUNW_COMDAT,
+ SHT_SUNW_syminfo,
+ SHT_GNU_VERDEF,
+ SHT_GNU_VERNEED,
+ SHT_GNU_VERSYM,
+ );
+ static FLAGS_SHT_MIPS: &[Flag<u32>] = &flags!(
+ SHT_MIPS_LIBLIST,
+ SHT_MIPS_MSYM,
+ SHT_MIPS_CONFLICT,
+ SHT_MIPS_GPTAB,
+ SHT_MIPS_UCODE,
+ SHT_MIPS_DEBUG,
+ SHT_MIPS_REGINFO,
+ SHT_MIPS_PACKAGE,
+ SHT_MIPS_PACKSYM,
+ SHT_MIPS_RELD,
+ SHT_MIPS_IFACE,
+ SHT_MIPS_CONTENT,
+ SHT_MIPS_OPTIONS,
+ SHT_MIPS_SHDR,
+ SHT_MIPS_FDESC,
+ SHT_MIPS_EXTSYM,
+ SHT_MIPS_DENSE,
+ SHT_MIPS_PDESC,
+ SHT_MIPS_LOCSYM,
+ SHT_MIPS_AUXSYM,
+ SHT_MIPS_OPTSYM,
+ SHT_MIPS_LOCSTR,
+ SHT_MIPS_LINE,
+ SHT_MIPS_RFDESC,
+ SHT_MIPS_DELTASYM,
+ SHT_MIPS_DELTAINST,
+ SHT_MIPS_DELTACLASS,
+ SHT_MIPS_DWARF,
+ SHT_MIPS_DELTADECL,
+ SHT_MIPS_SYMBOL_LIB,
+ SHT_MIPS_EVENTS,
+ SHT_MIPS_TRANSLATE,
+ SHT_MIPS_PIXIE,
+ SHT_MIPS_XLATE,
+ SHT_MIPS_XLATE_DEBUG,
+ SHT_MIPS_WHIRL,
+ SHT_MIPS_EH_REGION,
+ SHT_MIPS_XLATE_OLD,
+ SHT_MIPS_PDR_EXCEPTION,
+ );
+ static FLAGS_SHT_PARISC: &[Flag<u32>] =
+ &flags!(SHT_PARISC_EXT, SHT_PARISC_UNWIND, SHT_PARISC_DOC);
+ static FLAGS_SHT_ALPHA: &[Flag<u32>] = &flags!(SHT_ALPHA_DEBUG, SHT_ALPHA_REGINFO);
+ static FLAGS_SHT_ARM: &[Flag<u32>] =
+ &flags!(SHT_ARM_EXIDX, SHT_ARM_PREEMPTMAP, SHT_ARM_ATTRIBUTES);
+ static FLAGS_SHT_CSKY: &[Flag<u32>] = &flags!(SHT_CSKY_ATTRIBUTES);
+ static FLAGS_SHT_IA_64: &[Flag<u32>] = &flags!(SHT_IA_64_EXT, SHT_IA_64_UNWIND);
+ static FLAGS_SHT_X86_64: &[Flag<u32>] = &flags!(SHT_X86_64_UNWIND);
+ static FLAGS_SHF: &[Flag<u32>] = &flags!(
+ SHF_WRITE,
+ SHF_ALLOC,
+ SHF_EXECINSTR,
+ SHF_MERGE,
+ SHF_STRINGS,
+ SHF_INFO_LINK,
+ SHF_LINK_ORDER,
+ SHF_OS_NONCONFORMING,
+ SHF_GROUP,
+ SHF_TLS,
+ SHF_COMPRESSED,
+ );
+ static FLAGS_SHF_MIPS: &[Flag<u32>] = &flags!(
+ SHF_MIPS_GPREL,
+ SHF_MIPS_MERGE,
+ SHF_MIPS_ADDR,
+ SHF_MIPS_STRINGS,
+ SHF_MIPS_NOSTRIP,
+ SHF_MIPS_LOCAL,
+ SHF_MIPS_NAMES,
+ SHF_MIPS_NODUPE,
+ );
+ static FLAGS_SHF_PARISC: &[Flag<u32>] =
+ &flags!(SHF_PARISC_SHORT, SHF_PARISC_HUGE, SHF_PARISC_SBP);
+ static FLAGS_SHF_ALPHA: &[Flag<u32>] = &flags!(SHF_ALPHA_GPREL);
+ static FLAGS_SHF_ARM: &[Flag<u32>] = &flags!(SHF_ARM_ENTRYSECT, SHF_ARM_COMDEF);
+ static FLAGS_SHF_IA_64: &[Flag<u32>] = &flags!(SHF_IA_64_SHORT, SHF_IA_64_NORECOV);
+ static FLAGS_STT: &[Flag<u8>] = &flags!(
+ STT_NOTYPE,
+ STT_OBJECT,
+ STT_FUNC,
+ STT_SECTION,
+ STT_FILE,
+ STT_COMMON,
+ STT_TLS,
+ );
+ static FLAGS_STT_GNU: &[Flag<u8>] = &flags!(STT_GNU_IFUNC);
+ static FLAGS_STT_HP: &[Flag<u8>] = &flags!(STT_HP_OPAQUE, STT_HP_STUB);
+ static FLAGS_STT_SPARC: &[Flag<u8>] = &flags!(STT_SPARC_REGISTER);
+ static FLAGS_STT_PARISC: &[Flag<u8>] = &flags!(STT_PARISC_MILLICODE);
+ static FLAGS_STT_ARM: &[Flag<u8>] = &flags!(STT_ARM_TFUNC, STT_ARM_16BIT);
+ static FLAGS_STB: &[Flag<u8>] = &flags!(STB_LOCAL, STB_GLOBAL, STB_WEAK);
+ static FLAGS_STB_GNU: &[Flag<u8>] = &flags!(STB_GNU_UNIQUE);
+ static FLAGS_STB_MIPS: &[Flag<u8>] = &flags!(STB_MIPS_SPLIT_COMMON);
+ static FLAGS_STV: &[Flag<u8>] = &flags!(STV_DEFAULT, STV_INTERNAL, STV_HIDDEN, STV_PROTECTED);
+ static FLAGS_STO_MIPS: &[Flag<u8>] = &flags!(STO_MIPS_PLT);
+ static FLAGS_STO_ALPHA: &[Flag<u8>] = &flags!(STO_ALPHA_NOPV, STO_ALPHA_STD_GPLOAD);
+ static FLAGS_SHN: &[Flag<u16>] = &flags!(SHN_UNDEF, SHN_ABS, SHN_COMMON, SHN_XINDEX);
+ static FLAGS_SHN_MIPS: &[Flag<u16>] = &flags!(
+ SHN_MIPS_ACOMMON,
+ SHN_MIPS_TEXT,
+ SHN_MIPS_DATA,
+ SHN_MIPS_SCOMMON,
+ SHN_MIPS_SUNDEFINED,
+ );
+ static FLAGS_SHN_PARISC: &[Flag<u16>] = &flags!(SHN_PARISC_ANSI_COMMON, SHN_PARISC_HUGE_COMMON);
+ static FLAGS_R_68K: &[Flag<u32>] = &flags!(
+ R_68K_NONE,
+ R_68K_32,
+ R_68K_16,
+ R_68K_8,
+ R_68K_PC32,
+ R_68K_PC16,
+ R_68K_PC8,
+ R_68K_GOT32,
+ R_68K_GOT16,
+ R_68K_GOT8,
+ R_68K_GOT32O,
+ R_68K_GOT16O,
+ R_68K_GOT8O,
+ R_68K_PLT32,
+ R_68K_PLT16,
+ R_68K_PLT8,
+ R_68K_PLT32O,
+ R_68K_PLT16O,
+ R_68K_PLT8O,
+ R_68K_COPY,
+ R_68K_GLOB_DAT,
+ R_68K_JMP_SLOT,
+ R_68K_RELATIVE,
+ R_68K_TLS_GD32,
+ R_68K_TLS_GD16,
+ R_68K_TLS_GD8,
+ R_68K_TLS_LDM32,
+ R_68K_TLS_LDM16,
+ R_68K_TLS_LDM8,
+ R_68K_TLS_LDO32,
+ R_68K_TLS_LDO16,
+ R_68K_TLS_LDO8,
+ R_68K_TLS_IE32,
+ R_68K_TLS_IE16,
+ R_68K_TLS_IE8,
+ R_68K_TLS_LE32,
+ R_68K_TLS_LE16,
+ R_68K_TLS_LE8,
+ R_68K_TLS_DTPMOD32,
+ R_68K_TLS_DTPREL32,
+ R_68K_TLS_TPREL32,
+ );
+ static FLAGS_R_386: &[Flag<u32>] = &flags!(
+ R_386_NONE,
+ R_386_32,
+ R_386_PC32,
+ R_386_GOT32,
+ R_386_PLT32,
+ R_386_COPY,
+ R_386_GLOB_DAT,
+ R_386_JMP_SLOT,
+ R_386_RELATIVE,
+ R_386_GOTOFF,
+ R_386_GOTPC,
+ R_386_32PLT,
+ R_386_TLS_TPOFF,
+ R_386_TLS_IE,
+ R_386_TLS_GOTIE,
+ R_386_TLS_LE,
+ R_386_TLS_GD,
+ R_386_TLS_LDM,
+ R_386_16,
+ R_386_PC16,
+ R_386_8,
+ R_386_PC8,
+ R_386_TLS_GD_32,
+ R_386_TLS_GD_PUSH,
+ R_386_TLS_GD_CALL,
+ R_386_TLS_GD_POP,
+ R_386_TLS_LDM_32,
+ R_386_TLS_LDM_PUSH,
+ R_386_TLS_LDM_CALL,
+ R_386_TLS_LDM_POP,
+ R_386_TLS_LDO_32,
+ R_386_TLS_IE_32,
+ R_386_TLS_LE_32,
+ R_386_TLS_DTPMOD32,
+ R_386_TLS_DTPOFF32,
+ R_386_TLS_TPOFF32,
+ R_386_SIZE32,
+ R_386_TLS_GOTDESC,
+ R_386_TLS_DESC_CALL,
+ R_386_TLS_DESC,
+ R_386_IRELATIVE,
+ R_386_GOT32X,
+ );
+ static FLAGS_R_SPARC: &[Flag<u32>] = &flags!(
+ R_SPARC_NONE,
+ R_SPARC_8,
+ R_SPARC_16,
+ R_SPARC_32,
+ R_SPARC_DISP8,
+ R_SPARC_DISP16,
+ R_SPARC_DISP32,
+ R_SPARC_WDISP30,
+ R_SPARC_WDISP22,
+ R_SPARC_HI22,
+ R_SPARC_22,
+ R_SPARC_13,
+ R_SPARC_LO10,
+ R_SPARC_GOT10,
+ R_SPARC_GOT13,
+ R_SPARC_GOT22,
+ R_SPARC_PC10,
+ R_SPARC_PC22,
+ R_SPARC_WPLT30,
+ R_SPARC_COPY,
+ R_SPARC_GLOB_DAT,
+ R_SPARC_JMP_SLOT,
+ R_SPARC_RELATIVE,
+ R_SPARC_UA32,
+ R_SPARC_PLT32,
+ R_SPARC_HIPLT22,
+ R_SPARC_LOPLT10,
+ R_SPARC_PCPLT32,
+ R_SPARC_PCPLT22,
+ R_SPARC_PCPLT10,
+ R_SPARC_10,
+ R_SPARC_11,
+ R_SPARC_64,
+ R_SPARC_OLO10,
+ R_SPARC_HH22,
+ R_SPARC_HM10,
+ R_SPARC_LM22,
+ R_SPARC_PC_HH22,
+ R_SPARC_PC_HM10,
+ R_SPARC_PC_LM22,
+ R_SPARC_WDISP16,
+ R_SPARC_WDISP19,
+ R_SPARC_GLOB_JMP,
+ R_SPARC_7,
+ R_SPARC_5,
+ R_SPARC_6,
+ R_SPARC_DISP64,
+ R_SPARC_PLT64,
+ R_SPARC_HIX22,
+ R_SPARC_LOX10,
+ R_SPARC_H44,
+ R_SPARC_M44,
+ R_SPARC_L44,
+ R_SPARC_REGISTER,
+ R_SPARC_UA64,
+ R_SPARC_UA16,
+ R_SPARC_TLS_GD_HI22,
+ R_SPARC_TLS_GD_LO10,
+ R_SPARC_TLS_GD_ADD,
+ R_SPARC_TLS_GD_CALL,
+ R_SPARC_TLS_LDM_HI22,
+ R_SPARC_TLS_LDM_LO10,
+ R_SPARC_TLS_LDM_ADD,
+ R_SPARC_TLS_LDM_CALL,
+ R_SPARC_TLS_LDO_HIX22,
+ R_SPARC_TLS_LDO_LOX10,
+ R_SPARC_TLS_LDO_ADD,
+ R_SPARC_TLS_IE_HI22,
+ R_SPARC_TLS_IE_LO10,
+ R_SPARC_TLS_IE_LD,
+ R_SPARC_TLS_IE_LDX,
+ R_SPARC_TLS_IE_ADD,
+ R_SPARC_TLS_LE_HIX22,
+ R_SPARC_TLS_LE_LOX10,
+ R_SPARC_TLS_DTPMOD32,
+ R_SPARC_TLS_DTPMOD64,
+ R_SPARC_TLS_DTPOFF32,
+ R_SPARC_TLS_DTPOFF64,
+ R_SPARC_TLS_TPOFF32,
+ R_SPARC_TLS_TPOFF64,
+ R_SPARC_GOTDATA_HIX22,
+ R_SPARC_GOTDATA_LOX10,
+ R_SPARC_GOTDATA_OP_HIX22,
+ R_SPARC_GOTDATA_OP_LOX10,
+ R_SPARC_GOTDATA_OP,
+ R_SPARC_H34,
+ R_SPARC_SIZE32,
+ R_SPARC_SIZE64,
+ R_SPARC_WDISP10,
+ R_SPARC_JMP_IREL,
+ R_SPARC_IRELATIVE,
+ R_SPARC_GNU_VTINHERIT,
+ R_SPARC_GNU_VTENTRY,
+ R_SPARC_REV32,
+ );
+ static FLAGS_R_MIPS: &[Flag<u32>] = &flags!(
+ R_MIPS_NONE,
+ R_MIPS_16,
+ R_MIPS_32,
+ R_MIPS_REL32,
+ R_MIPS_26,
+ R_MIPS_HI16,
+ R_MIPS_LO16,
+ R_MIPS_GPREL16,
+ R_MIPS_LITERAL,
+ R_MIPS_GOT16,
+ R_MIPS_PC16,
+ R_MIPS_CALL16,
+ R_MIPS_GPREL32,
+ R_MIPS_SHIFT5,
+ R_MIPS_SHIFT6,
+ R_MIPS_64,
+ R_MIPS_GOT_DISP,
+ R_MIPS_GOT_PAGE,
+ R_MIPS_GOT_OFST,
+ R_MIPS_GOT_HI16,
+ R_MIPS_GOT_LO16,
+ R_MIPS_SUB,
+ R_MIPS_INSERT_A,
+ R_MIPS_INSERT_B,
+ R_MIPS_DELETE,
+ R_MIPS_HIGHER,
+ R_MIPS_HIGHEST,
+ R_MIPS_CALL_HI16,
+ R_MIPS_CALL_LO16,
+ R_MIPS_SCN_DISP,
+ R_MIPS_REL16,
+ R_MIPS_ADD_IMMEDIATE,
+ R_MIPS_PJUMP,
+ R_MIPS_RELGOT,
+ R_MIPS_JALR,
+ R_MIPS_TLS_DTPMOD32,
+ R_MIPS_TLS_DTPREL32,
+ R_MIPS_TLS_DTPMOD64,
+ R_MIPS_TLS_DTPREL64,
+ R_MIPS_TLS_GD,
+ R_MIPS_TLS_LDM,
+ R_MIPS_TLS_DTPREL_HI16,
+ R_MIPS_TLS_DTPREL_LO16,
+ R_MIPS_TLS_GOTTPREL,
+ R_MIPS_TLS_TPREL32,
+ R_MIPS_TLS_TPREL64,
+ R_MIPS_TLS_TPREL_HI16,
+ R_MIPS_TLS_TPREL_LO16,
+ R_MIPS_GLOB_DAT,
+ R_MIPS_COPY,
+ R_MIPS_JUMP_SLOT,
+ );
+ static FLAGS_R_PARISC: &[Flag<u32>] = &flags!(
+ R_PARISC_NONE,
+ R_PARISC_DIR32,
+ R_PARISC_DIR21L,
+ R_PARISC_DIR17R,
+ R_PARISC_DIR17F,
+ R_PARISC_DIR14R,
+ R_PARISC_PCREL32,
+ R_PARISC_PCREL21L,
+ R_PARISC_PCREL17R,
+ R_PARISC_PCREL17F,
+ R_PARISC_PCREL14R,
+ R_PARISC_DPREL21L,
+ R_PARISC_DPREL14R,
+ R_PARISC_GPREL21L,
+ R_PARISC_GPREL14R,
+ R_PARISC_LTOFF21L,
+ R_PARISC_LTOFF14R,
+ R_PARISC_SECREL32,
+ R_PARISC_SEGBASE,
+ R_PARISC_SEGREL32,
+ R_PARISC_PLTOFF21L,
+ R_PARISC_PLTOFF14R,
+ R_PARISC_LTOFF_FPTR32,
+ R_PARISC_LTOFF_FPTR21L,
+ R_PARISC_LTOFF_FPTR14R,
+ R_PARISC_FPTR64,
+ R_PARISC_PLABEL32,
+ R_PARISC_PLABEL21L,
+ R_PARISC_PLABEL14R,
+ R_PARISC_PCREL64,
+ R_PARISC_PCREL22F,
+ R_PARISC_PCREL14WR,
+ R_PARISC_PCREL14DR,
+ R_PARISC_PCREL16F,
+ R_PARISC_PCREL16WF,
+ R_PARISC_PCREL16DF,
+ R_PARISC_DIR64,
+ R_PARISC_DIR14WR,
+ R_PARISC_DIR14DR,
+ R_PARISC_DIR16F,
+ R_PARISC_DIR16WF,
+ R_PARISC_DIR16DF,
+ R_PARISC_GPREL64,
+ R_PARISC_GPREL14WR,
+ R_PARISC_GPREL14DR,
+ R_PARISC_GPREL16F,
+ R_PARISC_GPREL16WF,
+ R_PARISC_GPREL16DF,
+ R_PARISC_LTOFF64,
+ R_PARISC_LTOFF14WR,
+ R_PARISC_LTOFF14DR,
+ R_PARISC_LTOFF16F,
+ R_PARISC_LTOFF16WF,
+ R_PARISC_LTOFF16DF,
+ R_PARISC_SECREL64,
+ R_PARISC_SEGREL64,
+ R_PARISC_PLTOFF14WR,
+ R_PARISC_PLTOFF14DR,
+ R_PARISC_PLTOFF16F,
+ R_PARISC_PLTOFF16WF,
+ R_PARISC_PLTOFF16DF,
+ R_PARISC_LTOFF_FPTR64,
+ R_PARISC_LTOFF_FPTR14WR,
+ R_PARISC_LTOFF_FPTR14DR,
+ R_PARISC_LTOFF_FPTR16F,
+ R_PARISC_LTOFF_FPTR16WF,
+ R_PARISC_LTOFF_FPTR16DF,
+ R_PARISC_COPY,
+ R_PARISC_IPLT,
+ R_PARISC_EPLT,
+ R_PARISC_TPREL32,
+ R_PARISC_TPREL21L,
+ R_PARISC_TPREL14R,
+ R_PARISC_LTOFF_TP21L,
+ R_PARISC_LTOFF_TP14R,
+ R_PARISC_LTOFF_TP14F,
+ R_PARISC_TPREL64,
+ R_PARISC_TPREL14WR,
+ R_PARISC_TPREL14DR,
+ R_PARISC_TPREL16F,
+ R_PARISC_TPREL16WF,
+ R_PARISC_TPREL16DF,
+ R_PARISC_LTOFF_TP64,
+ R_PARISC_LTOFF_TP14WR,
+ R_PARISC_LTOFF_TP14DR,
+ R_PARISC_LTOFF_TP16F,
+ R_PARISC_LTOFF_TP16WF,
+ R_PARISC_LTOFF_TP16DF,
+ R_PARISC_GNU_VTENTRY,
+ R_PARISC_GNU_VTINHERIT,
+ R_PARISC_TLS_GD21L,
+ R_PARISC_TLS_GD14R,
+ R_PARISC_TLS_GDCALL,
+ R_PARISC_TLS_LDM21L,
+ R_PARISC_TLS_LDM14R,
+ R_PARISC_TLS_LDMCALL,
+ R_PARISC_TLS_LDO21L,
+ R_PARISC_TLS_LDO14R,
+ R_PARISC_TLS_DTPMOD32,
+ R_PARISC_TLS_DTPMOD64,
+ R_PARISC_TLS_DTPOFF32,
+ R_PARISC_TLS_DTPOFF64,
+ R_PARISC_TLS_LE21L,
+ R_PARISC_TLS_LE14R,
+ R_PARISC_TLS_IE21L,
+ R_PARISC_TLS_IE14R,
+ R_PARISC_TLS_TPREL32,
+ R_PARISC_TLS_TPREL64,
+ );
+ static FLAGS_R_ALPHA: &[Flag<u32>] = &flags!(
+ R_ALPHA_NONE,
+ R_ALPHA_REFLONG,
+ R_ALPHA_REFQUAD,
+ R_ALPHA_GPREL32,
+ R_ALPHA_LITERAL,
+ R_ALPHA_LITUSE,
+ R_ALPHA_GPDISP,
+ R_ALPHA_BRADDR,
+ R_ALPHA_HINT,
+ R_ALPHA_SREL16,
+ R_ALPHA_SREL32,
+ R_ALPHA_SREL64,
+ R_ALPHA_GPRELHIGH,
+ R_ALPHA_GPRELLOW,
+ R_ALPHA_GPREL16,
+ R_ALPHA_COPY,
+ R_ALPHA_GLOB_DAT,
+ R_ALPHA_JMP_SLOT,
+ R_ALPHA_RELATIVE,
+ R_ALPHA_TLS_GD_HI,
+ R_ALPHA_TLSGD,
+ R_ALPHA_TLS_LDM,
+ R_ALPHA_DTPMOD64,
+ R_ALPHA_GOTDTPREL,
+ R_ALPHA_DTPREL64,
+ R_ALPHA_DTPRELHI,
+ R_ALPHA_DTPRELLO,
+ R_ALPHA_DTPREL16,
+ R_ALPHA_GOTTPREL,
+ R_ALPHA_TPREL64,
+ R_ALPHA_TPRELHI,
+ R_ALPHA_TPRELLO,
+ R_ALPHA_TPREL16,
+ );
+ static FLAGS_R_PPC: &[Flag<u32>] = &flags!(
+ R_PPC_NONE,
+ R_PPC_ADDR32,
+ R_PPC_ADDR24,
+ R_PPC_ADDR16,
+ R_PPC_ADDR16_LO,
+ R_PPC_ADDR16_HI,
+ R_PPC_ADDR16_HA,
+ R_PPC_ADDR14,
+ R_PPC_ADDR14_BRTAKEN,
+ R_PPC_ADDR14_BRNTAKEN,
+ R_PPC_REL24,
+ R_PPC_REL14,
+ R_PPC_REL14_BRTAKEN,
+ R_PPC_REL14_BRNTAKEN,
+ R_PPC_GOT16,
+ R_PPC_GOT16_LO,
+ R_PPC_GOT16_HI,
+ R_PPC_GOT16_HA,
+ R_PPC_PLTREL24,
+ R_PPC_COPY,
+ R_PPC_GLOB_DAT,
+ R_PPC_JMP_SLOT,
+ R_PPC_RELATIVE,
+ R_PPC_LOCAL24PC,
+ R_PPC_UADDR32,
+ R_PPC_UADDR16,
+ R_PPC_REL32,
+ R_PPC_PLT32,
+ R_PPC_PLTREL32,
+ R_PPC_PLT16_LO,
+ R_PPC_PLT16_HI,
+ R_PPC_PLT16_HA,
+ R_PPC_SDAREL16,
+ R_PPC_SECTOFF,
+ R_PPC_SECTOFF_LO,
+ R_PPC_SECTOFF_HI,
+ R_PPC_SECTOFF_HA,
+ R_PPC_TLS,
+ R_PPC_DTPMOD32,
+ R_PPC_TPREL16,
+ R_PPC_TPREL16_LO,
+ R_PPC_TPREL16_HI,
+ R_PPC_TPREL16_HA,
+ R_PPC_TPREL32,
+ R_PPC_DTPREL16,
+ R_PPC_DTPREL16_LO,
+ R_PPC_DTPREL16_HI,
+ R_PPC_DTPREL16_HA,
+ R_PPC_DTPREL32,
+ R_PPC_GOT_TLSGD16,
+ R_PPC_GOT_TLSGD16_LO,
+ R_PPC_GOT_TLSGD16_HI,
+ R_PPC_GOT_TLSGD16_HA,
+ R_PPC_GOT_TLSLD16,
+ R_PPC_GOT_TLSLD16_LO,
+ R_PPC_GOT_TLSLD16_HI,
+ R_PPC_GOT_TLSLD16_HA,
+ R_PPC_GOT_TPREL16,
+ R_PPC_GOT_TPREL16_LO,
+ R_PPC_GOT_TPREL16_HI,
+ R_PPC_GOT_TPREL16_HA,
+ R_PPC_GOT_DTPREL16,
+ R_PPC_GOT_DTPREL16_LO,
+ R_PPC_GOT_DTPREL16_HI,
+ R_PPC_GOT_DTPREL16_HA,
+ R_PPC_TLSGD,
+ R_PPC_TLSLD,
+ R_PPC_EMB_NADDR32,
+ R_PPC_EMB_NADDR16,
+ R_PPC_EMB_NADDR16_LO,
+ R_PPC_EMB_NADDR16_HI,
+ R_PPC_EMB_NADDR16_HA,
+ R_PPC_EMB_SDAI16,
+ R_PPC_EMB_SDA2I16,
+ R_PPC_EMB_SDA2REL,
+ R_PPC_EMB_SDA21,
+ R_PPC_EMB_MRKREF,
+ R_PPC_EMB_RELSEC16,
+ R_PPC_EMB_RELST_LO,
+ R_PPC_EMB_RELST_HI,
+ R_PPC_EMB_RELST_HA,
+ R_PPC_EMB_BIT_FLD,
+ R_PPC_EMB_RELSDA,
+ R_PPC_DIAB_SDA21_LO,
+ R_PPC_DIAB_SDA21_HI,
+ R_PPC_DIAB_SDA21_HA,
+ R_PPC_DIAB_RELSDA_LO,
+ R_PPC_DIAB_RELSDA_HI,
+ R_PPC_DIAB_RELSDA_HA,
+ R_PPC_IRELATIVE,
+ R_PPC_REL16,
+ R_PPC_REL16_LO,
+ R_PPC_REL16_HI,
+ R_PPC_REL16_HA,
+ R_PPC_TOC16,
+ );
+ static FLAGS_R_PPC64: &[Flag<u32>] = &flags!(
+ R_PPC64_NONE,
+ R_PPC64_ADDR32,
+ R_PPC64_ADDR24,
+ R_PPC64_ADDR16,
+ R_PPC64_ADDR16_LO,
+ R_PPC64_ADDR16_HI,
+ R_PPC64_ADDR16_HA,
+ R_PPC64_ADDR14,
+ R_PPC64_ADDR14_BRTAKEN,
+ R_PPC64_ADDR14_BRNTAKEN,
+ R_PPC64_REL24,
+ R_PPC64_REL14,
+ R_PPC64_REL14_BRTAKEN,
+ R_PPC64_REL14_BRNTAKEN,
+ R_PPC64_GOT16,
+ R_PPC64_GOT16_LO,
+ R_PPC64_GOT16_HI,
+ R_PPC64_GOT16_HA,
+ R_PPC64_COPY,
+ R_PPC64_GLOB_DAT,
+ R_PPC64_JMP_SLOT,
+ R_PPC64_RELATIVE,
+ R_PPC64_UADDR32,
+ R_PPC64_UADDR16,
+ R_PPC64_REL32,
+ R_PPC64_PLT32,
+ R_PPC64_PLTREL32,
+ R_PPC64_PLT16_LO,
+ R_PPC64_PLT16_HI,
+ R_PPC64_PLT16_HA,
+ R_PPC64_SECTOFF,
+ R_PPC64_SECTOFF_LO,
+ R_PPC64_SECTOFF_HI,
+ R_PPC64_SECTOFF_HA,
+ R_PPC64_ADDR30,
+ R_PPC64_ADDR64,
+ R_PPC64_ADDR16_HIGHER,
+ R_PPC64_ADDR16_HIGHERA,
+ R_PPC64_ADDR16_HIGHEST,
+ R_PPC64_ADDR16_HIGHESTA,
+ R_PPC64_UADDR64,
+ R_PPC64_REL64,
+ R_PPC64_PLT64,
+ R_PPC64_PLTREL64,
+ R_PPC64_TOC16,
+ R_PPC64_TOC16_LO,
+ R_PPC64_TOC16_HI,
+ R_PPC64_TOC16_HA,
+ R_PPC64_TOC,
+ R_PPC64_PLTGOT16,
+ R_PPC64_PLTGOT16_LO,
+ R_PPC64_PLTGOT16_HI,
+ R_PPC64_PLTGOT16_HA,
+ R_PPC64_ADDR16_DS,
+ R_PPC64_ADDR16_LO_DS,
+ R_PPC64_GOT16_DS,
+ R_PPC64_GOT16_LO_DS,
+ R_PPC64_PLT16_LO_DS,
+ R_PPC64_SECTOFF_DS,
+ R_PPC64_SECTOFF_LO_DS,
+ R_PPC64_TOC16_DS,
+ R_PPC64_TOC16_LO_DS,
+ R_PPC64_PLTGOT16_DS,
+ R_PPC64_PLTGOT16_LO_DS,
+ R_PPC64_TLS,
+ R_PPC64_DTPMOD64,
+ R_PPC64_TPREL16,
+ R_PPC64_TPREL16_LO,
+ R_PPC64_TPREL16_HI,
+ R_PPC64_TPREL16_HA,
+ R_PPC64_TPREL64,
+ R_PPC64_DTPREL16,
+ R_PPC64_DTPREL16_LO,
+ R_PPC64_DTPREL16_HI,
+ R_PPC64_DTPREL16_HA,
+ R_PPC64_DTPREL64,
+ R_PPC64_GOT_TLSGD16,
+ R_PPC64_GOT_TLSGD16_LO,
+ R_PPC64_GOT_TLSGD16_HI,
+ R_PPC64_GOT_TLSGD16_HA,
+ R_PPC64_GOT_TLSLD16,
+ R_PPC64_GOT_TLSLD16_LO,
+ R_PPC64_GOT_TLSLD16_HI,
+ R_PPC64_GOT_TLSLD16_HA,
+ R_PPC64_GOT_TPREL16_DS,
+ R_PPC64_GOT_TPREL16_LO_DS,
+ R_PPC64_GOT_TPREL16_HI,
+ R_PPC64_GOT_TPREL16_HA,
+ R_PPC64_GOT_DTPREL16_DS,
+ R_PPC64_GOT_DTPREL16_LO_DS,
+ R_PPC64_GOT_DTPREL16_HI,
+ R_PPC64_GOT_DTPREL16_HA,
+ R_PPC64_TPREL16_DS,
+ R_PPC64_TPREL16_LO_DS,
+ R_PPC64_TPREL16_HIGHER,
+ R_PPC64_TPREL16_HIGHERA,
+ R_PPC64_TPREL16_HIGHEST,
+ R_PPC64_TPREL16_HIGHESTA,
+ R_PPC64_DTPREL16_DS,
+ R_PPC64_DTPREL16_LO_DS,
+ R_PPC64_DTPREL16_HIGHER,
+ R_PPC64_DTPREL16_HIGHERA,
+ R_PPC64_DTPREL16_HIGHEST,
+ R_PPC64_DTPREL16_HIGHESTA,
+ R_PPC64_TLSGD,
+ R_PPC64_TLSLD,
+ R_PPC64_TOCSAVE,
+ R_PPC64_ADDR16_HIGH,
+ R_PPC64_ADDR16_HIGHA,
+ R_PPC64_TPREL16_HIGH,
+ R_PPC64_TPREL16_HIGHA,
+ R_PPC64_DTPREL16_HIGH,
+ R_PPC64_DTPREL16_HIGHA,
+ R_PPC64_JMP_IREL,
+ R_PPC64_IRELATIVE,
+ R_PPC64_REL16,
+ R_PPC64_REL16_LO,
+ R_PPC64_REL16_HI,
+ R_PPC64_REL16_HA,
+ );
+ static FLAGS_R_AARCH64: &[Flag<u32>] = &flags!(
+ R_AARCH64_NONE,
+ R_AARCH64_P32_ABS32,
+ R_AARCH64_P32_COPY,
+ R_AARCH64_P32_GLOB_DAT,
+ R_AARCH64_P32_JUMP_SLOT,
+ R_AARCH64_P32_RELATIVE,
+ R_AARCH64_P32_TLS_DTPMOD,
+ R_AARCH64_P32_TLS_DTPREL,
+ R_AARCH64_P32_TLS_TPREL,
+ R_AARCH64_P32_TLSDESC,
+ R_AARCH64_P32_IRELATIVE,
+ R_AARCH64_ABS64,
+ R_AARCH64_ABS32,
+ R_AARCH64_ABS16,
+ R_AARCH64_PREL64,
+ R_AARCH64_PREL32,
+ R_AARCH64_PREL16,
+ R_AARCH64_MOVW_UABS_G0,
+ R_AARCH64_MOVW_UABS_G0_NC,
+ R_AARCH64_MOVW_UABS_G1,
+ R_AARCH64_MOVW_UABS_G1_NC,
+ R_AARCH64_MOVW_UABS_G2,
+ R_AARCH64_MOVW_UABS_G2_NC,
+ R_AARCH64_MOVW_UABS_G3,
+ R_AARCH64_MOVW_SABS_G0,
+ R_AARCH64_MOVW_SABS_G1,
+ R_AARCH64_MOVW_SABS_G2,
+ R_AARCH64_LD_PREL_LO19,
+ R_AARCH64_ADR_PREL_LO21,
+ R_AARCH64_ADR_PREL_PG_HI21,
+ R_AARCH64_ADR_PREL_PG_HI21_NC,
+ R_AARCH64_ADD_ABS_LO12_NC,
+ R_AARCH64_LDST8_ABS_LO12_NC,
+ R_AARCH64_TSTBR14,
+ R_AARCH64_CONDBR19,
+ R_AARCH64_JUMP26,
+ R_AARCH64_CALL26,
+ R_AARCH64_LDST16_ABS_LO12_NC,
+ R_AARCH64_LDST32_ABS_LO12_NC,
+ R_AARCH64_LDST64_ABS_LO12_NC,
+ R_AARCH64_MOVW_PREL_G0,
+ R_AARCH64_MOVW_PREL_G0_NC,
+ R_AARCH64_MOVW_PREL_G1,
+ R_AARCH64_MOVW_PREL_G1_NC,
+ R_AARCH64_MOVW_PREL_G2,
+ R_AARCH64_MOVW_PREL_G2_NC,
+ R_AARCH64_MOVW_PREL_G3,
+ R_AARCH64_LDST128_ABS_LO12_NC,
+ R_AARCH64_MOVW_GOTOFF_G0,
+ R_AARCH64_MOVW_GOTOFF_G0_NC,
+ R_AARCH64_MOVW_GOTOFF_G1,
+ R_AARCH64_MOVW_GOTOFF_G1_NC,
+ R_AARCH64_MOVW_GOTOFF_G2,
+ R_AARCH64_MOVW_GOTOFF_G2_NC,
+ R_AARCH64_MOVW_GOTOFF_G3,
+ R_AARCH64_GOTREL64,
+ R_AARCH64_GOTREL32,
+ R_AARCH64_GOT_LD_PREL19,
+ R_AARCH64_LD64_GOTOFF_LO15,
+ R_AARCH64_ADR_GOT_PAGE,
+ R_AARCH64_LD64_GOT_LO12_NC,
+ R_AARCH64_LD64_GOTPAGE_LO15,
+ R_AARCH64_TLSGD_ADR_PREL21,
+ R_AARCH64_TLSGD_ADR_PAGE21,
+ R_AARCH64_TLSGD_ADD_LO12_NC,
+ R_AARCH64_TLSGD_MOVW_G1,
+ R_AARCH64_TLSGD_MOVW_G0_NC,
+ R_AARCH64_TLSLD_ADR_PREL21,
+ R_AARCH64_TLSLD_ADR_PAGE21,
+ R_AARCH64_TLSLD_ADD_LO12_NC,
+ R_AARCH64_TLSLD_MOVW_G1,
+ R_AARCH64_TLSLD_MOVW_G0_NC,
+ R_AARCH64_TLSLD_LD_PREL19,
+ R_AARCH64_TLSLD_MOVW_DTPREL_G2,
+ R_AARCH64_TLSLD_MOVW_DTPREL_G1,
+ R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC,
+ R_AARCH64_TLSLD_MOVW_DTPREL_G0,
+ R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC,
+ R_AARCH64_TLSLD_ADD_DTPREL_HI12,
+ R_AARCH64_TLSLD_ADD_DTPREL_LO12,
+ R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC,
+ R_AARCH64_TLSLD_LDST8_DTPREL_LO12,
+ R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC,
+ R_AARCH64_TLSLD_LDST16_DTPREL_LO12,
+ R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC,
+ R_AARCH64_TLSLD_LDST32_DTPREL_LO12,
+ R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC,
+ R_AARCH64_TLSLD_LDST64_DTPREL_LO12,
+ R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC,
+ R_AARCH64_TLSIE_MOVW_GOTTPREL_G1,
+ R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC,
+ R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21,
+ R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC,
+ R_AARCH64_TLSIE_LD_GOTTPREL_PREL19,
+ R_AARCH64_TLSLE_MOVW_TPREL_G2,
+ R_AARCH64_TLSLE_MOVW_TPREL_G1,
+ R_AARCH64_TLSLE_MOVW_TPREL_G1_NC,
+ R_AARCH64_TLSLE_MOVW_TPREL_G0,
+ R_AARCH64_TLSLE_MOVW_TPREL_G0_NC,
+ R_AARCH64_TLSLE_ADD_TPREL_HI12,
+ R_AARCH64_TLSLE_ADD_TPREL_LO12,
+ R_AARCH64_TLSLE_ADD_TPREL_LO12_NC,
+ R_AARCH64_TLSLE_LDST8_TPREL_LO12,
+ R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC,
+ R_AARCH64_TLSLE_LDST16_TPREL_LO12,
+ R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC,
+ R_AARCH64_TLSLE_LDST32_TPREL_LO12,
+ R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC,
+ R_AARCH64_TLSLE_LDST64_TPREL_LO12,
+ R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC,
+ R_AARCH64_TLSDESC_LD_PREL19,
+ R_AARCH64_TLSDESC_ADR_PREL21,
+ R_AARCH64_TLSDESC_ADR_PAGE21,
+ R_AARCH64_TLSDESC_LD64_LO12,
+ R_AARCH64_TLSDESC_ADD_LO12,
+ R_AARCH64_TLSDESC_OFF_G1,
+ R_AARCH64_TLSDESC_OFF_G0_NC,
+ R_AARCH64_TLSDESC_LDR,
+ R_AARCH64_TLSDESC_ADD,
+ R_AARCH64_TLSDESC_CALL,
+ R_AARCH64_TLSLE_LDST128_TPREL_LO12,
+ R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC,
+ R_AARCH64_TLSLD_LDST128_DTPREL_LO12,
+ R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC,
+ R_AARCH64_COPY,
+ R_AARCH64_GLOB_DAT,
+ R_AARCH64_JUMP_SLOT,
+ R_AARCH64_RELATIVE,
+ R_AARCH64_TLS_DTPMOD,
+ R_AARCH64_TLS_DTPREL,
+ R_AARCH64_TLS_TPREL,
+ R_AARCH64_TLSDESC,
+ R_AARCH64_IRELATIVE,
+ );
+ static FLAGS_R_ARM: &[Flag<u32>] = &flags!(
+ R_ARM_NONE,
+ R_ARM_PC24,
+ R_ARM_ABS32,
+ R_ARM_REL32,
+ R_ARM_PC13,
+ R_ARM_ABS16,
+ R_ARM_ABS12,
+ R_ARM_THM_ABS5,
+ R_ARM_ABS8,
+ R_ARM_SBREL32,
+ R_ARM_THM_PC22,
+ R_ARM_THM_PC8,
+ R_ARM_AMP_VCALL9,
+ R_ARM_SWI24,
+ R_ARM_TLS_DESC,
+ R_ARM_THM_SWI8,
+ R_ARM_XPC25,
+ R_ARM_THM_XPC22,
+ R_ARM_TLS_DTPMOD32,
+ R_ARM_TLS_DTPOFF32,
+ R_ARM_TLS_TPOFF32,
+ R_ARM_COPY,
+ R_ARM_GLOB_DAT,
+ R_ARM_JUMP_SLOT,
+ R_ARM_RELATIVE,
+ R_ARM_GOTOFF,
+ R_ARM_GOTPC,
+ R_ARM_GOT32,
+ R_ARM_PLT32,
+ R_ARM_CALL,
+ R_ARM_JUMP24,
+ R_ARM_THM_JUMP24,
+ R_ARM_BASE_ABS,
+ R_ARM_ALU_PCREL_7_0,
+ R_ARM_ALU_PCREL_15_8,
+ R_ARM_ALU_PCREL_23_15,
+ R_ARM_LDR_SBREL_11_0,
+ R_ARM_ALU_SBREL_19_12,
+ R_ARM_ALU_SBREL_27_20,
+ R_ARM_TARGET1,
+ R_ARM_SBREL31,
+ R_ARM_V4BX,
+ R_ARM_TARGET2,
+ R_ARM_PREL31,
+ R_ARM_MOVW_ABS_NC,
+ R_ARM_MOVT_ABS,
+ R_ARM_MOVW_PREL_NC,
+ R_ARM_MOVT_PREL,
+ R_ARM_THM_MOVW_ABS_NC,
+ R_ARM_THM_MOVT_ABS,
+ R_ARM_THM_MOVW_PREL_NC,
+ R_ARM_THM_MOVT_PREL,
+ R_ARM_THM_JUMP19,
+ R_ARM_THM_JUMP6,
+ R_ARM_THM_ALU_PREL_11_0,
+ R_ARM_THM_PC12,
+ R_ARM_ABS32_NOI,
+ R_ARM_REL32_NOI,
+ R_ARM_ALU_PC_G0_NC,
+ R_ARM_ALU_PC_G0,
+ R_ARM_ALU_PC_G1_NC,
+ R_ARM_ALU_PC_G1,
+ R_ARM_ALU_PC_G2,
+ R_ARM_LDR_PC_G1,
+ R_ARM_LDR_PC_G2,
+ R_ARM_LDRS_PC_G0,
+ R_ARM_LDRS_PC_G1,
+ R_ARM_LDRS_PC_G2,
+ R_ARM_LDC_PC_G0,
+ R_ARM_LDC_PC_G1,
+ R_ARM_LDC_PC_G2,
+ R_ARM_ALU_SB_G0_NC,
+ R_ARM_ALU_SB_G0,
+ R_ARM_ALU_SB_G1_NC,
+ R_ARM_ALU_SB_G1,
+ R_ARM_ALU_SB_G2,
+ R_ARM_LDR_SB_G0,
+ R_ARM_LDR_SB_G1,
+ R_ARM_LDR_SB_G2,
+ R_ARM_LDRS_SB_G0,
+ R_ARM_LDRS_SB_G1,
+ R_ARM_LDRS_SB_G2,
+ R_ARM_LDC_SB_G0,
+ R_ARM_LDC_SB_G1,
+ R_ARM_LDC_SB_G2,
+ R_ARM_MOVW_BREL_NC,
+ R_ARM_MOVT_BREL,
+ R_ARM_MOVW_BREL,
+ R_ARM_THM_MOVW_BREL_NC,
+ R_ARM_THM_MOVT_BREL,
+ R_ARM_THM_MOVW_BREL,
+ R_ARM_TLS_GOTDESC,
+ R_ARM_TLS_CALL,
+ R_ARM_TLS_DESCSEQ,
+ R_ARM_THM_TLS_CALL,
+ R_ARM_PLT32_ABS,
+ R_ARM_GOT_ABS,
+ R_ARM_GOT_PREL,
+ R_ARM_GOT_BREL12,
+ R_ARM_GOTOFF12,
+ R_ARM_GOTRELAX,
+ R_ARM_GNU_VTENTRY,
+ R_ARM_GNU_VTINHERIT,
+ R_ARM_THM_PC11,
+ R_ARM_THM_PC9,
+ R_ARM_TLS_GD32,
+ R_ARM_TLS_LDM32,
+ R_ARM_TLS_LDO32,
+ R_ARM_TLS_IE32,
+ R_ARM_TLS_LE32,
+ R_ARM_TLS_LDO12,
+ R_ARM_TLS_LE12,
+ R_ARM_TLS_IE12GP,
+ R_ARM_ME_TOO,
+ R_ARM_THM_TLS_DESCSEQ,
+ R_ARM_THM_TLS_DESCSEQ16,
+ R_ARM_THM_TLS_DESCSEQ32,
+ R_ARM_THM_GOT_BREL12,
+ R_ARM_IRELATIVE,
+ R_ARM_RXPC25,
+ R_ARM_RSBREL32,
+ R_ARM_THM_RPC22,
+ R_ARM_RREL32,
+ R_ARM_RABS22,
+ R_ARM_RPC24,
+ R_ARM_RBASE,
+ );
+ static FLAGS_R_CKCORE: &[Flag<u32>] = &flags!(
+ R_CKCORE_NONE,
+ R_CKCORE_ADDR32,
+ R_CKCORE_PCRELIMM8BY4,
+ R_CKCORE_PCRELIMM11BY2,
+ R_CKCORE_PCREL32,
+ R_CKCORE_PCRELJSR_IMM11BY2,
+ R_CKCORE_RELATIVE,
+ R_CKCORE_COPY,
+ R_CKCORE_GLOB_DAT,
+ R_CKCORE_JUMP_SLOT,
+ R_CKCORE_GOTOFF,
+ R_CKCORE_GOTPC,
+ R_CKCORE_GOT32,
+ R_CKCORE_PLT32,
+ R_CKCORE_ADDRGOT,
+ R_CKCORE_ADDRPLT,
+ R_CKCORE_PCREL_IMM26BY2,
+ R_CKCORE_PCREL_IMM16BY2,
+ R_CKCORE_PCREL_IMM16BY4,
+ R_CKCORE_PCREL_IMM10BY2,
+ R_CKCORE_PCREL_IMM10BY4,
+ R_CKCORE_ADDR_HI16,
+ R_CKCORE_ADDR_LO16,
+ R_CKCORE_GOTPC_HI16,
+ R_CKCORE_GOTPC_LO16,
+ R_CKCORE_GOTOFF_HI16,
+ R_CKCORE_GOTOFF_LO16,
+ R_CKCORE_GOT12,
+ R_CKCORE_GOT_HI16,
+ R_CKCORE_GOT_LO16,
+ R_CKCORE_PLT12,
+ R_CKCORE_PLT_HI16,
+ R_CKCORE_PLT_LO16,
+ R_CKCORE_ADDRGOT_HI16,
+ R_CKCORE_ADDRGOT_LO16,
+ R_CKCORE_ADDRPLT_HI16,
+ R_CKCORE_ADDRPLT_LO16,
+ R_CKCORE_PCREL_JSR_IMM26BY2,
+ R_CKCORE_TOFFSET_LO16,
+ R_CKCORE_DOFFSET_LO16,
+ R_CKCORE_PCREL_IMM18BY2,
+ R_CKCORE_DOFFSET_IMM18,
+ R_CKCORE_DOFFSET_IMM18BY2,
+ R_CKCORE_DOFFSET_IMM18BY4,
+ R_CKCORE_GOT_IMM18BY4,
+ R_CKCORE_PLT_IMM18BY4,
+ R_CKCORE_PCREL_IMM7BY4,
+ R_CKCORE_TLS_LE32,
+ R_CKCORE_TLS_IE32,
+ R_CKCORE_TLS_GD32,
+ R_CKCORE_TLS_LDM32,
+ R_CKCORE_TLS_LDO32,
+ R_CKCORE_TLS_DTPMOD32,
+ R_CKCORE_TLS_DTPOFF32,
+ R_CKCORE_TLS_TPOFF32,
+ );
+ static FLAGS_R_IA64: &[Flag<u32>] = &flags!(
+ R_IA64_NONE,
+ R_IA64_IMM14,
+ R_IA64_IMM22,
+ R_IA64_IMM64,
+ R_IA64_DIR32MSB,
+ R_IA64_DIR32LSB,
+ R_IA64_DIR64MSB,
+ R_IA64_DIR64LSB,
+ R_IA64_GPREL22,
+ R_IA64_GPREL64I,
+ R_IA64_GPREL32MSB,
+ R_IA64_GPREL32LSB,
+ R_IA64_GPREL64MSB,
+ R_IA64_GPREL64LSB,
+ R_IA64_LTOFF22,
+ R_IA64_LTOFF64I,
+ R_IA64_PLTOFF22,
+ R_IA64_PLTOFF64I,
+ R_IA64_PLTOFF64MSB,
+ R_IA64_PLTOFF64LSB,
+ R_IA64_FPTR64I,
+ R_IA64_FPTR32MSB,
+ R_IA64_FPTR32LSB,
+ R_IA64_FPTR64MSB,
+ R_IA64_FPTR64LSB,
+ R_IA64_PCREL60B,
+ R_IA64_PCREL21B,
+ R_IA64_PCREL21M,
+ R_IA64_PCREL21F,
+ R_IA64_PCREL32MSB,
+ R_IA64_PCREL32LSB,
+ R_IA64_PCREL64MSB,
+ R_IA64_PCREL64LSB,
+ R_IA64_LTOFF_FPTR22,
+ R_IA64_LTOFF_FPTR64I,
+ R_IA64_LTOFF_FPTR32MSB,
+ R_IA64_LTOFF_FPTR32LSB,
+ R_IA64_LTOFF_FPTR64MSB,
+ R_IA64_LTOFF_FPTR64LSB,
+ R_IA64_SEGREL32MSB,
+ R_IA64_SEGREL32LSB,
+ R_IA64_SEGREL64MSB,
+ R_IA64_SEGREL64LSB,
+ R_IA64_SECREL32MSB,
+ R_IA64_SECREL32LSB,
+ R_IA64_SECREL64MSB,
+ R_IA64_SECREL64LSB,
+ R_IA64_REL32MSB,
+ R_IA64_REL32LSB,
+ R_IA64_REL64MSB,
+ R_IA64_REL64LSB,
+ R_IA64_LTV32MSB,
+ R_IA64_LTV32LSB,
+ R_IA64_LTV64MSB,
+ R_IA64_LTV64LSB,
+ R_IA64_PCREL21BI,
+ R_IA64_PCREL22,
+ R_IA64_PCREL64I,
+ R_IA64_IPLTMSB,
+ R_IA64_IPLTLSB,
+ R_IA64_COPY,
+ R_IA64_SUB,
+ R_IA64_LTOFF22X,
+ R_IA64_LDXMOV,
+ R_IA64_TPREL14,
+ R_IA64_TPREL22,
+ R_IA64_TPREL64I,
+ R_IA64_TPREL64MSB,
+ R_IA64_TPREL64LSB,
+ R_IA64_LTOFF_TPREL22,
+ R_IA64_DTPMOD64MSB,
+ R_IA64_DTPMOD64LSB,
+ R_IA64_LTOFF_DTPMOD22,
+ R_IA64_DTPREL14,
+ R_IA64_DTPREL22,
+ R_IA64_DTPREL64I,
+ R_IA64_DTPREL32MSB,
+ R_IA64_DTPREL32LSB,
+ R_IA64_DTPREL64MSB,
+ R_IA64_DTPREL64LSB,
+ R_IA64_LTOFF_DTPREL22,
+ );
+ static FLAGS_R_SH: &[Flag<u32>] = &flags!(
+ R_SH_NONE,
+ R_SH_DIR32,
+ R_SH_REL32,
+ R_SH_DIR8WPN,
+ R_SH_IND12W,
+ R_SH_DIR8WPL,
+ R_SH_DIR8WPZ,
+ R_SH_DIR8BP,
+ R_SH_DIR8W,
+ R_SH_DIR8L,
+ R_SH_SWITCH16,
+ R_SH_SWITCH32,
+ R_SH_USES,
+ R_SH_COUNT,
+ R_SH_ALIGN,
+ R_SH_CODE,
+ R_SH_DATA,
+ R_SH_LABEL,
+ R_SH_SWITCH8,
+ R_SH_GNU_VTINHERIT,
+ R_SH_GNU_VTENTRY,
+ R_SH_TLS_GD_32,
+ R_SH_TLS_LD_32,
+ R_SH_TLS_LDO_32,
+ R_SH_TLS_IE_32,
+ R_SH_TLS_LE_32,
+ R_SH_TLS_DTPMOD32,
+ R_SH_TLS_DTPOFF32,
+ R_SH_TLS_TPOFF32,
+ R_SH_GOT32,
+ R_SH_PLT32,
+ R_SH_COPY,
+ R_SH_GLOB_DAT,
+ R_SH_JMP_SLOT,
+ R_SH_RELATIVE,
+ R_SH_GOTOFF,
+ R_SH_GOTPC,
+ );
+ static FLAGS_R_390: &[Flag<u32>] = &flags!(
+ R_390_NONE,
+ R_390_8,
+ R_390_12,
+ R_390_16,
+ R_390_32,
+ R_390_PC32,
+ R_390_GOT12,
+ R_390_GOT32,
+ R_390_PLT32,
+ R_390_COPY,
+ R_390_GLOB_DAT,
+ R_390_JMP_SLOT,
+ R_390_RELATIVE,
+ R_390_GOTOFF32,
+ R_390_GOTPC,
+ R_390_GOT16,
+ R_390_PC16,
+ R_390_PC16DBL,
+ R_390_PLT16DBL,
+ R_390_PC32DBL,
+ R_390_PLT32DBL,
+ R_390_GOTPCDBL,
+ R_390_64,
+ R_390_PC64,
+ R_390_GOT64,
+ R_390_PLT64,
+ R_390_GOTENT,
+ R_390_GOTOFF16,
+ R_390_GOTOFF64,
+ R_390_GOTPLT12,
+ R_390_GOTPLT16,
+ R_390_GOTPLT32,
+ R_390_GOTPLT64,
+ R_390_GOTPLTENT,
+ R_390_PLTOFF16,
+ R_390_PLTOFF32,
+ R_390_PLTOFF64,
+ R_390_TLS_LOAD,
+ R_390_TLS_GDCALL,
+ R_390_TLS_LDCALL,
+ R_390_TLS_GD32,
+ R_390_TLS_GD64,
+ R_390_TLS_GOTIE12,
+ R_390_TLS_GOTIE32,
+ R_390_TLS_GOTIE64,
+ R_390_TLS_LDM32,
+ R_390_TLS_LDM64,
+ R_390_TLS_IE32,
+ R_390_TLS_IE64,
+ R_390_TLS_IEENT,
+ R_390_TLS_LE32,
+ R_390_TLS_LE64,
+ R_390_TLS_LDO32,
+ R_390_TLS_LDO64,
+ R_390_TLS_DTPMOD,
+ R_390_TLS_DTPOFF,
+ R_390_TLS_TPOFF,
+ R_390_20,
+ R_390_GOT20,
+ R_390_GOTPLT20,
+ R_390_TLS_GOTIE20,
+ R_390_IRELATIVE,
+ );
+ static FLAGS_R_CRIS: &[Flag<u32>] = &flags!(
+ R_CRIS_NONE,
+ R_CRIS_8,
+ R_CRIS_16,
+ R_CRIS_32,
+ R_CRIS_8_PCREL,
+ R_CRIS_16_PCREL,
+ R_CRIS_32_PCREL,
+ R_CRIS_GNU_VTINHERIT,
+ R_CRIS_GNU_VTENTRY,
+ R_CRIS_COPY,
+ R_CRIS_GLOB_DAT,
+ R_CRIS_JUMP_SLOT,
+ R_CRIS_RELATIVE,
+ R_CRIS_16_GOT,
+ R_CRIS_32_GOT,
+ R_CRIS_16_GOTPLT,
+ R_CRIS_32_GOTPLT,
+ R_CRIS_32_GOTREL,
+ R_CRIS_32_PLT_GOTREL,
+ R_CRIS_32_PLT_PCREL,
+ );
+ static FLAGS_R_X86_64: &[Flag<u32>] = &flags!(
+ R_X86_64_NONE,
+ R_X86_64_64,
+ R_X86_64_PC32,
+ R_X86_64_GOT32,
+ R_X86_64_PLT32,
+ R_X86_64_COPY,
+ R_X86_64_GLOB_DAT,
+ R_X86_64_JUMP_SLOT,
+ R_X86_64_RELATIVE,
+ R_X86_64_GOTPCREL,
+ R_X86_64_32,
+ R_X86_64_32S,
+ R_X86_64_16,
+ R_X86_64_PC16,
+ R_X86_64_8,
+ R_X86_64_PC8,
+ R_X86_64_DTPMOD64,
+ R_X86_64_DTPOFF64,
+ R_X86_64_TPOFF64,
+ R_X86_64_TLSGD,
+ R_X86_64_TLSLD,
+ R_X86_64_DTPOFF32,
+ R_X86_64_GOTTPOFF,
+ R_X86_64_TPOFF32,
+ R_X86_64_PC64,
+ R_X86_64_GOTOFF64,
+ R_X86_64_GOTPC32,
+ R_X86_64_GOT64,
+ R_X86_64_GOTPCREL64,
+ R_X86_64_GOTPC64,
+ R_X86_64_GOTPLT64,
+ R_X86_64_PLTOFF64,
+ R_X86_64_SIZE32,
+ R_X86_64_SIZE64,
+ R_X86_64_GOTPC32_TLSDESC,
+ R_X86_64_TLSDESC_CALL,
+ R_X86_64_TLSDESC,
+ R_X86_64_IRELATIVE,
+ R_X86_64_RELATIVE64,
+ R_X86_64_GOTPCRELX,
+ R_X86_64_REX_GOTPCRELX,
+ );
+ static FLAGS_R_MN10300: &[Flag<u32>] = &flags!(
+ R_MN10300_NONE,
+ R_MN10300_32,
+ R_MN10300_16,
+ R_MN10300_8,
+ R_MN10300_PCREL32,
+ R_MN10300_PCREL16,
+ R_MN10300_PCREL8,
+ R_MN10300_GNU_VTINHERIT,
+ R_MN10300_GNU_VTENTRY,
+ R_MN10300_24,
+ R_MN10300_GOTPC32,
+ R_MN10300_GOTPC16,
+ R_MN10300_GOTOFF32,
+ R_MN10300_GOTOFF24,
+ R_MN10300_GOTOFF16,
+ R_MN10300_PLT32,
+ R_MN10300_PLT16,
+ R_MN10300_GOT32,
+ R_MN10300_GOT24,
+ R_MN10300_GOT16,
+ R_MN10300_COPY,
+ R_MN10300_GLOB_DAT,
+ R_MN10300_JMP_SLOT,
+ R_MN10300_RELATIVE,
+ R_MN10300_TLS_GD,
+ R_MN10300_TLS_LD,
+ R_MN10300_TLS_LDO,
+ R_MN10300_TLS_GOTIE,
+ R_MN10300_TLS_IE,
+ R_MN10300_TLS_LE,
+ R_MN10300_TLS_DTPMOD,
+ R_MN10300_TLS_DTPOFF,
+ R_MN10300_TLS_TPOFF,
+ R_MN10300_SYM_DIFF,
+ R_MN10300_ALIGN,
+ );
+ static FLAGS_R_M32R: &[Flag<u32>] = &flags!(
+ R_M32R_NONE,
+ R_M32R_16,
+ R_M32R_32,
+ R_M32R_24,
+ R_M32R_10_PCREL,
+ R_M32R_18_PCREL,
+ R_M32R_26_PCREL,
+ R_M32R_HI16_ULO,
+ R_M32R_HI16_SLO,
+ R_M32R_LO16,
+ R_M32R_SDA16,
+ R_M32R_GNU_VTINHERIT,
+ R_M32R_GNU_VTENTRY,
+ R_M32R_16_RELA,
+ R_M32R_32_RELA,
+ R_M32R_24_RELA,
+ R_M32R_10_PCREL_RELA,
+ R_M32R_18_PCREL_RELA,
+ R_M32R_26_PCREL_RELA,
+ R_M32R_HI16_ULO_RELA,
+ R_M32R_HI16_SLO_RELA,
+ R_M32R_LO16_RELA,
+ R_M32R_SDA16_RELA,
+ R_M32R_RELA_GNU_VTINHERIT,
+ R_M32R_RELA_GNU_VTENTRY,
+ R_M32R_REL32,
+ R_M32R_GOT24,
+ R_M32R_26_PLTREL,
+ R_M32R_COPY,
+ R_M32R_GLOB_DAT,
+ R_M32R_JMP_SLOT,
+ R_M32R_RELATIVE,
+ R_M32R_GOTOFF,
+ R_M32R_GOTPC24,
+ R_M32R_GOT16_HI_ULO,
+ R_M32R_GOT16_HI_SLO,
+ R_M32R_GOT16_LO,
+ R_M32R_GOTPC_HI_ULO,
+ R_M32R_GOTPC_HI_SLO,
+ R_M32R_GOTPC_LO,
+ R_M32R_GOTOFF_HI_ULO,
+ R_M32R_GOTOFF_HI_SLO,
+ R_M32R_GOTOFF_LO,
+ R_M32R_NUM,
+ );
+ static FLAGS_R_MICROBLAZE: &[Flag<u32>] = &flags!(
+ R_MICROBLAZE_NONE,
+ R_MICROBLAZE_32,
+ R_MICROBLAZE_32_PCREL,
+ R_MICROBLAZE_64_PCREL,
+ R_MICROBLAZE_32_PCREL_LO,
+ R_MICROBLAZE_64,
+ R_MICROBLAZE_32_LO,
+ R_MICROBLAZE_SRO32,
+ R_MICROBLAZE_SRW32,
+ R_MICROBLAZE_64_NONE,
+ R_MICROBLAZE_32_SYM_OP_SYM,
+ R_MICROBLAZE_GNU_VTINHERIT,
+ R_MICROBLAZE_GNU_VTENTRY,
+ R_MICROBLAZE_GOTPC_64,
+ R_MICROBLAZE_GOT_64,
+ R_MICROBLAZE_PLT_64,
+ R_MICROBLAZE_REL,
+ R_MICROBLAZE_JUMP_SLOT,
+ R_MICROBLAZE_GLOB_DAT,
+ R_MICROBLAZE_GOTOFF_64,
+ R_MICROBLAZE_GOTOFF_32,
+ R_MICROBLAZE_COPY,
+ R_MICROBLAZE_TLS,
+ R_MICROBLAZE_TLSGD,
+ R_MICROBLAZE_TLSLD,
+ R_MICROBLAZE_TLSDTPMOD32,
+ R_MICROBLAZE_TLSDTPREL32,
+ R_MICROBLAZE_TLSDTPREL64,
+ R_MICROBLAZE_TLSGOTTPREL32,
+ R_MICROBLAZE_TLSTPREL32,
+ );
+ static FLAGS_R_NIOS2: &[Flag<u32>] = &flags!(
+ R_NIOS2_NONE,
+ R_NIOS2_S16,
+ R_NIOS2_U16,
+ R_NIOS2_PCREL16,
+ R_NIOS2_CALL26,
+ R_NIOS2_IMM5,
+ R_NIOS2_CACHE_OPX,
+ R_NIOS2_IMM6,
+ R_NIOS2_IMM8,
+ R_NIOS2_HI16,
+ R_NIOS2_LO16,
+ R_NIOS2_HIADJ16,
+ R_NIOS2_BFD_RELOC_32,
+ R_NIOS2_BFD_RELOC_16,
+ R_NIOS2_BFD_RELOC_8,
+ R_NIOS2_GPREL,
+ R_NIOS2_GNU_VTINHERIT,
+ R_NIOS2_GNU_VTENTRY,
+ R_NIOS2_UJMP,
+ R_NIOS2_CJMP,
+ R_NIOS2_CALLR,
+ R_NIOS2_ALIGN,
+ R_NIOS2_GOT16,
+ R_NIOS2_CALL16,
+ R_NIOS2_GOTOFF_LO,
+ R_NIOS2_GOTOFF_HA,
+ R_NIOS2_PCREL_LO,
+ R_NIOS2_PCREL_HA,
+ R_NIOS2_TLS_GD16,
+ R_NIOS2_TLS_LDM16,
+ R_NIOS2_TLS_LDO16,
+ R_NIOS2_TLS_IE16,
+ R_NIOS2_TLS_LE16,
+ R_NIOS2_TLS_DTPMOD,
+ R_NIOS2_TLS_DTPREL,
+ R_NIOS2_TLS_TPREL,
+ R_NIOS2_COPY,
+ R_NIOS2_GLOB_DAT,
+ R_NIOS2_JUMP_SLOT,
+ R_NIOS2_RELATIVE,
+ R_NIOS2_GOTOFF,
+ R_NIOS2_CALL26_NOAT,
+ R_NIOS2_GOT_LO,
+ R_NIOS2_GOT_HA,
+ R_NIOS2_CALL_LO,
+ R_NIOS2_CALL_HA,
+ );
+ static FLAGS_R_TILEPRO: &[Flag<u32>] = &flags!(
+ R_TILEPRO_NONE,
+ R_TILEPRO_32,
+ R_TILEPRO_16,
+ R_TILEPRO_8,
+ R_TILEPRO_32_PCREL,
+ R_TILEPRO_16_PCREL,
+ R_TILEPRO_8_PCREL,
+ R_TILEPRO_LO16,
+ R_TILEPRO_HI16,
+ R_TILEPRO_HA16,
+ R_TILEPRO_COPY,
+ R_TILEPRO_GLOB_DAT,
+ R_TILEPRO_JMP_SLOT,
+ R_TILEPRO_RELATIVE,
+ R_TILEPRO_BROFF_X1,
+ R_TILEPRO_JOFFLONG_X1,
+ R_TILEPRO_JOFFLONG_X1_PLT,
+ R_TILEPRO_IMM8_X0,
+ R_TILEPRO_IMM8_Y0,
+ R_TILEPRO_IMM8_X1,
+ R_TILEPRO_IMM8_Y1,
+ R_TILEPRO_MT_IMM15_X1,
+ R_TILEPRO_MF_IMM15_X1,
+ R_TILEPRO_IMM16_X0,
+ R_TILEPRO_IMM16_X1,
+ R_TILEPRO_IMM16_X0_LO,
+ R_TILEPRO_IMM16_X1_LO,
+ R_TILEPRO_IMM16_X0_HI,
+ R_TILEPRO_IMM16_X1_HI,
+ R_TILEPRO_IMM16_X0_HA,
+ R_TILEPRO_IMM16_X1_HA,
+ R_TILEPRO_IMM16_X0_PCREL,
+ R_TILEPRO_IMM16_X1_PCREL,
+ R_TILEPRO_IMM16_X0_LO_PCREL,
+ R_TILEPRO_IMM16_X1_LO_PCREL,
+ R_TILEPRO_IMM16_X0_HI_PCREL,
+ R_TILEPRO_IMM16_X1_HI_PCREL,
+ R_TILEPRO_IMM16_X0_HA_PCREL,
+ R_TILEPRO_IMM16_X1_HA_PCREL,
+ R_TILEPRO_IMM16_X0_GOT,
+ R_TILEPRO_IMM16_X1_GOT,
+ R_TILEPRO_IMM16_X0_GOT_LO,
+ R_TILEPRO_IMM16_X1_GOT_LO,
+ R_TILEPRO_IMM16_X0_GOT_HI,
+ R_TILEPRO_IMM16_X1_GOT_HI,
+ R_TILEPRO_IMM16_X0_GOT_HA,
+ R_TILEPRO_IMM16_X1_GOT_HA,
+ R_TILEPRO_MMSTART_X0,
+ R_TILEPRO_MMEND_X0,
+ R_TILEPRO_MMSTART_X1,
+ R_TILEPRO_MMEND_X1,
+ R_TILEPRO_SHAMT_X0,
+ R_TILEPRO_SHAMT_X1,
+ R_TILEPRO_SHAMT_Y0,
+ R_TILEPRO_SHAMT_Y1,
+ R_TILEPRO_DEST_IMM8_X1,
+ R_TILEPRO_TLS_GD_CALL,
+ R_TILEPRO_IMM8_X0_TLS_GD_ADD,
+ R_TILEPRO_IMM8_X1_TLS_GD_ADD,
+ R_TILEPRO_IMM8_Y0_TLS_GD_ADD,
+ R_TILEPRO_IMM8_Y1_TLS_GD_ADD,
+ R_TILEPRO_TLS_IE_LOAD,
+ R_TILEPRO_IMM16_X0_TLS_GD,
+ R_TILEPRO_IMM16_X1_TLS_GD,
+ R_TILEPRO_IMM16_X0_TLS_GD_LO,
+ R_TILEPRO_IMM16_X1_TLS_GD_LO,
+ R_TILEPRO_IMM16_X0_TLS_GD_HI,
+ R_TILEPRO_IMM16_X1_TLS_GD_HI,
+ R_TILEPRO_IMM16_X0_TLS_GD_HA,
+ R_TILEPRO_IMM16_X1_TLS_GD_HA,
+ R_TILEPRO_IMM16_X0_TLS_IE,
+ R_TILEPRO_IMM16_X1_TLS_IE,
+ R_TILEPRO_IMM16_X0_TLS_IE_LO,
+ R_TILEPRO_IMM16_X1_TLS_IE_LO,
+ R_TILEPRO_IMM16_X0_TLS_IE_HI,
+ R_TILEPRO_IMM16_X1_TLS_IE_HI,
+ R_TILEPRO_IMM16_X0_TLS_IE_HA,
+ R_TILEPRO_IMM16_X1_TLS_IE_HA,
+ R_TILEPRO_TLS_DTPMOD32,
+ R_TILEPRO_TLS_DTPOFF32,
+ R_TILEPRO_TLS_TPOFF32,
+ R_TILEPRO_IMM16_X0_TLS_LE,
+ R_TILEPRO_IMM16_X1_TLS_LE,
+ R_TILEPRO_IMM16_X0_TLS_LE_LO,
+ R_TILEPRO_IMM16_X1_TLS_LE_LO,
+ R_TILEPRO_IMM16_X0_TLS_LE_HI,
+ R_TILEPRO_IMM16_X1_TLS_LE_HI,
+ R_TILEPRO_IMM16_X0_TLS_LE_HA,
+ R_TILEPRO_IMM16_X1_TLS_LE_HA,
+ R_TILEPRO_GNU_VTINHERIT,
+ R_TILEPRO_GNU_VTENTRY,
+ );
+ static FLAGS_R_TILEGX: &[Flag<u32>] = &flags!(
+ R_TILEGX_NONE,
+ R_TILEGX_64,
+ R_TILEGX_32,
+ R_TILEGX_16,
+ R_TILEGX_8,
+ R_TILEGX_64_PCREL,
+ R_TILEGX_32_PCREL,
+ R_TILEGX_16_PCREL,
+ R_TILEGX_8_PCREL,
+ R_TILEGX_HW0,
+ R_TILEGX_HW1,
+ R_TILEGX_HW2,
+ R_TILEGX_HW3,
+ R_TILEGX_HW0_LAST,
+ R_TILEGX_HW1_LAST,
+ R_TILEGX_HW2_LAST,
+ R_TILEGX_COPY,
+ R_TILEGX_GLOB_DAT,
+ R_TILEGX_JMP_SLOT,
+ R_TILEGX_RELATIVE,
+ R_TILEGX_BROFF_X1,
+ R_TILEGX_JUMPOFF_X1,
+ R_TILEGX_JUMPOFF_X1_PLT,
+ R_TILEGX_IMM8_X0,
+ R_TILEGX_IMM8_Y0,
+ R_TILEGX_IMM8_X1,
+ R_TILEGX_IMM8_Y1,
+ R_TILEGX_DEST_IMM8_X1,
+ R_TILEGX_MT_IMM14_X1,
+ R_TILEGX_MF_IMM14_X1,
+ R_TILEGX_MMSTART_X0,
+ R_TILEGX_MMEND_X0,
+ R_TILEGX_SHAMT_X0,
+ R_TILEGX_SHAMT_X1,
+ R_TILEGX_SHAMT_Y0,
+ R_TILEGX_SHAMT_Y1,
+ R_TILEGX_IMM16_X0_HW0,
+ R_TILEGX_IMM16_X1_HW0,
+ R_TILEGX_IMM16_X0_HW1,
+ R_TILEGX_IMM16_X1_HW1,
+ R_TILEGX_IMM16_X0_HW2,
+ R_TILEGX_IMM16_X1_HW2,
+ R_TILEGX_IMM16_X0_HW3,
+ R_TILEGX_IMM16_X1_HW3,
+ R_TILEGX_IMM16_X0_HW0_LAST,
+ R_TILEGX_IMM16_X1_HW0_LAST,
+ R_TILEGX_IMM16_X0_HW1_LAST,
+ R_TILEGX_IMM16_X1_HW1_LAST,
+ R_TILEGX_IMM16_X0_HW2_LAST,
+ R_TILEGX_IMM16_X1_HW2_LAST,
+ R_TILEGX_IMM16_X0_HW0_PCREL,
+ R_TILEGX_IMM16_X1_HW0_PCREL,
+ R_TILEGX_IMM16_X0_HW1_PCREL,
+ R_TILEGX_IMM16_X1_HW1_PCREL,
+ R_TILEGX_IMM16_X0_HW2_PCREL,
+ R_TILEGX_IMM16_X1_HW2_PCREL,
+ R_TILEGX_IMM16_X0_HW3_PCREL,
+ R_TILEGX_IMM16_X1_HW3_PCREL,
+ R_TILEGX_IMM16_X0_HW0_LAST_PCREL,
+ R_TILEGX_IMM16_X1_HW0_LAST_PCREL,
+ R_TILEGX_IMM16_X0_HW1_LAST_PCREL,
+ R_TILEGX_IMM16_X1_HW1_LAST_PCREL,
+ R_TILEGX_IMM16_X0_HW2_LAST_PCREL,
+ R_TILEGX_IMM16_X1_HW2_LAST_PCREL,
+ R_TILEGX_IMM16_X0_HW0_GOT,
+ R_TILEGX_IMM16_X1_HW0_GOT,
+ R_TILEGX_IMM16_X0_HW0_PLT_PCREL,
+ R_TILEGX_IMM16_X1_HW0_PLT_PCREL,
+ R_TILEGX_IMM16_X0_HW1_PLT_PCREL,
+ R_TILEGX_IMM16_X1_HW1_PLT_PCREL,
+ R_TILEGX_IMM16_X0_HW2_PLT_PCREL,
+ R_TILEGX_IMM16_X1_HW2_PLT_PCREL,
+ R_TILEGX_IMM16_X0_HW0_LAST_GOT,
+ R_TILEGX_IMM16_X1_HW0_LAST_GOT,
+ R_TILEGX_IMM16_X0_HW1_LAST_GOT,
+ R_TILEGX_IMM16_X1_HW1_LAST_GOT,
+ R_TILEGX_IMM16_X0_HW3_PLT_PCREL,
+ R_TILEGX_IMM16_X1_HW3_PLT_PCREL,
+ R_TILEGX_IMM16_X0_HW0_TLS_GD,
+ R_TILEGX_IMM16_X1_HW0_TLS_GD,
+ R_TILEGX_IMM16_X0_HW0_TLS_LE,
+ R_TILEGX_IMM16_X1_HW0_TLS_LE,
+ R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE,
+ R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE,
+ R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE,
+ R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE,
+ R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD,
+ R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD,
+ R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD,
+ R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD,
+ R_TILEGX_IMM16_X0_HW0_TLS_IE,
+ R_TILEGX_IMM16_X1_HW0_TLS_IE,
+ R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL,
+ R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL,
+ R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL,
+ R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL,
+ R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL,
+ R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL,
+ R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE,
+ R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE,
+ R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE,
+ R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE,
+ R_TILEGX_TLS_DTPMOD64,
+ R_TILEGX_TLS_DTPOFF64,
+ R_TILEGX_TLS_TPOFF64,
+ R_TILEGX_TLS_DTPMOD32,
+ R_TILEGX_TLS_DTPOFF32,
+ R_TILEGX_TLS_TPOFF32,
+ R_TILEGX_TLS_GD_CALL,
+ R_TILEGX_IMM8_X0_TLS_GD_ADD,
+ R_TILEGX_IMM8_X1_TLS_GD_ADD,
+ R_TILEGX_IMM8_Y0_TLS_GD_ADD,
+ R_TILEGX_IMM8_Y1_TLS_GD_ADD,
+ R_TILEGX_TLS_IE_LOAD,
+ R_TILEGX_IMM8_X0_TLS_ADD,
+ R_TILEGX_IMM8_X1_TLS_ADD,
+ R_TILEGX_IMM8_Y0_TLS_ADD,
+ R_TILEGX_IMM8_Y1_TLS_ADD,
+ R_TILEGX_GNU_VTINHERIT,
+ R_TILEGX_GNU_VTENTRY,
+ );
+ static FLAGS_R_RISCV: &[Flag<u32>] = &flags!(
+ R_RISCV_NONE,
+ R_RISCV_32,
+ R_RISCV_64,
+ R_RISCV_RELATIVE,
+ R_RISCV_COPY,
+ R_RISCV_JUMP_SLOT,
+ R_RISCV_TLS_DTPMOD32,
+ R_RISCV_TLS_DTPMOD64,
+ R_RISCV_TLS_DTPREL32,
+ R_RISCV_TLS_DTPREL64,
+ R_RISCV_TLS_TPREL32,
+ R_RISCV_TLS_TPREL64,
+ R_RISCV_BRANCH,
+ R_RISCV_JAL,
+ R_RISCV_CALL,
+ R_RISCV_CALL_PLT,
+ R_RISCV_GOT_HI20,
+ R_RISCV_TLS_GOT_HI20,
+ R_RISCV_TLS_GD_HI20,
+ R_RISCV_PCREL_HI20,
+ R_RISCV_PCREL_LO12_I,
+ R_RISCV_PCREL_LO12_S,
+ R_RISCV_HI20,
+ R_RISCV_LO12_I,
+ R_RISCV_LO12_S,
+ R_RISCV_TPREL_HI20,
+ R_RISCV_TPREL_LO12_I,
+ R_RISCV_TPREL_LO12_S,
+ R_RISCV_TPREL_ADD,
+ R_RISCV_ADD8,
+ R_RISCV_ADD16,
+ R_RISCV_ADD32,
+ R_RISCV_ADD64,
+ R_RISCV_SUB8,
+ R_RISCV_SUB16,
+ R_RISCV_SUB32,
+ R_RISCV_SUB64,
+ R_RISCV_GNU_VTINHERIT,
+ R_RISCV_GNU_VTENTRY,
+ R_RISCV_ALIGN,
+ R_RISCV_RVC_BRANCH,
+ R_RISCV_RVC_JUMP,
+ R_RISCV_RVC_LUI,
+ R_RISCV_GPREL_I,
+ R_RISCV_GPREL_S,
+ R_RISCV_TPREL_I,
+ R_RISCV_TPREL_S,
+ R_RISCV_RELAX,
+ R_RISCV_SUB6,
+ R_RISCV_SET6,
+ R_RISCV_SET8,
+ R_RISCV_SET16,
+ R_RISCV_SET32,
+ R_RISCV_32_PCREL,
+ );
+ static FLAGS_R_BPF: &[Flag<u32>] = &flags!(R_BPF_NONE, R_BPF_64_64, R_BPF_64_32);
+ static FLAGS_R_METAG: &[Flag<u32>] = &flags!(
+ R_METAG_HIADDR16,
+ R_METAG_LOADDR16,
+ R_METAG_ADDR32,
+ R_METAG_NONE,
+ R_METAG_RELBRANCH,
+ R_METAG_GETSETOFF,
+ R_METAG_REG32OP1,
+ R_METAG_REG32OP2,
+ R_METAG_REG32OP3,
+ R_METAG_REG16OP1,
+ R_METAG_REG16OP2,
+ R_METAG_REG16OP3,
+ R_METAG_REG32OP4,
+ R_METAG_HIOG,
+ R_METAG_LOOG,
+ R_METAG_REL8,
+ R_METAG_REL16,
+ R_METAG_GNU_VTINHERIT,
+ R_METAG_GNU_VTENTRY,
+ R_METAG_HI16_GOTOFF,
+ R_METAG_LO16_GOTOFF,
+ R_METAG_GETSET_GOTOFF,
+ R_METAG_GETSET_GOT,
+ R_METAG_HI16_GOTPC,
+ R_METAG_LO16_GOTPC,
+ R_METAG_HI16_PLT,
+ R_METAG_LO16_PLT,
+ R_METAG_RELBRANCH_PLT,
+ R_METAG_GOTOFF,
+ R_METAG_PLT,
+ R_METAG_COPY,
+ R_METAG_JMP_SLOT,
+ R_METAG_RELATIVE,
+ R_METAG_GLOB_DAT,
+ R_METAG_TLS_GD,
+ R_METAG_TLS_LDM,
+ R_METAG_TLS_LDO_HI16,
+ R_METAG_TLS_LDO_LO16,
+ R_METAG_TLS_LDO,
+ R_METAG_TLS_IE,
+ R_METAG_TLS_IENONPIC,
+ R_METAG_TLS_IENONPIC_HI16,
+ R_METAG_TLS_IENONPIC_LO16,
+ R_METAG_TLS_TPOFF,
+ R_METAG_TLS_DTPMOD,
+ R_METAG_TLS_DTPOFF,
+ R_METAG_TLS_LE,
+ R_METAG_TLS_LE_HI16,
+ R_METAG_TLS_LE_LO16,
+ );
+ static FLAGS_R_NDS32: &[Flag<u32>] = &flags!(
+ R_NDS32_NONE,
+ R_NDS32_32_RELA,
+ R_NDS32_COPY,
+ R_NDS32_GLOB_DAT,
+ R_NDS32_JMP_SLOT,
+ R_NDS32_RELATIVE,
+ R_NDS32_TLS_TPOFF,
+ R_NDS32_TLS_DESC,
+ );
+ static FLAGS_NT_CORE: &[Flag<u32>] = &flags!(
+ NT_PRSTATUS,
+ NT_PRFPREG,
+ NT_FPREGSET,
+ NT_PRPSINFO,
+ NT_PRXREG,
+ NT_TASKSTRUCT,
+ NT_PLATFORM,
+ NT_AUXV,
+ NT_GWINDOWS,
+ NT_ASRS,
+ NT_PSTATUS,
+ NT_PSINFO,
+ NT_PRCRED,
+ NT_UTSNAME,
+ NT_LWPSTATUS,
+ NT_LWPSINFO,
+ NT_PRFPXREG,
+ NT_SIGINFO,
+ NT_FILE,
+ NT_PRXFPREG,
+ NT_PPC_VMX,
+ NT_PPC_SPE,
+ NT_PPC_VSX,
+ NT_PPC_TAR,
+ NT_PPC_PPR,
+ NT_PPC_DSCR,
+ NT_PPC_EBB,
+ NT_PPC_PMU,
+ NT_PPC_TM_CGPR,
+ NT_PPC_TM_CFPR,
+ NT_PPC_TM_CVMX,
+ NT_PPC_TM_CVSX,
+ NT_PPC_TM_SPR,
+ NT_PPC_TM_CTAR,
+ NT_PPC_TM_CPPR,
+ NT_PPC_TM_CDSCR,
+ NT_PPC_PKEY,
+ NT_386_TLS,
+ NT_386_IOPERM,
+ NT_X86_XSTATE,
+ NT_S390_HIGH_GPRS,
+ NT_S390_TIMER,
+ NT_S390_TODCMP,
+ NT_S390_TODPREG,
+ NT_S390_CTRS,
+ NT_S390_PREFIX,
+ NT_S390_LAST_BREAK,
+ NT_S390_SYSTEM_CALL,
+ NT_S390_TDB,
+ NT_S390_VXRS_LOW,
+ NT_S390_VXRS_HIGH,
+ NT_S390_GS_CB,
+ NT_S390_GS_BC,
+ NT_S390_RI_CB,
+ NT_ARM_VFP,
+ NT_ARM_TLS,
+ NT_ARM_HW_BREAK,
+ NT_ARM_HW_WATCH,
+ NT_ARM_SYSTEM_CALL,
+ NT_ARM_SVE,
+ NT_VMCOREDD,
+ NT_MIPS_DSP,
+ NT_MIPS_FP_MODE,
+ );
+ static FLAGS_NT_SOLARIS: &[Flag<u32>] = &flags!(NT_SOLARIS_PAGESIZE_HINT);
+ static FLAGS_NT_GNU: &[Flag<u32>] = &flags!(
+ NT_GNU_ABI_TAG,
+ NT_GNU_HWCAP,
+ NT_GNU_BUILD_ID,
+ NT_GNU_GOLD_VERSION,
+ NT_GNU_PROPERTY_TYPE_0,
+ );
+ static FLAGS_GRP: &[Flag<u32>] = &flags!(GRP_COMDAT);
+ static FLAGS_DT: &[Flag<u32>] = &flags!(
+ DT_NULL,
+ DT_NEEDED,
+ DT_PLTRELSZ,
+ DT_PLTGOT,
+ DT_HASH,
+ DT_STRTAB,
+ DT_SYMTAB,
+ DT_RELA,
+ DT_RELASZ,
+ DT_RELAENT,
+ DT_STRSZ,
+ DT_SYMENT,
+ DT_INIT,
+ DT_FINI,
+ DT_SONAME,
+ DT_RPATH,
+ DT_SYMBOLIC,
+ DT_REL,
+ DT_RELSZ,
+ DT_RELENT,
+ DT_PLTREL,
+ DT_DEBUG,
+ DT_TEXTREL,
+ DT_JMPREL,
+ DT_BIND_NOW,
+ DT_INIT_ARRAY,
+ DT_FINI_ARRAY,
+ DT_INIT_ARRAYSZ,
+ DT_FINI_ARRAYSZ,
+ DT_RUNPATH,
+ DT_FLAGS,
+ DT_PREINIT_ARRAY,
+ DT_PREINIT_ARRAYSZ,
+ DT_SYMTAB_SHNDX,
+ DT_GNU_PRELINKED,
+ DT_GNU_CONFLICTSZ,
+ DT_GNU_LIBLISTSZ,
+ DT_CHECKSUM,
+ DT_PLTPADSZ,
+ DT_MOVEENT,
+ DT_MOVESZ,
+ DT_FEATURE_1,
+ DT_POSFLAG_1,
+ DT_SYMINSZ,
+ DT_SYMINENT,
+ DT_GNU_HASH,
+ DT_TLSDESC_PLT,
+ DT_TLSDESC_GOT,
+ DT_GNU_CONFLICT,
+ DT_GNU_LIBLIST,
+ DT_CONFIG,
+ DT_DEPAUDIT,
+ DT_AUDIT,
+ DT_PLTPAD,
+ DT_MOVETAB,
+ DT_SYMINFO,
+ DT_VERSYM,
+ DT_RELACOUNT,
+ DT_RELCOUNT,
+ DT_FLAGS_1,
+ DT_VERDEF,
+ DT_VERDEFNUM,
+ DT_VERNEED,
+ DT_VERNEEDNUM,
+ DT_AUXILIARY,
+ DT_FILTER,
+ );
+ static FLAGS_DT_SPARC: &[Flag<u32>] = &flags!(DT_SPARC_REGISTER);
+ static FLAGS_DT_MIPS: &[Flag<u32>] = &flags!(
+ DT_MIPS_RLD_VERSION,
+ DT_MIPS_TIME_STAMP,
+ DT_MIPS_ICHECKSUM,
+ DT_MIPS_IVERSION,
+ DT_MIPS_FLAGS,
+ DT_MIPS_BASE_ADDRESS,
+ DT_MIPS_MSYM,
+ DT_MIPS_CONFLICT,
+ DT_MIPS_LIBLIST,
+ DT_MIPS_LOCAL_GOTNO,
+ DT_MIPS_CONFLICTNO,
+ DT_MIPS_LIBLISTNO,
+ DT_MIPS_SYMTABNO,
+ DT_MIPS_UNREFEXTNO,
+ DT_MIPS_GOTSYM,
+ DT_MIPS_HIPAGENO,
+ DT_MIPS_RLD_MAP,
+ DT_MIPS_DELTA_CLASS,
+ DT_MIPS_DELTA_CLASS_NO,
+ DT_MIPS_DELTA_INSTANCE,
+ DT_MIPS_DELTA_INSTANCE_NO,
+ DT_MIPS_DELTA_RELOC,
+ DT_MIPS_DELTA_RELOC_NO,
+ DT_MIPS_DELTA_SYM,
+ DT_MIPS_DELTA_SYM_NO,
+ DT_MIPS_DELTA_CLASSSYM,
+ DT_MIPS_DELTA_CLASSSYM_NO,
+ DT_MIPS_CXX_FLAGS,
+ DT_MIPS_PIXIE_INIT,
+ DT_MIPS_SYMBOL_LIB,
+ DT_MIPS_LOCALPAGE_GOTIDX,
+ DT_MIPS_LOCAL_GOTIDX,
+ DT_MIPS_HIDDEN_GOTIDX,
+ DT_MIPS_PROTECTED_GOTIDX,
+ DT_MIPS_OPTIONS,
+ DT_MIPS_INTERFACE,
+ DT_MIPS_DYNSTR_ALIGN,
+ DT_MIPS_INTERFACE_SIZE,
+ DT_MIPS_RLD_TEXT_RESOLVE_ADDR,
+ DT_MIPS_PERF_SUFFIX,
+ DT_MIPS_COMPACT_SIZE,
+ DT_MIPS_GP_VALUE,
+ DT_MIPS_AUX_DYNAMIC,
+ DT_MIPS_PLTGOT,
+ DT_MIPS_RWPLT,
+ DT_MIPS_RLD_MAP_REL,
+ );
+ static FLAGS_DT_ALPHA: &[Flag<u32>] = &flags!(DT_ALPHA_PLTRO);
+ static FLAGS_DT_PPC: &[Flag<u32>] = &flags!(DT_PPC_GOT, DT_PPC_OPT);
+ static FLAGS_DT_PPC64: &[Flag<u32>] =
+ &flags!(DT_PPC64_GLINK, DT_PPC64_OPD, DT_PPC64_OPDSZ, DT_PPC64_OPT);
+ static FLAGS_DT_IA_64: &[Flag<u32>] = &flags!(DT_IA_64_PLT_RESERVE);
+ static FLAGS_DT_NIOS2: &[Flag<u32>] = &flags!(DT_NIOS2_GP);
+ static FLAGS_DF: &[Flag<u32>] = &flags!(
+ DF_ORIGIN,
+ DF_SYMBOLIC,
+ DF_TEXTREL,
+ DF_BIND_NOW,
+ DF_STATIC_TLS,
+ );
+ static FLAGS_DF_1: &[Flag<u32>] = &flags!(
+ DF_1_NOW,
+ DF_1_GLOBAL,
+ DF_1_GROUP,
+ DF_1_NODELETE,
+ DF_1_LOADFLTR,
+ DF_1_INITFIRST,
+ DF_1_NOOPEN,
+ DF_1_ORIGIN,
+ DF_1_DIRECT,
+ DF_1_TRANS,
+ DF_1_INTERPOSE,
+ DF_1_NODEFLIB,
+ DF_1_NODUMP,
+ DF_1_CONFALT,
+ DF_1_ENDFILTEE,
+ DF_1_DISPRELDNE,
+ DF_1_DISPRELPND,
+ DF_1_NODIRECT,
+ DF_1_IGNMULDEF,
+ DF_1_NOKSYMS,
+ DF_1_NOHDR,
+ DF_1_EDITED,
+ DF_1_NORELOC,
+ DF_1_SYMINTPOSE,
+ DF_1_GLOBAUDIT,
+ DF_1_SINGLETON,
+ DF_1_STUB,
+ DF_1_PIE,
+ );
+ static FLAGS_VER_FLG: &[Flag<u16>] = &flags!(VER_FLG_BASE, VER_FLG_WEAK);
+ static FLAGS_VER_NDX: &[Flag<u16>] = &flags!(VER_NDX_HIDDEN);
+}
+
+mod macho {
+ use super::*;
+ use object::macho::*;
+ use object::read::macho::*;
+ use object::BigEndian;
+
+ pub(super) fn print_dyld_cache(p: &mut Printer<impl Write>, data: &[u8]) {
+ if let Ok(header) = DyldCacheHeader::<Endianness>::parse(data) {
+ if let Ok((_, endian)) = header.parse_magic() {
+ print_dyld_cache_header(p, endian, header);
+ let mappings = header.mappings(endian, data).ok();
+ if let Some(mappings) = mappings {
+ print_dyld_cache_mappings(p, endian, mappings);
+ }
+ if let Ok(images) = header.images(endian, data) {
+ print_dyld_cache_images(p, endian, data, mappings, images);
+ }
+ }
+ }
+ }
+
+ pub(super) fn print_dyld_cache_header(
+ p: &mut Printer<impl Write>,
+ endian: Endianness,
+ header: &DyldCacheHeader<Endianness>,
+ ) {
+ p.group("DyldCacheHeader", |p| {
+ p.field_bytes("Magic", &header.magic);
+ p.field_hex("MappingOffset", header.mapping_offset.get(endian));
+ p.field("MappingCount", header.mapping_count.get(endian));
+ p.field_hex("ImagesOffset", header.images_offset.get(endian));
+ p.field("ImagesCount", header.images_count.get(endian));
+ p.field_hex("DyldBaseAddress", header.dyld_base_address.get(endian));
+ });
+ }
+
+ pub(super) fn print_dyld_cache_mappings(
+ p: &mut Printer<impl Write>,
+ endian: Endianness,
+ mappings: &[DyldCacheMappingInfo<Endianness>],
+ ) {
+ for mapping in mappings {
+ p.group("DyldCacheMappingInfo", |p| {
+ p.field_hex("Address", mapping.address.get(endian));
+ p.field_hex("Size", mapping.size.get(endian));
+ p.field_hex("FileOffset", mapping.file_offset.get(endian));
+ p.field_hex("MaxProt", mapping.max_prot.get(endian));
+ p.flags(mapping.max_prot.get(endian), 0, FLAGS_VM);
+ p.field_hex("InitProt", mapping.init_prot.get(endian));
+ p.flags(mapping.init_prot.get(endian), 0, FLAGS_VM);
+ });
+ }
+ }
+
+ pub(super) fn print_dyld_cache_images(
+ p: &mut Printer<impl Write>,
+ endian: Endianness,
+ data: &[u8],
+ mappings: Option<&[DyldCacheMappingInfo<Endianness>]>,
+ images: &[DyldCacheImageInfo<Endianness>],
+ ) {
+ for image in images {
+ p.group("DyldCacheImageInfo", |p| {
+ p.field_hex("Address", image.address.get(endian));
+ p.field_hex("ModTime", image.mod_time.get(endian));
+ p.field_hex("Inode", image.inode.get(endian));
+ p.field_string(
+ "Path",
+ image.path_file_offset.get(endian),
+ image.path(endian, data).ok(),
+ );
+ p.field_hex("Pad", image.pad.get(endian));
+ });
+ if let Some(offset) =
+ mappings.and_then(|mappings| image.file_offset(endian, mappings).ok())
+ {
+ p.blank();
+ print_object_at(p, data, offset);
+ p.blank();
+ }
+ }
+ }
+
+ pub(super) fn print_macho_fat32(p: &mut Printer<impl Write>, data: &[u8]) {
+ if let Ok(arches) = FatHeader::parse_arch32(data) {
+ println!("Format: Mach-O Fat 32-bit");
+ print_fat_header(p, data);
+ for arch in arches {
+ print_fat_arch(p, arch);
+ }
+ for arch in arches {
+ if let Ok(data) = arch.data(data) {
+ p.blank();
+ print_object(p, data);
+ }
+ }
+ }
+ }
+
+ pub(super) fn print_macho_fat64(p: &mut Printer<impl Write>, data: &[u8]) {
+ if let Ok(arches) = FatHeader::parse_arch64(data) {
+ println!("Format: Mach-O Fat 64-bit");
+ print_fat_header(p, data);
+ for arch in arches {
+ print_fat_arch(p, arch);
+ }
+ for arch in arches {
+ if let Ok(data) = arch.data(data) {
+ p.blank();
+ print_object(p, data);
+ }
+ }
+ }
+ }
+
+ pub(super) fn print_fat_header(p: &mut Printer<impl Write>, data: &[u8]) {
+ if let Ok(header) = FatHeader::parse(data) {
+ p.group("FatHeader", |p| {
+ p.field_hex("Magic", header.magic.get(BigEndian));
+ p.field("NumberOfFatArch", header.nfat_arch.get(BigEndian));
+ });
+ }
+ }
+
+ pub(super) fn print_fat_arch<Arch: FatArch>(p: &mut Printer<impl Write>, arch: &Arch) {
+ p.group("FatArch", |p| {
+ print_cputype(p, arch.cputype(), arch.cpusubtype());
+ p.field_hex("Offset", arch.offset().into());
+ p.field_hex("Size", arch.size().into());
+ p.field("Align", arch.align());
+ });
+ }
+
+ pub(super) fn print_macho32(p: &mut Printer<impl Write>, data: &[u8], offset: u64) {
+ if let Ok(header) = MachHeader32::parse(data, offset) {
+ println!("Format: Mach-O 32-bit");
+ print_macho(p, header, data, offset);
+ }
+ }
+
+ pub(super) fn print_macho64(p: &mut Printer<impl Write>, data: &[u8], offset: u64) {
+ if let Ok(header) = MachHeader64::parse(data, offset) {
+ println!("Format: Mach-O 64-bit");
+ print_macho(p, header, data, offset);
+ }
+ }
+
+ #[derive(Default)]
+ struct MachState {
+ section_index: usize,
+ }
+
+ fn print_macho<Mach: MachHeader<Endian = Endianness>>(
+ p: &mut Printer<impl Write>,
+ header: &Mach,
+ data: &[u8],
+ offset: u64,
+ ) {
+ if let Ok(endian) = header.endian() {
+ let mut state = MachState::default();
+ print_mach_header(p, endian, header);
+ if let Ok(mut commands) = header.load_commands(endian, data, offset) {
+ while let Ok(Some(command)) = commands.next() {
+ print_load_command(p, endian, data, header, command, &mut state);
+ }
+ }
+ }
+ }
+
+ fn print_mach_header<Mach: MachHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Mach::Endian,
+ header: &Mach,
+ ) {
+ p.group("MachHeader", |p| {
+ p.field_hex("Magic", header.magic().to_be());
+ print_cputype(p, header.cputype(endian), header.cpusubtype(endian));
+ p.field_enum("FileType", header.filetype(endian), FLAGS_MH_FILETYPE);
+ p.field("NumberOfCmds", header.ncmds(endian));
+ p.field_hex("SizeOfCmds", header.sizeofcmds(endian));
+ p.field_enum("Flags", header.flags(endian), FLAGS_MH);
+ });
+ }
+
+ fn print_load_command<Mach: MachHeader>(
+ p: &mut Printer<impl Write>,
+ endian: Mach::Endian,
+ data: &[u8],
+ header: &Mach,
+ command: LoadCommandData<Mach::Endian>,
+ state: &mut MachState,
+ ) {
+ if let Ok(variant) = command.variant() {
+ match variant {
+ LoadCommandVariant::Segment32(segment, section_data) => {
+ print_segment(
+ p,
+ endian,
+ data,
+ header.cputype(endian),
+ segment,
+ section_data,
+ state,
+ );
+ }
+ LoadCommandVariant::Segment64(segment, section_data) => {
+ print_segment(
+ p,
+ endian,
+ data,
+ header.cputype(endian),
+ segment,
+ section_data,
+ state,
+ );
+ }
+ LoadCommandVariant::Symtab(symtab) => {
+ print_symtab::<Mach, _>(p, endian, data, symtab);
+ }
+ LoadCommandVariant::Thread(x, _thread_data) => {
+ p.group("ThreadCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ // TODO: thread_data
+ });
+ }
+ LoadCommandVariant::Dysymtab(x) => {
+ p.group("DysymtabCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ // TODO: dump the tables these are all pointing to
+ p.field("IndexOfLocalSymbols", x.ilocalsym.get(endian));
+ p.field("NumberOfLocalSymbols", x.nlocalsym.get(endian));
+ p.field("IndexOfExternallyDefinedSymbols", x.iextdefsym.get(endian));
+ p.field("NumberOfExternallyDefinedSymbols", x.nextdefsym.get(endian));
+ p.field("IndexOfUndefinedSymbols", x.iundefsym.get(endian));
+ p.field("NumberOfUndefinedSymbols", x.nundefsym.get(endian));
+ p.field_hex("TocOffset", x.tocoff.get(endian));
+ p.field("NumberOfTocEntries", x.ntoc.get(endian));
+ p.field_hex("ModuleTableOffset", x.modtaboff.get(endian));
+ p.field("NumberOfModuleTableEntries", x.nmodtab.get(endian));
+ p.field_hex("ExternalRefSymbolOffset", x.extrefsymoff.get(endian));
+ p.field("NumberOfExternalRefSymbols", x.nextrefsyms.get(endian));
+ p.field_hex("IndirectSymbolOffset", x.indirectsymoff.get(endian));
+ p.field("NumberOfIndirectSymbols", x.nindirectsyms.get(endian));
+ p.field_hex("ExternalRelocationOffset", x.extreloff.get(endian));
+ p.field("NumberOfExternalRelocations", x.nextrel.get(endian));
+ p.field_hex("LocalRelocationOffset", x.locreloff.get(endian));
+ p.field("NumberOfLocalRelocations", x.nlocrel.get(endian));
+ });
+ }
+ LoadCommandVariant::Dylib(x) | LoadCommandVariant::IdDylib(x) => {
+ p.group("DylibCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.group("Dylib", |p| {
+ p.field_string(
+ "Name",
+ x.dylib.name.offset.get(endian),
+ command.string(endian, x.dylib.name).ok(),
+ );
+ p.field("Timestamp", x.dylib.timestamp.get(endian));
+ p.field_hex("CurrentVersion", x.dylib.current_version.get(endian));
+ p.field_hex(
+ "CompatibilityVersion",
+ x.dylib.compatibility_version.get(endian),
+ );
+ });
+ });
+ }
+ LoadCommandVariant::LoadDylinker(x)
+ | LoadCommandVariant::IdDylinker(x)
+ | LoadCommandVariant::DyldEnvironment(x) => {
+ p.group("DylinkerCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_string(
+ "Name",
+ x.name.offset.get(endian),
+ command.string(endian, x.name).ok(),
+ );
+ });
+ }
+ LoadCommandVariant::PreboundDylib(x) => {
+ p.group("PreboundDylibCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_string(
+ "Name",
+ x.name.offset.get(endian),
+ command.string(endian, x.name).ok(),
+ );
+ p.field("NumberOfModules", x.nmodules.get(endian));
+ // TODO: display bit vector
+ p.field_hex("LinkedModules", x.linked_modules.offset.get(endian));
+ });
+ }
+ LoadCommandVariant::Routines32(x) => {
+ p.group("RoutinesCommand32", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("InitAddress", x.init_address.get(endian));
+ p.field_hex("InitModule", x.init_module.get(endian));
+ p.field_hex("Reserved1", x.reserved1.get(endian));
+ p.field_hex("Reserved2", x.reserved2.get(endian));
+ p.field_hex("Reserved3", x.reserved3.get(endian));
+ p.field_hex("Reserved4", x.reserved4.get(endian));
+ p.field_hex("Reserved5", x.reserved5.get(endian));
+ p.field_hex("Reserved6", x.reserved6.get(endian));
+ });
+ }
+ LoadCommandVariant::Routines64(x) => {
+ p.group("RoutinesCommand64", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("InitAddress", x.init_address.get(endian));
+ p.field_hex("InitModule", x.init_module.get(endian));
+ p.field_hex("Reserved1", x.reserved1.get(endian));
+ p.field_hex("Reserved2", x.reserved2.get(endian));
+ p.field_hex("Reserved3", x.reserved3.get(endian));
+ p.field_hex("Reserved4", x.reserved4.get(endian));
+ p.field_hex("Reserved5", x.reserved5.get(endian));
+ p.field_hex("Reserved6", x.reserved6.get(endian));
+ });
+ }
+ LoadCommandVariant::SubFramework(x) => {
+ p.group("SubFrameworkCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_string(
+ "Umbrella",
+ x.umbrella.offset.get(endian),
+ command.string(endian, x.umbrella).ok(),
+ );
+ });
+ }
+ LoadCommandVariant::SubUmbrella(x) => {
+ p.group("SubUmbrellaCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_string(
+ "SubUmbrella",
+ x.sub_umbrella.offset.get(endian),
+ command.string(endian, x.sub_umbrella).ok(),
+ );
+ });
+ }
+ LoadCommandVariant::SubClient(x) => {
+ p.group("SubClientCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_string(
+ "Client",
+ x.client.offset.get(endian),
+ command.string(endian, x.client).ok(),
+ );
+ });
+ }
+ LoadCommandVariant::SubLibrary(x) => {
+ p.group("SubLibraryCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_string(
+ "SubLibrary",
+ x.sub_library.offset.get(endian),
+ command.string(endian, x.sub_library).ok(),
+ );
+ });
+ }
+ LoadCommandVariant::TwolevelHints(x) => {
+ p.group("TwolevelHintsCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("Offset", x.offset.get(endian));
+ p.field_hex("NumberOfHints", x.nhints.get(endian));
+ // TODO: display hints
+ });
+ }
+ LoadCommandVariant::PrebindCksum(x) => {
+ p.group("PrebindCksumCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("Cksum", x.cksum.get(endian));
+ });
+ }
+ LoadCommandVariant::Uuid(x) => {
+ p.group("UuidCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field("Uuid", format!("{:X?}", x.uuid));
+ });
+ }
+ LoadCommandVariant::Rpath(x) => {
+ p.group("RpathCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_string(
+ "Path",
+ x.path.offset.get(endian),
+ command.string(endian, x.path).ok(),
+ );
+ });
+ }
+ LoadCommandVariant::LinkeditData(x) => {
+ p.group("LinkeditDataCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("DataOffset", x.dataoff.get(endian));
+ p.field_hex("DataSize", x.datasize.get(endian));
+ });
+ }
+ LoadCommandVariant::EncryptionInfo32(x) => {
+ p.group("EncryptionInfoCommand32", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("CryptOffset", x.cryptoff.get(endian));
+ p.field_hex("CryptSize", x.cryptsize.get(endian));
+ p.field_hex("CryptId", x.cryptid.get(endian));
+ });
+ }
+ LoadCommandVariant::EncryptionInfo64(x) => {
+ p.group("EncryptionInfoCommand64", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("CryptOffset", x.cryptoff.get(endian));
+ p.field_hex("CryptSize", x.cryptsize.get(endian));
+ p.field_hex("CryptId", x.cryptid.get(endian));
+ p.field_hex("Pad", x.pad.get(endian));
+ });
+ }
+ LoadCommandVariant::DyldInfo(x) => {
+ p.group("DyldInfoCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ // TODO: dump the tables these are all pointing to
+ p.field_hex("RebaseOffset", x.rebase_off.get(endian));
+ p.field_hex("RebaseSize", x.rebase_size.get(endian));
+ p.field_hex("BindOffset", x.bind_off.get(endian));
+ p.field_hex("BindSize", x.bind_size.get(endian));
+ p.field_hex("WeakBindOffset", x.weak_bind_off.get(endian));
+ p.field_hex("WeakBindSize", x.weak_bind_size.get(endian));
+ p.field_hex("LazyBindOffset", x.lazy_bind_off.get(endian));
+ p.field_hex("LazyBindSize", x.lazy_bind_size.get(endian));
+ p.field_hex("ExportOffset", x.export_off.get(endian));
+ p.field_hex("ExportSize", x.export_size.get(endian));
+ });
+ }
+ LoadCommandVariant::VersionMin(x) => {
+ p.group("VersionMinCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("Version", x.version.get(endian));
+ p.field_hex("Sdk", x.sdk.get(endian));
+ });
+ }
+ LoadCommandVariant::EntryPoint(x) => {
+ p.group("EntryPointCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("EntryOffset", x.entryoff.get(endian));
+ p.field_hex("StackSize", x.stacksize.get(endian));
+ });
+ }
+ LoadCommandVariant::SourceVersion(x) => {
+ p.group("SourceVersionCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("Version", x.version.get(endian));
+ });
+ }
+ LoadCommandVariant::LinkerOption(x) => {
+ p.group("LinkerOptionCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("Count", x.count.get(endian));
+ // TODO: dump strings
+ });
+ }
+ LoadCommandVariant::Note(x) => {
+ p.group("NoteCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ // TODO: string?
+ p.field("DataOwner", format!("{:X?}", x.data_owner));
+ p.field_hex("Offset", x.offset.get(endian));
+ p.field_hex("Size", x.size.get(endian));
+ });
+ }
+ LoadCommandVariant::BuildVersion(x) => {
+ p.group("BuildVersionCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_enum("Platform", x.platform.get(endian), FLAGS_PLATFORM);
+ p.field_hex("MinOs", x.minos.get(endian));
+ p.field_hex("Sdk", x.sdk.get(endian));
+ p.field_hex("NumberOfTools", x.ntools.get(endian));
+ // TODO: dump tools
+ });
+ }
+ LoadCommandVariant::FilesetEntry(x) => {
+ p.group("FilesetEntryCommand", |p| {
+ p.field_enum("Cmd", x.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", x.cmdsize.get(endian));
+ p.field_hex("VmAddress", x.vmaddr.get(endian));
+ p.field_hex("FileOffset", x.fileoff.get(endian));
+ p.field_string(
+ "EntryId",
+ x.entry_id.offset.get(endian),
+ command.string(endian, x.entry_id).ok(),
+ );
+ p.field_hex("Reserved", x.reserved.get(endian));
+ });
+ }
+ _ => {
+ p.group("LoadCommand", |p| {
+ p.field_enum("Cmd", command.cmd(), FLAGS_LC);
+ p.field_hex("CmdSize", command.cmdsize());
+ });
+ }
+ }
+ } else {
+ p.group("LoadCommand", |p| {
+ p.field_enum("Cmd", command.cmd(), FLAGS_LC);
+ p.field_hex("CmdSize", command.cmdsize());
+ });
+ }
+ }
+
+ fn print_segment<S: Segment>(
+ p: &mut Printer<impl Write>,
+ endian: S::Endian,
+ data: &[u8],
+ cputype: u32,
+ segment: &S,
+ section_data: &[u8],
+ state: &mut MachState,
+ ) {
+ p.group("SegmentCommand", |p| {
+ p.field_enum("Cmd", segment.cmd(endian), FLAGS_LC);
+ p.field_hex("CmdSize", segment.cmdsize(endian));
+ p.field_inline_string("SegmentName", segment.name());
+ p.field_hex("VmAddress", segment.vmaddr(endian).into());
+ p.field_hex("VmSize", segment.vmsize(endian).into());
+ p.field_hex("FileOffset", segment.fileoff(endian).into());
+ p.field_hex("FileSize", segment.filesize(endian).into());
+ p.field_hex("MaxProt", segment.maxprot(endian));
+ p.flags(segment.maxprot(endian), 0, FLAGS_VM);
+ p.field_hex("InitProt", segment.initprot(endian));
+ p.flags(segment.initprot(endian), 0, FLAGS_VM);
+ p.field("NumberOfSections", segment.nsects(endian));
+ p.field_hex("Flags", segment.flags(endian));
+ p.flags(segment.flags(endian), 0, FLAGS_SG);
+ if let Ok(sections) = segment.sections(endian, section_data) {
+ for section in sections {
+ print_section(p, endian, data, cputype, section, state);
+ }
+ }
+ });
+ }
+
+ fn print_section<S: Section>(
+ p: &mut Printer<impl Write>,
+ endian: S::Endian,
+ data: &[u8],
+ cputype: u32,
+ section: &S,
+ state: &mut MachState,
+ ) {
+ p.group("Section", |p| {
+ p.field("Index", state.section_index);
+ state.section_index += 1;
+ p.field_inline_string("SectionName", section.name());
+ p.field_inline_string("SegmentName", section.segment_name());
+ p.field_hex("Address", section.addr(endian).into());
+ p.field_hex("Size", section.size(endian).into());
+ p.field_hex("Offset", section.offset(endian));
+ p.field_hex("Align", section.align(endian));
+ p.field_hex("RelocationOffset", section.reloff(endian));
+ p.field_hex("NumberOfRelocations", section.nreloc(endian));
+ let flags = section.flags(endian);
+ if flags & SECTION_TYPE == flags {
+ p.field_enum("Flags", flags, FLAGS_S_TYPE);
+ } else {
+ p.field_hex("Flags", section.flags(endian));
+ p.flags(flags, SECTION_TYPE, FLAGS_S_TYPE);
+ p.flags(flags, 0, FLAGS_S_ATTR);
+ }
+ if let Ok(relocations) = section.relocations(endian, data) {
+ let proc = match cputype {
+ CPU_TYPE_X86 => FLAGS_GENERIC_RELOC,
+ CPU_TYPE_X86_64 => FLAGS_X86_64_RELOC,
+ CPU_TYPE_ARM => FLAGS_ARM_RELOC,
+ CPU_TYPE_ARM64 | CPU_TYPE_ARM64_32 => FLAGS_ARM64_RELOC,
+ CPU_TYPE_POWERPC | CPU_TYPE_POWERPC64 => FLAGS_PPC_RELOC,
+ _ => &[],
+ };
+ for relocation in relocations {
+ if relocation.r_scattered(endian, cputype) {
+ let info = relocation.scattered_info(endian);
+ p.group("ScatteredRelocationInfo", |p| {
+ p.field_hex("Address", info.r_address);
+ p.field("PcRel", if info.r_pcrel { "yes" } else { "no" });
+ p.field("Length", info.r_length);
+ p.field_enum("Type", info.r_type, proc);
+ p.field_hex("Value", info.r_value);
+ });
+ } else {
+ let info = relocation.info(endian);
+ p.group("RelocationInfo", |p| {
+ p.field_hex("Address", info.r_address);
+ if info.r_extern {
+ // TODO: symbol name
+ p.field("Symbol", info.r_symbolnum);
+ } else {
+ p.field("Section", info.r_symbolnum);
+ }
+ p.field("PcRel", if info.r_pcrel { "yes" } else { "no" });
+ p.field("Length", info.r_length);
+ p.field("Extern", if info.r_extern { "yes" } else { "no" });
+ p.field_enum("Type", info.r_type, proc);
+ });
+ }
+ }
+ }
+ });
+ }
+
+ fn print_symtab<Mach: MachHeader, W: Write>(
+ p: &mut Printer<W>,
+ endian: Mach::Endian,
+ data: &[u8],
+ symtab: &SymtabCommand<Mach::Endian>,
+ ) {
+ p.group("SymtabCommand", |p| {
+ p.field_enum("Cmd", symtab.cmd.get(endian), FLAGS_LC);
+ p.field_hex("CmdSize", symtab.cmdsize.get(endian));
+ p.field_hex("SymbolOffset", symtab.symoff.get(endian));
+ p.field_hex("NumberOfSymbols", symtab.nsyms.get(endian));
+ p.field_hex("StringOffset", symtab.stroff.get(endian));
+ p.field_hex("StringSize", symtab.strsize.get(endian));
+ if let Ok(symbols) = symtab.symbols::<Mach, _>(endian, data) {
+ for (index, nlist) in symbols.iter().enumerate() {
+ p.group("Nlist", |p| {
+ p.field("Index", index);
+ p.field_string(
+ "String",
+ nlist.n_strx(endian),
+ nlist.name(endian, symbols.strings()).ok(),
+ );
+ let n_type = nlist.n_type();
+ if nlist.is_stab() {
+ p.field_enum("Type", n_type, FLAGS_N_STAB);
+ } else if n_type & N_TYPE == n_type {
+ // Avoid an extra line if no flags.
+ p.field_enum("Type", n_type, FLAGS_N_TYPE);
+ } else {
+ p.field_hex("Type", n_type);
+ p.flags(n_type, N_TYPE, FLAGS_N_TYPE);
+ p.flags(n_type, 0, FLAGS_N_EXT);
+ }
+ p.field("Section", nlist.n_sect());
+ let n_desc = nlist.n_desc(endian);
+ p.field_hex("Desc", n_desc);
+ if nlist.is_undefined() {
+ p.flags(n_desc, REFERENCE_TYPE, FLAGS_REFERENCE);
+ }
+ if !nlist.is_stab() {
+ p.flags(n_desc, 0, FLAGS_N_DESC);
+ }
+ p.field_hex("Value", nlist.n_value(endian).into());
+ });
+ }
+ }
+ });
+ }
+
+ fn print_cputype(p: &mut Printer<impl Write>, cputype: u32, cpusubtype: u32) {
+ let proc = match cputype {
+ CPU_TYPE_ANY => FLAGS_CPU_SUBTYPE_ANY,
+ CPU_TYPE_VAX => FLAGS_CPU_SUBTYPE_VAX,
+ CPU_TYPE_MC680X0 => FLAGS_CPU_SUBTYPE_MC680X0,
+ CPU_TYPE_X86 => FLAGS_CPU_SUBTYPE_X86,
+ CPU_TYPE_X86_64 => FLAGS_CPU_SUBTYPE_X86_64,
+ CPU_TYPE_MIPS => FLAGS_CPU_SUBTYPE_MIPS,
+ CPU_TYPE_MC98000 => FLAGS_CPU_SUBTYPE_MC98000,
+ CPU_TYPE_HPPA => FLAGS_CPU_SUBTYPE_HPPA,
+ CPU_TYPE_ARM => FLAGS_CPU_SUBTYPE_ARM,
+ CPU_TYPE_ARM64 => FLAGS_CPU_SUBTYPE_ARM64,
+ CPU_TYPE_ARM64_32 => FLAGS_CPU_SUBTYPE_ARM64_32,
+ CPU_TYPE_MC88000 => FLAGS_CPU_SUBTYPE_MC88000,
+ CPU_TYPE_SPARC => FLAGS_CPU_SUBTYPE_SPARC,
+ CPU_TYPE_I860 => FLAGS_CPU_SUBTYPE_I860,
+ CPU_TYPE_POWERPC | CPU_TYPE_POWERPC64 => FLAGS_CPU_SUBTYPE_POWERPC,
+ _ => &[],
+ };
+ p.field_enum("CpuType", cputype, FLAGS_CPU_TYPE);
+ p.field_hex("CpuSubtype", cpusubtype);
+ p.flags(cpusubtype, !CPU_SUBTYPE_MASK, proc);
+ p.flags(cpusubtype, 0, FLAGS_CPU_SUBTYPE);
+ }
+
+ static FLAGS_CPU_TYPE: &[Flag<u32>] = &flags!(
+ CPU_TYPE_ANY,
+ CPU_TYPE_VAX,
+ CPU_TYPE_MC680X0,
+ CPU_TYPE_X86,
+ CPU_TYPE_X86_64,
+ CPU_TYPE_MIPS,
+ CPU_TYPE_MC98000,
+ CPU_TYPE_HPPA,
+ CPU_TYPE_ARM,
+ CPU_TYPE_ARM64,
+ CPU_TYPE_ARM64_32,
+ CPU_TYPE_MC88000,
+ CPU_TYPE_SPARC,
+ CPU_TYPE_I860,
+ CPU_TYPE_ALPHA,
+ CPU_TYPE_POWERPC,
+ CPU_TYPE_POWERPC64,
+ );
+ static FLAGS_CPU_SUBTYPE: &[Flag<u32>] = &flags!(CPU_SUBTYPE_LIB64);
+ static FLAGS_CPU_SUBTYPE_ANY: &[Flag<u32>] = &flags!(
+ CPU_SUBTYPE_MULTIPLE,
+ CPU_SUBTYPE_LITTLE_ENDIAN,
+ CPU_SUBTYPE_BIG_ENDIAN,
+ );
+ static FLAGS_CPU_SUBTYPE_VAX: &[Flag<u32>] = &flags!(
+ CPU_SUBTYPE_VAX_ALL,
+ CPU_SUBTYPE_VAX780,
+ CPU_SUBTYPE_VAX785,
+ CPU_SUBTYPE_VAX750,
+ CPU_SUBTYPE_VAX730,
+ CPU_SUBTYPE_UVAXI,
+ CPU_SUBTYPE_UVAXII,
+ CPU_SUBTYPE_VAX8200,
+ CPU_SUBTYPE_VAX8500,
+ CPU_SUBTYPE_VAX8600,
+ CPU_SUBTYPE_VAX8650,
+ CPU_SUBTYPE_VAX8800,
+ CPU_SUBTYPE_UVAXIII,
+ );
+ static FLAGS_CPU_SUBTYPE_MC680X0: &[Flag<u32>] = &flags!(
+ CPU_SUBTYPE_MC680X0_ALL,
+ CPU_SUBTYPE_MC68040,
+ CPU_SUBTYPE_MC68030_ONLY,
+ );
+ static FLAGS_CPU_SUBTYPE_X86: &[Flag<u32>] = &flags!(
+ CPU_SUBTYPE_I386_ALL,
+ CPU_SUBTYPE_386,
+ CPU_SUBTYPE_486,
+ CPU_SUBTYPE_486SX,
+ CPU_SUBTYPE_586,
+ CPU_SUBTYPE_PENT,
+ CPU_SUBTYPE_PENTPRO,
+ CPU_SUBTYPE_PENTII_M3,
+ CPU_SUBTYPE_PENTII_M5,
+ CPU_SUBTYPE_CELERON,
+ CPU_SUBTYPE_CELERON_MOBILE,
+ CPU_SUBTYPE_PENTIUM_3,
+ CPU_SUBTYPE_PENTIUM_3_M,
+ CPU_SUBTYPE_PENTIUM_3_XEON,
+ CPU_SUBTYPE_PENTIUM_M,
+ CPU_SUBTYPE_PENTIUM_4,
+ CPU_SUBTYPE_PENTIUM_4_M,
+ CPU_SUBTYPE_ITANIUM,
+ CPU_SUBTYPE_ITANIUM_2,
+ CPU_SUBTYPE_XEON,
+ CPU_SUBTYPE_XEON_MP,
+ );
+ static FLAGS_CPU_SUBTYPE_X86_64: &[Flag<u32>] = &flags!(
+ CPU_SUBTYPE_X86_64_ALL,
+ CPU_SUBTYPE_X86_ARCH1,
+ CPU_SUBTYPE_X86_64_H,
+ );
+ static FLAGS_CPU_SUBTYPE_MIPS: &[Flag<u32>] = &flags!(
+ CPU_SUBTYPE_MIPS_ALL,
+ CPU_SUBTYPE_MIPS_R2300,
+ CPU_SUBTYPE_MIPS_R2600,
+ CPU_SUBTYPE_MIPS_R2800,
+ CPU_SUBTYPE_MIPS_R2000A,
+ CPU_SUBTYPE_MIPS_R2000,
+ CPU_SUBTYPE_MIPS_R3000A,
+ CPU_SUBTYPE_MIPS_R3000,
+ );
+ static FLAGS_CPU_SUBTYPE_MC98000: &[Flag<u32>] =
+ &flags!(CPU_SUBTYPE_MC98000_ALL, CPU_SUBTYPE_MC98601);
+ static FLAGS_CPU_SUBTYPE_HPPA: &[Flag<u32>] =
+ &flags!(CPU_SUBTYPE_HPPA_ALL, CPU_SUBTYPE_HPPA_7100LC);
+ static FLAGS_CPU_SUBTYPE_MC88000: &[Flag<u32>] = &flags!(
+ CPU_SUBTYPE_MC88000_ALL,
+ CPU_SUBTYPE_MC88100,
+ CPU_SUBTYPE_MC88110,
+ );
+ static FLAGS_CPU_SUBTYPE_SPARC: &[Flag<u32>] = &flags!(CPU_SUBTYPE_SPARC_ALL);
+ static FLAGS_CPU_SUBTYPE_I860: &[Flag<u32>] =
+ &flags!(CPU_SUBTYPE_I860_ALL, CPU_SUBTYPE_I860_860);
+ static FLAGS_CPU_SUBTYPE_POWERPC: &[Flag<u32>] = &flags!(
+ CPU_SUBTYPE_POWERPC_ALL,
+ CPU_SUBTYPE_POWERPC_601,
+ CPU_SUBTYPE_POWERPC_602,
+ CPU_SUBTYPE_POWERPC_603,
+ CPU_SUBTYPE_POWERPC_603E,
+ CPU_SUBTYPE_POWERPC_603EV,
+ CPU_SUBTYPE_POWERPC_604,
+ CPU_SUBTYPE_POWERPC_604E,
+ CPU_SUBTYPE_POWERPC_620,
+ CPU_SUBTYPE_POWERPC_750,
+ CPU_SUBTYPE_POWERPC_7400,
+ CPU_SUBTYPE_POWERPC_7450,
+ CPU_SUBTYPE_POWERPC_970,
+ );
+ static FLAGS_CPU_SUBTYPE_ARM: &[Flag<u32>] = &flags!(
+ CPU_SUBTYPE_ARM_ALL,
+ CPU_SUBTYPE_ARM_V4T,
+ CPU_SUBTYPE_ARM_V6,
+ CPU_SUBTYPE_ARM_V5TEJ,
+ CPU_SUBTYPE_ARM_XSCALE,
+ CPU_SUBTYPE_ARM_V7,
+ CPU_SUBTYPE_ARM_V7F,
+ CPU_SUBTYPE_ARM_V7S,
+ CPU_SUBTYPE_ARM_V7K,
+ CPU_SUBTYPE_ARM_V8,
+ CPU_SUBTYPE_ARM_V6M,
+ CPU_SUBTYPE_ARM_V7M,
+ CPU_SUBTYPE_ARM_V7EM,
+ CPU_SUBTYPE_ARM_V8M,
+ );
+ static FLAGS_CPU_SUBTYPE_ARM64: &[Flag<u32>] = &flags!(
+ CPU_SUBTYPE_ARM64_ALL,
+ CPU_SUBTYPE_ARM64_V8,
+ CPU_SUBTYPE_ARM64E,
+ );
+ static FLAGS_CPU_SUBTYPE_ARM64_32: &[Flag<u32>] =
+ &flags!(CPU_SUBTYPE_ARM64_32_ALL, CPU_SUBTYPE_ARM64_32_V8);
+ static FLAGS_MH_FILETYPE: &[Flag<u32>] = &flags!(
+ MH_OBJECT,
+ MH_EXECUTE,
+ MH_FVMLIB,
+ MH_CORE,
+ MH_PRELOAD,
+ MH_DYLIB,
+ MH_DYLINKER,
+ MH_BUNDLE,
+ MH_DYLIB_STUB,
+ MH_DSYM,
+ MH_KEXT_BUNDLE,
+ MH_FILESET,
+ );
+ static FLAGS_MH: &[Flag<u32>] = &flags!(
+ MH_NOUNDEFS,
+ MH_INCRLINK,
+ MH_DYLDLINK,
+ MH_BINDATLOAD,
+ MH_PREBOUND,
+ MH_SPLIT_SEGS,
+ MH_LAZY_INIT,
+ MH_TWOLEVEL,
+ MH_FORCE_FLAT,
+ MH_NOMULTIDEFS,
+ MH_NOFIXPREBINDING,
+ MH_PREBINDABLE,
+ MH_ALLMODSBOUND,
+ MH_SUBSECTIONS_VIA_SYMBOLS,
+ MH_CANONICAL,
+ MH_WEAK_DEFINES,
+ MH_BINDS_TO_WEAK,
+ MH_ALLOW_STACK_EXECUTION,
+ MH_ROOT_SAFE,
+ MH_SETUID_SAFE,
+ MH_NO_REEXPORTED_DYLIBS,
+ MH_PIE,
+ MH_DEAD_STRIPPABLE_DYLIB,
+ MH_HAS_TLV_DESCRIPTORS,
+ MH_NO_HEAP_EXECUTION,
+ MH_APP_EXTENSION_SAFE,
+ MH_NLIST_OUTOFSYNC_WITH_DYLDINFO,
+ MH_SIM_SUPPORT,
+ MH_DYLIB_IN_CACHE,
+ );
+ static FLAGS_LC: &[Flag<u32>] = &flags!(
+ LC_SEGMENT,
+ LC_SYMTAB,
+ LC_SYMSEG,
+ LC_THREAD,
+ LC_UNIXTHREAD,
+ LC_LOADFVMLIB,
+ LC_IDFVMLIB,
+ LC_IDENT,
+ LC_FVMFILE,
+ LC_PREPAGE,
+ LC_DYSYMTAB,
+ LC_LOAD_DYLIB,
+ LC_ID_DYLIB,
+ LC_LOAD_DYLINKER,
+ LC_ID_DYLINKER,
+ LC_PREBOUND_DYLIB,
+ LC_ROUTINES,
+ LC_SUB_FRAMEWORK,
+ LC_SUB_UMBRELLA,
+ LC_SUB_CLIENT,
+ LC_SUB_LIBRARY,
+ LC_TWOLEVEL_HINTS,
+ LC_PREBIND_CKSUM,
+ LC_LOAD_WEAK_DYLIB,
+ LC_SEGMENT_64,
+ LC_ROUTINES_64,
+ LC_UUID,
+ LC_RPATH,
+ LC_CODE_SIGNATURE,
+ LC_SEGMENT_SPLIT_INFO,
+ LC_REEXPORT_DYLIB,
+ LC_LAZY_LOAD_DYLIB,
+ LC_ENCRYPTION_INFO,
+ LC_DYLD_INFO,
+ LC_DYLD_INFO_ONLY,
+ LC_LOAD_UPWARD_DYLIB,
+ LC_VERSION_MIN_MACOSX,
+ LC_VERSION_MIN_IPHONEOS,
+ LC_FUNCTION_STARTS,
+ LC_DYLD_ENVIRONMENT,
+ LC_MAIN,
+ LC_DATA_IN_CODE,
+ LC_SOURCE_VERSION,
+ LC_DYLIB_CODE_SIGN_DRS,
+ LC_ENCRYPTION_INFO_64,
+ LC_LINKER_OPTION,
+ LC_LINKER_OPTIMIZATION_HINT,
+ LC_VERSION_MIN_TVOS,
+ LC_VERSION_MIN_WATCHOS,
+ LC_NOTE,
+ LC_BUILD_VERSION,
+ LC_DYLD_EXPORTS_TRIE,
+ LC_DYLD_CHAINED_FIXUPS,
+ LC_FILESET_ENTRY,
+ );
+ static FLAGS_VM: &[Flag<u32>] = &flags!(VM_PROT_READ, VM_PROT_WRITE, VM_PROT_EXECUTE);
+ static FLAGS_SG: &[Flag<u32>] = &flags!(
+ SG_HIGHVM,
+ SG_FVMLIB,
+ SG_NORELOC,
+ SG_PROTECTED_VERSION_1,
+ SG_READ_ONLY,
+ );
+ static FLAGS_S_TYPE: &[Flag<u32>] = &flags!(
+ S_REGULAR,
+ S_ZEROFILL,
+ S_CSTRING_LITERALS,
+ S_4BYTE_LITERALS,
+ S_8BYTE_LITERALS,
+ S_LITERAL_POINTERS,
+ S_NON_LAZY_SYMBOL_POINTERS,
+ S_LAZY_SYMBOL_POINTERS,
+ S_SYMBOL_STUBS,
+ S_MOD_INIT_FUNC_POINTERS,
+ S_MOD_TERM_FUNC_POINTERS,
+ S_COALESCED,
+ S_GB_ZEROFILL,
+ S_INTERPOSING,
+ S_16BYTE_LITERALS,
+ S_DTRACE_DOF,
+ S_LAZY_DYLIB_SYMBOL_POINTERS,
+ S_THREAD_LOCAL_REGULAR,
+ S_THREAD_LOCAL_ZEROFILL,
+ S_THREAD_LOCAL_VARIABLES,
+ S_THREAD_LOCAL_VARIABLE_POINTERS,
+ S_THREAD_LOCAL_INIT_FUNCTION_POINTERS,
+ S_INIT_FUNC_OFFSETS,
+ );
+ static FLAGS_S_ATTR: &[Flag<u32>] = &flags!(
+ S_ATTR_PURE_INSTRUCTIONS,
+ S_ATTR_NO_TOC,
+ S_ATTR_STRIP_STATIC_SYMS,
+ S_ATTR_NO_DEAD_STRIP,
+ S_ATTR_LIVE_SUPPORT,
+ S_ATTR_SELF_MODIFYING_CODE,
+ S_ATTR_DEBUG,
+ S_ATTR_SOME_INSTRUCTIONS,
+ S_ATTR_EXT_RELOC,
+ S_ATTR_LOC_RELOC,
+ );
+ static FLAGS_PLATFORM: &[Flag<u32>] = &flags!(
+ PLATFORM_MACOS,
+ PLATFORM_IOS,
+ PLATFORM_TVOS,
+ PLATFORM_WATCHOS,
+ PLATFORM_BRIDGEOS,
+ PLATFORM_MACCATALYST,
+ PLATFORM_IOSSIMULATOR,
+ PLATFORM_TVOSSIMULATOR,
+ PLATFORM_WATCHOSSIMULATOR,
+ PLATFORM_DRIVERKIT,
+ );
+ static FLAGS_N_EXT: &[Flag<u8>] = &flags!(N_PEXT, N_EXT);
+ static FLAGS_N_TYPE: &[Flag<u8>] = &flags!(N_UNDF, N_ABS, N_SECT, N_PBUD, N_INDR);
+ static FLAGS_N_STAB: &[Flag<u8>] = &flags!(
+ N_GSYM, N_FNAME, N_FUN, N_STSYM, N_LCSYM, N_BNSYM, N_AST, N_OPT, N_RSYM, N_SLINE, N_ENSYM,
+ N_SSYM, N_SO, N_OSO, N_LSYM, N_BINCL, N_SOL, N_PARAMS, N_VERSION, N_OLEVEL, N_PSYM,
+ N_EINCL, N_ENTRY, N_LBRAC, N_EXCL, N_RBRAC, N_BCOMM, N_ECOMM, N_ECOML, N_LENG, N_PC,
+ );
+ static FLAGS_REFERENCE: &[Flag<u16>] = &flags!(
+ REFERENCE_FLAG_UNDEFINED_NON_LAZY,
+ REFERENCE_FLAG_UNDEFINED_LAZY,
+ REFERENCE_FLAG_DEFINED,
+ REFERENCE_FLAG_PRIVATE_DEFINED,
+ REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY,
+ REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY,
+ );
+ static FLAGS_N_DESC: &[Flag<u16>] = &flags!(
+ REFERENCED_DYNAMICALLY,
+ N_NO_DEAD_STRIP,
+ N_DESC_DISCARDED,
+ N_WEAK_REF,
+ N_WEAK_DEF,
+ N_REF_TO_WEAK,
+ N_ARM_THUMB_DEF,
+ N_SYMBOL_RESOLVER,
+ N_ALT_ENTRY,
+ );
+ static FLAGS_GENERIC_RELOC: &[Flag<u8>] = &flags!(
+ GENERIC_RELOC_VANILLA,
+ GENERIC_RELOC_PAIR,
+ GENERIC_RELOC_SECTDIFF,
+ GENERIC_RELOC_PB_LA_PTR,
+ GENERIC_RELOC_LOCAL_SECTDIFF,
+ GENERIC_RELOC_TLV,
+ );
+ static FLAGS_ARM_RELOC: &[Flag<u8>] = &flags!(
+ ARM_RELOC_VANILLA,
+ ARM_RELOC_PAIR,
+ ARM_RELOC_SECTDIFF,
+ ARM_RELOC_LOCAL_SECTDIFF,
+ ARM_RELOC_PB_LA_PTR,
+ ARM_RELOC_BR24,
+ ARM_THUMB_RELOC_BR22,
+ ARM_THUMB_32BIT_BRANCH,
+ ARM_RELOC_HALF,
+ ARM_RELOC_HALF_SECTDIFF,
+ );
+ static FLAGS_ARM64_RELOC: &[Flag<u8>] = &flags!(
+ ARM64_RELOC_UNSIGNED,
+ ARM64_RELOC_SUBTRACTOR,
+ ARM64_RELOC_BRANCH26,
+ ARM64_RELOC_PAGE21,
+ ARM64_RELOC_PAGEOFF12,
+ ARM64_RELOC_GOT_LOAD_PAGE21,
+ ARM64_RELOC_GOT_LOAD_PAGEOFF12,
+ ARM64_RELOC_POINTER_TO_GOT,
+ ARM64_RELOC_TLVP_LOAD_PAGE21,
+ ARM64_RELOC_TLVP_LOAD_PAGEOFF12,
+ ARM64_RELOC_ADDEND,
+ ARM64_RELOC_AUTHENTICATED_POINTER,
+ );
+ static FLAGS_PPC_RELOC: &[Flag<u8>] = &flags!(
+ PPC_RELOC_VANILLA,
+ PPC_RELOC_PAIR,
+ PPC_RELOC_BR14,
+ PPC_RELOC_BR24,
+ PPC_RELOC_HI16,
+ PPC_RELOC_LO16,
+ PPC_RELOC_HA16,
+ PPC_RELOC_LO14,
+ PPC_RELOC_SECTDIFF,
+ PPC_RELOC_PB_LA_PTR,
+ PPC_RELOC_HI16_SECTDIFF,
+ PPC_RELOC_LO16_SECTDIFF,
+ PPC_RELOC_HA16_SECTDIFF,
+ PPC_RELOC_JBSR,
+ PPC_RELOC_LO14_SECTDIFF,
+ PPC_RELOC_LOCAL_SECTDIFF,
+ );
+ static FLAGS_X86_64_RELOC: &[Flag<u8>] = &flags!(
+ X86_64_RELOC_UNSIGNED,
+ X86_64_RELOC_SIGNED,
+ X86_64_RELOC_BRANCH,
+ X86_64_RELOC_GOT_LOAD,
+ X86_64_RELOC_GOT,
+ X86_64_RELOC_SUBTRACTOR,
+ X86_64_RELOC_SIGNED_1,
+ X86_64_RELOC_SIGNED_2,
+ X86_64_RELOC_SIGNED_4,
+ X86_64_RELOC_TLV,
+ );
+}
+
+mod pe {
+ use super::*;
+ use object::pe::*;
+ use object::read::pe::*;
+ use object::LittleEndian as LE;
+
+ pub(super) fn print_coff(p: &mut Printer<impl Write>, data: &[u8]) {
+ let mut offset = 0;
+ if let Ok(header) = ImageFileHeader::parse(data, &mut offset) {
+ println!("Format: COFF");
+ print_file(p, header);
+ let sections = header.sections(data, offset).ok();
+ let symbols = header.symbols(data).ok();
+ if let Some(ref sections) = sections {
+ print_sections(p, data, header.machine.get(LE), symbols.as_ref(), &sections);
+ }
+ if let Some(ref symbols) = symbols {
+ print_symbols(p, sections.as_ref(), &symbols);
+ }
+ }
+ }
+
+ pub(super) fn print_pe32(p: &mut Printer<impl Write>, data: &[u8]) {
+ println!("Format: PE 32-bit");
+ print_pe::<ImageNtHeaders32, _>(p, data);
+ }
+
+ pub(super) fn print_pe64(p: &mut Printer<impl Write>, data: &[u8]) {
+ println!("Format: PE 64-bit");
+ print_pe::<ImageNtHeaders64, _>(p, data);
+ }
+
+ fn print_pe<Pe: ImageNtHeaders, W: Write>(p: &mut Printer<W>, data: &[u8]) {
+ if let Ok(dos_header) = ImageDosHeader::parse(data) {
+ p.group("ImageDosHeader", |p| {
+ p.field_hex("Magic", dos_header.e_magic.get(LE));
+ p.field_hex("CountBytesLastPage", dos_header.e_cblp.get(LE));
+ p.field_hex("CountPages", dos_header.e_cp.get(LE));
+ p.field_hex("CountRelocations", dos_header.e_crlc.get(LE));
+ p.field_hex("CountHeaderParagraphs", dos_header.e_cparhdr.get(LE));
+ p.field_hex("MinAllocParagraphs", dos_header.e_minalloc.get(LE));
+ p.field_hex("MaxAllocParagraphs", dos_header.e_maxalloc.get(LE));
+ p.field_hex("StackSegment", dos_header.e_ss.get(LE));
+ p.field_hex("StackPointer", dos_header.e_sp.get(LE));
+ p.field_hex("Checksum", dos_header.e_csum.get(LE));
+ p.field_hex("InstructionPointer", dos_header.e_ip.get(LE));
+ p.field_hex("CodeSegment", dos_header.e_cs.get(LE));
+ p.field_hex("AddressOfRelocations", dos_header.e_lfarlc.get(LE));
+ p.field_hex("OverlayNumber", dos_header.e_ovno.get(LE));
+ p.field_hex("OemId", dos_header.e_oemid.get(LE));
+ p.field_hex("OemInfo", dos_header.e_oeminfo.get(LE));
+ p.field_hex("AddressOfNewHeader", dos_header.e_lfanew.get(LE));
+ });
+ let mut offset = dos_header.nt_headers_offset().into();
+ if let Ok((nt_headers, data_directories)) = Pe::parse(data, &mut offset) {
+ p.group("ImageNtHeaders", |p| {
+ p.field_hex("Signature", nt_headers.signature());
+ });
+ let header = nt_headers.file_header();
+ let sections = header.sections(data, offset).ok();
+ let symbols = header.symbols(data).ok();
+ print_file(p, header);
+ print_optional(p, nt_headers.optional_header());
+ for (index, dir) in data_directories.iter().enumerate() {
+ p.group("ImageDataDirectory", |p| {
+ p.field_enum("Index", index, FLAGS_IMAGE_DIRECTORY_ENTRY);
+ p.field_hex("VirtualAddress", dir.virtual_address.get(LE));
+ p.field_hex("Size", dir.size.get(LE));
+ if let Some(dir_data) = sections
+ .as_ref()
+ .and_then(|sections| dir.data(data, sections).ok())
+ {
+ match index {
+ IMAGE_DIRECTORY_ENTRY_EXPORT => print_export_dir(p, dir, dir_data),
+ // TODO
+ _ => {}
+ }
+ }
+ });
+ }
+ if let Some(ref sections) = sections {
+ print_sections(p, data, header.machine.get(LE), symbols.as_ref(), &sections);
+ }
+ if let Some(ref symbols) = symbols {
+ print_symbols(p, sections.as_ref(), &symbols);
+ }
+ }
+ }
+ }
+
+ fn print_file(p: &mut Printer<impl Write>, header: &ImageFileHeader) {
+ p.group("ImageFileHeader", |p| {
+ p.field_enum("Machine", header.machine.get(LE), FLAGS_IMAGE_FILE_MACHINE);
+ p.field("NumberOfSections", header.number_of_sections.get(LE));
+ p.field("TimeDateStamp", header.time_date_stamp.get(LE));
+ p.field_hex(
+ "PointerToSymbolTable",
+ header.pointer_to_symbol_table.get(LE),
+ );
+ p.field("NumberOfSymbols", header.number_of_symbols.get(LE));
+ p.field_hex(
+ "SizeOfOptionalHeader",
+ header.size_of_optional_header.get(LE),
+ );
+ p.field_hex("Characteristics", header.characteristics.get(LE));
+ p.flags(header.characteristics.get(LE), 0, FLAGS_IMAGE_FILE);
+ });
+ }
+
+ fn print_optional(p: &mut Printer<impl Write>, header: &impl ImageOptionalHeader) {
+ p.group("ImageOptionalHeader", |p| {
+ p.field_hex("Magic", header.magic());
+ p.field("MajorLinkerVersion", header.major_linker_version());
+ p.field("MinorLinkerVersion", header.minor_linker_version());
+ p.field_hex("SizeOfCode", header.size_of_code());
+ p.field_hex("SizeOfInitializedData", header.size_of_initialized_data());
+ p.field_hex(
+ "SizeOfUninitializedData",
+ header.size_of_uninitialized_data(),
+ );
+ p.field_hex("AddressOfEntryPoint", header.address_of_entry_point());
+ p.field_hex("BaseOfCode", header.base_of_code());
+ p.field_hex("ImageBase", header.image_base());
+ p.field_hex("SectionAlignment", header.section_alignment());
+ p.field(
+ "MajorOperatingSystemVersion",
+ header.major_operating_system_version(),
+ );
+ p.field(
+ "MinorOperatingSystemVersion",
+ header.minor_operating_system_version(),
+ );
+ p.field("MajorImageVersion", header.major_image_version());
+ p.field("MinorImageVersion", header.minor_image_version());
+ p.field("MajorSubsystemVersion", header.major_subsystem_version());
+ p.field("MinorSubsystemVersion", header.minor_subsystem_version());
+ p.field("Win32VersionValue", header.win32_version_value());
+ p.field_hex("SizeOfImage", header.size_of_image());
+ p.field_hex("SizeOfHeaders", header.size_of_headers());
+ p.field_hex("CheckSum", header.check_sum());
+ p.field_enum("Subsystem", header.subsystem(), FLAGS_IMAGE_SUBSYSTEM);
+ p.field_hex("DllCharacteristics", header.dll_characteristics());
+ p.flags(
+ header.dll_characteristics(),
+ 0,
+ FLAGS_IMAGE_DLLCHARACTERISTICS,
+ );
+ p.field_hex("SizeOfStackReserve", header.size_of_stack_reserve());
+ p.field_hex("SizeOfStackCommit", header.size_of_stack_commit());
+ p.field_hex("SizeOfHeapReserve", header.size_of_heap_reserve());
+ p.field_hex("SizeOfHeapCommit", header.size_of_heap_commit());
+ p.field_hex("LoaderFlags", header.loader_flags());
+ p.field_hex("NumberOfRvaAndSizes", header.number_of_rva_and_sizes());
+ });
+ }
+
+ fn print_export_dir(p: &mut Printer<impl Write>, _dir: &ImageDataDirectory, dir_data: &[u8]) {
+ if let Ok((export_dir, _)) = object::from_bytes::<pe::ImageExportDirectory>(dir_data) {
+ p.group("ImageExportDirectory", |p| {
+ p.field_hex("Characteristics", export_dir.characteristics.get(LE));
+ p.field_hex("TimeDateStamp", export_dir.time_date_stamp.get(LE));
+ p.field("MajorVersion", export_dir.major_version.get(LE));
+ p.field("MinorVersion", export_dir.minor_version.get(LE));
+ p.field_hex("Name", export_dir.name.get(LE));
+ p.field("Base", export_dir.base.get(LE));
+ p.field("NumberOfFunctions", export_dir.number_of_functions.get(LE));
+ p.field("NumberOfNames", export_dir.number_of_names.get(LE));
+ p.field_hex(
+ "AddressOfFunctions",
+ export_dir.address_of_functions.get(LE),
+ );
+ p.field_hex("AddressOfNames", export_dir.address_of_names.get(LE));
+ p.field_hex(
+ "AddressOfNameOrdinals",
+ export_dir.address_of_name_ordinals.get(LE),
+ );
+ // TODO: display tables
+ });
+ }
+ }
+
+ fn print_sections(
+ p: &mut Printer<impl Write>,
+ data: &[u8],
+ machine: u16,
+ symbols: Option<&SymbolTable>,
+ sections: &SectionTable,
+ ) {
+ for (index, section) in sections.iter().enumerate() {
+ p.group("ImageSectionHeader", |p| {
+ p.field("Index", index + 1);
+ if let Some(name) = symbols.and_then(|symbols| section.name(symbols.strings()).ok())
+ {
+ p.field_inline_string("Name", name);
+ } else {
+ p.field_inline_string("Name", section.raw_name());
+ }
+ p.field_hex("VirtualSize", section.virtual_size.get(LE));
+ p.field_hex("VirtualAddress", section.virtual_address.get(LE));
+ p.field_hex("SizeOfRawData", section.size_of_raw_data.get(LE));
+ p.field_hex("PointerToRawData", section.pointer_to_raw_data.get(LE));
+ p.field_hex(
+ "PointerToRelocations",
+ section.pointer_to_relocations.get(LE),
+ );
+ p.field_hex(
+ "PointerToLinenumbers",
+ section.pointer_to_linenumbers.get(LE),
+ );
+ p.field("NumberOfRelocations", section.number_of_relocations.get(LE));
+ p.field("NumberOfLinenumbers", section.number_of_linenumbers.get(LE));
+ p.field_hex("Characteristics", section.characteristics.get(LE));
+ p.flags(section.characteristics.get(LE), 0, FLAGS_IMAGE_SCN);
+ p.flags(
+ section.characteristics.get(LE),
+ IMAGE_SCN_ALIGN_MASK,
+ FLAGS_IMAGE_SCN_ALIGN,
+ );
+ if let Ok(relocations) = section.coff_relocations(data) {
+ for relocation in relocations {
+ p.group("ImageRelocation", |p| {
+ p.field_hex("VirtualAddress", relocation.virtual_address.get(LE));
+ let index = relocation.symbol_table_index.get(LE);
+ let name = symbols.and_then(|symbols| {
+ symbols
+ .symbol(index as usize)
+ .and_then(|symbol| symbol.name(symbols.strings()))
+ .ok()
+ });
+ p.field_string("Symbol", index, name);
+ let proc = match machine {
+ IMAGE_FILE_MACHINE_I386 => FLAGS_IMAGE_REL_I386,
+ IMAGE_FILE_MACHINE_MIPS16
+ | IMAGE_FILE_MACHINE_MIPSFPU
+ | IMAGE_FILE_MACHINE_MIPSFPU16 => FLAGS_IMAGE_REL_MIPS,
+ IMAGE_FILE_MACHINE_ALPHA | IMAGE_FILE_MACHINE_ALPHA64 => {
+ FLAGS_IMAGE_REL_ALPHA
+ }
+ IMAGE_FILE_MACHINE_POWERPC | IMAGE_FILE_MACHINE_POWERPCFP => {
+ FLAGS_IMAGE_REL_PPC
+ }
+ IMAGE_FILE_MACHINE_SH3
+ | IMAGE_FILE_MACHINE_SH3DSP
+ | IMAGE_FILE_MACHINE_SH3E
+ | IMAGE_FILE_MACHINE_SH4
+ | IMAGE_FILE_MACHINE_SH5 => FLAGS_IMAGE_REL_SH,
+ IMAGE_FILE_MACHINE_ARM => FLAGS_IMAGE_REL_ARM,
+ IMAGE_FILE_MACHINE_AM33 => FLAGS_IMAGE_REL_AM,
+ IMAGE_FILE_MACHINE_ARM64 => FLAGS_IMAGE_REL_ARM64,
+ IMAGE_FILE_MACHINE_AMD64 => FLAGS_IMAGE_REL_AMD64,
+ IMAGE_FILE_MACHINE_IA64 => FLAGS_IMAGE_REL_IA64,
+ IMAGE_FILE_MACHINE_CEF => FLAGS_IMAGE_REL_CEF,
+ IMAGE_FILE_MACHINE_CEE => FLAGS_IMAGE_REL_CEE,
+ IMAGE_FILE_MACHINE_M32R => FLAGS_IMAGE_REL_M32R,
+ IMAGE_FILE_MACHINE_EBC => FLAGS_IMAGE_REL_EBC,
+ _ => &[],
+ };
+ let typ = relocation.typ.get(LE);
+ p.field_enum("Type", typ, proc);
+ match machine {
+ IMAGE_FILE_MACHINE_POWERPC | IMAGE_FILE_MACHINE_POWERPCFP => {
+ p.flags(typ, 0, FLAGS_IMAGE_REL_PPC_BITS)
+ }
+ IMAGE_FILE_MACHINE_SH3
+ | IMAGE_FILE_MACHINE_SH3DSP
+ | IMAGE_FILE_MACHINE_SH3E
+ | IMAGE_FILE_MACHINE_SH4
+ | IMAGE_FILE_MACHINE_SH5 => {
+ p.flags(typ, 0, FLAGS_IMAGE_REL_SH_BITS)
+ }
+ _ => {}
+ }
+ });
+ }
+ }
+ });
+ }
+ }
+
+ fn print_symbols(
+ p: &mut Printer<impl Write>,
+ sections: Option<&SectionTable>,
+ symbols: &SymbolTable,
+ ) {
+ for (index, symbol) in symbols.iter() {
+ p.group("ImageSymbol", |p| {
+ p.field("Index", index);
+ if let Ok(name) = symbol.name(symbols.strings()) {
+ p.field_inline_string("Name", name);
+ } else {
+ p.field("Name", format!("{:X?}", symbol.name));
+ }
+ p.field_hex("Value", symbol.value.get(LE));
+ let section = symbol.section_number.get(LE);
+ if section == 0 || section >= IMAGE_SYM_SECTION_MAX {
+ p.field_enum("Section", section, FLAGS_IMAGE_SYM);
+ } else {
+ let section_name = sections.and_then(|sections| {
+ sections
+ .section(section.into())
+ .and_then(|section| section.name(symbols.strings()))
+ .ok()
+ });
+ p.field_string("Section", section, section_name);
+ }
+ p.field_hex("Type", symbol.typ.get(LE));
+ p.field_enum("BaseType", symbol.base_type(), FLAGS_IMAGE_SYM_TYPE);
+ p.field_enum("DerivedType", symbol.derived_type(), FLAGS_IMAGE_SYM_DTYPE);
+ p.field_enum("StorageClass", symbol.storage_class, FLAGS_IMAGE_SYM_CLASS);
+ p.field_hex("NumberOfAuxSymbols", symbol.number_of_aux_symbols);
+ if symbol.has_aux_file_name() {
+ if let Ok(name) = symbols.aux_file_name(index, symbol.number_of_aux_symbols) {
+ p.group("ImageAuxSymbolFile", |p| {
+ p.field_inline_string("Name", name);
+ });
+ }
+ } else if symbol.has_aux_function() {
+ if let Ok(aux) = symbols.aux_function(index) {
+ p.group("ImageAuxSymbolFunction", |p| {
+ p.field("TagIndex", aux.tag_index.get(LE));
+ p.field("TotalSize", aux.total_size.get(LE));
+ p.field_hex("PointerToLinenumber", aux.pointer_to_linenumber.get(LE));
+ p.field(
+ "PointerToNextFunction",
+ aux.pointer_to_next_function.get(LE),
+ );
+ p.field("Unused", format!("{:X?}", aux.unused));
+ });
+ }
+ } else if symbol.has_aux_section() {
+ if let Ok(aux) = symbols.aux_section(index) {
+ p.group("ImageAuxSymbolSection", |p| {
+ p.field_hex("Length", aux.length.get(LE));
+ p.field("NumberOfRelocations", aux.number_of_relocations.get(LE));
+ p.field("NumberOfLinenumbers", aux.number_of_linenumbers.get(LE));
+ p.field_hex("CheckSum", aux.check_sum.get(LE));
+ p.field("Number", aux.number.get(LE));
+ p.field_enum("Selection", aux.selection, FLAGS_IMAGE_COMDAT_SELECT);
+ p.field_hex("Reserved", aux.reserved);
+ p.field("HighNumber", aux.high_number.get(LE));
+ });
+ }
+ }
+ // TODO: ImageAuxSymbolFunctionBeginEnd
+ // TODO: ImageAuxSymbolWeak
+ });
+ }
+ }
+
+ static FLAGS_IMAGE_FILE: &[Flag<u16>] = &flags!(
+ IMAGE_FILE_RELOCS_STRIPPED,
+ IMAGE_FILE_EXECUTABLE_IMAGE,
+ IMAGE_FILE_LINE_NUMS_STRIPPED,
+ IMAGE_FILE_LOCAL_SYMS_STRIPPED,
+ IMAGE_FILE_AGGRESIVE_WS_TRIM,
+ IMAGE_FILE_LARGE_ADDRESS_AWARE,
+ IMAGE_FILE_BYTES_REVERSED_LO,
+ IMAGE_FILE_32BIT_MACHINE,
+ IMAGE_FILE_DEBUG_STRIPPED,
+ IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP,
+ IMAGE_FILE_NET_RUN_FROM_SWAP,
+ IMAGE_FILE_SYSTEM,
+ IMAGE_FILE_DLL,
+ IMAGE_FILE_UP_SYSTEM_ONLY,
+ IMAGE_FILE_BYTES_REVERSED_HI,
+ );
+ static FLAGS_IMAGE_FILE_MACHINE: &[Flag<u16>] = &flags!(
+ IMAGE_FILE_MACHINE_UNKNOWN,
+ IMAGE_FILE_MACHINE_TARGET_HOST,
+ IMAGE_FILE_MACHINE_I386,
+ IMAGE_FILE_MACHINE_R3000,
+ IMAGE_FILE_MACHINE_R4000,
+ IMAGE_FILE_MACHINE_R10000,
+ IMAGE_FILE_MACHINE_WCEMIPSV2,
+ IMAGE_FILE_MACHINE_ALPHA,
+ IMAGE_FILE_MACHINE_SH3,
+ IMAGE_FILE_MACHINE_SH3DSP,
+ IMAGE_FILE_MACHINE_SH3E,
+ IMAGE_FILE_MACHINE_SH4,
+ IMAGE_FILE_MACHINE_SH5,
+ IMAGE_FILE_MACHINE_ARM,
+ IMAGE_FILE_MACHINE_THUMB,
+ IMAGE_FILE_MACHINE_ARMNT,
+ IMAGE_FILE_MACHINE_AM33,
+ IMAGE_FILE_MACHINE_POWERPC,
+ IMAGE_FILE_MACHINE_POWERPCFP,
+ IMAGE_FILE_MACHINE_IA64,
+ IMAGE_FILE_MACHINE_MIPS16,
+ IMAGE_FILE_MACHINE_ALPHA64,
+ IMAGE_FILE_MACHINE_MIPSFPU,
+ IMAGE_FILE_MACHINE_MIPSFPU16,
+ IMAGE_FILE_MACHINE_AXP64,
+ IMAGE_FILE_MACHINE_TRICORE,
+ IMAGE_FILE_MACHINE_CEF,
+ IMAGE_FILE_MACHINE_EBC,
+ IMAGE_FILE_MACHINE_AMD64,
+ IMAGE_FILE_MACHINE_M32R,
+ IMAGE_FILE_MACHINE_ARM64,
+ IMAGE_FILE_MACHINE_CEE,
+ IMAGE_FILE_MACHINE_RISCV32,
+ IMAGE_FILE_MACHINE_RISCV64,
+ IMAGE_FILE_MACHINE_RISCV128,
+ );
+ static FLAGS_IMAGE_SCN: &[Flag<u32>] = &flags!(
+ IMAGE_SCN_TYPE_NO_PAD,
+ IMAGE_SCN_CNT_CODE,
+ IMAGE_SCN_CNT_INITIALIZED_DATA,
+ IMAGE_SCN_CNT_UNINITIALIZED_DATA,
+ IMAGE_SCN_LNK_OTHER,
+ IMAGE_SCN_LNK_INFO,
+ IMAGE_SCN_LNK_REMOVE,
+ IMAGE_SCN_LNK_COMDAT,
+ IMAGE_SCN_NO_DEFER_SPEC_EXC,
+ IMAGE_SCN_GPREL,
+ IMAGE_SCN_MEM_FARDATA,
+ IMAGE_SCN_MEM_PURGEABLE,
+ IMAGE_SCN_MEM_16BIT,
+ IMAGE_SCN_MEM_LOCKED,
+ IMAGE_SCN_MEM_PRELOAD,
+ IMAGE_SCN_LNK_NRELOC_OVFL,
+ IMAGE_SCN_MEM_DISCARDABLE,
+ IMAGE_SCN_MEM_NOT_CACHED,
+ IMAGE_SCN_MEM_NOT_PAGED,
+ IMAGE_SCN_MEM_SHARED,
+ IMAGE_SCN_MEM_EXECUTE,
+ IMAGE_SCN_MEM_READ,
+ IMAGE_SCN_MEM_WRITE,
+ );
+ static FLAGS_IMAGE_SCN_ALIGN: &[Flag<u32>] = &flags!(
+ IMAGE_SCN_ALIGN_1BYTES,
+ IMAGE_SCN_ALIGN_2BYTES,
+ IMAGE_SCN_ALIGN_4BYTES,
+ IMAGE_SCN_ALIGN_8BYTES,
+ IMAGE_SCN_ALIGN_16BYTES,
+ IMAGE_SCN_ALIGN_32BYTES,
+ IMAGE_SCN_ALIGN_64BYTES,
+ IMAGE_SCN_ALIGN_128BYTES,
+ IMAGE_SCN_ALIGN_256BYTES,
+ IMAGE_SCN_ALIGN_512BYTES,
+ IMAGE_SCN_ALIGN_1024BYTES,
+ IMAGE_SCN_ALIGN_2048BYTES,
+ IMAGE_SCN_ALIGN_4096BYTES,
+ IMAGE_SCN_ALIGN_8192BYTES,
+ );
+ static FLAGS_IMAGE_REL_I386: &[Flag<u16>] = &flags!(
+ IMAGE_REL_I386_ABSOLUTE,
+ IMAGE_REL_I386_DIR16,
+ IMAGE_REL_I386_REL16,
+ IMAGE_REL_I386_DIR32,
+ IMAGE_REL_I386_DIR32NB,
+ IMAGE_REL_I386_SEG12,
+ IMAGE_REL_I386_SECTION,
+ IMAGE_REL_I386_SECREL,
+ IMAGE_REL_I386_TOKEN,
+ IMAGE_REL_I386_SECREL7,
+ IMAGE_REL_I386_REL32,
+ );
+ static FLAGS_IMAGE_REL_MIPS: &[Flag<u16>] = &flags!(
+ IMAGE_REL_MIPS_ABSOLUTE,
+ IMAGE_REL_MIPS_REFHALF,
+ IMAGE_REL_MIPS_REFWORD,
+ IMAGE_REL_MIPS_JMPADDR,
+ IMAGE_REL_MIPS_REFHI,
+ IMAGE_REL_MIPS_REFLO,
+ IMAGE_REL_MIPS_GPREL,
+ IMAGE_REL_MIPS_LITERAL,
+ IMAGE_REL_MIPS_SECTION,
+ IMAGE_REL_MIPS_SECREL,
+ IMAGE_REL_MIPS_SECRELLO,
+ IMAGE_REL_MIPS_SECRELHI,
+ IMAGE_REL_MIPS_TOKEN,
+ IMAGE_REL_MIPS_JMPADDR16,
+ IMAGE_REL_MIPS_REFWORDNB,
+ IMAGE_REL_MIPS_PAIR,
+ );
+ static FLAGS_IMAGE_REL_ALPHA: &[Flag<u16>] = &flags!(
+ IMAGE_REL_ALPHA_ABSOLUTE,
+ IMAGE_REL_ALPHA_REFLONG,
+ IMAGE_REL_ALPHA_REFQUAD,
+ IMAGE_REL_ALPHA_GPREL32,
+ IMAGE_REL_ALPHA_LITERAL,
+ IMAGE_REL_ALPHA_LITUSE,
+ IMAGE_REL_ALPHA_GPDISP,
+ IMAGE_REL_ALPHA_BRADDR,
+ IMAGE_REL_ALPHA_HINT,
+ IMAGE_REL_ALPHA_INLINE_REFLONG,
+ IMAGE_REL_ALPHA_REFHI,
+ IMAGE_REL_ALPHA_REFLO,
+ IMAGE_REL_ALPHA_PAIR,
+ IMAGE_REL_ALPHA_MATCH,
+ IMAGE_REL_ALPHA_SECTION,
+ IMAGE_REL_ALPHA_SECREL,
+ IMAGE_REL_ALPHA_REFLONGNB,
+ IMAGE_REL_ALPHA_SECRELLO,
+ IMAGE_REL_ALPHA_SECRELHI,
+ IMAGE_REL_ALPHA_REFQ3,
+ IMAGE_REL_ALPHA_REFQ2,
+ IMAGE_REL_ALPHA_REFQ1,
+ IMAGE_REL_ALPHA_GPRELLO,
+ IMAGE_REL_ALPHA_GPRELHI,
+ );
+ static FLAGS_IMAGE_REL_PPC: &[Flag<u16>] = &flags!(
+ IMAGE_REL_PPC_ABSOLUTE,
+ IMAGE_REL_PPC_ADDR64,
+ IMAGE_REL_PPC_ADDR32,
+ IMAGE_REL_PPC_ADDR24,
+ IMAGE_REL_PPC_ADDR16,
+ IMAGE_REL_PPC_ADDR14,
+ IMAGE_REL_PPC_REL24,
+ IMAGE_REL_PPC_REL14,
+ IMAGE_REL_PPC_TOCREL16,
+ IMAGE_REL_PPC_TOCREL14,
+ IMAGE_REL_PPC_ADDR32NB,
+ IMAGE_REL_PPC_SECREL,
+ IMAGE_REL_PPC_SECTION,
+ IMAGE_REL_PPC_IFGLUE,
+ IMAGE_REL_PPC_IMGLUE,
+ IMAGE_REL_PPC_SECREL16,
+ IMAGE_REL_PPC_REFHI,
+ IMAGE_REL_PPC_REFLO,
+ IMAGE_REL_PPC_PAIR,
+ IMAGE_REL_PPC_SECRELLO,
+ IMAGE_REL_PPC_SECRELHI,
+ IMAGE_REL_PPC_GPREL,
+ IMAGE_REL_PPC_TOKEN,
+ );
+ static FLAGS_IMAGE_REL_PPC_BITS: &[Flag<u16>] = &flags!(
+ IMAGE_REL_PPC_NEG,
+ IMAGE_REL_PPC_BRTAKEN,
+ IMAGE_REL_PPC_BRNTAKEN,
+ IMAGE_REL_PPC_TOCDEFN,
+ );
+ static FLAGS_IMAGE_REL_SH: &[Flag<u16>] = &flags!(
+ IMAGE_REL_SH3_ABSOLUTE,
+ IMAGE_REL_SH3_DIRECT16,
+ IMAGE_REL_SH3_DIRECT32,
+ IMAGE_REL_SH3_DIRECT8,
+ IMAGE_REL_SH3_DIRECT8_WORD,
+ IMAGE_REL_SH3_DIRECT8_LONG,
+ IMAGE_REL_SH3_DIRECT4,
+ IMAGE_REL_SH3_DIRECT4_WORD,
+ IMAGE_REL_SH3_DIRECT4_LONG,
+ IMAGE_REL_SH3_PCREL8_WORD,
+ IMAGE_REL_SH3_PCREL8_LONG,
+ IMAGE_REL_SH3_PCREL12_WORD,
+ IMAGE_REL_SH3_STARTOF_SECTION,
+ IMAGE_REL_SH3_SIZEOF_SECTION,
+ IMAGE_REL_SH3_SECTION,
+ IMAGE_REL_SH3_SECREL,
+ IMAGE_REL_SH3_DIRECT32_NB,
+ IMAGE_REL_SH3_GPREL4_LONG,
+ IMAGE_REL_SH3_TOKEN,
+ IMAGE_REL_SHM_PCRELPT,
+ IMAGE_REL_SHM_REFLO,
+ IMAGE_REL_SHM_REFHALF,
+ IMAGE_REL_SHM_RELLO,
+ IMAGE_REL_SHM_RELHALF,
+ IMAGE_REL_SHM_PAIR,
+ );
+ static FLAGS_IMAGE_REL_SH_BITS: &[Flag<u16>] = &flags!(IMAGE_REL_SH_NOMODE,);
+ static FLAGS_IMAGE_REL_ARM: &[Flag<u16>] = &flags!(
+ IMAGE_REL_ARM_ABSOLUTE,
+ IMAGE_REL_ARM_ADDR32,
+ IMAGE_REL_ARM_ADDR32NB,
+ IMAGE_REL_ARM_BRANCH24,
+ IMAGE_REL_ARM_BRANCH11,
+ IMAGE_REL_ARM_TOKEN,
+ IMAGE_REL_ARM_GPREL12,
+ IMAGE_REL_ARM_GPREL7,
+ IMAGE_REL_ARM_BLX24,
+ IMAGE_REL_ARM_BLX11,
+ IMAGE_REL_ARM_SECTION,
+ IMAGE_REL_ARM_SECREL,
+ IMAGE_REL_ARM_MOV32A,
+ IMAGE_REL_ARM_MOV32T,
+ IMAGE_REL_ARM_BRANCH20T,
+ IMAGE_REL_ARM_BRANCH24T,
+ IMAGE_REL_ARM_BLX23T,
+ );
+ static FLAGS_IMAGE_REL_AM: &[Flag<u16>] = &flags!(
+ IMAGE_REL_AM_ABSOLUTE,
+ IMAGE_REL_AM_ADDR32,
+ IMAGE_REL_AM_ADDR32NB,
+ IMAGE_REL_AM_CALL32,
+ IMAGE_REL_AM_FUNCINFO,
+ IMAGE_REL_AM_REL32_1,
+ IMAGE_REL_AM_REL32_2,
+ IMAGE_REL_AM_SECREL,
+ IMAGE_REL_AM_SECTION,
+ IMAGE_REL_AM_TOKEN,
+ );
+ static FLAGS_IMAGE_REL_ARM64: &[Flag<u16>] = &flags!(
+ IMAGE_REL_ARM64_ABSOLUTE,
+ IMAGE_REL_ARM64_ADDR32,
+ IMAGE_REL_ARM64_ADDR32NB,
+ IMAGE_REL_ARM64_BRANCH26,
+ IMAGE_REL_ARM64_PAGEBASE_REL21,
+ IMAGE_REL_ARM64_REL21,
+ IMAGE_REL_ARM64_PAGEOFFSET_12A,
+ IMAGE_REL_ARM64_PAGEOFFSET_12L,
+ IMAGE_REL_ARM64_SECREL,
+ IMAGE_REL_ARM64_SECREL_LOW12A,
+ IMAGE_REL_ARM64_SECREL_HIGH12A,
+ IMAGE_REL_ARM64_SECREL_LOW12L,
+ IMAGE_REL_ARM64_TOKEN,
+ IMAGE_REL_ARM64_SECTION,
+ IMAGE_REL_ARM64_ADDR64,
+ IMAGE_REL_ARM64_BRANCH19,
+ );
+ static FLAGS_IMAGE_REL_AMD64: &[Flag<u16>] = &flags!(
+ IMAGE_REL_AMD64_ABSOLUTE,
+ IMAGE_REL_AMD64_ADDR64,
+ IMAGE_REL_AMD64_ADDR32,
+ IMAGE_REL_AMD64_ADDR32NB,
+ IMAGE_REL_AMD64_REL32,
+ IMAGE_REL_AMD64_REL32_1,
+ IMAGE_REL_AMD64_REL32_2,
+ IMAGE_REL_AMD64_REL32_3,
+ IMAGE_REL_AMD64_REL32_4,
+ IMAGE_REL_AMD64_REL32_5,
+ IMAGE_REL_AMD64_SECTION,
+ IMAGE_REL_AMD64_SECREL,
+ IMAGE_REL_AMD64_SECREL7,
+ IMAGE_REL_AMD64_TOKEN,
+ IMAGE_REL_AMD64_SREL32,
+ IMAGE_REL_AMD64_PAIR,
+ IMAGE_REL_AMD64_SSPAN32,
+ IMAGE_REL_AMD64_EHANDLER,
+ IMAGE_REL_AMD64_IMPORT_BR,
+ IMAGE_REL_AMD64_IMPORT_CALL,
+ IMAGE_REL_AMD64_CFG_BR,
+ IMAGE_REL_AMD64_CFG_BR_REX,
+ IMAGE_REL_AMD64_CFG_CALL,
+ IMAGE_REL_AMD64_INDIR_BR,
+ IMAGE_REL_AMD64_INDIR_BR_REX,
+ IMAGE_REL_AMD64_INDIR_CALL,
+ IMAGE_REL_AMD64_INDIR_BR_SWITCHTABLE_FIRST,
+ IMAGE_REL_AMD64_INDIR_BR_SWITCHTABLE_LAST,
+ );
+ static FLAGS_IMAGE_REL_IA64: &[Flag<u16>] = &flags!(
+ IMAGE_REL_IA64_ABSOLUTE,
+ IMAGE_REL_IA64_IMM14,
+ IMAGE_REL_IA64_IMM22,
+ IMAGE_REL_IA64_IMM64,
+ IMAGE_REL_IA64_DIR32,
+ IMAGE_REL_IA64_DIR64,
+ IMAGE_REL_IA64_PCREL21B,
+ IMAGE_REL_IA64_PCREL21M,
+ IMAGE_REL_IA64_PCREL21F,
+ IMAGE_REL_IA64_GPREL22,
+ IMAGE_REL_IA64_LTOFF22,
+ IMAGE_REL_IA64_SECTION,
+ IMAGE_REL_IA64_SECREL22,
+ IMAGE_REL_IA64_SECREL64I,
+ IMAGE_REL_IA64_SECREL32,
+ IMAGE_REL_IA64_DIR32NB,
+ IMAGE_REL_IA64_SREL14,
+ IMAGE_REL_IA64_SREL22,
+ IMAGE_REL_IA64_SREL32,
+ IMAGE_REL_IA64_UREL32,
+ IMAGE_REL_IA64_PCREL60X,
+ IMAGE_REL_IA64_PCREL60B,
+ IMAGE_REL_IA64_PCREL60F,
+ IMAGE_REL_IA64_PCREL60I,
+ IMAGE_REL_IA64_PCREL60M,
+ IMAGE_REL_IA64_IMMGPREL64,
+ IMAGE_REL_IA64_TOKEN,
+ IMAGE_REL_IA64_GPREL32,
+ IMAGE_REL_IA64_ADDEND,
+ );
+ static FLAGS_IMAGE_REL_CEF: &[Flag<u16>] = &flags!(
+ IMAGE_REL_CEF_ABSOLUTE,
+ IMAGE_REL_CEF_ADDR32,
+ IMAGE_REL_CEF_ADDR64,
+ IMAGE_REL_CEF_ADDR32NB,
+ IMAGE_REL_CEF_SECTION,
+ IMAGE_REL_CEF_SECREL,
+ IMAGE_REL_CEF_TOKEN,
+ );
+ static FLAGS_IMAGE_REL_CEE: &[Flag<u16>] = &flags!(
+ IMAGE_REL_CEE_ABSOLUTE,
+ IMAGE_REL_CEE_ADDR32,
+ IMAGE_REL_CEE_ADDR64,
+ IMAGE_REL_CEE_ADDR32NB,
+ IMAGE_REL_CEE_SECTION,
+ IMAGE_REL_CEE_SECREL,
+ IMAGE_REL_CEE_TOKEN,
+ );
+ static FLAGS_IMAGE_REL_M32R: &[Flag<u16>] = &flags!(
+ IMAGE_REL_M32R_ABSOLUTE,
+ IMAGE_REL_M32R_ADDR32,
+ IMAGE_REL_M32R_ADDR32NB,
+ IMAGE_REL_M32R_ADDR24,
+ IMAGE_REL_M32R_GPREL16,
+ IMAGE_REL_M32R_PCREL24,
+ IMAGE_REL_M32R_PCREL16,
+ IMAGE_REL_M32R_PCREL8,
+ IMAGE_REL_M32R_REFHALF,
+ IMAGE_REL_M32R_REFHI,
+ IMAGE_REL_M32R_REFLO,
+ IMAGE_REL_M32R_PAIR,
+ IMAGE_REL_M32R_SECTION,
+ IMAGE_REL_M32R_SECREL32,
+ IMAGE_REL_M32R_TOKEN,
+ );
+ static FLAGS_IMAGE_REL_EBC: &[Flag<u16>] = &flags!(
+ IMAGE_REL_EBC_ABSOLUTE,
+ IMAGE_REL_EBC_ADDR32NB,
+ IMAGE_REL_EBC_REL32,
+ IMAGE_REL_EBC_SECTION,
+ IMAGE_REL_EBC_SECREL,
+ );
+ static FLAGS_IMAGE_SYM: &[Flag<u16>] =
+ &flags!(IMAGE_SYM_UNDEFINED, IMAGE_SYM_ABSOLUTE, IMAGE_SYM_DEBUG,);
+ static FLAGS_IMAGE_SYM_TYPE: &[Flag<u16>] = &flags!(
+ IMAGE_SYM_TYPE_NULL,
+ IMAGE_SYM_TYPE_VOID,
+ IMAGE_SYM_TYPE_CHAR,
+ IMAGE_SYM_TYPE_SHORT,
+ IMAGE_SYM_TYPE_INT,
+ IMAGE_SYM_TYPE_LONG,
+ IMAGE_SYM_TYPE_FLOAT,
+ IMAGE_SYM_TYPE_DOUBLE,
+ IMAGE_SYM_TYPE_STRUCT,
+ IMAGE_SYM_TYPE_UNION,
+ IMAGE_SYM_TYPE_ENUM,
+ IMAGE_SYM_TYPE_MOE,
+ IMAGE_SYM_TYPE_BYTE,
+ IMAGE_SYM_TYPE_WORD,
+ IMAGE_SYM_TYPE_UINT,
+ IMAGE_SYM_TYPE_DWORD,
+ IMAGE_SYM_TYPE_PCODE,
+ );
+ static FLAGS_IMAGE_SYM_DTYPE: &[Flag<u16>] = &flags!(
+ IMAGE_SYM_DTYPE_NULL,
+ IMAGE_SYM_DTYPE_POINTER,
+ IMAGE_SYM_DTYPE_FUNCTION,
+ IMAGE_SYM_DTYPE_ARRAY,
+ );
+ static FLAGS_IMAGE_SYM_CLASS: &[Flag<u8>] = &flags!(
+ IMAGE_SYM_CLASS_END_OF_FUNCTION,
+ IMAGE_SYM_CLASS_NULL,
+ IMAGE_SYM_CLASS_AUTOMATIC,
+ IMAGE_SYM_CLASS_EXTERNAL,
+ IMAGE_SYM_CLASS_STATIC,
+ IMAGE_SYM_CLASS_REGISTER,
+ IMAGE_SYM_CLASS_EXTERNAL_DEF,
+ IMAGE_SYM_CLASS_LABEL,
+ IMAGE_SYM_CLASS_UNDEFINED_LABEL,
+ IMAGE_SYM_CLASS_MEMBER_OF_STRUCT,
+ IMAGE_SYM_CLASS_ARGUMENT,
+ IMAGE_SYM_CLASS_STRUCT_TAG,
+ IMAGE_SYM_CLASS_MEMBER_OF_UNION,
+ IMAGE_SYM_CLASS_UNION_TAG,
+ IMAGE_SYM_CLASS_TYPE_DEFINITION,
+ IMAGE_SYM_CLASS_UNDEFINED_STATIC,
+ IMAGE_SYM_CLASS_ENUM_TAG,
+ IMAGE_SYM_CLASS_MEMBER_OF_ENUM,
+ IMAGE_SYM_CLASS_REGISTER_PARAM,
+ IMAGE_SYM_CLASS_BIT_FIELD,
+ IMAGE_SYM_CLASS_FAR_EXTERNAL,
+ IMAGE_SYM_CLASS_BLOCK,
+ IMAGE_SYM_CLASS_FUNCTION,
+ IMAGE_SYM_CLASS_END_OF_STRUCT,
+ IMAGE_SYM_CLASS_FILE,
+ IMAGE_SYM_CLASS_SECTION,
+ IMAGE_SYM_CLASS_WEAK_EXTERNAL,
+ IMAGE_SYM_CLASS_CLR_TOKEN,
+ );
+ static FLAGS_IMAGE_COMDAT_SELECT: &[Flag<u8>] = &flags!(
+ IMAGE_COMDAT_SELECT_NODUPLICATES,
+ IMAGE_COMDAT_SELECT_ANY,
+ IMAGE_COMDAT_SELECT_SAME_SIZE,
+ IMAGE_COMDAT_SELECT_EXACT_MATCH,
+ IMAGE_COMDAT_SELECT_ASSOCIATIVE,
+ IMAGE_COMDAT_SELECT_LARGEST,
+ IMAGE_COMDAT_SELECT_NEWEST,
+ );
+ static FLAGS_IMAGE_SUBSYSTEM: &[Flag<u16>] = &flags!(
+ IMAGE_SUBSYSTEM_UNKNOWN,
+ IMAGE_SUBSYSTEM_NATIVE,
+ IMAGE_SUBSYSTEM_WINDOWS_GUI,
+ IMAGE_SUBSYSTEM_WINDOWS_CUI,
+ IMAGE_SUBSYSTEM_OS2_CUI,
+ IMAGE_SUBSYSTEM_POSIX_CUI,
+ IMAGE_SUBSYSTEM_NATIVE_WINDOWS,
+ IMAGE_SUBSYSTEM_WINDOWS_CE_GUI,
+ IMAGE_SUBSYSTEM_EFI_APPLICATION,
+ IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER,
+ IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER,
+ IMAGE_SUBSYSTEM_EFI_ROM,
+ IMAGE_SUBSYSTEM_XBOX,
+ IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION,
+ IMAGE_SUBSYSTEM_XBOX_CODE_CATALOG,
+ );
+ static FLAGS_IMAGE_DLLCHARACTERISTICS: &[Flag<u16>] = &flags!(
+ IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA,
+ IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE,
+ IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY,
+ IMAGE_DLLCHARACTERISTICS_NX_COMPAT,
+ IMAGE_DLLCHARACTERISTICS_NO_ISOLATION,
+ IMAGE_DLLCHARACTERISTICS_NO_SEH,
+ IMAGE_DLLCHARACTERISTICS_NO_BIND,
+ IMAGE_DLLCHARACTERISTICS_APPCONTAINER,
+ IMAGE_DLLCHARACTERISTICS_WDM_DRIVER,
+ IMAGE_DLLCHARACTERISTICS_GUARD_CF,
+ IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE,
+ );
+ static FLAGS_IMAGE_DIRECTORY_ENTRY: &[Flag<usize>] = &flags!(
+ IMAGE_DIRECTORY_ENTRY_EXPORT,
+ IMAGE_DIRECTORY_ENTRY_IMPORT,
+ IMAGE_DIRECTORY_ENTRY_RESOURCE,
+ IMAGE_DIRECTORY_ENTRY_EXCEPTION,
+ IMAGE_DIRECTORY_ENTRY_SECURITY,
+ IMAGE_DIRECTORY_ENTRY_BASERELOC,
+ IMAGE_DIRECTORY_ENTRY_DEBUG,
+ IMAGE_DIRECTORY_ENTRY_ARCHITECTURE,
+ IMAGE_DIRECTORY_ENTRY_GLOBALPTR,
+ IMAGE_DIRECTORY_ENTRY_TLS,
+ IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG,
+ IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT,
+ IMAGE_DIRECTORY_ENTRY_IAT,
+ IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT,
+ IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR,
+ );
+}
diff --git a/vendor/object-0.26.2/src/archive.rs b/vendor/object-0.26.2/src/archive.rs
new file mode 100644
index 000000000..d4b419beb
--- /dev/null
+++ b/vendor/object-0.26.2/src/archive.rs
@@ -0,0 +1,39 @@
+//! Archive definitions.
+//!
+//! These definitions are independent of read/write support, although we do implement
+//! some traits useful for those.
+
+use crate::pod::Pod;
+
+/// File identification bytes stored at the beginning of the file.
+pub const MAGIC: [u8; 8] = *b"!<arch>\n";
+
+/// File identification bytes stored at the beginning of a thin archive.
+///
+/// A thin archive only contains a symbol table and file names.
+pub const THIN_MAGIC: [u8; 8] = *b"!<thin>\n";
+
+/// The terminator for each archive member header.
+pub const TERMINATOR: [u8; 2] = *b"`\n";
+
+/// The header at the start of an archive member.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Header {
+ /// The file name.
+ pub name: [u8; 16],
+ /// File modification timestamp in decimal.
+ pub date: [u8; 12],
+ /// User ID in decimal.
+ pub uid: [u8; 6],
+ /// Group ID in decimal.
+ pub gid: [u8; 6],
+ /// File mode in octal.
+ pub mode: [u8; 8],
+ /// File size in decimal.
+ pub size: [u8; 10],
+ /// Must be equal to `TERMINATOR`.
+ pub terminator: [u8; 2],
+}
+
+unsafe_impl_pod!(Header);
diff --git a/vendor/object-0.26.2/src/common.rs b/vendor/object-0.26.2/src/common.rs
new file mode 100644
index 000000000..c86665c21
--- /dev/null
+++ b/vendor/object-0.26.2/src/common.rs
@@ -0,0 +1,417 @@
+/// A CPU architecture.
+#[allow(missing_docs)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum Architecture {
+ Unknown,
+ Aarch64,
+ Arm,
+ Avr,
+ Bpf,
+ I386,
+ X86_64,
+ #[allow(non_camel_case_types)]
+ X86_64_X32,
+ Hexagon,
+ Mips,
+ Mips64,
+ Msp430,
+ PowerPc,
+ PowerPc64,
+ Riscv32,
+ Riscv64,
+ S390x,
+ Sparc64,
+ Wasm32,
+}
+
+impl Architecture {
+ /// The size of an address value for this architecture.
+ ///
+ /// Returns `None` for unknown architectures.
+ pub fn address_size(self) -> Option<AddressSize> {
+ match self {
+ Architecture::Unknown => None,
+ Architecture::Aarch64 => Some(AddressSize::U64),
+ Architecture::Arm => Some(AddressSize::U32),
+ Architecture::Avr => Some(AddressSize::U8),
+ Architecture::Bpf => Some(AddressSize::U64),
+ Architecture::I386 => Some(AddressSize::U32),
+ Architecture::X86_64 => Some(AddressSize::U64),
+ Architecture::X86_64_X32 => Some(AddressSize::U32),
+ Architecture::Hexagon => Some(AddressSize::U32),
+ Architecture::Mips => Some(AddressSize::U32),
+ Architecture::Mips64 => Some(AddressSize::U64),
+ Architecture::Msp430 => Some(AddressSize::U16),
+ Architecture::PowerPc => Some(AddressSize::U32),
+ Architecture::PowerPc64 => Some(AddressSize::U64),
+ Architecture::Riscv32 => Some(AddressSize::U32),
+ Architecture::Riscv64 => Some(AddressSize::U64),
+ Architecture::S390x => Some(AddressSize::U64),
+ Architecture::Sparc64 => Some(AddressSize::U64),
+ Architecture::Wasm32 => Some(AddressSize::U32),
+ }
+ }
+}
+
+/// The size of an address value for an architecture.
+///
+/// This may differ from the address size supported by the file format (such as for COFF).
+#[allow(missing_docs)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+#[repr(u8)]
+pub enum AddressSize {
+ U8 = 1,
+ U16 = 2,
+ U32 = 4,
+ U64 = 8,
+}
+
+impl AddressSize {
+ /// The size in bytes of an address value.
+ #[inline]
+ pub fn bytes(self) -> u8 {
+ self as u8
+ }
+}
+
+/// A binary file format.
+#[allow(missing_docs)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum BinaryFormat {
+ Coff,
+ Elf,
+ MachO,
+ Pe,
+ Wasm,
+}
+
+/// The kind of a section.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum SectionKind {
+ /// The section kind is unknown.
+ Unknown,
+ /// An executable code section.
+ ///
+ /// Example ELF sections: `.text`
+ ///
+ /// Example Mach-O sections: `__TEXT/__text`
+ Text,
+ /// A data section.
+ ///
+ /// Example ELF sections: `.data`
+ ///
+ /// Example Mach-O sections: `__DATA/__data`
+ Data,
+ /// A read only data section.
+ ///
+ /// Example ELF sections: `.rodata`
+ ///
+ /// Example Mach-O sections: `__TEXT/__const`, `__DATA/__const`, `__TEXT/__literal4`
+ ReadOnlyData,
+ /// A loadable string section.
+ ///
+ /// Example ELF sections: `.rodata.str`
+ ///
+ /// Example Mach-O sections: `__TEXT/__cstring`
+ ReadOnlyString,
+ /// An uninitialized data section.
+ ///
+ /// Example ELF sections: `.bss`
+ ///
+ /// Example Mach-O sections: `__DATA/__bss`
+ UninitializedData,
+ /// An uninitialized common data section.
+ ///
+ /// Example Mach-O sections: `__DATA/__common`
+ Common,
+ /// A TLS data section.
+ ///
+ /// Example ELF sections: `.tdata`
+ ///
+ /// Example Mach-O sections: `__DATA/__thread_data`
+ Tls,
+ /// An uninitialized TLS data section.
+ ///
+ /// Example ELF sections: `.tbss`
+ ///
+ /// Example Mach-O sections: `__DATA/__thread_bss`
+ UninitializedTls,
+ /// A TLS variables section.
+ ///
+ /// This contains TLS variable structures, rather than the variable initializers.
+ ///
+ /// Example Mach-O sections: `__DATA/__thread_vars`
+ TlsVariables,
+ /// A non-loadable string section.
+ ///
+ /// Example ELF sections: `.comment`, `.debug_str`
+ OtherString,
+ /// Some other non-loadable section.
+ ///
+ /// Example ELF sections: `.debug_info`
+ Other,
+ /// Debug information.
+ ///
+ /// Example Mach-O sections: `__DWARF/__debug_info`
+ Debug,
+ /// Information for the linker.
+ ///
+ /// Example COFF sections: `.drectve`
+ Linker,
+ /// ELF note section.
+ Note,
+ /// Metadata such as symbols or relocations.
+ ///
+ /// Example ELF sections: `.symtab`, `.strtab`, `.group`
+ Metadata,
+ /// Some other ELF section type.
+ ///
+ /// This is the `sh_type` field in the section header.
+ /// The meaning may be dependent on the architecture.
+ Elf(u32),
+}
+
+impl SectionKind {
+ /// Return true if this section contains zerofill data.
+ pub fn is_bss(self) -> bool {
+ self == SectionKind::UninitializedData
+ || self == SectionKind::UninitializedTls
+ || self == SectionKind::Common
+ }
+}
+
+/// The selection kind for a COMDAT section group.
+///
+/// This determines the way in which the linker resolves multiple definitions of the COMDAT
+/// sections.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum ComdatKind {
+ /// The selection kind is unknown.
+ Unknown,
+ /// Multiple definitions are allowed.
+ ///
+ /// An arbitrary definition is selected, and the rest are removed.
+ ///
+ /// This is the only supported selection kind for ELF.
+ Any,
+ /// Multiple definitions are not allowed.
+ ///
+ /// This is used to group sections without allowing duplicates.
+ NoDuplicates,
+ /// Multiple definitions must have the same size.
+ ///
+ /// An arbitrary definition is selected, and the rest are removed.
+ SameSize,
+ /// Multiple definitions must match exactly.
+ ///
+ /// An arbitrary definition is selected, and the rest are removed.
+ ExactMatch,
+ /// Multiple definitions are allowed, and the largest is selected.
+ ///
+ /// An arbitrary definition with the largest size is selected, and the rest are removed.
+ Largest,
+ /// Multiple definitions are allowed, and the newest is selected.
+ Newest,
+}
+
+/// The kind of a symbol.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum SymbolKind {
+ /// The symbol kind is unknown.
+ Unknown,
+ /// The symbol is a null placeholder.
+ Null,
+ /// The symbol is for executable code.
+ Text,
+ /// The symbol is for a data object.
+ Data,
+ /// The symbol is for a section.
+ Section,
+ /// The symbol is the name of a file. It precedes symbols within that file.
+ File,
+ /// The symbol is for a code label.
+ Label,
+ /// The symbol is for a thread local storage entity.
+ Tls,
+}
+
+/// A symbol scope.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum SymbolScope {
+ /// Unknown scope.
+ Unknown,
+ /// Symbol is visible to the compilation unit.
+ Compilation,
+ /// Symbol is visible to the static linkage unit.
+ Linkage,
+ /// Symbol is visible to dynamically linked objects.
+ Dynamic,
+}
+
+/// The operation used to calculate the result of the relocation.
+///
+/// The relocation descriptions use the following definitions. Note that
+/// these definitions probably don't match any ELF ABI.
+///
+/// * A - The value of the addend.
+/// * G - The address of the symbol's entry within the global offset table.
+/// * L - The address of the symbol's entry within the procedure linkage table.
+/// * P - The address of the place of the relocation.
+/// * S - The address of the symbol.
+/// * GotBase - The address of the global offset table.
+/// * Image - The base address of the image.
+/// * Section - The address of the section containing the symbol.
+///
+/// 'XxxRelative' means 'Xxx + A - P'. 'XxxOffset' means 'S + A - Xxx'.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum RelocationKind {
+ /// S + A
+ Absolute,
+ /// S + A - P
+ Relative,
+ /// G + A - GotBase
+ Got,
+ /// G + A - P
+ GotRelative,
+ /// GotBase + A - P
+ GotBaseRelative,
+ /// S + A - GotBase
+ GotBaseOffset,
+ /// L + A - P
+ PltRelative,
+ /// S + A - Image
+ ImageOffset,
+ /// S + A - Section
+ SectionOffset,
+ /// The index of the section containing the symbol.
+ SectionIndex,
+ /// Some other ELF relocation. The value is dependent on the architecture.
+ Elf(u32),
+ /// Some other Mach-O relocation. The value is dependent on the architecture.
+ MachO {
+ /// The relocation type.
+ value: u8,
+ /// Whether the relocation is relative to the place.
+ relative: bool,
+ },
+ /// Some other COFF relocation. The value is dependent on the architecture.
+ Coff(u16),
+}
+
+/// Information about how the result of the relocation operation is encoded in the place.
+///
+/// This is usually architecture specific, such as specifying an addressing mode or
+/// a specific instruction.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum RelocationEncoding {
+ /// Generic encoding.
+ Generic,
+
+ /// x86 sign extension at runtime.
+ ///
+ /// Used with `RelocationKind::Absolute`.
+ X86Signed,
+ /// x86 rip-relative addressing.
+ ///
+ /// The `RelocationKind` must be PC relative.
+ X86RipRelative,
+ /// x86 rip-relative addressing in movq instruction.
+ ///
+ /// The `RelocationKind` must be PC relative.
+ X86RipRelativeMovq,
+ /// x86 branch instruction.
+ ///
+ /// The `RelocationKind` must be PC relative.
+ X86Branch,
+
+ /// s390x PC-relative offset shifted right by one bit.
+ ///
+ /// The `RelocationKind` must be PC relative.
+ S390xDbl,
+
+ /// AArch64 call target.
+ ///
+ /// The `RelocationKind` must be PC relative.
+ AArch64Call,
+}
+
+/// File flags that are specific to each file format.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum FileFlags {
+ /// No file flags.
+ None,
+ /// ELF file flags.
+ Elf {
+ /// `e_flags` field in the ELF file header.
+ e_flags: u32,
+ },
+ /// Mach-O file flags.
+ MachO {
+ /// `flags` field in the Mach-O file header.
+ flags: u32,
+ },
+ /// COFF file flags.
+ Coff {
+ /// `Characteristics` field in the COFF file header.
+ characteristics: u16,
+ },
+}
+
+/// Section flags that are specific to each file format.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum SectionFlags {
+ /// No section flags.
+ None,
+ /// ELF section flags.
+ Elf {
+ /// `sh_flags` field in the section header.
+ sh_flags: u64,
+ },
+ /// Mach-O section flags.
+ MachO {
+ /// `flags` field in the section header.
+ flags: u32,
+ },
+ /// COFF section flags.
+ Coff {
+ /// `Characteristics` field in the section header.
+ characteristics: u32,
+ },
+}
+
+/// Symbol flags that are specific to each file format.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum SymbolFlags<Section> {
+ /// No symbol flags.
+ None,
+ /// ELF symbol flags.
+ Elf {
+ /// `st_info` field in the ELF symbol.
+ st_info: u8,
+ /// `st_other` field in the ELF symbol.
+ st_other: u8,
+ },
+ /// Mach-O symbol flags.
+ MachO {
+ /// `n_desc` field in the Mach-O symbol.
+ n_desc: u16,
+ },
+ /// COFF flags for a section symbol.
+ CoffSection {
+ /// `Selection` field in the auxiliary symbol for the section.
+ selection: u8,
+ /// `Number` field in the auxiliary symbol for the section.
+ associative_section: Option<Section>,
+ },
+}
diff --git a/vendor/object-0.26.2/src/elf.rs b/vendor/object-0.26.2/src/elf.rs
new file mode 100644
index 000000000..28ac16bbe
--- /dev/null
+++ b/vendor/object-0.26.2/src/elf.rs
@@ -0,0 +1,6248 @@
+//! ELF definitions.
+//!
+//! These definitions are independent of read/write support, although we do implement
+//! some traits useful for those.
+//!
+//! This module is the equivalent of /usr/include/elf.h, and is based heavily on it.
+
+#![allow(clippy::identity_op)]
+
+use crate::endian::{Endian, U32Bytes, U64Bytes, I32, I64, U16, U32, U64};
+use crate::pod::Pod;
+
+/// The header at the start of every 32-bit ELF file.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct FileHeader32<E: Endian> {
+ /// Magic number and other information.
+ pub e_ident: Ident,
+ /// Object file type. One of the `ET_*` constants.
+ pub e_type: U16<E>,
+ /// Architecture. One of the `EM_*` constants.
+ pub e_machine: U16<E>,
+ /// Object file version. Must be `EV_CURRENT`.
+ pub e_version: U32<E>,
+ /// Entry point virtual address.
+ pub e_entry: U32<E>,
+ /// Program header table file offset.
+ pub e_phoff: U32<E>,
+ /// Section header table file offset.
+ pub e_shoff: U32<E>,
+ /// Processor-specific flags.
+ ///
+ /// A combination of the `EF_*` constants.
+ pub e_flags: U32<E>,
+ /// Size in bytes of this header.
+ pub e_ehsize: U16<E>,
+ /// Program header table entry size.
+ pub e_phentsize: U16<E>,
+ /// Program header table entry count.
+ ///
+ /// If the count is greater than or equal to `PN_XNUM` then this field is set to
+ /// `PN_XNUM` and the count is stored in the `sh_info` field of section 0.
+ pub e_phnum: U16<E>,
+ /// Section header table entry size.
+ pub e_shentsize: U16<E>,
+ /// Section header table entry count.
+ ///
+ /// If the count is greater than or equal to `SHN_LORESERVE` then this field is set to
+ /// `0` and the count is stored in the `sh_size` field of section 0.
+ /// first section header.
+ pub e_shnum: U16<E>,
+ /// Section header string table index.
+ ///
+ /// If the index is greater than or equal to `SHN_LORESERVE` then this field is set to
+ /// `SHN_XINDEX` and the index is stored in the `sh_link` field of section 0.
+ pub e_shstrndx: U16<E>,
+}
+
+/// The header at the start of every 64-bit ELF file.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct FileHeader64<E: Endian> {
+ /// Magic number and other information.
+ pub e_ident: Ident,
+ /// Object file type. One of the `ET_*` constants.
+ pub e_type: U16<E>,
+ /// Architecture. One of the `EM_*` constants.
+ pub e_machine: U16<E>,
+ /// Object file version. Must be `EV_CURRENT`.
+ pub e_version: U32<E>,
+ /// Entry point virtual address.
+ pub e_entry: U64<E>,
+ /// Program header table file offset.
+ pub e_phoff: U64<E>,
+ /// Section header table file offset.
+ pub e_shoff: U64<E>,
+ /// Processor-specific flags.
+ ///
+ /// A combination of the `EF_*` constants.
+ pub e_flags: U32<E>,
+ /// Size in bytes of this header.
+ pub e_ehsize: U16<E>,
+ /// Program header table entry size.
+ pub e_phentsize: U16<E>,
+ /// Program header table entry count.
+ ///
+ /// If the count is greater than or equal to `PN_XNUM` then this field is set to
+ /// `PN_XNUM` and the count is stored in the `sh_info` field of section 0.
+ pub e_phnum: U16<E>,
+ /// Section header table entry size.
+ pub e_shentsize: U16<E>,
+ /// Section header table entry count.
+ ///
+ /// If the count is greater than or equal to `SHN_LORESERVE` then this field is set to
+ /// `0` and the count is stored in the `sh_size` field of section 0.
+ /// first section header.
+ pub e_shnum: U16<E>,
+ /// Section header string table index.
+ ///
+ /// If the index is greater than or equal to `SHN_LORESERVE` then this field is set to
+ /// `SHN_XINDEX` and the index is stored in the `sh_link` field of section 0.
+ pub e_shstrndx: U16<E>,
+}
+
+/// Magic number and other information.
+///
+/// Contained in the file header.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Ident {
+ /// Magic number. Must be `ELFMAG`.
+ pub magic: [u8; 4],
+ /// File class. One of the `ELFCLASS*` constants.
+ pub class: u8,
+ /// Data encoding. One of the `ELFDATA*` constants.
+ pub data: u8,
+ /// ELF version. Must be `EV_CURRENT`.
+ pub version: u8,
+ /// OS ABI identification. One of the `ELFOSABI*` constants.
+ pub os_abi: u8,
+ /// ABI version.
+ ///
+ /// The meaning of this field depends on the `os_abi` value.
+ pub abi_version: u8,
+ /// Padding bytes.
+ pub padding: [u8; 7],
+}
+
+/// File identification bytes stored in `Ident::magic`.
+pub const ELFMAG: [u8; 4] = [0x7f, b'E', b'L', b'F'];
+
+// Values for `Ident::class`.
+/// Invalid class.
+pub const ELFCLASSNONE: u8 = 0;
+/// 32-bit object.
+pub const ELFCLASS32: u8 = 1;
+/// 64-bit object.
+pub const ELFCLASS64: u8 = 2;
+
+// Values for `Ident::data`.
+/// Invalid data encoding.
+pub const ELFDATANONE: u8 = 0;
+/// 2's complement, little endian.
+pub const ELFDATA2LSB: u8 = 1;
+/// 2's complement, big endian.
+pub const ELFDATA2MSB: u8 = 2;
+
+// Values for `Ident::os_abi`.
+/// UNIX System V ABI.
+pub const ELFOSABI_NONE: u8 = 0;
+/// UNIX System V ABI.
+///
+/// Alias.
+pub const ELFOSABI_SYSV: u8 = 0;
+/// HP-UX.
+pub const ELFOSABI_HPUX: u8 = 1;
+/// NetBSD.
+pub const ELFOSABI_NETBSD: u8 = 2;
+/// Object uses GNU ELF extensions.
+pub const ELFOSABI_GNU: u8 = 3;
+/// Object uses GNU ELF extensions.
+///
+/// Compatibility alias.
+pub const ELFOSABI_LINUX: u8 = ELFOSABI_GNU;
+/// Sun Solaris.
+pub const ELFOSABI_SOLARIS: u8 = 6;
+/// IBM AIX.
+pub const ELFOSABI_AIX: u8 = 7;
+/// SGI Irix.
+pub const ELFOSABI_IRIX: u8 = 8;
+/// FreeBSD.
+pub const ELFOSABI_FREEBSD: u8 = 9;
+/// Compaq TRU64 UNIX.
+pub const ELFOSABI_TRU64: u8 = 10;
+/// Novell Modesto.
+pub const ELFOSABI_MODESTO: u8 = 11;
+/// OpenBSD.
+pub const ELFOSABI_OPENBSD: u8 = 12;
+/// ARM EABI.
+pub const ELFOSABI_ARM_AEABI: u8 = 64;
+/// ARM.
+pub const ELFOSABI_ARM: u8 = 97;
+/// Standalone (embedded) application.
+pub const ELFOSABI_STANDALONE: u8 = 255;
+
+// Values for `FileHeader*::e_type`.
+/// No file type.
+pub const ET_NONE: u16 = 0;
+/// Relocatable file.
+pub const ET_REL: u16 = 1;
+/// Executable file.
+pub const ET_EXEC: u16 = 2;
+/// Shared object file.
+pub const ET_DYN: u16 = 3;
+/// Core file.
+pub const ET_CORE: u16 = 4;
+/// OS-specific range start.
+pub const ET_LOOS: u16 = 0xfe00;
+/// OS-specific range end.
+pub const ET_HIOS: u16 = 0xfeff;
+/// Processor-specific range start.
+pub const ET_LOPROC: u16 = 0xff00;
+/// Processor-specific range end.
+pub const ET_HIPROC: u16 = 0xffff;
+
+// Values for `FileHeader*::e_machine`.
+/// No machine
+pub const EM_NONE: u16 = 0;
+/// AT&T WE 32100
+pub const EM_M32: u16 = 1;
+/// SUN SPARC
+pub const EM_SPARC: u16 = 2;
+/// Intel 80386
+pub const EM_386: u16 = 3;
+/// Motorola m68k family
+pub const EM_68K: u16 = 4;
+/// Motorola m88k family
+pub const EM_88K: u16 = 5;
+/// Intel MCU
+pub const EM_IAMCU: u16 = 6;
+/// Intel 80860
+pub const EM_860: u16 = 7;
+/// MIPS R3000 big-endian
+pub const EM_MIPS: u16 = 8;
+/// IBM System/370
+pub const EM_S370: u16 = 9;
+/// MIPS R3000 little-endian
+pub const EM_MIPS_RS3_LE: u16 = 10;
+/// HPPA
+pub const EM_PARISC: u16 = 15;
+/// Fujitsu VPP500
+pub const EM_VPP500: u16 = 17;
+/// Sun's "v8plus"
+pub const EM_SPARC32PLUS: u16 = 18;
+/// Intel 80960
+pub const EM_960: u16 = 19;
+/// PowerPC
+pub const EM_PPC: u16 = 20;
+/// PowerPC 64-bit
+pub const EM_PPC64: u16 = 21;
+/// IBM S390
+pub const EM_S390: u16 = 22;
+/// IBM SPU/SPC
+pub const EM_SPU: u16 = 23;
+/// NEC V800 series
+pub const EM_V800: u16 = 36;
+/// Fujitsu FR20
+pub const EM_FR20: u16 = 37;
+/// TRW RH-32
+pub const EM_RH32: u16 = 38;
+/// Motorola RCE
+pub const EM_RCE: u16 = 39;
+/// ARM
+pub const EM_ARM: u16 = 40;
+/// Digital Alpha
+pub const EM_FAKE_ALPHA: u16 = 41;
+/// Hitachi SH
+pub const EM_SH: u16 = 42;
+/// SPARC v9 64-bit
+pub const EM_SPARCV9: u16 = 43;
+/// Siemens Tricore
+pub const EM_TRICORE: u16 = 44;
+/// Argonaut RISC Core
+pub const EM_ARC: u16 = 45;
+/// Hitachi H8/300
+pub const EM_H8_300: u16 = 46;
+/// Hitachi H8/300H
+pub const EM_H8_300H: u16 = 47;
+/// Hitachi H8S
+pub const EM_H8S: u16 = 48;
+/// Hitachi H8/500
+pub const EM_H8_500: u16 = 49;
+/// Intel Merced
+pub const EM_IA_64: u16 = 50;
+/// Stanford MIPS-X
+pub const EM_MIPS_X: u16 = 51;
+/// Motorola Coldfire
+pub const EM_COLDFIRE: u16 = 52;
+/// Motorola M68HC12
+pub const EM_68HC12: u16 = 53;
+/// Fujitsu MMA Multimedia Accelerator
+pub const EM_MMA: u16 = 54;
+/// Siemens PCP
+pub const EM_PCP: u16 = 55;
+/// Sony nCPU embeeded RISC
+pub const EM_NCPU: u16 = 56;
+/// Denso NDR1 microprocessor
+pub const EM_NDR1: u16 = 57;
+/// Motorola Start*Core processor
+pub const EM_STARCORE: u16 = 58;
+/// Toyota ME16 processor
+pub const EM_ME16: u16 = 59;
+/// STMicroelectronic ST100 processor
+pub const EM_ST100: u16 = 60;
+/// Advanced Logic Corp. Tinyj emb.fam
+pub const EM_TINYJ: u16 = 61;
+/// AMD x86-64 architecture
+pub const EM_X86_64: u16 = 62;
+/// Sony DSP Processor
+pub const EM_PDSP: u16 = 63;
+/// Digital PDP-10
+pub const EM_PDP10: u16 = 64;
+/// Digital PDP-11
+pub const EM_PDP11: u16 = 65;
+/// Siemens FX66 microcontroller
+pub const EM_FX66: u16 = 66;
+/// STMicroelectronics ST9+ 8/16 mc
+pub const EM_ST9PLUS: u16 = 67;
+/// STmicroelectronics ST7 8 bit mc
+pub const EM_ST7: u16 = 68;
+/// Motorola MC68HC16 microcontroller
+pub const EM_68HC16: u16 = 69;
+/// Motorola MC68HC11 microcontroller
+pub const EM_68HC11: u16 = 70;
+/// Motorola MC68HC08 microcontroller
+pub const EM_68HC08: u16 = 71;
+/// Motorola MC68HC05 microcontroller
+pub const EM_68HC05: u16 = 72;
+/// Silicon Graphics SVx
+pub const EM_SVX: u16 = 73;
+/// STMicroelectronics ST19 8 bit mc
+pub const EM_ST19: u16 = 74;
+/// Digital VAX
+pub const EM_VAX: u16 = 75;
+/// Axis Communications 32-bit emb.proc
+pub const EM_CRIS: u16 = 76;
+/// Infineon Technologies 32-bit emb.proc
+pub const EM_JAVELIN: u16 = 77;
+/// Element 14 64-bit DSP Processor
+pub const EM_FIREPATH: u16 = 78;
+/// LSI Logic 16-bit DSP Processor
+pub const EM_ZSP: u16 = 79;
+/// Donald Knuth's educational 64-bit proc
+pub const EM_MMIX: u16 = 80;
+/// Harvard University machine-independent object files
+pub const EM_HUANY: u16 = 81;
+/// SiTera Prism
+pub const EM_PRISM: u16 = 82;
+/// Atmel AVR 8-bit microcontroller
+pub const EM_AVR: u16 = 83;
+/// Fujitsu FR30
+pub const EM_FR30: u16 = 84;
+/// Mitsubishi D10V
+pub const EM_D10V: u16 = 85;
+/// Mitsubishi D30V
+pub const EM_D30V: u16 = 86;
+/// NEC v850
+pub const EM_V850: u16 = 87;
+/// Mitsubishi M32R
+pub const EM_M32R: u16 = 88;
+/// Matsushita MN10300
+pub const EM_MN10300: u16 = 89;
+/// Matsushita MN10200
+pub const EM_MN10200: u16 = 90;
+/// picoJava
+pub const EM_PJ: u16 = 91;
+/// OpenRISC 32-bit embedded processor
+pub const EM_OPENRISC: u16 = 92;
+/// ARC International ARCompact
+pub const EM_ARC_COMPACT: u16 = 93;
+/// Tensilica Xtensa Architecture
+pub const EM_XTENSA: u16 = 94;
+/// Alphamosaic VideoCore
+pub const EM_VIDEOCORE: u16 = 95;
+/// Thompson Multimedia General Purpose Proc
+pub const EM_TMM_GPP: u16 = 96;
+/// National Semi. 32000
+pub const EM_NS32K: u16 = 97;
+/// Tenor Network TPC
+pub const EM_TPC: u16 = 98;
+/// Trebia SNP 1000
+pub const EM_SNP1K: u16 = 99;
+/// STMicroelectronics ST200
+pub const EM_ST200: u16 = 100;
+/// Ubicom IP2xxx
+pub const EM_IP2K: u16 = 101;
+/// MAX processor
+pub const EM_MAX: u16 = 102;
+/// National Semi. CompactRISC
+pub const EM_CR: u16 = 103;
+/// Fujitsu F2MC16
+pub const EM_F2MC16: u16 = 104;
+/// Texas Instruments msp430
+pub const EM_MSP430: u16 = 105;
+/// Analog Devices Blackfin DSP
+pub const EM_BLACKFIN: u16 = 106;
+/// Seiko Epson S1C33 family
+pub const EM_SE_C33: u16 = 107;
+/// Sharp embedded microprocessor
+pub const EM_SEP: u16 = 108;
+/// Arca RISC
+pub const EM_ARCA: u16 = 109;
+/// PKU-Unity & MPRC Peking Uni. mc series
+pub const EM_UNICORE: u16 = 110;
+/// eXcess configurable cpu
+pub const EM_EXCESS: u16 = 111;
+/// Icera Semi. Deep Execution Processor
+pub const EM_DXP: u16 = 112;
+/// Altera Nios II
+pub const EM_ALTERA_NIOS2: u16 = 113;
+/// National Semi. CompactRISC CRX
+pub const EM_CRX: u16 = 114;
+/// Motorola XGATE
+pub const EM_XGATE: u16 = 115;
+/// Infineon C16x/XC16x
+pub const EM_C166: u16 = 116;
+/// Renesas M16C
+pub const EM_M16C: u16 = 117;
+/// Microchip Technology dsPIC30F
+pub const EM_DSPIC30F: u16 = 118;
+/// Freescale Communication Engine RISC
+pub const EM_CE: u16 = 119;
+/// Renesas M32C
+pub const EM_M32C: u16 = 120;
+/// Altium TSK3000
+pub const EM_TSK3000: u16 = 131;
+/// Freescale RS08
+pub const EM_RS08: u16 = 132;
+/// Analog Devices SHARC family
+pub const EM_SHARC: u16 = 133;
+/// Cyan Technology eCOG2
+pub const EM_ECOG2: u16 = 134;
+/// Sunplus S+core7 RISC
+pub const EM_SCORE7: u16 = 135;
+/// New Japan Radio (NJR) 24-bit DSP
+pub const EM_DSP24: u16 = 136;
+/// Broadcom VideoCore III
+pub const EM_VIDEOCORE3: u16 = 137;
+/// RISC for Lattice FPGA
+pub const EM_LATTICEMICO32: u16 = 138;
+/// Seiko Epson C17
+pub const EM_SE_C17: u16 = 139;
+/// Texas Instruments TMS320C6000 DSP
+pub const EM_TI_C6000: u16 = 140;
+/// Texas Instruments TMS320C2000 DSP
+pub const EM_TI_C2000: u16 = 141;
+/// Texas Instruments TMS320C55x DSP
+pub const EM_TI_C5500: u16 = 142;
+/// Texas Instruments App. Specific RISC
+pub const EM_TI_ARP32: u16 = 143;
+/// Texas Instruments Prog. Realtime Unit
+pub const EM_TI_PRU: u16 = 144;
+/// STMicroelectronics 64bit VLIW DSP
+pub const EM_MMDSP_PLUS: u16 = 160;
+/// Cypress M8C
+pub const EM_CYPRESS_M8C: u16 = 161;
+/// Renesas R32C
+pub const EM_R32C: u16 = 162;
+/// NXP Semi. TriMedia
+pub const EM_TRIMEDIA: u16 = 163;
+/// QUALCOMM Hexagon
+pub const EM_HEXAGON: u16 = 164;
+/// Intel 8051 and variants
+pub const EM_8051: u16 = 165;
+/// STMicroelectronics STxP7x
+pub const EM_STXP7X: u16 = 166;
+/// Andes Tech. compact code emb. RISC
+pub const EM_NDS32: u16 = 167;
+/// Cyan Technology eCOG1X
+pub const EM_ECOG1X: u16 = 168;
+/// Dallas Semi. MAXQ30 mc
+pub const EM_MAXQ30: u16 = 169;
+/// New Japan Radio (NJR) 16-bit DSP
+pub const EM_XIMO16: u16 = 170;
+/// M2000 Reconfigurable RISC
+pub const EM_MANIK: u16 = 171;
+/// Cray NV2 vector architecture
+pub const EM_CRAYNV2: u16 = 172;
+/// Renesas RX
+pub const EM_RX: u16 = 173;
+/// Imagination Tech. META
+pub const EM_METAG: u16 = 174;
+/// MCST Elbrus
+pub const EM_MCST_ELBRUS: u16 = 175;
+/// Cyan Technology eCOG16
+pub const EM_ECOG16: u16 = 176;
+/// National Semi. CompactRISC CR16
+pub const EM_CR16: u16 = 177;
+/// Freescale Extended Time Processing Unit
+pub const EM_ETPU: u16 = 178;
+/// Infineon Tech. SLE9X
+pub const EM_SLE9X: u16 = 179;
+/// Intel L10M
+pub const EM_L10M: u16 = 180;
+/// Intel K10M
+pub const EM_K10M: u16 = 181;
+/// ARM AARCH64
+pub const EM_AARCH64: u16 = 183;
+/// Amtel 32-bit microprocessor
+pub const EM_AVR32: u16 = 185;
+/// STMicroelectronics STM8
+pub const EM_STM8: u16 = 186;
+/// Tileta TILE64
+pub const EM_TILE64: u16 = 187;
+/// Tilera TILEPro
+pub const EM_TILEPRO: u16 = 188;
+/// Xilinx MicroBlaze
+pub const EM_MICROBLAZE: u16 = 189;
+/// NVIDIA CUDA
+pub const EM_CUDA: u16 = 190;
+/// Tilera TILE-Gx
+pub const EM_TILEGX: u16 = 191;
+/// CloudShield
+pub const EM_CLOUDSHIELD: u16 = 192;
+/// KIPO-KAIST Core-A 1st gen.
+pub const EM_COREA_1ST: u16 = 193;
+/// KIPO-KAIST Core-A 2nd gen.
+pub const EM_COREA_2ND: u16 = 194;
+/// Synopsys ARCompact V2
+pub const EM_ARC_COMPACT2: u16 = 195;
+/// Open8 RISC
+pub const EM_OPEN8: u16 = 196;
+/// Renesas RL78
+pub const EM_RL78: u16 = 197;
+/// Broadcom VideoCore V
+pub const EM_VIDEOCORE5: u16 = 198;
+/// Renesas 78KOR
+pub const EM_78KOR: u16 = 199;
+/// Freescale 56800EX DSC
+pub const EM_56800EX: u16 = 200;
+/// Beyond BA1
+pub const EM_BA1: u16 = 201;
+/// Beyond BA2
+pub const EM_BA2: u16 = 202;
+/// XMOS xCORE
+pub const EM_XCORE: u16 = 203;
+/// Microchip 8-bit PIC(r)
+pub const EM_MCHP_PIC: u16 = 204;
+/// KM211 KM32
+pub const EM_KM32: u16 = 210;
+/// KM211 KMX32
+pub const EM_KMX32: u16 = 211;
+/// KM211 KMX16
+pub const EM_EMX16: u16 = 212;
+/// KM211 KMX8
+pub const EM_EMX8: u16 = 213;
+/// KM211 KVARC
+pub const EM_KVARC: u16 = 214;
+/// Paneve CDP
+pub const EM_CDP: u16 = 215;
+/// Cognitive Smart Memory Processor
+pub const EM_COGE: u16 = 216;
+/// Bluechip CoolEngine
+pub const EM_COOL: u16 = 217;
+/// Nanoradio Optimized RISC
+pub const EM_NORC: u16 = 218;
+/// CSR Kalimba
+pub const EM_CSR_KALIMBA: u16 = 219;
+/// Zilog Z80
+pub const EM_Z80: u16 = 220;
+/// Controls and Data Services VISIUMcore
+pub const EM_VISIUM: u16 = 221;
+/// FTDI Chip FT32
+pub const EM_FT32: u16 = 222;
+/// Moxie processor
+pub const EM_MOXIE: u16 = 223;
+/// AMD GPU
+pub const EM_AMDGPU: u16 = 224;
+/// RISC-V
+pub const EM_RISCV: u16 = 243;
+/// Linux BPF -- in-kernel virtual machine
+pub const EM_BPF: u16 = 247;
+/// C-SKY
+pub const EM_CSKY: u16 = 252;
+/// Digital Alpha
+pub const EM_ALPHA: u16 = 0x9026;
+
+// Values for `FileHeader*::e_version` and `Ident::version`.
+/// Invalid ELF version.
+pub const EV_NONE: u8 = 0;
+/// Current ELF version.
+pub const EV_CURRENT: u8 = 1;
+
+/// Section header.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SectionHeader32<E: Endian> {
+ /// Section name.
+ ///
+ /// This is an offset into the section header string table.
+ pub sh_name: U32<E>,
+ /// Section type. One of the `SHT_*` constants.
+ pub sh_type: U32<E>,
+ /// Section flags. A combination of the `SHF_*` constants.
+ pub sh_flags: U32<E>,
+ /// Section virtual address at execution.
+ pub sh_addr: U32<E>,
+ /// Section file offset.
+ pub sh_offset: U32<E>,
+ /// Section size in bytes.
+ pub sh_size: U32<E>,
+ /// Link to another section.
+ ///
+ /// The section relationship depends on the `sh_type` value.
+ pub sh_link: U32<E>,
+ /// Additional section information.
+ ///
+ /// The meaning of this field depends on the `sh_type` value.
+ pub sh_info: U32<E>,
+ /// Section alignment.
+ pub sh_addralign: U32<E>,
+ /// Entry size if the section holds a table.
+ pub sh_entsize: U32<E>,
+}
+
+/// Section header.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SectionHeader64<E: Endian> {
+ /// Section name.
+ ///
+ /// This is an offset into the section header string table.
+ pub sh_name: U32<E>,
+ /// Section type. One of the `SHT_*` constants.
+ pub sh_type: U32<E>,
+ /// Section flags. A combination of the `SHF_*` constants.
+ pub sh_flags: U64<E>,
+ /// Section virtual address at execution.
+ pub sh_addr: U64<E>,
+ /// Section file offset.
+ pub sh_offset: U64<E>,
+ /// Section size in bytes.
+ pub sh_size: U64<E>,
+ /// Link to another section.
+ ///
+ /// The section relationship depends on the `sh_type` value.
+ pub sh_link: U32<E>,
+ /// Additional section information.
+ ///
+ /// The meaning of this field depends on the `sh_type` value.
+ pub sh_info: U32<E>,
+ /// Section alignment.
+ pub sh_addralign: U64<E>,
+ /// Entry size if the section holds a table.
+ pub sh_entsize: U64<E>,
+}
+
+// Special values for section indices.
+/// Undefined section.
+pub const SHN_UNDEF: u16 = 0;
+/// OS-specific range start.
+/// Start of reserved section indices.
+pub const SHN_LORESERVE: u16 = 0xff00;
+/// Start of processor-specific section indices.
+pub const SHN_LOPROC: u16 = 0xff00;
+/// End of processor-specific section indices.
+pub const SHN_HIPROC: u16 = 0xff1f;
+/// Start of OS-specific section indices.
+pub const SHN_LOOS: u16 = 0xff20;
+/// End of OS-specific section indices.
+pub const SHN_HIOS: u16 = 0xff3f;
+/// Associated symbol is absolute.
+pub const SHN_ABS: u16 = 0xfff1;
+/// Associated symbol is common.
+pub const SHN_COMMON: u16 = 0xfff2;
+/// Section index is in the `SHT_SYMTAB_SHNDX` section.
+pub const SHN_XINDEX: u16 = 0xffff;
+/// End of reserved section indices.
+pub const SHN_HIRESERVE: u16 = 0xffff;
+
+// Values for `SectionHeader*::sh_type`.
+/// Section header table entry is unused.
+pub const SHT_NULL: u32 = 0;
+/// Program data.
+pub const SHT_PROGBITS: u32 = 1;
+/// Symbol table.
+pub const SHT_SYMTAB: u32 = 2;
+/// String table.
+pub const SHT_STRTAB: u32 = 3;
+/// Relocation entries with explicit addends.
+pub const SHT_RELA: u32 = 4;
+/// Symbol hash table.
+pub const SHT_HASH: u32 = 5;
+/// Dynamic linking information.
+pub const SHT_DYNAMIC: u32 = 6;
+/// Notes.
+pub const SHT_NOTE: u32 = 7;
+/// Program space with no data (bss).
+pub const SHT_NOBITS: u32 = 8;
+/// Relocation entries without explicit addends.
+pub const SHT_REL: u32 = 9;
+/// Reserved section type.
+pub const SHT_SHLIB: u32 = 10;
+/// Dynamic linker symbol table.
+pub const SHT_DYNSYM: u32 = 11;
+/// Array of constructors.
+pub const SHT_INIT_ARRAY: u32 = 14;
+/// Array of destructors.
+pub const SHT_FINI_ARRAY: u32 = 15;
+/// Array of pre-constructors.
+pub const SHT_PREINIT_ARRAY: u32 = 16;
+/// Section group.
+pub const SHT_GROUP: u32 = 17;
+/// Extended section indices for a symbol table.
+pub const SHT_SYMTAB_SHNDX: u32 = 18;
+/// Start of OS-specific section types.
+pub const SHT_LOOS: u32 = 0x6000_0000;
+/// Object attributes.
+pub const SHT_GNU_ATTRIBUTES: u32 = 0x6fff_fff5;
+/// GNU-style hash table.
+pub const SHT_GNU_HASH: u32 = 0x6fff_fff6;
+/// Prelink library list
+pub const SHT_GNU_LIBLIST: u32 = 0x6fff_fff7;
+/// Checksum for DSO content.
+pub const SHT_CHECKSUM: u32 = 0x6fff_fff8;
+/// Sun-specific low bound.
+pub const SHT_LOSUNW: u32 = 0x6fff_fffa;
+#[allow(missing_docs, non_upper_case_globals)]
+pub const SHT_SUNW_move: u32 = 0x6fff_fffa;
+#[allow(missing_docs)]
+pub const SHT_SUNW_COMDAT: u32 = 0x6fff_fffb;
+#[allow(missing_docs, non_upper_case_globals)]
+pub const SHT_SUNW_syminfo: u32 = 0x6fff_fffc;
+/// Version definition section.
+#[allow(non_upper_case_globals)]
+pub const SHT_GNU_VERDEF: u32 = 0x6fff_fffd;
+/// Version needs section.
+#[allow(non_upper_case_globals)]
+pub const SHT_GNU_VERNEED: u32 = 0x6fff_fffe;
+/// Version symbol table.
+#[allow(non_upper_case_globals)]
+pub const SHT_GNU_VERSYM: u32 = 0x6fff_ffff;
+/// Sun-specific high bound.
+pub const SHT_HISUNW: u32 = 0x6fff_ffff;
+/// End of OS-specific section types.
+pub const SHT_HIOS: u32 = 0x6fff_ffff;
+/// Start of processor-specific section types.
+pub const SHT_LOPROC: u32 = 0x7000_0000;
+/// End of processor-specific section types.
+pub const SHT_HIPROC: u32 = 0x7fff_ffff;
+/// Start of application-specific section types.
+pub const SHT_LOUSER: u32 = 0x8000_0000;
+/// End of application-specific section types.
+pub const SHT_HIUSER: u32 = 0x8fff_ffff;
+
+// Values for `SectionHeader*::sh_flags`.
+/// Section is writable.
+pub const SHF_WRITE: u32 = 1 << 0;
+/// Section occupies memory during execution.
+pub const SHF_ALLOC: u32 = 1 << 1;
+/// Section is executable.
+pub const SHF_EXECINSTR: u32 = 1 << 2;
+/// Section may be be merged to eliminate duplication.
+pub const SHF_MERGE: u32 = 1 << 4;
+/// Section contains nul-terminated strings.
+pub const SHF_STRINGS: u32 = 1 << 5;
+/// The `sh_info` field contains a section header table index.
+pub const SHF_INFO_LINK: u32 = 1 << 6;
+/// Section has special ordering requirements when combining sections.
+pub const SHF_LINK_ORDER: u32 = 1 << 7;
+/// Section requires special OS-specific handling.
+pub const SHF_OS_NONCONFORMING: u32 = 1 << 8;
+/// Section is a member of a group.
+pub const SHF_GROUP: u32 = 1 << 9;
+/// Section holds thread-local storage.
+pub const SHF_TLS: u32 = 1 << 10;
+/// Section is compressed.
+///
+/// Compressed sections begin with one of the `CompressionHeader*` headers.
+pub const SHF_COMPRESSED: u32 = 1 << 11;
+/// OS-specific section flags.
+pub const SHF_MASKOS: u32 = 0x0ff0_0000;
+/// Processor-specific section flags.
+pub const SHF_MASKPROC: u32 = 0xf000_0000;
+/// This section is excluded from the final executable or shared library.
+pub const SHF_EXCLUDE: u32 = 0x8000_0000;
+
+/// Section compression header.
+///
+/// Used when `SHF_COMPRESSED` is set.
+///
+/// Note: this type currently allows for misaligned headers, but that may be
+/// changed in a future version.
+#[derive(Debug, Default, Clone, Copy)]
+#[repr(C)]
+pub struct CompressionHeader32<E: Endian> {
+ /// Compression format. One of the `ELFCOMPRESS_*` values.
+ pub ch_type: U32Bytes<E>,
+ /// Uncompressed data size.
+ pub ch_size: U32Bytes<E>,
+ /// Uncompressed data alignment.
+ pub ch_addralign: U32Bytes<E>,
+}
+
+/// Section compression header.
+///
+/// Used when `SHF_COMPRESSED` is set.
+///
+/// Note: this type currently allows for misaligned headers, but that may be
+/// changed in a future version.
+#[derive(Debug, Default, Clone, Copy)]
+#[repr(C)]
+pub struct CompressionHeader64<E: Endian> {
+ /// Compression format. One of the `ELFCOMPRESS_*` values.
+ pub ch_type: U32Bytes<E>,
+ /// Reserved.
+ pub ch_reserved: U32Bytes<E>,
+ /// Uncompressed data size.
+ pub ch_size: U64Bytes<E>,
+ /// Uncompressed data alignment.
+ pub ch_addralign: U64Bytes<E>,
+}
+
+/// ZLIB/DEFLATE algorithm.
+pub const ELFCOMPRESS_ZLIB: u32 = 1;
+/// Start of OS-specific compression types.
+pub const ELFCOMPRESS_LOOS: u32 = 0x6000_0000;
+/// End of OS-specific compression types.
+pub const ELFCOMPRESS_HIOS: u32 = 0x6fff_ffff;
+/// Start of processor-specific compression types.
+pub const ELFCOMPRESS_LOPROC: u32 = 0x7000_0000;
+/// End of processor-specific compression types.
+pub const ELFCOMPRESS_HIPROC: u32 = 0x7fff_ffff;
+
+// Values for the flag entry for section groups.
+/// Mark group as COMDAT.
+pub const GRP_COMDAT: u32 = 1;
+
+/// Symbol table entry.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Sym32<E: Endian> {
+ /// Symbol name.
+ ///
+ /// This is an offset into the symbol string table.
+ pub st_name: U32<E>,
+ /// Symbol value.
+ pub st_value: U32<E>,
+ /// Symbol size.
+ pub st_size: U32<E>,
+ /// Symbol type and binding.
+ ///
+ /// Use the `st_type` and `st_bind` methods to access this value.
+ pub st_info: u8,
+ /// Symbol visibility.
+ ///
+ /// Use the `st_visibility` method to access this value.
+ pub st_other: u8,
+ /// Section index or one of the `SHN_*` values.
+ pub st_shndx: U16<E>,
+}
+
+impl<E: Endian> Sym32<E> {
+ /// Get the `st_bind` component of the `st_info` field.
+ #[inline]
+ pub fn st_bind(&self) -> u8 {
+ self.st_info >> 4
+ }
+
+ /// Get the `st_type` component of the `st_info` field.
+ #[inline]
+ pub fn st_type(&self) -> u8 {
+ self.st_info & 0xf
+ }
+
+ /// Set the `st_info` field given the `st_bind` and `st_type` components.
+ #[inline]
+ pub fn set_st_info(&mut self, st_bind: u8, st_type: u8) {
+ self.st_info = (st_bind << 4) + (st_type & 0xf);
+ }
+
+ /// Get the `st_visibility` component of the `st_info` field.
+ #[inline]
+ pub fn st_visibility(&self) -> u8 {
+ self.st_other & 0x3
+ }
+}
+
+/// Symbol table entry.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Sym64<E: Endian> {
+ /// Symbol name.
+ ///
+ /// This is an offset into the symbol string table.
+ pub st_name: U32<E>,
+ /// Symbol type and binding.
+ ///
+ /// Use the `st_bind` and `st_type` methods to access this value.
+ pub st_info: u8,
+ /// Symbol visibility.
+ ///
+ /// Use the `st_visibility` method to access this value.
+ pub st_other: u8,
+ /// Section index or one of the `SHN_*` values.
+ pub st_shndx: U16<E>,
+ /// Symbol value.
+ pub st_value: U64<E>,
+ /// Symbol size.
+ pub st_size: U64<E>,
+}
+
+impl<E: Endian> Sym64<E> {
+ /// Get the `st_bind` component of the `st_info` field.
+ #[inline]
+ pub fn st_bind(&self) -> u8 {
+ self.st_info >> 4
+ }
+
+ /// Get the `st_type` component of the `st_info` field.
+ #[inline]
+ pub fn st_type(&self) -> u8 {
+ self.st_info & 0xf
+ }
+
+ /// Set the `st_info` field given the `st_bind` and `st_type` components.
+ #[inline]
+ pub fn set_st_info(&mut self, st_bind: u8, st_type: u8) {
+ self.st_info = (st_bind << 4) + (st_type & 0xf);
+ }
+
+ /// Get the `st_visibility` component of the `st_info` field.
+ #[inline]
+ pub fn st_visibility(&self) -> u8 {
+ self.st_other & 0x3
+ }
+}
+
+/// Additional information about a `Sym32`.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Syminfo32<E: Endian> {
+ /// Direct bindings, symbol bound to.
+ pub si_boundto: U16<E>,
+ /// Per symbol flags.
+ pub si_flags: U16<E>,
+}
+
+/// Additional information about a `Sym64`.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Syminfo64<E: Endian> {
+ /// Direct bindings, symbol bound to.
+ pub si_boundto: U16<E>,
+ /// Per symbol flags.
+ pub si_flags: U16<E>,
+}
+
+// Values for `Syminfo*::si_boundto`.
+/// Symbol bound to self
+pub const SYMINFO_BT_SELF: u16 = 0xffff;
+/// Symbol bound to parent
+pub const SYMINFO_BT_PARENT: u16 = 0xfffe;
+/// Beginning of reserved entries
+pub const SYMINFO_BT_LOWRESERVE: u16 = 0xff00;
+
+// Values for `Syminfo*::si_flags`.
+/// Direct bound symbol
+pub const SYMINFO_FLG_DIRECT: u16 = 0x0001;
+/// Pass-thru symbol for translator
+pub const SYMINFO_FLG_PASSTHRU: u16 = 0x0002;
+/// Symbol is a copy-reloc
+pub const SYMINFO_FLG_COPY: u16 = 0x0004;
+/// Symbol bound to object to be lazy loaded
+pub const SYMINFO_FLG_LAZYLOAD: u16 = 0x0008;
+
+// Syminfo version values.
+#[allow(missing_docs)]
+pub const SYMINFO_NONE: u16 = 0;
+#[allow(missing_docs)]
+pub const SYMINFO_CURRENT: u16 = 1;
+#[allow(missing_docs)]
+pub const SYMINFO_NUM: u16 = 2;
+
+// Values for bind component of `Sym*::st_info`.
+/// Local symbol.
+pub const STB_LOCAL: u8 = 0;
+/// Global symbol.
+pub const STB_GLOBAL: u8 = 1;
+/// Weak symbol.
+pub const STB_WEAK: u8 = 2;
+/// Start of OS-specific symbol binding.
+pub const STB_LOOS: u8 = 10;
+/// Unique symbol.
+pub const STB_GNU_UNIQUE: u8 = 10;
+/// End of OS-specific symbol binding.
+pub const STB_HIOS: u8 = 12;
+/// Start of processor-specific symbol binding.
+pub const STB_LOPROC: u8 = 13;
+/// End of processor-specific symbol binding.
+pub const STB_HIPROC: u8 = 15;
+
+// Values for type component of `Sym*::st_info`.
+/// Symbol type is unspecified.
+pub const STT_NOTYPE: u8 = 0;
+/// Symbol is a data object.
+pub const STT_OBJECT: u8 = 1;
+/// Symbol is a code object.
+pub const STT_FUNC: u8 = 2;
+/// Symbol is associated with a section.
+pub const STT_SECTION: u8 = 3;
+/// Symbol's name is a file name.
+pub const STT_FILE: u8 = 4;
+/// Symbol is a common data object.
+pub const STT_COMMON: u8 = 5;
+/// Symbol is a thread-local storage object.
+pub const STT_TLS: u8 = 6;
+/// Start of OS-specific symbol types.
+pub const STT_LOOS: u8 = 10;
+/// Symbol is an indirect code object.
+pub const STT_GNU_IFUNC: u8 = 10;
+/// End of OS-specific symbol types.
+pub const STT_HIOS: u8 = 12;
+/// Start of processor-specific symbol types.
+pub const STT_LOPROC: u8 = 13;
+/// End of processor-specific symbol types.
+pub const STT_HIPROC: u8 = 15;
+
+// Values for visibility component of `Symbol*::st_other`.
+/// Default symbol visibility rules.
+pub const STV_DEFAULT: u8 = 0;
+/// Processor specific hidden class.
+pub const STV_INTERNAL: u8 = 1;
+/// Symbol is not visible to other components.
+pub const STV_HIDDEN: u8 = 2;
+/// Symbol is visible to other components, but is not preemptible.
+pub const STV_PROTECTED: u8 = 3;
+
+/// Relocation table entry without explicit addend.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Rel32<E: Endian> {
+ /// Relocation address.
+ pub r_offset: U32<E>,
+ /// Relocation type and symbol index.
+ pub r_info: U32<E>,
+}
+
+impl<E: Endian> Rel32<E> {
+ /// Get the `r_sym` component of the `r_info` field.
+ #[inline]
+ pub fn r_sym(&self, endian: E) -> u32 {
+ self.r_info.get(endian) >> 8
+ }
+
+ /// Get the `r_type` component of the `r_info` field.
+ #[inline]
+ pub fn r_type(&self, endian: E) -> u32 {
+ self.r_info.get(endian) & 0xff
+ }
+
+ /// Calculate the `r_info` field given the `r_sym` and `r_type` components.
+ pub fn r_info(endian: E, r_sym: u32, r_type: u8) -> U32<E> {
+ U32::new(endian, (r_sym << 8) | u32::from(r_type))
+ }
+
+ /// Set the `r_info` field given the `r_sym` and `r_type` components.
+ pub fn set_r_info(&mut self, endian: E, r_sym: u32, r_type: u8) {
+ self.r_info = Self::r_info(endian, r_sym, r_type)
+ }
+}
+
+/// Relocation table entry with explicit addend.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Rela32<E: Endian> {
+ /// Relocation address.
+ pub r_offset: U32<E>,
+ /// Relocation type and symbol index.
+ pub r_info: U32<E>,
+ /// Explicit addend.
+ pub r_addend: I32<E>,
+}
+
+impl<E: Endian> Rela32<E> {
+ /// Get the `r_sym` component of the `r_info` field.
+ #[inline]
+ pub fn r_sym(&self, endian: E) -> u32 {
+ self.r_info.get(endian) >> 8
+ }
+
+ /// Get the `r_type` component of the `r_info` field.
+ #[inline]
+ pub fn r_type(&self, endian: E) -> u32 {
+ self.r_info.get(endian) & 0xff
+ }
+
+ /// Calculate the `r_info` field given the `r_sym` and `r_type` components.
+ pub fn r_info(endian: E, r_sym: u32, r_type: u8) -> U32<E> {
+ U32::new(endian, (r_sym << 8) | u32::from(r_type))
+ }
+
+ /// Set the `r_info` field given the `r_sym` and `r_type` components.
+ pub fn set_r_info(&mut self, endian: E, r_sym: u32, r_type: u8) {
+ self.r_info = Self::r_info(endian, r_sym, r_type)
+ }
+}
+
+impl<E: Endian> From<Rel32<E>> for Rela32<E> {
+ fn from(rel: Rel32<E>) -> Self {
+ Rela32 {
+ r_offset: rel.r_offset,
+ r_info: rel.r_info,
+ r_addend: I32::default(),
+ }
+ }
+}
+
+/// Relocation table entry without explicit addend.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Rel64<E: Endian> {
+ /// Relocation address.
+ pub r_offset: U64<E>,
+ /// Relocation type and symbol index.
+ pub r_info: U64<E>,
+}
+
+impl<E: Endian> Rel64<E> {
+ /// Get the `r_sym` component of the `r_info` field.
+ #[inline]
+ pub fn r_sym(&self, endian: E) -> u32 {
+ (self.r_info.get(endian) >> 32) as u32
+ }
+
+ /// Get the `r_type` component of the `r_info` field.
+ #[inline]
+ pub fn r_type(&self, endian: E) -> u32 {
+ (self.r_info.get(endian) & 0xffff_ffff) as u32
+ }
+
+ /// Calculate the `r_info` field given the `r_sym` and `r_type` components.
+ pub fn r_info(endian: E, r_sym: u32, r_type: u32) -> U64<E> {
+ U64::new(endian, (u64::from(r_sym) << 32) | u64::from(r_type))
+ }
+
+ /// Set the `r_info` field given the `r_sym` and `r_type` components.
+ pub fn set_r_info(&mut self, endian: E, r_sym: u32, r_type: u32) {
+ self.r_info = Self::r_info(endian, r_sym, r_type)
+ }
+}
+
+impl<E: Endian> From<Rel64<E>> for Rela64<E> {
+ fn from(rel: Rel64<E>) -> Self {
+ Rela64 {
+ r_offset: rel.r_offset,
+ r_info: rel.r_info,
+ r_addend: I64::default(),
+ }
+ }
+}
+
+/// Relocation table entry with explicit addend.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Rela64<E: Endian> {
+ /// Relocation address.
+ pub r_offset: U64<E>,
+ /// Relocation type and symbol index.
+ pub r_info: U64<E>,
+ /// Explicit addend.
+ pub r_addend: I64<E>,
+}
+
+impl<E: Endian> Rela64<E> {
+ pub(crate) fn get_r_info(&self, endian: E, is_mips64el: bool) -> u64 {
+ let mut t = self.r_info.get(endian);
+ if is_mips64el {
+ t = (t << 32)
+ | ((t >> 8) & 0xff000000)
+ | ((t >> 24) & 0x00ff0000)
+ | ((t >> 40) & 0x0000ff00)
+ | ((t >> 56) & 0x000000ff);
+ }
+ t
+ }
+
+ /// Get the `r_sym` component of the `r_info` field.
+ #[inline]
+ pub fn r_sym(&self, endian: E, is_mips64el: bool) -> u32 {
+ (self.get_r_info(endian, is_mips64el) >> 32) as u32
+ }
+
+ /// Get the `r_type` component of the `r_info` field.
+ #[inline]
+ pub fn r_type(&self, endian: E, is_mips64el: bool) -> u32 {
+ (self.get_r_info(endian, is_mips64el) & 0xffff_ffff) as u32
+ }
+
+ /// Calculate the `r_info` field given the `r_sym` and `r_type` components.
+ pub fn r_info(endian: E, is_mips64el: bool, r_sym: u32, r_type: u32) -> U64<E> {
+ let mut t = (u64::from(r_sym) << 32) | u64::from(r_type);
+ if is_mips64el {
+ t = (t >> 32)
+ | ((t & 0xff000000) << 8)
+ | ((t & 0x00ff0000) << 24)
+ | ((t & 0x0000ff00) << 40)
+ | ((t & 0x000000ff) << 56);
+ }
+ U64::new(endian, t)
+ }
+
+ /// Set the `r_info` field given the `r_sym` and `r_type` components.
+ pub fn set_r_info(&mut self, endian: E, is_mips64el: bool, r_sym: u32, r_type: u32) {
+ self.r_info = Self::r_info(endian, is_mips64el, r_sym, r_type);
+ }
+}
+
+/// Program segment header.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ProgramHeader32<E: Endian> {
+ /// Segment type. One of the `PT_*` constants.
+ pub p_type: U32<E>,
+ /// Segment file offset.
+ pub p_offset: U32<E>,
+ /// Segment virtual address.
+ pub p_vaddr: U32<E>,
+ /// Segment physical address.
+ pub p_paddr: U32<E>,
+ /// Segment size in the file.
+ pub p_filesz: U32<E>,
+ /// Segment size in memory.
+ pub p_memsz: U32<E>,
+ /// Segment flags. A combination of the `PF_*` constants.
+ pub p_flags: U32<E>,
+ /// Segment alignment.
+ pub p_align: U32<E>,
+}
+
+/// Program segment header.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ProgramHeader64<E: Endian> {
+ /// Segment type. One of the `PT_*` constants.
+ pub p_type: U32<E>,
+ /// Segment flags. A combination of the `PF_*` constants.
+ pub p_flags: U32<E>,
+ /// Segment file offset.
+ pub p_offset: U64<E>,
+ /// Segment virtual address.
+ pub p_vaddr: U64<E>,
+ /// Segment physical address.
+ pub p_paddr: U64<E>,
+ /// Segment size in the file.
+ pub p_filesz: U64<E>,
+ /// Segment size in memory.
+ pub p_memsz: U64<E>,
+ /// Segment alignment.
+ pub p_align: U64<E>,
+}
+
+/// Special value for `FileHeader*::e_phnum`.
+///
+/// This indicates that the real number of program headers is too large to fit into e_phnum.
+/// Instead the real value is in the field `sh_info` of section 0.
+pub const PN_XNUM: u16 = 0xffff;
+
+// Values for `ProgramHeader*::p_type`.
+/// Program header table entry is unused.
+pub const PT_NULL: u32 = 0;
+/// Loadable program segment.
+pub const PT_LOAD: u32 = 1;
+/// Dynamic linking information.
+pub const PT_DYNAMIC: u32 = 2;
+/// Program interpreter.
+pub const PT_INTERP: u32 = 3;
+/// Auxiliary information.
+pub const PT_NOTE: u32 = 4;
+/// Reserved.
+pub const PT_SHLIB: u32 = 5;
+/// Segment contains the program header table.
+pub const PT_PHDR: u32 = 6;
+/// Thread-local storage segment.
+pub const PT_TLS: u32 = 7;
+/// Start of OS-specific segment types.
+pub const PT_LOOS: u32 = 0x6000_0000;
+/// GCC `.eh_frame_hdr` segment.
+pub const PT_GNU_EH_FRAME: u32 = 0x6474_e550;
+/// Indicates stack executability.
+pub const PT_GNU_STACK: u32 = 0x6474_e551;
+/// Read-only after relocation.
+pub const PT_GNU_RELRO: u32 = 0x6474_e552;
+/// End of OS-specific segment types.
+pub const PT_HIOS: u32 = 0x6fff_ffff;
+/// Start of processor-specific segment types.
+pub const PT_LOPROC: u32 = 0x7000_0000;
+/// End of processor-specific segment types.
+pub const PT_HIPROC: u32 = 0x7fff_ffff;
+
+// Values for `ProgramHeader*::p_flags`.
+/// Segment is executable.
+pub const PF_X: u32 = 1 << 0;
+/// Segment is writable.
+pub const PF_W: u32 = 1 << 1;
+/// Segment is readable.
+pub const PF_R: u32 = 1 << 2;
+/// OS-specific segment flags.
+pub const PF_MASKOS: u32 = 0x0ff0_0000;
+/// Processor-specific segment flags.
+pub const PF_MASKPROC: u32 = 0xf000_0000;
+
+/// Note name for core files.
+pub static ELF_NOTE_CORE: &[u8] = b"CORE";
+/// Note name for linux core files.
+///
+/// Notes in linux core files may also use `ELF_NOTE_CORE`.
+pub static ELF_NOTE_LINUX: &[u8] = b"LINUX";
+
+// Values for `NoteHeader*::n_type` in core files.
+//
+/// Contains copy of prstatus struct.
+pub const NT_PRSTATUS: u32 = 1;
+/// Contains copy of fpregset struct.
+pub const NT_PRFPREG: u32 = 2;
+/// Contains copy of fpregset struct.
+pub const NT_FPREGSET: u32 = 2;
+/// Contains copy of prpsinfo struct.
+pub const NT_PRPSINFO: u32 = 3;
+/// Contains copy of prxregset struct.
+pub const NT_PRXREG: u32 = 4;
+/// Contains copy of task structure.
+pub const NT_TASKSTRUCT: u32 = 4;
+/// String from sysinfo(SI_PLATFORM).
+pub const NT_PLATFORM: u32 = 5;
+/// Contains copy of auxv array.
+pub const NT_AUXV: u32 = 6;
+/// Contains copy of gwindows struct.
+pub const NT_GWINDOWS: u32 = 7;
+/// Contains copy of asrset struct.
+pub const NT_ASRS: u32 = 8;
+/// Contains copy of pstatus struct.
+pub const NT_PSTATUS: u32 = 10;
+/// Contains copy of psinfo struct.
+pub const NT_PSINFO: u32 = 13;
+/// Contains copy of prcred struct.
+pub const NT_PRCRED: u32 = 14;
+/// Contains copy of utsname struct.
+pub const NT_UTSNAME: u32 = 15;
+/// Contains copy of lwpstatus struct.
+pub const NT_LWPSTATUS: u32 = 16;
+/// Contains copy of lwpinfo struct.
+pub const NT_LWPSINFO: u32 = 17;
+/// Contains copy of fprxregset struct.
+pub const NT_PRFPXREG: u32 = 20;
+/// Contains copy of siginfo_t, size might increase.
+pub const NT_SIGINFO: u32 = 0x5349_4749;
+/// Contains information about mapped files.
+pub const NT_FILE: u32 = 0x4649_4c45;
+/// Contains copy of user_fxsr_struct.
+pub const NT_PRXFPREG: u32 = 0x46e6_2b7f;
+/// PowerPC Altivec/VMX registers.
+pub const NT_PPC_VMX: u32 = 0x100;
+/// PowerPC SPE/EVR registers.
+pub const NT_PPC_SPE: u32 = 0x101;
+/// PowerPC VSX registers.
+pub const NT_PPC_VSX: u32 = 0x102;
+/// Target Address Register.
+pub const NT_PPC_TAR: u32 = 0x103;
+/// Program Priority Register.
+pub const NT_PPC_PPR: u32 = 0x104;
+/// Data Stream Control Register.
+pub const NT_PPC_DSCR: u32 = 0x105;
+/// Event Based Branch Registers.
+pub const NT_PPC_EBB: u32 = 0x106;
+/// Performance Monitor Registers.
+pub const NT_PPC_PMU: u32 = 0x107;
+/// TM checkpointed GPR Registers.
+pub const NT_PPC_TM_CGPR: u32 = 0x108;
+/// TM checkpointed FPR Registers.
+pub const NT_PPC_TM_CFPR: u32 = 0x109;
+/// TM checkpointed VMX Registers.
+pub const NT_PPC_TM_CVMX: u32 = 0x10a;
+/// TM checkpointed VSX Registers.
+pub const NT_PPC_TM_CVSX: u32 = 0x10b;
+/// TM Special Purpose Registers.
+pub const NT_PPC_TM_SPR: u32 = 0x10c;
+/// TM checkpointed Target Address Register.
+pub const NT_PPC_TM_CTAR: u32 = 0x10d;
+/// TM checkpointed Program Priority Register.
+pub const NT_PPC_TM_CPPR: u32 = 0x10e;
+/// TM checkpointed Data Stream Control Register.
+pub const NT_PPC_TM_CDSCR: u32 = 0x10f;
+/// Memory Protection Keys registers.
+pub const NT_PPC_PKEY: u32 = 0x110;
+/// i386 TLS slots (struct user_desc).
+pub const NT_386_TLS: u32 = 0x200;
+/// x86 io permission bitmap (1=deny).
+pub const NT_386_IOPERM: u32 = 0x201;
+/// x86 extended state using xsave.
+pub const NT_X86_XSTATE: u32 = 0x202;
+/// s390 upper register halves.
+pub const NT_S390_HIGH_GPRS: u32 = 0x300;
+/// s390 timer register.
+pub const NT_S390_TIMER: u32 = 0x301;
+/// s390 TOD clock comparator register.
+pub const NT_S390_TODCMP: u32 = 0x302;
+/// s390 TOD programmable register.
+pub const NT_S390_TODPREG: u32 = 0x303;
+/// s390 control registers.
+pub const NT_S390_CTRS: u32 = 0x304;
+/// s390 prefix register.
+pub const NT_S390_PREFIX: u32 = 0x305;
+/// s390 breaking event address.
+pub const NT_S390_LAST_BREAK: u32 = 0x306;
+/// s390 system call restart data.
+pub const NT_S390_SYSTEM_CALL: u32 = 0x307;
+/// s390 transaction diagnostic block.
+pub const NT_S390_TDB: u32 = 0x308;
+/// s390 vector registers 0-15 upper half.
+pub const NT_S390_VXRS_LOW: u32 = 0x309;
+/// s390 vector registers 16-31.
+pub const NT_S390_VXRS_HIGH: u32 = 0x30a;
+/// s390 guarded storage registers.
+pub const NT_S390_GS_CB: u32 = 0x30b;
+/// s390 guarded storage broadcast control block.
+pub const NT_S390_GS_BC: u32 = 0x30c;
+/// s390 runtime instrumentation.
+pub const NT_S390_RI_CB: u32 = 0x30d;
+/// ARM VFP/NEON registers.
+pub const NT_ARM_VFP: u32 = 0x400;
+/// ARM TLS register.
+pub const NT_ARM_TLS: u32 = 0x401;
+/// ARM hardware breakpoint registers.
+pub const NT_ARM_HW_BREAK: u32 = 0x402;
+/// ARM hardware watchpoint registers.
+pub const NT_ARM_HW_WATCH: u32 = 0x403;
+/// ARM system call number.
+pub const NT_ARM_SYSTEM_CALL: u32 = 0x404;
+/// ARM Scalable Vector Extension registers.
+pub const NT_ARM_SVE: u32 = 0x405;
+/// Vmcore Device Dump Note.
+pub const NT_VMCOREDD: u32 = 0x700;
+/// MIPS DSP ASE registers.
+pub const NT_MIPS_DSP: u32 = 0x800;
+/// MIPS floating-point mode.
+pub const NT_MIPS_FP_MODE: u32 = 0x801;
+
+/// Note type for version string.
+///
+/// This note may appear in object files.
+///
+/// It must be handled as a special case because it has no descriptor, and instead
+/// uses the note name as the version string.
+pub const NT_VERSION: u32 = 1;
+
+/// Dynamic section entry.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Dyn32<E: Endian> {
+ /// Dynamic entry type.
+ pub d_tag: U32<E>,
+ /// Value (integer or address).
+ pub d_val: U32<E>,
+}
+
+/// Dynamic section entry.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Dyn64<E: Endian> {
+ /// Dynamic entry type.
+ pub d_tag: U64<E>,
+ /// Value (integer or address).
+ pub d_val: U64<E>,
+}
+
+// Values for `Dyn*::d_tag`.
+
+/// Marks end of dynamic section
+pub const DT_NULL: u32 = 0;
+/// Name of needed library
+pub const DT_NEEDED: u32 = 1;
+/// Size in bytes of PLT relocs
+pub const DT_PLTRELSZ: u32 = 2;
+/// Processor defined value
+pub const DT_PLTGOT: u32 = 3;
+/// Address of symbol hash table
+pub const DT_HASH: u32 = 4;
+/// Address of string table
+pub const DT_STRTAB: u32 = 5;
+/// Address of symbol table
+pub const DT_SYMTAB: u32 = 6;
+/// Address of Rela relocs
+pub const DT_RELA: u32 = 7;
+/// Total size of Rela relocs
+pub const DT_RELASZ: u32 = 8;
+/// Size of one Rela reloc
+pub const DT_RELAENT: u32 = 9;
+/// Size of string table
+pub const DT_STRSZ: u32 = 10;
+/// Size of one symbol table entry
+pub const DT_SYMENT: u32 = 11;
+/// Address of init function
+pub const DT_INIT: u32 = 12;
+/// Address of termination function
+pub const DT_FINI: u32 = 13;
+/// Name of shared object
+pub const DT_SONAME: u32 = 14;
+/// Library search path (deprecated)
+pub const DT_RPATH: u32 = 15;
+/// Start symbol search here
+pub const DT_SYMBOLIC: u32 = 16;
+/// Address of Rel relocs
+pub const DT_REL: u32 = 17;
+/// Total size of Rel relocs
+pub const DT_RELSZ: u32 = 18;
+/// Size of one Rel reloc
+pub const DT_RELENT: u32 = 19;
+/// Type of reloc in PLT
+pub const DT_PLTREL: u32 = 20;
+/// For debugging; unspecified
+pub const DT_DEBUG: u32 = 21;
+/// Reloc might modify .text
+pub const DT_TEXTREL: u32 = 22;
+/// Address of PLT relocs
+pub const DT_JMPREL: u32 = 23;
+/// Process relocations of object
+pub const DT_BIND_NOW: u32 = 24;
+/// Array with addresses of init fct
+pub const DT_INIT_ARRAY: u32 = 25;
+/// Array with addresses of fini fct
+pub const DT_FINI_ARRAY: u32 = 26;
+/// Size in bytes of DT_INIT_ARRAY
+pub const DT_INIT_ARRAYSZ: u32 = 27;
+/// Size in bytes of DT_FINI_ARRAY
+pub const DT_FINI_ARRAYSZ: u32 = 28;
+/// Library search path
+pub const DT_RUNPATH: u32 = 29;
+/// Flags for the object being loaded
+pub const DT_FLAGS: u32 = 30;
+/// Start of encoded range
+pub const DT_ENCODING: u32 = 32;
+/// Array with addresses of preinit fct
+pub const DT_PREINIT_ARRAY: u32 = 32;
+/// size in bytes of DT_PREINIT_ARRAY
+pub const DT_PREINIT_ARRAYSZ: u32 = 33;
+/// Address of SYMTAB_SHNDX section
+pub const DT_SYMTAB_SHNDX: u32 = 34;
+/// Start of OS-specific
+pub const DT_LOOS: u32 = 0x6000_000d;
+/// End of OS-specific
+pub const DT_HIOS: u32 = 0x6fff_f000;
+/// Start of processor-specific
+pub const DT_LOPROC: u32 = 0x7000_0000;
+/// End of processor-specific
+pub const DT_HIPROC: u32 = 0x7fff_ffff;
+
+// `DT_*` entries between `DT_VALRNGHI` & `DT_VALRNGLO` use `d_val` as a value.
+#[allow(missing_docs)]
+pub const DT_VALRNGLO: u32 = 0x6fff_fd00;
+/// Prelinking timestamp
+pub const DT_GNU_PRELINKED: u32 = 0x6fff_fdf5;
+/// Size of conflict section
+pub const DT_GNU_CONFLICTSZ: u32 = 0x6fff_fdf6;
+/// Size of library list
+pub const DT_GNU_LIBLISTSZ: u32 = 0x6fff_fdf7;
+#[allow(missing_docs)]
+pub const DT_CHECKSUM: u32 = 0x6fff_fdf8;
+#[allow(missing_docs)]
+pub const DT_PLTPADSZ: u32 = 0x6fff_fdf9;
+#[allow(missing_docs)]
+pub const DT_MOVEENT: u32 = 0x6fff_fdfa;
+#[allow(missing_docs)]
+pub const DT_MOVESZ: u32 = 0x6fff_fdfb;
+/// Feature selection (DTF_*).
+pub const DT_FEATURE_1: u32 = 0x6fff_fdfc;
+/// Flags for DT_* entries, affecting the following DT_* entry.
+pub const DT_POSFLAG_1: u32 = 0x6fff_fdfd;
+/// Size of syminfo table (in bytes)
+pub const DT_SYMINSZ: u32 = 0x6fff_fdfe;
+/// Entry size of syminfo
+pub const DT_SYMINENT: u32 = 0x6fff_fdff;
+#[allow(missing_docs)]
+pub const DT_VALRNGHI: u32 = 0x6fff_fdff;
+
+// `DT_*` entries between `DT_ADDRRNGHI` & `DT_ADDRRNGLO` use `d_val` as an address.
+//
+// If any adjustment is made to the ELF object after it has been
+// built these entries will need to be adjusted.
+#[allow(missing_docs)]
+pub const DT_ADDRRNGLO: u32 = 0x6fff_fe00;
+/// GNU-style hash table.
+pub const DT_GNU_HASH: u32 = 0x6fff_fef5;
+#[allow(missing_docs)]
+pub const DT_TLSDESC_PLT: u32 = 0x6fff_fef6;
+#[allow(missing_docs)]
+pub const DT_TLSDESC_GOT: u32 = 0x6fff_fef7;
+/// Start of conflict section
+pub const DT_GNU_CONFLICT: u32 = 0x6fff_fef8;
+/// Library list
+pub const DT_GNU_LIBLIST: u32 = 0x6fff_fef9;
+/// Configuration information.
+pub const DT_CONFIG: u32 = 0x6fff_fefa;
+/// Dependency auditing.
+pub const DT_DEPAUDIT: u32 = 0x6fff_fefb;
+/// Object auditing.
+pub const DT_AUDIT: u32 = 0x6fff_fefc;
+/// PLT padding.
+pub const DT_PLTPAD: u32 = 0x6fff_fefd;
+/// Move table.
+pub const DT_MOVETAB: u32 = 0x6fff_fefe;
+/// Syminfo table.
+pub const DT_SYMINFO: u32 = 0x6fff_feff;
+#[allow(missing_docs)]
+pub const DT_ADDRRNGHI: u32 = 0x6fff_feff;
+
+// The versioning entry types. The next are defined as part of the
+// GNU extension.
+#[allow(missing_docs)]
+pub const DT_VERSYM: u32 = 0x6fff_fff0;
+#[allow(missing_docs)]
+pub const DT_RELACOUNT: u32 = 0x6fff_fff9;
+#[allow(missing_docs)]
+pub const DT_RELCOUNT: u32 = 0x6fff_fffa;
+/// State flags, see DF_1_* below.
+pub const DT_FLAGS_1: u32 = 0x6fff_fffb;
+/// Address of version definition table
+pub const DT_VERDEF: u32 = 0x6fff_fffc;
+/// Number of version definitions
+pub const DT_VERDEFNUM: u32 = 0x6fff_fffd;
+/// Address of table with needed versions
+pub const DT_VERNEED: u32 = 0x6fff_fffe;
+/// Number of needed versions
+pub const DT_VERNEEDNUM: u32 = 0x6fff_ffff;
+
+// Machine-independent extensions in the "processor-specific" range.
+/// Shared object to load before self
+pub const DT_AUXILIARY: u32 = 0x7fff_fffd;
+/// Shared object to get values from
+pub const DT_FILTER: u32 = 0x7fff_ffff;
+
+// Values of `Dyn*::d_val` in the `DT_FLAGS` entry.
+/// Object may use DF_ORIGIN
+pub const DF_ORIGIN: u32 = 0x0000_0001;
+/// Symbol resolutions starts here
+pub const DF_SYMBOLIC: u32 = 0x0000_0002;
+/// Object contains text relocations
+pub const DF_TEXTREL: u32 = 0x0000_0004;
+/// No lazy binding for this object
+pub const DF_BIND_NOW: u32 = 0x0000_0008;
+/// Module uses the static TLS model
+pub const DF_STATIC_TLS: u32 = 0x0000_0010;
+
+// Values of `Dyn*::d_val` in the `DT_FLAGS_1` entry.
+/// Set RTLD_NOW for this object.
+pub const DF_1_NOW: u32 = 0x0000_0001;
+/// Set RTLD_GLOBAL for this object.
+pub const DF_1_GLOBAL: u32 = 0x0000_0002;
+/// Set RTLD_GROUP for this object.
+pub const DF_1_GROUP: u32 = 0x0000_0004;
+/// Set RTLD_NODELETE for this object.
+pub const DF_1_NODELETE: u32 = 0x0000_0008;
+/// Trigger filtee loading at runtime.
+pub const DF_1_LOADFLTR: u32 = 0x0000_0010;
+/// Set RTLD_INITFIRST for this object.
+pub const DF_1_INITFIRST: u32 = 0x0000_0020;
+/// Set RTLD_NOOPEN for this object.
+pub const DF_1_NOOPEN: u32 = 0x0000_0040;
+/// $ORIGIN must be handled.
+pub const DF_1_ORIGIN: u32 = 0x0000_0080;
+/// Direct binding enabled.
+pub const DF_1_DIRECT: u32 = 0x0000_0100;
+#[allow(missing_docs)]
+pub const DF_1_TRANS: u32 = 0x0000_0200;
+/// Object is used to interpose.
+pub const DF_1_INTERPOSE: u32 = 0x0000_0400;
+/// Ignore default lib search path.
+pub const DF_1_NODEFLIB: u32 = 0x0000_0800;
+/// Object can't be dldump'ed.
+pub const DF_1_NODUMP: u32 = 0x0000_1000;
+/// Configuration alternative created.
+pub const DF_1_CONFALT: u32 = 0x0000_2000;
+/// Filtee terminates filters search.
+pub const DF_1_ENDFILTEE: u32 = 0x0000_4000;
+/// Disp reloc applied at build time.
+pub const DF_1_DISPRELDNE: u32 = 0x0000_8000;
+/// Disp reloc applied at run-time.
+pub const DF_1_DISPRELPND: u32 = 0x0001_0000;
+/// Object has no-direct binding.
+pub const DF_1_NODIRECT: u32 = 0x0002_0000;
+#[allow(missing_docs)]
+pub const DF_1_IGNMULDEF: u32 = 0x0004_0000;
+#[allow(missing_docs)]
+pub const DF_1_NOKSYMS: u32 = 0x0008_0000;
+#[allow(missing_docs)]
+pub const DF_1_NOHDR: u32 = 0x0010_0000;
+/// Object is modified after built.
+pub const DF_1_EDITED: u32 = 0x0020_0000;
+#[allow(missing_docs)]
+pub const DF_1_NORELOC: u32 = 0x0040_0000;
+/// Object has individual interposers.
+pub const DF_1_SYMINTPOSE: u32 = 0x0080_0000;
+/// Global auditing required.
+pub const DF_1_GLOBAUDIT: u32 = 0x0100_0000;
+/// Singleton symbols are used.
+pub const DF_1_SINGLETON: u32 = 0x0200_0000;
+#[allow(missing_docs)]
+pub const DF_1_STUB: u32 = 0x0400_0000;
+#[allow(missing_docs)]
+pub const DF_1_PIE: u32 = 0x0800_0000;
+
+/// Version symbol information
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Versym<E: Endian>(pub U16<E>);
+
+/// Version definition sections
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Verdef<E: Endian> {
+ /// Version revision
+ pub vd_version: U16<E>,
+ /// Version information
+ pub vd_flags: U16<E>,
+ /// Version Index
+ pub vd_ndx: U16<E>,
+ /// Number of associated aux entries
+ pub vd_cnt: U16<E>,
+ /// Version name hash value
+ pub vd_hash: U32<E>,
+ /// Offset in bytes to verdaux array
+ pub vd_aux: U32<E>,
+ /// Offset in bytes to next verdef entry
+ pub vd_next: U32<E>,
+}
+
+// Legal values for vd_version (version revision).
+/// No version
+pub const VER_DEF_NONE: u16 = 0;
+/// Current version
+pub const VER_DEF_CURRENT: u16 = 1;
+
+// Legal values for vd_flags and vna_flags (version information flags).
+/// Version definition of file itself
+pub const VER_FLG_BASE: u16 = 0x1;
+/// Weak version identifier
+pub const VER_FLG_WEAK: u16 = 0x2;
+
+// Versym symbol index values.
+/// Symbol is local.
+pub const VER_NDX_LOCAL: u16 = 0;
+/// Symbol is global.
+pub const VER_NDX_GLOBAL: u16 = 1;
+/// Symbol is hidden.
+pub const VER_NDX_HIDDEN: u16 = 0x8000;
+
+/// Auxiliary version information.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Verdaux<E: Endian> {
+ /// Version or dependency names
+ pub vda_name: U32<E>,
+ /// Offset in bytes to next verdaux
+ pub vda_next: U32<E>,
+}
+
+/// Version dependency.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Verneed<E: Endian> {
+ /// Version of structure
+ pub vn_version: U16<E>,
+ /// Number of associated aux entries
+ pub vn_cnt: U16<E>,
+ /// Offset of filename for this dependency
+ pub vn_file: U32<E>,
+ /// Offset in bytes to vernaux array
+ pub vn_aux: U32<E>,
+ /// Offset in bytes to next verneed entry
+ pub vn_next: U32<E>,
+}
+
+// Legal values for vn_version (version revision).
+/// No version
+pub const VER_NEED_NONE: u16 = 0;
+/// Current version
+pub const VER_NEED_CURRENT: u16 = 1;
+
+/// Auxiliary needed version information.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Vernaux<E: Endian> {
+ /// Hash value of dependency name
+ pub vna_hash: U32<E>,
+ /// Dependency specific information
+ pub vna_flags: U16<E>,
+ /// Version Index
+ pub vna_other: U16<E>,
+ /// Dependency name string offset
+ pub vna_name: U32<E>,
+ /// Offset in bytes to next vernaux entry
+ pub vna_next: U32<E>,
+}
+
+// TODO: Elf*_auxv_t, AT_*
+
+/// Note section entry header.
+///
+/// A note consists of a header followed by a variable length name and descriptor.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct NoteHeader32<E: Endian> {
+ /// Length of the note's name.
+ ///
+ /// Some known names are defined by the `ELF_NOTE_*` constants.
+ pub n_namesz: U32<E>,
+ /// Length of the note's descriptor.
+ ///
+ /// The content of the descriptor depends on the note name and type.
+ pub n_descsz: U32<E>,
+ /// Type of the note.
+ ///
+ /// One of the `NT_*` constants. The note name determines which
+ /// `NT_*` constants are valid.
+ pub n_type: U32<E>,
+}
+
+/// Note section entry header.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct NoteHeader64<E: Endian> {
+ /// Length of the note's name.
+ ///
+ /// Some known names are defined by the `ELF_NOTE_*` constants.
+ pub n_namesz: U32<E>,
+ /// Length of the note's descriptor.
+ ///
+ /// The content of the descriptor depends on the note name and type.
+ pub n_descsz: U32<E>,
+ /// Type of the note.
+ ///
+ /// One of the `NT_*` constants. The note name determines which
+ /// `NT_*` constants are valid.
+ pub n_type: U32<E>,
+}
+
+/// Solaris entries in the note section have this name.
+pub static ELF_NOTE_SOLARIS: &[u8] = b"SUNW Solaris";
+
+// Values for `n_type` when the name is `ELF_NOTE_SOLARIS`.
+/// Desired pagesize for the binary.
+pub const NT_SOLARIS_PAGESIZE_HINT: u32 = 1;
+
+/// GNU entries in the note section have this name.
+pub static ELF_NOTE_GNU: &[u8] = b"GNU";
+
+// Note types for `ELF_NOTE_GNU`.
+
+/// ABI information.
+///
+/// The descriptor consists of words:
+/// - word 0: OS descriptor
+/// - word 1: major version of the ABI
+/// - word 2: minor version of the ABI
+/// - word 3: subminor version of the ABI
+pub const NT_GNU_ABI_TAG: u32 = 1;
+
+/// OS descriptor for `NT_GNU_ABI_TAG`.
+pub const ELF_NOTE_OS_LINUX: u32 = 0;
+/// OS descriptor for `NT_GNU_ABI_TAG`.
+pub const ELF_NOTE_OS_GNU: u32 = 1;
+/// OS descriptor for `NT_GNU_ABI_TAG`.
+pub const ELF_NOTE_OS_SOLARIS2: u32 = 2;
+/// OS descriptor for `NT_GNU_ABI_TAG`.
+pub const ELF_NOTE_OS_FREEBSD: u32 = 3;
+
+/// Synthetic hwcap information.
+///
+/// The descriptor begins with two words:
+/// - word 0: number of entries
+/// - word 1: bitmask of enabled entries
+/// Then follow variable-length entries, one byte followed by a
+/// '\0'-terminated hwcap name string. The byte gives the bit
+/// number to test if enabled, (1U << bit) & bitmask. */
+pub const NT_GNU_HWCAP: u32 = 2;
+
+/// Build ID bits as generated by `ld --build-id`.
+///
+/// The descriptor consists of any nonzero number of bytes.
+pub const NT_GNU_BUILD_ID: u32 = 3;
+
+/// Version note generated by GNU gold containing a version string.
+pub const NT_GNU_GOLD_VERSION: u32 = 4;
+
+/// Program property.
+pub const NT_GNU_PROPERTY_TYPE_0: u32 = 5;
+
+// TODO: GNU_PROPERTY_*
+// TODO: Elf*_Move
+
+/// Header of `SHT_HASH` section.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct HashHeader<E: Endian> {
+ /// The number of hash buckets.
+ pub bucket_count: U32<E>,
+ /// The number of chain values.
+ pub chain_count: U32<E>,
+ // Array of hash bucket start indices.
+ // buckets: U32<E>[bucket_count]
+ // Array of hash chain links. An index of 0 terminates the chain.
+ // chains: U32<E>[chain_count]
+}
+
+/// Calculate the SysV hash for a symbol name.
+///
+/// Used for `SHT_HASH`.
+pub fn hash(name: &[u8]) -> u32 {
+ let mut hash = 0u32;
+ for byte in name {
+ hash = hash.wrapping_mul(16).wrapping_add(u32::from(*byte));
+ hash ^= (hash >> 24) & 0xf0;
+ }
+ hash & 0xfff_ffff
+}
+
+/// Header of `SHT_GNU_HASH` section.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct GnuHashHeader<E: Endian> {
+ /// The number of hash buckets.
+ pub bucket_count: U32<E>,
+ /// The symbol table index of the first symbol in the hash.
+ pub symbol_base: U32<E>,
+ /// The number of words in the bloom filter.
+ ///
+ /// Must be a non-zero power of 2.
+ pub bloom_count: U32<E>,
+ /// The bit shift count for the bloom filter.
+ pub bloom_shift: U32<E>,
+ // Array of bloom filter words.
+ // bloom_filters: U32<E>[bloom_count] or U64<E>[bloom_count]
+ // Array of hash bucket start indices.
+ // buckets: U32<E>[bucket_count]
+ // Array of hash values, one for each symbol starting at symbol_base.
+ // values: U32<E>[symbol_count]
+}
+
+/// Calculate the GNU hash for a symbol name.
+///
+/// Used for `SHT_GNU_HASH`.
+pub fn gnu_hash(name: &[u8]) -> u32 {
+ let mut hash = 5381u32;
+ for byte in name {
+ hash = hash.wrapping_mul(33).wrapping_add(u32::from(*byte));
+ }
+ hash
+}
+
+// Motorola 68k specific definitions.
+
+// m68k values for `Rel*::r_type`.
+
+/// No reloc
+pub const R_68K_NONE: u32 = 0;
+/// Direct 32 bit
+pub const R_68K_32: u32 = 1;
+/// Direct 16 bit
+pub const R_68K_16: u32 = 2;
+/// Direct 8 bit
+pub const R_68K_8: u32 = 3;
+/// PC relative 32 bit
+pub const R_68K_PC32: u32 = 4;
+/// PC relative 16 bit
+pub const R_68K_PC16: u32 = 5;
+/// PC relative 8 bit
+pub const R_68K_PC8: u32 = 6;
+/// 32 bit PC relative GOT entry
+pub const R_68K_GOT32: u32 = 7;
+/// 16 bit PC relative GOT entry
+pub const R_68K_GOT16: u32 = 8;
+/// 8 bit PC relative GOT entry
+pub const R_68K_GOT8: u32 = 9;
+/// 32 bit GOT offset
+pub const R_68K_GOT32O: u32 = 10;
+/// 16 bit GOT offset
+pub const R_68K_GOT16O: u32 = 11;
+/// 8 bit GOT offset
+pub const R_68K_GOT8O: u32 = 12;
+/// 32 bit PC relative PLT address
+pub const R_68K_PLT32: u32 = 13;
+/// 16 bit PC relative PLT address
+pub const R_68K_PLT16: u32 = 14;
+/// 8 bit PC relative PLT address
+pub const R_68K_PLT8: u32 = 15;
+/// 32 bit PLT offset
+pub const R_68K_PLT32O: u32 = 16;
+/// 16 bit PLT offset
+pub const R_68K_PLT16O: u32 = 17;
+/// 8 bit PLT offset
+pub const R_68K_PLT8O: u32 = 18;
+/// Copy symbol at runtime
+pub const R_68K_COPY: u32 = 19;
+/// Create GOT entry
+pub const R_68K_GLOB_DAT: u32 = 20;
+/// Create PLT entry
+pub const R_68K_JMP_SLOT: u32 = 21;
+/// Adjust by program base
+pub const R_68K_RELATIVE: u32 = 22;
+/// 32 bit GOT offset for GD
+pub const R_68K_TLS_GD32: u32 = 25;
+/// 16 bit GOT offset for GD
+pub const R_68K_TLS_GD16: u32 = 26;
+/// 8 bit GOT offset for GD
+pub const R_68K_TLS_GD8: u32 = 27;
+/// 32 bit GOT offset for LDM
+pub const R_68K_TLS_LDM32: u32 = 28;
+/// 16 bit GOT offset for LDM
+pub const R_68K_TLS_LDM16: u32 = 29;
+/// 8 bit GOT offset for LDM
+pub const R_68K_TLS_LDM8: u32 = 30;
+/// 32 bit module-relative offset
+pub const R_68K_TLS_LDO32: u32 = 31;
+/// 16 bit module-relative offset
+pub const R_68K_TLS_LDO16: u32 = 32;
+/// 8 bit module-relative offset
+pub const R_68K_TLS_LDO8: u32 = 33;
+/// 32 bit GOT offset for IE
+pub const R_68K_TLS_IE32: u32 = 34;
+/// 16 bit GOT offset for IE
+pub const R_68K_TLS_IE16: u32 = 35;
+/// 8 bit GOT offset for IE
+pub const R_68K_TLS_IE8: u32 = 36;
+/// 32 bit offset relative to static TLS block
+pub const R_68K_TLS_LE32: u32 = 37;
+/// 16 bit offset relative to static TLS block
+pub const R_68K_TLS_LE16: u32 = 38;
+/// 8 bit offset relative to static TLS block
+pub const R_68K_TLS_LE8: u32 = 39;
+/// 32 bit module number
+pub const R_68K_TLS_DTPMOD32: u32 = 40;
+/// 32 bit module-relative offset
+pub const R_68K_TLS_DTPREL32: u32 = 41;
+/// 32 bit TP-relative offset
+pub const R_68K_TLS_TPREL32: u32 = 42;
+
+// Intel 80386 specific definitions.
+
+// i386 values for `Rel*::r_type`.
+
+/// No reloc
+pub const R_386_NONE: u32 = 0;
+/// Direct 32 bit
+pub const R_386_32: u32 = 1;
+/// PC relative 32 bit
+pub const R_386_PC32: u32 = 2;
+/// 32 bit GOT entry
+pub const R_386_GOT32: u32 = 3;
+/// 32 bit PLT address
+pub const R_386_PLT32: u32 = 4;
+/// Copy symbol at runtime
+pub const R_386_COPY: u32 = 5;
+/// Create GOT entry
+pub const R_386_GLOB_DAT: u32 = 6;
+/// Create PLT entry
+pub const R_386_JMP_SLOT: u32 = 7;
+/// Adjust by program base
+pub const R_386_RELATIVE: u32 = 8;
+/// 32 bit offset to GOT
+pub const R_386_GOTOFF: u32 = 9;
+/// 32 bit PC relative offset to GOT
+pub const R_386_GOTPC: u32 = 10;
+/// Direct 32 bit PLT address
+pub const R_386_32PLT: u32 = 11;
+/// Offset in static TLS block
+pub const R_386_TLS_TPOFF: u32 = 14;
+/// Address of GOT entry for static TLS block offset
+pub const R_386_TLS_IE: u32 = 15;
+/// GOT entry for static TLS block offset
+pub const R_386_TLS_GOTIE: u32 = 16;
+/// Offset relative to static TLS block
+pub const R_386_TLS_LE: u32 = 17;
+/// Direct 32 bit for GNU version of general dynamic thread local data
+pub const R_386_TLS_GD: u32 = 18;
+/// Direct 32 bit for GNU version of local dynamic thread local data in LE code
+pub const R_386_TLS_LDM: u32 = 19;
+/// Direct 16 bit
+pub const R_386_16: u32 = 20;
+/// PC relative 16 bit
+pub const R_386_PC16: u32 = 21;
+/// Direct 8 bit
+pub const R_386_8: u32 = 22;
+/// PC relative 8 bit
+pub const R_386_PC8: u32 = 23;
+/// Direct 32 bit for general dynamic thread local data
+pub const R_386_TLS_GD_32: u32 = 24;
+/// Tag for pushl in GD TLS code
+pub const R_386_TLS_GD_PUSH: u32 = 25;
+/// Relocation for call to __tls_get_addr()
+pub const R_386_TLS_GD_CALL: u32 = 26;
+/// Tag for popl in GD TLS code
+pub const R_386_TLS_GD_POP: u32 = 27;
+/// Direct 32 bit for local dynamic thread local data in LE code
+pub const R_386_TLS_LDM_32: u32 = 28;
+/// Tag for pushl in LDM TLS code
+pub const R_386_TLS_LDM_PUSH: u32 = 29;
+/// Relocation for call to __tls_get_addr() in LDM code
+pub const R_386_TLS_LDM_CALL: u32 = 30;
+/// Tag for popl in LDM TLS code
+pub const R_386_TLS_LDM_POP: u32 = 31;
+/// Offset relative to TLS block
+pub const R_386_TLS_LDO_32: u32 = 32;
+/// GOT entry for negated static TLS block offset
+pub const R_386_TLS_IE_32: u32 = 33;
+/// Negated offset relative to static TLS block
+pub const R_386_TLS_LE_32: u32 = 34;
+/// ID of module containing symbol
+pub const R_386_TLS_DTPMOD32: u32 = 35;
+/// Offset in TLS block
+pub const R_386_TLS_DTPOFF32: u32 = 36;
+/// Negated offset in static TLS block
+pub const R_386_TLS_TPOFF32: u32 = 37;
+/// 32-bit symbol size
+pub const R_386_SIZE32: u32 = 38;
+/// GOT offset for TLS descriptor.
+pub const R_386_TLS_GOTDESC: u32 = 39;
+/// Marker of call through TLS descriptor for relaxation.
+pub const R_386_TLS_DESC_CALL: u32 = 40;
+/// TLS descriptor containing pointer to code and to argument, returning the TLS offset for the symbol.
+pub const R_386_TLS_DESC: u32 = 41;
+/// Adjust indirectly by program base
+pub const R_386_IRELATIVE: u32 = 42;
+/// Load from 32 bit GOT entry, relaxable.
+pub const R_386_GOT32X: u32 = 43;
+
+// SUN SPARC specific definitions.
+
+// SPARC values for `st_type` component of `Sym*::st_info`.
+
+/// Global register reserved to app.
+pub const STT_SPARC_REGISTER: u8 = 13;
+
+// SPARC values for `FileHeader64::e_flags`.
+
+#[allow(missing_docs)]
+pub const EF_SPARCV9_MM: u32 = 3;
+#[allow(missing_docs)]
+pub const EF_SPARCV9_TSO: u32 = 0;
+#[allow(missing_docs)]
+pub const EF_SPARCV9_PSO: u32 = 1;
+#[allow(missing_docs)]
+pub const EF_SPARCV9_RMO: u32 = 2;
+/// little endian data
+pub const EF_SPARC_LEDATA: u32 = 0x80_0000;
+#[allow(missing_docs)]
+pub const EF_SPARC_EXT_MASK: u32 = 0xFF_FF00;
+/// generic V8+ features
+pub const EF_SPARC_32PLUS: u32 = 0x00_0100;
+/// Sun UltraSPARC1 extensions
+pub const EF_SPARC_SUN_US1: u32 = 0x00_0200;
+/// HAL R1 extensions
+pub const EF_SPARC_HAL_R1: u32 = 0x00_0400;
+/// Sun UltraSPARCIII extensions
+pub const EF_SPARC_SUN_US3: u32 = 0x00_0800;
+
+// SPARC values for `Rel*::r_type`.
+
+/// No reloc
+pub const R_SPARC_NONE: u32 = 0;
+/// Direct 8 bit
+pub const R_SPARC_8: u32 = 1;
+/// Direct 16 bit
+pub const R_SPARC_16: u32 = 2;
+/// Direct 32 bit
+pub const R_SPARC_32: u32 = 3;
+/// PC relative 8 bit
+pub const R_SPARC_DISP8: u32 = 4;
+/// PC relative 16 bit
+pub const R_SPARC_DISP16: u32 = 5;
+/// PC relative 32 bit
+pub const R_SPARC_DISP32: u32 = 6;
+/// PC relative 30 bit shifted
+pub const R_SPARC_WDISP30: u32 = 7;
+/// PC relative 22 bit shifted
+pub const R_SPARC_WDISP22: u32 = 8;
+/// High 22 bit
+pub const R_SPARC_HI22: u32 = 9;
+/// Direct 22 bit
+pub const R_SPARC_22: u32 = 10;
+/// Direct 13 bit
+pub const R_SPARC_13: u32 = 11;
+/// Truncated 10 bit
+pub const R_SPARC_LO10: u32 = 12;
+/// Truncated 10 bit GOT entry
+pub const R_SPARC_GOT10: u32 = 13;
+/// 13 bit GOT entry
+pub const R_SPARC_GOT13: u32 = 14;
+/// 22 bit GOT entry shifted
+pub const R_SPARC_GOT22: u32 = 15;
+/// PC relative 10 bit truncated
+pub const R_SPARC_PC10: u32 = 16;
+/// PC relative 22 bit shifted
+pub const R_SPARC_PC22: u32 = 17;
+/// 30 bit PC relative PLT address
+pub const R_SPARC_WPLT30: u32 = 18;
+/// Copy symbol at runtime
+pub const R_SPARC_COPY: u32 = 19;
+/// Create GOT entry
+pub const R_SPARC_GLOB_DAT: u32 = 20;
+/// Create PLT entry
+pub const R_SPARC_JMP_SLOT: u32 = 21;
+/// Adjust by program base
+pub const R_SPARC_RELATIVE: u32 = 22;
+/// Direct 32 bit unaligned
+pub const R_SPARC_UA32: u32 = 23;
+
+// Sparc64 values for `Rel*::r_type`.
+
+/// Direct 32 bit ref to PLT entry
+pub const R_SPARC_PLT32: u32 = 24;
+/// High 22 bit PLT entry
+pub const R_SPARC_HIPLT22: u32 = 25;
+/// Truncated 10 bit PLT entry
+pub const R_SPARC_LOPLT10: u32 = 26;
+/// PC rel 32 bit ref to PLT entry
+pub const R_SPARC_PCPLT32: u32 = 27;
+/// PC rel high 22 bit PLT entry
+pub const R_SPARC_PCPLT22: u32 = 28;
+/// PC rel trunc 10 bit PLT entry
+pub const R_SPARC_PCPLT10: u32 = 29;
+/// Direct 10 bit
+pub const R_SPARC_10: u32 = 30;
+/// Direct 11 bit
+pub const R_SPARC_11: u32 = 31;
+/// Direct 64 bit
+pub const R_SPARC_64: u32 = 32;
+/// 10bit with secondary 13bit addend
+pub const R_SPARC_OLO10: u32 = 33;
+/// Top 22 bits of direct 64 bit
+pub const R_SPARC_HH22: u32 = 34;
+/// High middle 10 bits of ...
+pub const R_SPARC_HM10: u32 = 35;
+/// Low middle 22 bits of ...
+pub const R_SPARC_LM22: u32 = 36;
+/// Top 22 bits of pc rel 64 bit
+pub const R_SPARC_PC_HH22: u32 = 37;
+/// High middle 10 bit of ...
+pub const R_SPARC_PC_HM10: u32 = 38;
+/// Low miggle 22 bits of ...
+pub const R_SPARC_PC_LM22: u32 = 39;
+/// PC relative 16 bit shifted
+pub const R_SPARC_WDISP16: u32 = 40;
+/// PC relative 19 bit shifted
+pub const R_SPARC_WDISP19: u32 = 41;
+/// was part of v9 ABI but was removed
+pub const R_SPARC_GLOB_JMP: u32 = 42;
+/// Direct 7 bit
+pub const R_SPARC_7: u32 = 43;
+/// Direct 5 bit
+pub const R_SPARC_5: u32 = 44;
+/// Direct 6 bit
+pub const R_SPARC_6: u32 = 45;
+/// PC relative 64 bit
+pub const R_SPARC_DISP64: u32 = 46;
+/// Direct 64 bit ref to PLT entry
+pub const R_SPARC_PLT64: u32 = 47;
+/// High 22 bit complemented
+pub const R_SPARC_HIX22: u32 = 48;
+/// Truncated 11 bit complemented
+pub const R_SPARC_LOX10: u32 = 49;
+/// Direct high 12 of 44 bit
+pub const R_SPARC_H44: u32 = 50;
+/// Direct mid 22 of 44 bit
+pub const R_SPARC_M44: u32 = 51;
+/// Direct low 10 of 44 bit
+pub const R_SPARC_L44: u32 = 52;
+/// Global register usage
+pub const R_SPARC_REGISTER: u32 = 53;
+/// Direct 64 bit unaligned
+pub const R_SPARC_UA64: u32 = 54;
+/// Direct 16 bit unaligned
+pub const R_SPARC_UA16: u32 = 55;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_GD_HI22: u32 = 56;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_GD_LO10: u32 = 57;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_GD_ADD: u32 = 58;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_GD_CALL: u32 = 59;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_LDM_HI22: u32 = 60;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_LDM_LO10: u32 = 61;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_LDM_ADD: u32 = 62;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_LDM_CALL: u32 = 63;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_LDO_HIX22: u32 = 64;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_LDO_LOX10: u32 = 65;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_LDO_ADD: u32 = 66;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_IE_HI22: u32 = 67;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_IE_LO10: u32 = 68;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_IE_LD: u32 = 69;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_IE_LDX: u32 = 70;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_IE_ADD: u32 = 71;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_LE_HIX22: u32 = 72;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_LE_LOX10: u32 = 73;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_DTPMOD32: u32 = 74;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_DTPMOD64: u32 = 75;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_DTPOFF32: u32 = 76;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_DTPOFF64: u32 = 77;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_TPOFF32: u32 = 78;
+#[allow(missing_docs)]
+pub const R_SPARC_TLS_TPOFF64: u32 = 79;
+#[allow(missing_docs)]
+pub const R_SPARC_GOTDATA_HIX22: u32 = 80;
+#[allow(missing_docs)]
+pub const R_SPARC_GOTDATA_LOX10: u32 = 81;
+#[allow(missing_docs)]
+pub const R_SPARC_GOTDATA_OP_HIX22: u32 = 82;
+#[allow(missing_docs)]
+pub const R_SPARC_GOTDATA_OP_LOX10: u32 = 83;
+#[allow(missing_docs)]
+pub const R_SPARC_GOTDATA_OP: u32 = 84;
+#[allow(missing_docs)]
+pub const R_SPARC_H34: u32 = 85;
+#[allow(missing_docs)]
+pub const R_SPARC_SIZE32: u32 = 86;
+#[allow(missing_docs)]
+pub const R_SPARC_SIZE64: u32 = 87;
+#[allow(missing_docs)]
+pub const R_SPARC_WDISP10: u32 = 88;
+#[allow(missing_docs)]
+pub const R_SPARC_JMP_IREL: u32 = 248;
+#[allow(missing_docs)]
+pub const R_SPARC_IRELATIVE: u32 = 249;
+#[allow(missing_docs)]
+pub const R_SPARC_GNU_VTINHERIT: u32 = 250;
+#[allow(missing_docs)]
+pub const R_SPARC_GNU_VTENTRY: u32 = 251;
+#[allow(missing_docs)]
+pub const R_SPARC_REV32: u32 = 252;
+
+// Sparc64 values for `Dyn32::d_tag`.
+
+#[allow(missing_docs)]
+pub const DT_SPARC_REGISTER: u32 = 0x7000_0001;
+
+// MIPS R3000 specific definitions.
+
+// MIPS values for `FileHeader32::e_flags`.
+
+/// A .noreorder directive was used.
+pub const EF_MIPS_NOREORDER: u32 = 1;
+/// Contains PIC code.
+pub const EF_MIPS_PIC: u32 = 2;
+/// Uses PIC calling sequence.
+pub const EF_MIPS_CPIC: u32 = 4;
+#[allow(missing_docs)]
+pub const EF_MIPS_XGOT: u32 = 8;
+#[allow(missing_docs)]
+pub const EF_MIPS_64BIT_WHIRL: u32 = 16;
+#[allow(missing_docs)]
+pub const EF_MIPS_ABI2: u32 = 32;
+#[allow(missing_docs)]
+pub const EF_MIPS_ABI_ON32: u32 = 64;
+/// Uses FP64 (12 callee-saved).
+pub const EF_MIPS_FP64: u32 = 512;
+/// Uses IEEE 754-2008 NaN encoding.
+pub const EF_MIPS_NAN2008: u32 = 1024;
+/// MIPS architecture level.
+pub const EF_MIPS_ARCH: u32 = 0xf000_0000;
+
+// Legal values for MIPS architecture level.
+
+/// -mips1 code.
+pub const EF_MIPS_ARCH_1: u32 = 0x0000_0000;
+/// -mips2 code.
+pub const EF_MIPS_ARCH_2: u32 = 0x1000_0000;
+/// -mips3 code.
+pub const EF_MIPS_ARCH_3: u32 = 0x2000_0000;
+/// -mips4 code.
+pub const EF_MIPS_ARCH_4: u32 = 0x3000_0000;
+/// -mips5 code.
+pub const EF_MIPS_ARCH_5: u32 = 0x4000_0000;
+/// MIPS32 code.
+pub const EF_MIPS_ARCH_32: u32 = 0x5000_0000;
+/// MIPS64 code.
+pub const EF_MIPS_ARCH_64: u32 = 0x6000_0000;
+/// MIPS32r2 code.
+pub const EF_MIPS_ARCH_32R2: u32 = 0x7000_0000;
+/// MIPS64r2 code.
+pub const EF_MIPS_ARCH_64R2: u32 = 0x8000_0000;
+
+// MIPS values for `Sym32::st_shndx`.
+
+/// Allocated common symbols.
+pub const SHN_MIPS_ACOMMON: u16 = 0xff00;
+/// Allocated test symbols.
+pub const SHN_MIPS_TEXT: u16 = 0xff01;
+/// Allocated data symbols.
+pub const SHN_MIPS_DATA: u16 = 0xff02;
+/// Small common symbols.
+pub const SHN_MIPS_SCOMMON: u16 = 0xff03;
+/// Small undefined symbols.
+pub const SHN_MIPS_SUNDEFINED: u16 = 0xff04;
+
+// MIPS values for `SectionHeader32::sh_type`.
+
+/// Shared objects used in link.
+pub const SHT_MIPS_LIBLIST: u32 = 0x7000_0000;
+#[allow(missing_docs)]
+pub const SHT_MIPS_MSYM: u32 = 0x7000_0001;
+/// Conflicting symbols.
+pub const SHT_MIPS_CONFLICT: u32 = 0x7000_0002;
+/// Global data area sizes.
+pub const SHT_MIPS_GPTAB: u32 = 0x7000_0003;
+/// Reserved for SGI/MIPS compilers
+pub const SHT_MIPS_UCODE: u32 = 0x7000_0004;
+/// MIPS ECOFF debugging info.
+pub const SHT_MIPS_DEBUG: u32 = 0x7000_0005;
+/// Register usage information.
+pub const SHT_MIPS_REGINFO: u32 = 0x7000_0006;
+#[allow(missing_docs)]
+pub const SHT_MIPS_PACKAGE: u32 = 0x7000_0007;
+#[allow(missing_docs)]
+pub const SHT_MIPS_PACKSYM: u32 = 0x7000_0008;
+#[allow(missing_docs)]
+pub const SHT_MIPS_RELD: u32 = 0x7000_0009;
+#[allow(missing_docs)]
+pub const SHT_MIPS_IFACE: u32 = 0x7000_000b;
+#[allow(missing_docs)]
+pub const SHT_MIPS_CONTENT: u32 = 0x7000_000c;
+/// Miscellaneous options.
+pub const SHT_MIPS_OPTIONS: u32 = 0x7000_000d;
+#[allow(missing_docs)]
+pub const SHT_MIPS_SHDR: u32 = 0x7000_0010;
+#[allow(missing_docs)]
+pub const SHT_MIPS_FDESC: u32 = 0x7000_0011;
+#[allow(missing_docs)]
+pub const SHT_MIPS_EXTSYM: u32 = 0x7000_0012;
+#[allow(missing_docs)]
+pub const SHT_MIPS_DENSE: u32 = 0x7000_0013;
+#[allow(missing_docs)]
+pub const SHT_MIPS_PDESC: u32 = 0x7000_0014;
+#[allow(missing_docs)]
+pub const SHT_MIPS_LOCSYM: u32 = 0x7000_0015;
+#[allow(missing_docs)]
+pub const SHT_MIPS_AUXSYM: u32 = 0x7000_0016;
+#[allow(missing_docs)]
+pub const SHT_MIPS_OPTSYM: u32 = 0x7000_0017;
+#[allow(missing_docs)]
+pub const SHT_MIPS_LOCSTR: u32 = 0x7000_0018;
+#[allow(missing_docs)]
+pub const SHT_MIPS_LINE: u32 = 0x7000_0019;
+#[allow(missing_docs)]
+pub const SHT_MIPS_RFDESC: u32 = 0x7000_001a;
+#[allow(missing_docs)]
+pub const SHT_MIPS_DELTASYM: u32 = 0x7000_001b;
+#[allow(missing_docs)]
+pub const SHT_MIPS_DELTAINST: u32 = 0x7000_001c;
+#[allow(missing_docs)]
+pub const SHT_MIPS_DELTACLASS: u32 = 0x7000_001d;
+/// DWARF debugging information.
+pub const SHT_MIPS_DWARF: u32 = 0x7000_001e;
+#[allow(missing_docs)]
+pub const SHT_MIPS_DELTADECL: u32 = 0x7000_001f;
+#[allow(missing_docs)]
+pub const SHT_MIPS_SYMBOL_LIB: u32 = 0x7000_0020;
+/// Event section.
+pub const SHT_MIPS_EVENTS: u32 = 0x7000_0021;
+#[allow(missing_docs)]
+pub const SHT_MIPS_TRANSLATE: u32 = 0x7000_0022;
+#[allow(missing_docs)]
+pub const SHT_MIPS_PIXIE: u32 = 0x7000_0023;
+#[allow(missing_docs)]
+pub const SHT_MIPS_XLATE: u32 = 0x7000_0024;
+#[allow(missing_docs)]
+pub const SHT_MIPS_XLATE_DEBUG: u32 = 0x7000_0025;
+#[allow(missing_docs)]
+pub const SHT_MIPS_WHIRL: u32 = 0x7000_0026;
+#[allow(missing_docs)]
+pub const SHT_MIPS_EH_REGION: u32 = 0x7000_0027;
+#[allow(missing_docs)]
+pub const SHT_MIPS_XLATE_OLD: u32 = 0x7000_0028;
+#[allow(missing_docs)]
+pub const SHT_MIPS_PDR_EXCEPTION: u32 = 0x7000_0029;
+
+// MIPS values for `SectionHeader32::sh_flags`.
+
+/// Must be in global data area.
+pub const SHF_MIPS_GPREL: u32 = 0x1000_0000;
+#[allow(missing_docs)]
+pub const SHF_MIPS_MERGE: u32 = 0x2000_0000;
+#[allow(missing_docs)]
+pub const SHF_MIPS_ADDR: u32 = 0x4000_0000;
+#[allow(missing_docs)]
+pub const SHF_MIPS_STRINGS: u32 = 0x8000_0000;
+#[allow(missing_docs)]
+pub const SHF_MIPS_NOSTRIP: u32 = 0x0800_0000;
+#[allow(missing_docs)]
+pub const SHF_MIPS_LOCAL: u32 = 0x0400_0000;
+#[allow(missing_docs)]
+pub const SHF_MIPS_NAMES: u32 = 0x0200_0000;
+#[allow(missing_docs)]
+pub const SHF_MIPS_NODUPE: u32 = 0x0100_0000;
+
+// MIPS values for `Sym32::st_other`.
+
+#[allow(missing_docs)]
+pub const STO_MIPS_PLT: u8 = 0x8;
+/// Only valid for `STB_MIPS_SPLIT_COMMON`.
+pub const STO_MIPS_SC_ALIGN_UNUSED: u8 = 0xff;
+
+// MIPS values for `Sym32::st_info'.
+#[allow(missing_docs)]
+pub const STB_MIPS_SPLIT_COMMON: u8 = 13;
+
+// Entries found in sections of type `SHT_MIPS_GPTAB`.
+
+// TODO: Elf32_gptab, Elf32_RegInfo, Elf_Options
+
+// Values for `Elf_Options::kind`.
+
+/// Undefined.
+pub const ODK_NULL: u32 = 0;
+/// Register usage information.
+pub const ODK_REGINFO: u32 = 1;
+/// Exception processing options.
+pub const ODK_EXCEPTIONS: u32 = 2;
+/// Section padding options.
+pub const ODK_PAD: u32 = 3;
+/// Hardware workarounds performed
+pub const ODK_HWPATCH: u32 = 4;
+/// record the fill value used by the linker.
+pub const ODK_FILL: u32 = 5;
+/// reserve space for desktop tools to write.
+pub const ODK_TAGS: u32 = 6;
+/// HW workarounds. 'AND' bits when merging.
+pub const ODK_HWAND: u32 = 7;
+/// HW workarounds. 'OR' bits when merging.
+pub const ODK_HWOR: u32 = 8;
+
+// Values for `Elf_Options::info` for `ODK_EXCEPTIONS` entries.
+
+/// FPE's which MUST be enabled.
+pub const OEX_FPU_MIN: u32 = 0x1f;
+/// FPE's which MAY be enabled.
+pub const OEX_FPU_MAX: u32 = 0x1f00;
+/// page zero must be mapped.
+pub const OEX_PAGE0: u32 = 0x10000;
+/// Force sequential memory mode?
+pub const OEX_SMM: u32 = 0x20000;
+/// Force floating point debug mode?
+pub const OEX_FPDBUG: u32 = 0x40000;
+#[allow(missing_docs)]
+pub const OEX_PRECISEFP: u32 = OEX_FPDBUG;
+/// Dismiss invalid address faults?
+pub const OEX_DISMISS: u32 = 0x80000;
+
+#[allow(missing_docs)]
+pub const OEX_FPU_INVAL: u32 = 0x10;
+#[allow(missing_docs)]
+pub const OEX_FPU_DIV0: u32 = 0x08;
+#[allow(missing_docs)]
+pub const OEX_FPU_OFLO: u32 = 0x04;
+#[allow(missing_docs)]
+pub const OEX_FPU_UFLO: u32 = 0x02;
+#[allow(missing_docs)]
+pub const OEX_FPU_INEX: u32 = 0x01;
+
+// Masks for `Elf_Options::info` for an `ODK_HWPATCH` entry. */
+/// R4000 end-of-page patch.
+pub const OHW_R4KEOP: u32 = 0x1;
+/// may need R8000 prefetch patch.
+pub const OHW_R8KPFETCH: u32 = 0x2;
+/// R5000 end-of-page patch.
+pub const OHW_R5KEOP: u32 = 0x4;
+/// R5000 cvt.[ds].l bug. clean=1.
+pub const OHW_R5KCVTL: u32 = 0x8;
+
+#[allow(missing_docs)]
+pub const OPAD_PREFIX: u32 = 0x1;
+#[allow(missing_docs)]
+pub const OPAD_POSTFIX: u32 = 0x2;
+#[allow(missing_docs)]
+pub const OPAD_SYMBOL: u32 = 0x4;
+
+// Entries found in sections of type `SHT_MIPS_OPTIONS`.
+
+// TODO: Elf_Options_Hw
+
+// Masks for `ElfOptions::info` for `ODK_HWAND` and `ODK_HWOR` entries.
+
+#[allow(missing_docs)]
+pub const OHWA0_R4KEOP_CHECKED: u32 = 0x0000_0001;
+#[allow(missing_docs)]
+pub const OHWA1_R4KEOP_CLEAN: u32 = 0x0000_0002;
+
+// MIPS values for `Rel*::r_type`.
+
+/// No reloc
+pub const R_MIPS_NONE: u32 = 0;
+/// Direct 16 bit
+pub const R_MIPS_16: u32 = 1;
+/// Direct 32 bit
+pub const R_MIPS_32: u32 = 2;
+/// PC relative 32 bit
+pub const R_MIPS_REL32: u32 = 3;
+/// Direct 26 bit shifted
+pub const R_MIPS_26: u32 = 4;
+/// High 16 bit
+pub const R_MIPS_HI16: u32 = 5;
+/// Low 16 bit
+pub const R_MIPS_LO16: u32 = 6;
+/// GP relative 16 bit
+pub const R_MIPS_GPREL16: u32 = 7;
+/// 16 bit literal entry
+pub const R_MIPS_LITERAL: u32 = 8;
+/// 16 bit GOT entry
+pub const R_MIPS_GOT16: u32 = 9;
+/// PC relative 16 bit
+pub const R_MIPS_PC16: u32 = 10;
+/// 16 bit GOT entry for function
+pub const R_MIPS_CALL16: u32 = 11;
+/// GP relative 32 bit
+pub const R_MIPS_GPREL32: u32 = 12;
+
+#[allow(missing_docs)]
+pub const R_MIPS_SHIFT5: u32 = 16;
+#[allow(missing_docs)]
+pub const R_MIPS_SHIFT6: u32 = 17;
+#[allow(missing_docs)]
+pub const R_MIPS_64: u32 = 18;
+#[allow(missing_docs)]
+pub const R_MIPS_GOT_DISP: u32 = 19;
+#[allow(missing_docs)]
+pub const R_MIPS_GOT_PAGE: u32 = 20;
+#[allow(missing_docs)]
+pub const R_MIPS_GOT_OFST: u32 = 21;
+#[allow(missing_docs)]
+pub const R_MIPS_GOT_HI16: u32 = 22;
+#[allow(missing_docs)]
+pub const R_MIPS_GOT_LO16: u32 = 23;
+#[allow(missing_docs)]
+pub const R_MIPS_SUB: u32 = 24;
+#[allow(missing_docs)]
+pub const R_MIPS_INSERT_A: u32 = 25;
+#[allow(missing_docs)]
+pub const R_MIPS_INSERT_B: u32 = 26;
+#[allow(missing_docs)]
+pub const R_MIPS_DELETE: u32 = 27;
+#[allow(missing_docs)]
+pub const R_MIPS_HIGHER: u32 = 28;
+#[allow(missing_docs)]
+pub const R_MIPS_HIGHEST: u32 = 29;
+#[allow(missing_docs)]
+pub const R_MIPS_CALL_HI16: u32 = 30;
+#[allow(missing_docs)]
+pub const R_MIPS_CALL_LO16: u32 = 31;
+#[allow(missing_docs)]
+pub const R_MIPS_SCN_DISP: u32 = 32;
+#[allow(missing_docs)]
+pub const R_MIPS_REL16: u32 = 33;
+#[allow(missing_docs)]
+pub const R_MIPS_ADD_IMMEDIATE: u32 = 34;
+#[allow(missing_docs)]
+pub const R_MIPS_PJUMP: u32 = 35;
+#[allow(missing_docs)]
+pub const R_MIPS_RELGOT: u32 = 36;
+#[allow(missing_docs)]
+pub const R_MIPS_JALR: u32 = 37;
+/// Module number 32 bit
+pub const R_MIPS_TLS_DTPMOD32: u32 = 38;
+/// Module-relative offset 32 bit
+pub const R_MIPS_TLS_DTPREL32: u32 = 39;
+/// Module number 64 bit
+pub const R_MIPS_TLS_DTPMOD64: u32 = 40;
+/// Module-relative offset 64 bit
+pub const R_MIPS_TLS_DTPREL64: u32 = 41;
+/// 16 bit GOT offset for GD
+pub const R_MIPS_TLS_GD: u32 = 42;
+/// 16 bit GOT offset for LDM
+pub const R_MIPS_TLS_LDM: u32 = 43;
+/// Module-relative offset, high 16 bits
+pub const R_MIPS_TLS_DTPREL_HI16: u32 = 44;
+/// Module-relative offset, low 16 bits
+pub const R_MIPS_TLS_DTPREL_LO16: u32 = 45;
+/// 16 bit GOT offset for IE
+pub const R_MIPS_TLS_GOTTPREL: u32 = 46;
+/// TP-relative offset, 32 bit
+pub const R_MIPS_TLS_TPREL32: u32 = 47;
+/// TP-relative offset, 64 bit
+pub const R_MIPS_TLS_TPREL64: u32 = 48;
+/// TP-relative offset, high 16 bits
+pub const R_MIPS_TLS_TPREL_HI16: u32 = 49;
+/// TP-relative offset, low 16 bits
+pub const R_MIPS_TLS_TPREL_LO16: u32 = 50;
+#[allow(missing_docs)]
+pub const R_MIPS_GLOB_DAT: u32 = 51;
+#[allow(missing_docs)]
+pub const R_MIPS_COPY: u32 = 126;
+#[allow(missing_docs)]
+pub const R_MIPS_JUMP_SLOT: u32 = 127;
+
+// MIPS values for `ProgramHeader32::p_type`.
+
+/// Register usage information.
+pub const PT_MIPS_REGINFO: u32 = 0x7000_0000;
+/// Runtime procedure table.
+pub const PT_MIPS_RTPROC: u32 = 0x7000_0001;
+#[allow(missing_docs)]
+pub const PT_MIPS_OPTIONS: u32 = 0x7000_0002;
+/// FP mode requirement.
+pub const PT_MIPS_ABIFLAGS: u32 = 0x7000_0003;
+
+// MIPS values for `ProgramHeader32::p_flags`.
+
+#[allow(missing_docs)]
+pub const PF_MIPS_LOCAL: u32 = 0x1000_0000;
+
+// MIPS values for `Dyn32::d_tag`.
+
+/// Runtime linker interface version
+pub const DT_MIPS_RLD_VERSION: u32 = 0x7000_0001;
+/// Timestamp
+pub const DT_MIPS_TIME_STAMP: u32 = 0x7000_0002;
+/// Checksum
+pub const DT_MIPS_ICHECKSUM: u32 = 0x7000_0003;
+/// Version string (string tbl index)
+pub const DT_MIPS_IVERSION: u32 = 0x7000_0004;
+/// Flags
+pub const DT_MIPS_FLAGS: u32 = 0x7000_0005;
+/// Base address
+pub const DT_MIPS_BASE_ADDRESS: u32 = 0x7000_0006;
+#[allow(missing_docs)]
+pub const DT_MIPS_MSYM: u32 = 0x7000_0007;
+/// Address of CONFLICT section
+pub const DT_MIPS_CONFLICT: u32 = 0x7000_0008;
+/// Address of LIBLIST section
+pub const DT_MIPS_LIBLIST: u32 = 0x7000_0009;
+/// Number of local GOT entries
+pub const DT_MIPS_LOCAL_GOTNO: u32 = 0x7000_000a;
+/// Number of CONFLICT entries
+pub const DT_MIPS_CONFLICTNO: u32 = 0x7000_000b;
+/// Number of LIBLIST entries
+pub const DT_MIPS_LIBLISTNO: u32 = 0x7000_0010;
+/// Number of DYNSYM entries
+pub const DT_MIPS_SYMTABNO: u32 = 0x7000_0011;
+/// First external DYNSYM
+pub const DT_MIPS_UNREFEXTNO: u32 = 0x7000_0012;
+/// First GOT entry in DYNSYM
+pub const DT_MIPS_GOTSYM: u32 = 0x7000_0013;
+/// Number of GOT page table entries
+pub const DT_MIPS_HIPAGENO: u32 = 0x7000_0014;
+/// Address of run time loader map.
+pub const DT_MIPS_RLD_MAP: u32 = 0x7000_0016;
+/// Delta C++ class definition.
+pub const DT_MIPS_DELTA_CLASS: u32 = 0x7000_0017;
+/// Number of entries in DT_MIPS_DELTA_CLASS.
+pub const DT_MIPS_DELTA_CLASS_NO: u32 = 0x7000_0018;
+/// Delta C++ class instances.
+pub const DT_MIPS_DELTA_INSTANCE: u32 = 0x7000_0019;
+/// Number of entries in DT_MIPS_DELTA_INSTANCE.
+pub const DT_MIPS_DELTA_INSTANCE_NO: u32 = 0x7000_001a;
+/// Delta relocations.
+pub const DT_MIPS_DELTA_RELOC: u32 = 0x7000_001b;
+/// Number of entries in DT_MIPS_DELTA_RELOC.
+pub const DT_MIPS_DELTA_RELOC_NO: u32 = 0x7000_001c;
+/// Delta symbols that Delta relocations refer to.
+pub const DT_MIPS_DELTA_SYM: u32 = 0x7000_001d;
+/// Number of entries in DT_MIPS_DELTA_SYM.
+pub const DT_MIPS_DELTA_SYM_NO: u32 = 0x7000_001e;
+/// Delta symbols that hold the class declaration.
+pub const DT_MIPS_DELTA_CLASSSYM: u32 = 0x7000_0020;
+/// Number of entries in DT_MIPS_DELTA_CLASSSYM.
+pub const DT_MIPS_DELTA_CLASSSYM_NO: u32 = 0x7000_0021;
+/// Flags indicating for C++ flavor.
+pub const DT_MIPS_CXX_FLAGS: u32 = 0x7000_0022;
+#[allow(missing_docs)]
+pub const DT_MIPS_PIXIE_INIT: u32 = 0x7000_0023;
+#[allow(missing_docs)]
+pub const DT_MIPS_SYMBOL_LIB: u32 = 0x7000_0024;
+#[allow(missing_docs)]
+pub const DT_MIPS_LOCALPAGE_GOTIDX: u32 = 0x7000_0025;
+#[allow(missing_docs)]
+pub const DT_MIPS_LOCAL_GOTIDX: u32 = 0x7000_0026;
+#[allow(missing_docs)]
+pub const DT_MIPS_HIDDEN_GOTIDX: u32 = 0x7000_0027;
+#[allow(missing_docs)]
+pub const DT_MIPS_PROTECTED_GOTIDX: u32 = 0x7000_0028;
+/// Address of .options.
+pub const DT_MIPS_OPTIONS: u32 = 0x7000_0029;
+/// Address of .interface.
+pub const DT_MIPS_INTERFACE: u32 = 0x7000_002a;
+#[allow(missing_docs)]
+pub const DT_MIPS_DYNSTR_ALIGN: u32 = 0x7000_002b;
+/// Size of the .interface section.
+pub const DT_MIPS_INTERFACE_SIZE: u32 = 0x7000_002c;
+/// Address of rld_text_rsolve function stored in GOT.
+pub const DT_MIPS_RLD_TEXT_RESOLVE_ADDR: u32 = 0x7000_002d;
+/// Default suffix of dso to be added by rld on dlopen() calls.
+pub const DT_MIPS_PERF_SUFFIX: u32 = 0x7000_002e;
+/// (O32)Size of compact rel section.
+pub const DT_MIPS_COMPACT_SIZE: u32 = 0x7000_002f;
+/// GP value for aux GOTs.
+pub const DT_MIPS_GP_VALUE: u32 = 0x7000_0030;
+/// Address of aux .dynamic.
+pub const DT_MIPS_AUX_DYNAMIC: u32 = 0x7000_0031;
+/// The address of .got.plt in an executable using the new non-PIC ABI.
+pub const DT_MIPS_PLTGOT: u32 = 0x7000_0032;
+/// The base of the PLT in an executable using the new non-PIC ABI if that PLT is writable. For a non-writable PLT, this is omitted or has a zero value.
+pub const DT_MIPS_RWPLT: u32 = 0x7000_0034;
+/// An alternative description of the classic MIPS RLD_MAP that is usable in a PIE as it stores a relative offset from the address of the tag rather than an absolute address.
+pub const DT_MIPS_RLD_MAP_REL: u32 = 0x7000_0035;
+
+// Values for `DT_MIPS_FLAGS` `Dyn32` entry.
+
+/// No flags
+pub const RHF_NONE: u32 = 0;
+/// Use quickstart
+pub const RHF_QUICKSTART: u32 = 1 << 0;
+/// Hash size not power of 2
+pub const RHF_NOTPOT: u32 = 1 << 1;
+/// Ignore LD_LIBRARY_PATH
+pub const RHF_NO_LIBRARY_REPLACEMENT: u32 = 1 << 2;
+#[allow(missing_docs)]
+pub const RHF_NO_MOVE: u32 = 1 << 3;
+#[allow(missing_docs)]
+pub const RHF_SGI_ONLY: u32 = 1 << 4;
+#[allow(missing_docs)]
+pub const RHF_GUARANTEE_INIT: u32 = 1 << 5;
+#[allow(missing_docs)]
+pub const RHF_DELTA_C_PLUS_PLUS: u32 = 1 << 6;
+#[allow(missing_docs)]
+pub const RHF_GUARANTEE_START_INIT: u32 = 1 << 7;
+#[allow(missing_docs)]
+pub const RHF_PIXIE: u32 = 1 << 8;
+#[allow(missing_docs)]
+pub const RHF_DEFAULT_DELAY_LOAD: u32 = 1 << 9;
+#[allow(missing_docs)]
+pub const RHF_REQUICKSTART: u32 = 1 << 10;
+#[allow(missing_docs)]
+pub const RHF_REQUICKSTARTED: u32 = 1 << 11;
+#[allow(missing_docs)]
+pub const RHF_CORD: u32 = 1 << 12;
+#[allow(missing_docs)]
+pub const RHF_NO_UNRES_UNDEF: u32 = 1 << 13;
+#[allow(missing_docs)]
+pub const RHF_RLD_ORDER_SAFE: u32 = 1 << 14;
+
+// Entries found in sections of type `SHT_MIPS_LIBLIST`.
+
+// TODO: Elf32_Lib, Elf64_Lib
+
+// Values for `Lib*::l_flags`.
+
+#[allow(missing_docs)]
+pub const LL_NONE: u32 = 0;
+/// Require exact match
+pub const LL_EXACT_MATCH: u32 = 1 << 0;
+/// Ignore interface version
+pub const LL_IGNORE_INT_VER: u32 = 1 << 1;
+#[allow(missing_docs)]
+pub const LL_REQUIRE_MINOR: u32 = 1 << 2;
+#[allow(missing_docs)]
+pub const LL_EXPORTS: u32 = 1 << 3;
+#[allow(missing_docs)]
+pub const LL_DELAY_LOAD: u32 = 1 << 4;
+#[allow(missing_docs)]
+pub const LL_DELTA: u32 = 1 << 5;
+
+// TODO: MIPS ABI flags
+
+// PA-RISC specific definitions.
+
+// PA-RISC values for `FileHeader32::e_flags`.
+
+/// Trap nil pointer dereference.
+pub const EF_PARISC_TRAPNIL: u32 = 0x0001_0000;
+/// Program uses arch. extensions.
+pub const EF_PARISC_EXT: u32 = 0x0002_0000;
+/// Program expects little endian.
+pub const EF_PARISC_LSB: u32 = 0x0004_0000;
+/// Program expects wide mode.
+pub const EF_PARISC_WIDE: u32 = 0x0008_0000;
+/// No kernel assisted branch prediction.
+pub const EF_PARISC_NO_KABP: u32 = 0x0010_0000;
+/// Allow lazy swapping.
+pub const EF_PARISC_LAZYSWAP: u32 = 0x0040_0000;
+/// Architecture version.
+pub const EF_PARISC_ARCH: u32 = 0x0000_ffff;
+
+// Values for `EF_PARISC_ARCH'.
+
+/// PA-RISC 1.0 big-endian.
+pub const EFA_PARISC_1_0: u32 = 0x020b;
+/// PA-RISC 1.1 big-endian.
+pub const EFA_PARISC_1_1: u32 = 0x0210;
+/// PA-RISC 2.0 big-endian.
+pub const EFA_PARISC_2_0: u32 = 0x0214;
+
+// PA-RISC values for `Sym*::st_shndx`.
+
+/// Section for tenatively declared symbols in ANSI C.
+pub const SHN_PARISC_ANSI_COMMON: u16 = 0xff00;
+/// Common blocks in huge model.
+pub const SHN_PARISC_HUGE_COMMON: u16 = 0xff01;
+
+// PA-RISC values for `SectionHeader32::sh_type`.
+
+/// Contains product specific ext.
+pub const SHT_PARISC_EXT: u32 = 0x7000_0000;
+/// Unwind information.
+pub const SHT_PARISC_UNWIND: u32 = 0x7000_0001;
+/// Debug info for optimized code.
+pub const SHT_PARISC_DOC: u32 = 0x7000_0002;
+
+// PA-RISC values for `SectionHeader32::sh_flags`.
+
+/// Section with short addressing.
+pub const SHF_PARISC_SHORT: u32 = 0x2000_0000;
+/// Section far from gp.
+pub const SHF_PARISC_HUGE: u32 = 0x4000_0000;
+/// Static branch prediction code.
+pub const SHF_PARISC_SBP: u32 = 0x8000_0000;
+
+// PA-RISC values for `st_type` component of `Sym32::st_info`.
+
+/// Millicode function entry point.
+pub const STT_PARISC_MILLICODE: u8 = 13;
+
+#[allow(missing_docs)]
+pub const STT_HP_OPAQUE: u8 = STT_LOOS + 0x1;
+#[allow(missing_docs)]
+pub const STT_HP_STUB: u8 = STT_LOOS + 0x2;
+
+// PA-RISC values for `Rel*::r_type`.
+
+/// No reloc.
+pub const R_PARISC_NONE: u32 = 0;
+/// Direct 32-bit reference.
+pub const R_PARISC_DIR32: u32 = 1;
+/// Left 21 bits of eff. address.
+pub const R_PARISC_DIR21L: u32 = 2;
+/// Right 17 bits of eff. address.
+pub const R_PARISC_DIR17R: u32 = 3;
+/// 17 bits of eff. address.
+pub const R_PARISC_DIR17F: u32 = 4;
+/// Right 14 bits of eff. address.
+pub const R_PARISC_DIR14R: u32 = 6;
+/// 32-bit rel. address.
+pub const R_PARISC_PCREL32: u32 = 9;
+/// Left 21 bits of rel. address.
+pub const R_PARISC_PCREL21L: u32 = 10;
+/// Right 17 bits of rel. address.
+pub const R_PARISC_PCREL17R: u32 = 11;
+/// 17 bits of rel. address.
+pub const R_PARISC_PCREL17F: u32 = 12;
+/// Right 14 bits of rel. address.
+pub const R_PARISC_PCREL14R: u32 = 14;
+/// Left 21 bits of rel. address.
+pub const R_PARISC_DPREL21L: u32 = 18;
+/// Right 14 bits of rel. address.
+pub const R_PARISC_DPREL14R: u32 = 22;
+/// GP-relative, left 21 bits.
+pub const R_PARISC_GPREL21L: u32 = 26;
+/// GP-relative, right 14 bits.
+pub const R_PARISC_GPREL14R: u32 = 30;
+/// LT-relative, left 21 bits.
+pub const R_PARISC_LTOFF21L: u32 = 34;
+/// LT-relative, right 14 bits.
+pub const R_PARISC_LTOFF14R: u32 = 38;
+/// 32 bits section rel. address.
+pub const R_PARISC_SECREL32: u32 = 41;
+/// No relocation, set segment base.
+pub const R_PARISC_SEGBASE: u32 = 48;
+/// 32 bits segment rel. address.
+pub const R_PARISC_SEGREL32: u32 = 49;
+/// PLT rel. address, left 21 bits.
+pub const R_PARISC_PLTOFF21L: u32 = 50;
+/// PLT rel. address, right 14 bits.
+pub const R_PARISC_PLTOFF14R: u32 = 54;
+/// 32 bits LT-rel. function pointer.
+pub const R_PARISC_LTOFF_FPTR32: u32 = 57;
+/// LT-rel. fct ptr, left 21 bits.
+pub const R_PARISC_LTOFF_FPTR21L: u32 = 58;
+/// LT-rel. fct ptr, right 14 bits.
+pub const R_PARISC_LTOFF_FPTR14R: u32 = 62;
+/// 64 bits function address.
+pub const R_PARISC_FPTR64: u32 = 64;
+/// 32 bits function address.
+pub const R_PARISC_PLABEL32: u32 = 65;
+/// Left 21 bits of fdesc address.
+pub const R_PARISC_PLABEL21L: u32 = 66;
+/// Right 14 bits of fdesc address.
+pub const R_PARISC_PLABEL14R: u32 = 70;
+/// 64 bits PC-rel. address.
+pub const R_PARISC_PCREL64: u32 = 72;
+/// 22 bits PC-rel. address.
+pub const R_PARISC_PCREL22F: u32 = 74;
+/// PC-rel. address, right 14 bits.
+pub const R_PARISC_PCREL14WR: u32 = 75;
+/// PC rel. address, right 14 bits.
+pub const R_PARISC_PCREL14DR: u32 = 76;
+/// 16 bits PC-rel. address.
+pub const R_PARISC_PCREL16F: u32 = 77;
+/// 16 bits PC-rel. address.
+pub const R_PARISC_PCREL16WF: u32 = 78;
+/// 16 bits PC-rel. address.
+pub const R_PARISC_PCREL16DF: u32 = 79;
+/// 64 bits of eff. address.
+pub const R_PARISC_DIR64: u32 = 80;
+/// 14 bits of eff. address.
+pub const R_PARISC_DIR14WR: u32 = 83;
+/// 14 bits of eff. address.
+pub const R_PARISC_DIR14DR: u32 = 84;
+/// 16 bits of eff. address.
+pub const R_PARISC_DIR16F: u32 = 85;
+/// 16 bits of eff. address.
+pub const R_PARISC_DIR16WF: u32 = 86;
+/// 16 bits of eff. address.
+pub const R_PARISC_DIR16DF: u32 = 87;
+/// 64 bits of GP-rel. address.
+pub const R_PARISC_GPREL64: u32 = 88;
+/// GP-rel. address, right 14 bits.
+pub const R_PARISC_GPREL14WR: u32 = 91;
+/// GP-rel. address, right 14 bits.
+pub const R_PARISC_GPREL14DR: u32 = 92;
+/// 16 bits GP-rel. address.
+pub const R_PARISC_GPREL16F: u32 = 93;
+/// 16 bits GP-rel. address.
+pub const R_PARISC_GPREL16WF: u32 = 94;
+/// 16 bits GP-rel. address.
+pub const R_PARISC_GPREL16DF: u32 = 95;
+/// 64 bits LT-rel. address.
+pub const R_PARISC_LTOFF64: u32 = 96;
+/// LT-rel. address, right 14 bits.
+pub const R_PARISC_LTOFF14WR: u32 = 99;
+/// LT-rel. address, right 14 bits.
+pub const R_PARISC_LTOFF14DR: u32 = 100;
+/// 16 bits LT-rel. address.
+pub const R_PARISC_LTOFF16F: u32 = 101;
+/// 16 bits LT-rel. address.
+pub const R_PARISC_LTOFF16WF: u32 = 102;
+/// 16 bits LT-rel. address.
+pub const R_PARISC_LTOFF16DF: u32 = 103;
+/// 64 bits section rel. address.
+pub const R_PARISC_SECREL64: u32 = 104;
+/// 64 bits segment rel. address.
+pub const R_PARISC_SEGREL64: u32 = 112;
+/// PLT-rel. address, right 14 bits.
+pub const R_PARISC_PLTOFF14WR: u32 = 115;
+/// PLT-rel. address, right 14 bits.
+pub const R_PARISC_PLTOFF14DR: u32 = 116;
+/// 16 bits LT-rel. address.
+pub const R_PARISC_PLTOFF16F: u32 = 117;
+/// 16 bits PLT-rel. address.
+pub const R_PARISC_PLTOFF16WF: u32 = 118;
+/// 16 bits PLT-rel. address.
+pub const R_PARISC_PLTOFF16DF: u32 = 119;
+/// 64 bits LT-rel. function ptr.
+pub const R_PARISC_LTOFF_FPTR64: u32 = 120;
+/// LT-rel. fct. ptr., right 14 bits.
+pub const R_PARISC_LTOFF_FPTR14WR: u32 = 123;
+/// LT-rel. fct. ptr., right 14 bits.
+pub const R_PARISC_LTOFF_FPTR14DR: u32 = 124;
+/// 16 bits LT-rel. function ptr.
+pub const R_PARISC_LTOFF_FPTR16F: u32 = 125;
+/// 16 bits LT-rel. function ptr.
+pub const R_PARISC_LTOFF_FPTR16WF: u32 = 126;
+/// 16 bits LT-rel. function ptr.
+pub const R_PARISC_LTOFF_FPTR16DF: u32 = 127;
+#[allow(missing_docs)]
+pub const R_PARISC_LORESERVE: u32 = 128;
+/// Copy relocation.
+pub const R_PARISC_COPY: u32 = 128;
+/// Dynamic reloc, imported PLT
+pub const R_PARISC_IPLT: u32 = 129;
+/// Dynamic reloc, exported PLT
+pub const R_PARISC_EPLT: u32 = 130;
+/// 32 bits TP-rel. address.
+pub const R_PARISC_TPREL32: u32 = 153;
+/// TP-rel. address, left 21 bits.
+pub const R_PARISC_TPREL21L: u32 = 154;
+/// TP-rel. address, right 14 bits.
+pub const R_PARISC_TPREL14R: u32 = 158;
+/// LT-TP-rel. address, left 21 bits.
+pub const R_PARISC_LTOFF_TP21L: u32 = 162;
+/// LT-TP-rel. address, right 14 bits.
+pub const R_PARISC_LTOFF_TP14R: u32 = 166;
+/// 14 bits LT-TP-rel. address.
+pub const R_PARISC_LTOFF_TP14F: u32 = 167;
+/// 64 bits TP-rel. address.
+pub const R_PARISC_TPREL64: u32 = 216;
+/// TP-rel. address, right 14 bits.
+pub const R_PARISC_TPREL14WR: u32 = 219;
+/// TP-rel. address, right 14 bits.
+pub const R_PARISC_TPREL14DR: u32 = 220;
+/// 16 bits TP-rel. address.
+pub const R_PARISC_TPREL16F: u32 = 221;
+/// 16 bits TP-rel. address.
+pub const R_PARISC_TPREL16WF: u32 = 222;
+/// 16 bits TP-rel. address.
+pub const R_PARISC_TPREL16DF: u32 = 223;
+/// 64 bits LT-TP-rel. address.
+pub const R_PARISC_LTOFF_TP64: u32 = 224;
+/// LT-TP-rel. address, right 14 bits.
+pub const R_PARISC_LTOFF_TP14WR: u32 = 227;
+/// LT-TP-rel. address, right 14 bits.
+pub const R_PARISC_LTOFF_TP14DR: u32 = 228;
+/// 16 bits LT-TP-rel. address.
+pub const R_PARISC_LTOFF_TP16F: u32 = 229;
+/// 16 bits LT-TP-rel. address.
+pub const R_PARISC_LTOFF_TP16WF: u32 = 230;
+/// 16 bits LT-TP-rel. address.
+pub const R_PARISC_LTOFF_TP16DF: u32 = 231;
+#[allow(missing_docs)]
+pub const R_PARISC_GNU_VTENTRY: u32 = 232;
+#[allow(missing_docs)]
+pub const R_PARISC_GNU_VTINHERIT: u32 = 233;
+/// GD 21-bit left.
+pub const R_PARISC_TLS_GD21L: u32 = 234;
+/// GD 14-bit right.
+pub const R_PARISC_TLS_GD14R: u32 = 235;
+/// GD call to __t_g_a.
+pub const R_PARISC_TLS_GDCALL: u32 = 236;
+/// LD module 21-bit left.
+pub const R_PARISC_TLS_LDM21L: u32 = 237;
+/// LD module 14-bit right.
+pub const R_PARISC_TLS_LDM14R: u32 = 238;
+/// LD module call to __t_g_a.
+pub const R_PARISC_TLS_LDMCALL: u32 = 239;
+/// LD offset 21-bit left.
+pub const R_PARISC_TLS_LDO21L: u32 = 240;
+/// LD offset 14-bit right.
+pub const R_PARISC_TLS_LDO14R: u32 = 241;
+/// DTP module 32-bit.
+pub const R_PARISC_TLS_DTPMOD32: u32 = 242;
+/// DTP module 64-bit.
+pub const R_PARISC_TLS_DTPMOD64: u32 = 243;
+/// DTP offset 32-bit.
+pub const R_PARISC_TLS_DTPOFF32: u32 = 244;
+/// DTP offset 32-bit.
+pub const R_PARISC_TLS_DTPOFF64: u32 = 245;
+#[allow(missing_docs)]
+pub const R_PARISC_TLS_LE21L: u32 = R_PARISC_TPREL21L;
+#[allow(missing_docs)]
+pub const R_PARISC_TLS_LE14R: u32 = R_PARISC_TPREL14R;
+#[allow(missing_docs)]
+pub const R_PARISC_TLS_IE21L: u32 = R_PARISC_LTOFF_TP21L;
+#[allow(missing_docs)]
+pub const R_PARISC_TLS_IE14R: u32 = R_PARISC_LTOFF_TP14R;
+#[allow(missing_docs)]
+pub const R_PARISC_TLS_TPREL32: u32 = R_PARISC_TPREL32;
+#[allow(missing_docs)]
+pub const R_PARISC_TLS_TPREL64: u32 = R_PARISC_TPREL64;
+#[allow(missing_docs)]
+pub const R_PARISC_HIRESERVE: u32 = 255;
+
+// PA-RISC values for `ProgramHeader*::p_type`.
+
+#[allow(missing_docs)]
+pub const PT_HP_TLS: u32 = PT_LOOS + 0x0;
+#[allow(missing_docs)]
+pub const PT_HP_CORE_NONE: u32 = PT_LOOS + 0x1;
+#[allow(missing_docs)]
+pub const PT_HP_CORE_VERSION: u32 = PT_LOOS + 0x2;
+#[allow(missing_docs)]
+pub const PT_HP_CORE_KERNEL: u32 = PT_LOOS + 0x3;
+#[allow(missing_docs)]
+pub const PT_HP_CORE_COMM: u32 = PT_LOOS + 0x4;
+#[allow(missing_docs)]
+pub const PT_HP_CORE_PROC: u32 = PT_LOOS + 0x5;
+#[allow(missing_docs)]
+pub const PT_HP_CORE_LOADABLE: u32 = PT_LOOS + 0x6;
+#[allow(missing_docs)]
+pub const PT_HP_CORE_STACK: u32 = PT_LOOS + 0x7;
+#[allow(missing_docs)]
+pub const PT_HP_CORE_SHM: u32 = PT_LOOS + 0x8;
+#[allow(missing_docs)]
+pub const PT_HP_CORE_MMF: u32 = PT_LOOS + 0x9;
+#[allow(missing_docs)]
+pub const PT_HP_PARALLEL: u32 = PT_LOOS + 0x10;
+#[allow(missing_docs)]
+pub const PT_HP_FASTBIND: u32 = PT_LOOS + 0x11;
+#[allow(missing_docs)]
+pub const PT_HP_OPT_ANNOT: u32 = PT_LOOS + 0x12;
+#[allow(missing_docs)]
+pub const PT_HP_HSL_ANNOT: u32 = PT_LOOS + 0x13;
+#[allow(missing_docs)]
+pub const PT_HP_STACK: u32 = PT_LOOS + 0x14;
+
+#[allow(missing_docs)]
+pub const PT_PARISC_ARCHEXT: u32 = 0x7000_0000;
+#[allow(missing_docs)]
+pub const PT_PARISC_UNWIND: u32 = 0x7000_0001;
+
+// PA-RISC values for `ProgramHeader*::p_flags`.
+
+#[allow(missing_docs)]
+pub const PF_PARISC_SBP: u32 = 0x0800_0000;
+
+#[allow(missing_docs)]
+pub const PF_HP_PAGE_SIZE: u32 = 0x0010_0000;
+#[allow(missing_docs)]
+pub const PF_HP_FAR_SHARED: u32 = 0x0020_0000;
+#[allow(missing_docs)]
+pub const PF_HP_NEAR_SHARED: u32 = 0x0040_0000;
+#[allow(missing_docs)]
+pub const PF_HP_CODE: u32 = 0x0100_0000;
+#[allow(missing_docs)]
+pub const PF_HP_MODIFY: u32 = 0x0200_0000;
+#[allow(missing_docs)]
+pub const PF_HP_LAZYSWAP: u32 = 0x0400_0000;
+#[allow(missing_docs)]
+pub const PF_HP_SBP: u32 = 0x0800_0000;
+
+// Alpha specific definitions.
+
+// Alpha values for `FileHeader64::e_flags`.
+
+/// All addresses must be < 2GB.
+pub const EF_ALPHA_32BIT: u32 = 1;
+/// Relocations for relaxing exist.
+pub const EF_ALPHA_CANRELAX: u32 = 2;
+
+// Alpha values for `SectionHeader64::sh_type`.
+
+// These two are primerily concerned with ECOFF debugging info.
+#[allow(missing_docs)]
+pub const SHT_ALPHA_DEBUG: u32 = 0x7000_0001;
+#[allow(missing_docs)]
+pub const SHT_ALPHA_REGINFO: u32 = 0x7000_0002;
+
+// Alpha values for `SectionHeader64::sh_flags`.
+
+#[allow(missing_docs)]
+pub const SHF_ALPHA_GPREL: u32 = 0x1000_0000;
+
+// Alpha values for `Sym64::st_other`.
+/// No PV required.
+pub const STO_ALPHA_NOPV: u8 = 0x80;
+/// PV only used for initial ldgp.
+pub const STO_ALPHA_STD_GPLOAD: u8 = 0x88;
+
+// Alpha values for `Rel64::r_type`.
+
+/// No reloc
+pub const R_ALPHA_NONE: u32 = 0;
+/// Direct 32 bit
+pub const R_ALPHA_REFLONG: u32 = 1;
+/// Direct 64 bit
+pub const R_ALPHA_REFQUAD: u32 = 2;
+/// GP relative 32 bit
+pub const R_ALPHA_GPREL32: u32 = 3;
+/// GP relative 16 bit w/optimization
+pub const R_ALPHA_LITERAL: u32 = 4;
+/// Optimization hint for LITERAL
+pub const R_ALPHA_LITUSE: u32 = 5;
+/// Add displacement to GP
+pub const R_ALPHA_GPDISP: u32 = 6;
+/// PC+4 relative 23 bit shifted
+pub const R_ALPHA_BRADDR: u32 = 7;
+/// PC+4 relative 16 bit shifted
+pub const R_ALPHA_HINT: u32 = 8;
+/// PC relative 16 bit
+pub const R_ALPHA_SREL16: u32 = 9;
+/// PC relative 32 bit
+pub const R_ALPHA_SREL32: u32 = 10;
+/// PC relative 64 bit
+pub const R_ALPHA_SREL64: u32 = 11;
+/// GP relative 32 bit, high 16 bits
+pub const R_ALPHA_GPRELHIGH: u32 = 17;
+/// GP relative 32 bit, low 16 bits
+pub const R_ALPHA_GPRELLOW: u32 = 18;
+/// GP relative 16 bit
+pub const R_ALPHA_GPREL16: u32 = 19;
+/// Copy symbol at runtime
+pub const R_ALPHA_COPY: u32 = 24;
+/// Create GOT entry
+pub const R_ALPHA_GLOB_DAT: u32 = 25;
+/// Create PLT entry
+pub const R_ALPHA_JMP_SLOT: u32 = 26;
+/// Adjust by program base
+pub const R_ALPHA_RELATIVE: u32 = 27;
+#[allow(missing_docs)]
+pub const R_ALPHA_TLS_GD_HI: u32 = 28;
+#[allow(missing_docs)]
+pub const R_ALPHA_TLSGD: u32 = 29;
+#[allow(missing_docs)]
+pub const R_ALPHA_TLS_LDM: u32 = 30;
+#[allow(missing_docs)]
+pub const R_ALPHA_DTPMOD64: u32 = 31;
+#[allow(missing_docs)]
+pub const R_ALPHA_GOTDTPREL: u32 = 32;
+#[allow(missing_docs)]
+pub const R_ALPHA_DTPREL64: u32 = 33;
+#[allow(missing_docs)]
+pub const R_ALPHA_DTPRELHI: u32 = 34;
+#[allow(missing_docs)]
+pub const R_ALPHA_DTPRELLO: u32 = 35;
+#[allow(missing_docs)]
+pub const R_ALPHA_DTPREL16: u32 = 36;
+#[allow(missing_docs)]
+pub const R_ALPHA_GOTTPREL: u32 = 37;
+#[allow(missing_docs)]
+pub const R_ALPHA_TPREL64: u32 = 38;
+#[allow(missing_docs)]
+pub const R_ALPHA_TPRELHI: u32 = 39;
+#[allow(missing_docs)]
+pub const R_ALPHA_TPRELLO: u32 = 40;
+#[allow(missing_docs)]
+pub const R_ALPHA_TPREL16: u32 = 41;
+
+// Magic values of the `R_ALPHA_LITUSE` relocation addend.
+#[allow(missing_docs)]
+pub const LITUSE_ALPHA_ADDR: u32 = 0;
+#[allow(missing_docs)]
+pub const LITUSE_ALPHA_BASE: u32 = 1;
+#[allow(missing_docs)]
+pub const LITUSE_ALPHA_BYTOFF: u32 = 2;
+#[allow(missing_docs)]
+pub const LITUSE_ALPHA_JSR: u32 = 3;
+#[allow(missing_docs)]
+pub const LITUSE_ALPHA_TLS_GD: u32 = 4;
+#[allow(missing_docs)]
+pub const LITUSE_ALPHA_TLS_LDM: u32 = 5;
+
+// Alpha values for `Dyn64::d_tag`.
+#[allow(missing_docs)]
+pub const DT_ALPHA_PLTRO: u32 = DT_LOPROC + 0;
+
+// PowerPC specific declarations.
+
+// PowerPC values for `FileHeader*::e_flags`.
+/// PowerPC embedded flag
+pub const EF_PPC_EMB: u32 = 0x8000_0000;
+
+// Cygnus local bits below .
+/// PowerPC -mrelocatable flag
+pub const EF_PPC_RELOCATABLE: u32 = 0x0001_0000;
+/// PowerPC -mrelocatable-lib flag
+pub const EF_PPC_RELOCATABLE_LIB: u32 = 0x0000_8000;
+
+// PowerPC values for `Rel*::r_type` defined by the ABIs.
+#[allow(missing_docs)]
+pub const R_PPC_NONE: u32 = 0;
+/// 32bit absolute address
+pub const R_PPC_ADDR32: u32 = 1;
+/// 26bit address, 2 bits ignored.
+pub const R_PPC_ADDR24: u32 = 2;
+/// 16bit absolute address
+pub const R_PPC_ADDR16: u32 = 3;
+/// lower 16bit of absolute address
+pub const R_PPC_ADDR16_LO: u32 = 4;
+/// high 16bit of absolute address
+pub const R_PPC_ADDR16_HI: u32 = 5;
+/// adjusted high 16bit
+pub const R_PPC_ADDR16_HA: u32 = 6;
+/// 16bit address, 2 bits ignored
+pub const R_PPC_ADDR14: u32 = 7;
+#[allow(missing_docs)]
+pub const R_PPC_ADDR14_BRTAKEN: u32 = 8;
+#[allow(missing_docs)]
+pub const R_PPC_ADDR14_BRNTAKEN: u32 = 9;
+/// PC relative 26 bit
+pub const R_PPC_REL24: u32 = 10;
+/// PC relative 16 bit
+pub const R_PPC_REL14: u32 = 11;
+#[allow(missing_docs)]
+pub const R_PPC_REL14_BRTAKEN: u32 = 12;
+#[allow(missing_docs)]
+pub const R_PPC_REL14_BRNTAKEN: u32 = 13;
+#[allow(missing_docs)]
+pub const R_PPC_GOT16: u32 = 14;
+#[allow(missing_docs)]
+pub const R_PPC_GOT16_LO: u32 = 15;
+#[allow(missing_docs)]
+pub const R_PPC_GOT16_HI: u32 = 16;
+#[allow(missing_docs)]
+pub const R_PPC_GOT16_HA: u32 = 17;
+#[allow(missing_docs)]
+pub const R_PPC_PLTREL24: u32 = 18;
+#[allow(missing_docs)]
+pub const R_PPC_COPY: u32 = 19;
+#[allow(missing_docs)]
+pub const R_PPC_GLOB_DAT: u32 = 20;
+#[allow(missing_docs)]
+pub const R_PPC_JMP_SLOT: u32 = 21;
+#[allow(missing_docs)]
+pub const R_PPC_RELATIVE: u32 = 22;
+#[allow(missing_docs)]
+pub const R_PPC_LOCAL24PC: u32 = 23;
+#[allow(missing_docs)]
+pub const R_PPC_UADDR32: u32 = 24;
+#[allow(missing_docs)]
+pub const R_PPC_UADDR16: u32 = 25;
+#[allow(missing_docs)]
+pub const R_PPC_REL32: u32 = 26;
+#[allow(missing_docs)]
+pub const R_PPC_PLT32: u32 = 27;
+#[allow(missing_docs)]
+pub const R_PPC_PLTREL32: u32 = 28;
+#[allow(missing_docs)]
+pub const R_PPC_PLT16_LO: u32 = 29;
+#[allow(missing_docs)]
+pub const R_PPC_PLT16_HI: u32 = 30;
+#[allow(missing_docs)]
+pub const R_PPC_PLT16_HA: u32 = 31;
+#[allow(missing_docs)]
+pub const R_PPC_SDAREL16: u32 = 32;
+#[allow(missing_docs)]
+pub const R_PPC_SECTOFF: u32 = 33;
+#[allow(missing_docs)]
+pub const R_PPC_SECTOFF_LO: u32 = 34;
+#[allow(missing_docs)]
+pub const R_PPC_SECTOFF_HI: u32 = 35;
+#[allow(missing_docs)]
+pub const R_PPC_SECTOFF_HA: u32 = 36;
+
+// PowerPC values for `Rel*::r_type` defined for the TLS access ABI.
+/// none (sym+add)@tls
+pub const R_PPC_TLS: u32 = 67;
+/// word32 (sym+add)@dtpmod
+pub const R_PPC_DTPMOD32: u32 = 68;
+/// half16* (sym+add)@tprel
+pub const R_PPC_TPREL16: u32 = 69;
+/// half16 (sym+add)@tprel@l
+pub const R_PPC_TPREL16_LO: u32 = 70;
+/// half16 (sym+add)@tprel@h
+pub const R_PPC_TPREL16_HI: u32 = 71;
+/// half16 (sym+add)@tprel@ha
+pub const R_PPC_TPREL16_HA: u32 = 72;
+/// word32 (sym+add)@tprel
+pub const R_PPC_TPREL32: u32 = 73;
+/// half16*(sym+add)@dtprel
+pub const R_PPC_DTPREL16: u32 = 74;
+/// half16 (sym+add)@dtprel@l
+pub const R_PPC_DTPREL16_LO: u32 = 75;
+/// half16 (sym+add)@dtprel@h
+pub const R_PPC_DTPREL16_HI: u32 = 76;
+/// half16 (sym+add)@dtprel@ha
+pub const R_PPC_DTPREL16_HA: u32 = 77;
+/// word32 (sym+add)@dtprel
+pub const R_PPC_DTPREL32: u32 = 78;
+/// half16* (sym+add)@got@tlsgd
+pub const R_PPC_GOT_TLSGD16: u32 = 79;
+/// half16 (sym+add)@got@tlsgd@l
+pub const R_PPC_GOT_TLSGD16_LO: u32 = 80;
+/// half16 (sym+add)@got@tlsgd@h
+pub const R_PPC_GOT_TLSGD16_HI: u32 = 81;
+/// half16 (sym+add)@got@tlsgd@ha
+pub const R_PPC_GOT_TLSGD16_HA: u32 = 82;
+/// half16* (sym+add)@got@tlsld
+pub const R_PPC_GOT_TLSLD16: u32 = 83;
+/// half16 (sym+add)@got@tlsld@l
+pub const R_PPC_GOT_TLSLD16_LO: u32 = 84;
+/// half16 (sym+add)@got@tlsld@h
+pub const R_PPC_GOT_TLSLD16_HI: u32 = 85;
+/// half16 (sym+add)@got@tlsld@ha
+pub const R_PPC_GOT_TLSLD16_HA: u32 = 86;
+/// half16* (sym+add)@got@tprel
+pub const R_PPC_GOT_TPREL16: u32 = 87;
+/// half16 (sym+add)@got@tprel@l
+pub const R_PPC_GOT_TPREL16_LO: u32 = 88;
+/// half16 (sym+add)@got@tprel@h
+pub const R_PPC_GOT_TPREL16_HI: u32 = 89;
+/// half16 (sym+add)@got@tprel@ha
+pub const R_PPC_GOT_TPREL16_HA: u32 = 90;
+/// half16* (sym+add)@got@dtprel
+pub const R_PPC_GOT_DTPREL16: u32 = 91;
+/// half16* (sym+add)@got@dtprel@l
+pub const R_PPC_GOT_DTPREL16_LO: u32 = 92;
+/// half16* (sym+add)@got@dtprel@h
+pub const R_PPC_GOT_DTPREL16_HI: u32 = 93;
+/// half16* (sym+add)@got@dtprel@ha
+pub const R_PPC_GOT_DTPREL16_HA: u32 = 94;
+/// none (sym+add)@tlsgd
+pub const R_PPC_TLSGD: u32 = 95;
+/// none (sym+add)@tlsld
+pub const R_PPC_TLSLD: u32 = 96;
+
+// PowerPC values for `Rel*::r_type` from the Embedded ELF ABI.
+#[allow(missing_docs)]
+pub const R_PPC_EMB_NADDR32: u32 = 101;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_NADDR16: u32 = 102;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_NADDR16_LO: u32 = 103;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_NADDR16_HI: u32 = 104;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_NADDR16_HA: u32 = 105;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_SDAI16: u32 = 106;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_SDA2I16: u32 = 107;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_SDA2REL: u32 = 108;
+/// 16 bit offset in SDA
+pub const R_PPC_EMB_SDA21: u32 = 109;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_MRKREF: u32 = 110;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_RELSEC16: u32 = 111;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_RELST_LO: u32 = 112;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_RELST_HI: u32 = 113;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_RELST_HA: u32 = 114;
+#[allow(missing_docs)]
+pub const R_PPC_EMB_BIT_FLD: u32 = 115;
+/// 16 bit relative offset in SDA
+pub const R_PPC_EMB_RELSDA: u32 = 116;
+
+// Diab tool values for `Rel*::r_type`.
+/// like EMB_SDA21, but lower 16 bit
+pub const R_PPC_DIAB_SDA21_LO: u32 = 180;
+/// like EMB_SDA21, but high 16 bit
+pub const R_PPC_DIAB_SDA21_HI: u32 = 181;
+/// like EMB_SDA21, adjusted high 16
+pub const R_PPC_DIAB_SDA21_HA: u32 = 182;
+/// like EMB_RELSDA, but lower 16 bit
+pub const R_PPC_DIAB_RELSDA_LO: u32 = 183;
+/// like EMB_RELSDA, but high 16 bit
+pub const R_PPC_DIAB_RELSDA_HI: u32 = 184;
+/// like EMB_RELSDA, adjusted high 16
+pub const R_PPC_DIAB_RELSDA_HA: u32 = 185;
+
+/// GNU extension to support local ifunc.
+pub const R_PPC_IRELATIVE: u32 = 248;
+
+// GNU relocs used in PIC code sequences.
+/// half16 (sym+add-.)
+pub const R_PPC_REL16: u32 = 249;
+/// half16 (sym+add-.)@l
+pub const R_PPC_REL16_LO: u32 = 250;
+/// half16 (sym+add-.)@h
+pub const R_PPC_REL16_HI: u32 = 251;
+/// half16 (sym+add-.)@ha
+pub const R_PPC_REL16_HA: u32 = 252;
+
+/// This is a phony reloc to handle any old fashioned TOC16 references that may
+/// still be in object files.
+pub const R_PPC_TOC16: u32 = 255;
+
+// PowerPC specific values for `Dyn*::d_tag`.
+#[allow(missing_docs)]
+pub const DT_PPC_GOT: u32 = DT_LOPROC + 0;
+#[allow(missing_docs)]
+pub const DT_PPC_OPT: u32 = DT_LOPROC + 1;
+
+// PowerPC specific values for the `DT_PPC_OPT` entry.
+#[allow(missing_docs)]
+pub const PPC_OPT_TLS: u32 = 1;
+
+// PowerPC64 values for `Rel*::r_type` defined by the ABIs.
+#[allow(missing_docs)]
+pub const R_PPC64_NONE: u32 = R_PPC_NONE;
+/// 32bit absolute address
+pub const R_PPC64_ADDR32: u32 = R_PPC_ADDR32;
+/// 26bit address, word aligned
+pub const R_PPC64_ADDR24: u32 = R_PPC_ADDR24;
+/// 16bit absolute address
+pub const R_PPC64_ADDR16: u32 = R_PPC_ADDR16;
+/// lower 16bits of address
+pub const R_PPC64_ADDR16_LO: u32 = R_PPC_ADDR16_LO;
+/// high 16bits of address.
+pub const R_PPC64_ADDR16_HI: u32 = R_PPC_ADDR16_HI;
+/// adjusted high 16bits.
+pub const R_PPC64_ADDR16_HA: u32 = R_PPC_ADDR16_HA;
+/// 16bit address, word aligned
+pub const R_PPC64_ADDR14: u32 = R_PPC_ADDR14;
+#[allow(missing_docs)]
+pub const R_PPC64_ADDR14_BRTAKEN: u32 = R_PPC_ADDR14_BRTAKEN;
+#[allow(missing_docs)]
+pub const R_PPC64_ADDR14_BRNTAKEN: u32 = R_PPC_ADDR14_BRNTAKEN;
+/// PC-rel. 26 bit, word aligned
+pub const R_PPC64_REL24: u32 = R_PPC_REL24;
+/// PC relative 16 bit
+pub const R_PPC64_REL14: u32 = R_PPC_REL14;
+#[allow(missing_docs)]
+pub const R_PPC64_REL14_BRTAKEN: u32 = R_PPC_REL14_BRTAKEN;
+#[allow(missing_docs)]
+pub const R_PPC64_REL14_BRNTAKEN: u32 = R_PPC_REL14_BRNTAKEN;
+#[allow(missing_docs)]
+pub const R_PPC64_GOT16: u32 = R_PPC_GOT16;
+#[allow(missing_docs)]
+pub const R_PPC64_GOT16_LO: u32 = R_PPC_GOT16_LO;
+#[allow(missing_docs)]
+pub const R_PPC64_GOT16_HI: u32 = R_PPC_GOT16_HI;
+#[allow(missing_docs)]
+pub const R_PPC64_GOT16_HA: u32 = R_PPC_GOT16_HA;
+
+#[allow(missing_docs)]
+pub const R_PPC64_COPY: u32 = R_PPC_COPY;
+#[allow(missing_docs)]
+pub const R_PPC64_GLOB_DAT: u32 = R_PPC_GLOB_DAT;
+#[allow(missing_docs)]
+pub const R_PPC64_JMP_SLOT: u32 = R_PPC_JMP_SLOT;
+#[allow(missing_docs)]
+pub const R_PPC64_RELATIVE: u32 = R_PPC_RELATIVE;
+
+#[allow(missing_docs)]
+pub const R_PPC64_UADDR32: u32 = R_PPC_UADDR32;
+#[allow(missing_docs)]
+pub const R_PPC64_UADDR16: u32 = R_PPC_UADDR16;
+#[allow(missing_docs)]
+pub const R_PPC64_REL32: u32 = R_PPC_REL32;
+#[allow(missing_docs)]
+pub const R_PPC64_PLT32: u32 = R_PPC_PLT32;
+#[allow(missing_docs)]
+pub const R_PPC64_PLTREL32: u32 = R_PPC_PLTREL32;
+#[allow(missing_docs)]
+pub const R_PPC64_PLT16_LO: u32 = R_PPC_PLT16_LO;
+#[allow(missing_docs)]
+pub const R_PPC64_PLT16_HI: u32 = R_PPC_PLT16_HI;
+#[allow(missing_docs)]
+pub const R_PPC64_PLT16_HA: u32 = R_PPC_PLT16_HA;
+
+#[allow(missing_docs)]
+pub const R_PPC64_SECTOFF: u32 = R_PPC_SECTOFF;
+#[allow(missing_docs)]
+pub const R_PPC64_SECTOFF_LO: u32 = R_PPC_SECTOFF_LO;
+#[allow(missing_docs)]
+pub const R_PPC64_SECTOFF_HI: u32 = R_PPC_SECTOFF_HI;
+#[allow(missing_docs)]
+pub const R_PPC64_SECTOFF_HA: u32 = R_PPC_SECTOFF_HA;
+/// word30 (S + A - P) >> 2
+pub const R_PPC64_ADDR30: u32 = 37;
+/// doubleword64 S + A
+pub const R_PPC64_ADDR64: u32 = 38;
+/// half16 #higher(S + A)
+pub const R_PPC64_ADDR16_HIGHER: u32 = 39;
+/// half16 #highera(S + A)
+pub const R_PPC64_ADDR16_HIGHERA: u32 = 40;
+/// half16 #highest(S + A)
+pub const R_PPC64_ADDR16_HIGHEST: u32 = 41;
+/// half16 #highesta(S + A)
+pub const R_PPC64_ADDR16_HIGHESTA: u32 = 42;
+/// doubleword64 S + A
+pub const R_PPC64_UADDR64: u32 = 43;
+/// doubleword64 S + A - P
+pub const R_PPC64_REL64: u32 = 44;
+/// doubleword64 L + A
+pub const R_PPC64_PLT64: u32 = 45;
+/// doubleword64 L + A - P
+pub const R_PPC64_PLTREL64: u32 = 46;
+/// half16* S + A - .TOC
+pub const R_PPC64_TOC16: u32 = 47;
+/// half16 #lo(S + A - .TOC.)
+pub const R_PPC64_TOC16_LO: u32 = 48;
+/// half16 #hi(S + A - .TOC.)
+pub const R_PPC64_TOC16_HI: u32 = 49;
+/// half16 #ha(S + A - .TOC.)
+pub const R_PPC64_TOC16_HA: u32 = 50;
+/// doubleword64 .TOC
+pub const R_PPC64_TOC: u32 = 51;
+/// half16* M + A
+pub const R_PPC64_PLTGOT16: u32 = 52;
+/// half16 #lo(M + A)
+pub const R_PPC64_PLTGOT16_LO: u32 = 53;
+/// half16 #hi(M + A)
+pub const R_PPC64_PLTGOT16_HI: u32 = 54;
+/// half16 #ha(M + A)
+pub const R_PPC64_PLTGOT16_HA: u32 = 55;
+
+/// half16ds* (S + A) >> 2
+pub const R_PPC64_ADDR16_DS: u32 = 56;
+/// half16ds #lo(S + A) >> 2
+pub const R_PPC64_ADDR16_LO_DS: u32 = 57;
+/// half16ds* (G + A) >> 2
+pub const R_PPC64_GOT16_DS: u32 = 58;
+/// half16ds #lo(G + A) >> 2
+pub const R_PPC64_GOT16_LO_DS: u32 = 59;
+/// half16ds #lo(L + A) >> 2
+pub const R_PPC64_PLT16_LO_DS: u32 = 60;
+/// half16ds* (R + A) >> 2
+pub const R_PPC64_SECTOFF_DS: u32 = 61;
+/// half16ds #lo(R + A) >> 2
+pub const R_PPC64_SECTOFF_LO_DS: u32 = 62;
+/// half16ds* (S + A - .TOC.) >> 2
+pub const R_PPC64_TOC16_DS: u32 = 63;
+/// half16ds #lo(S + A - .TOC.) >> 2
+pub const R_PPC64_TOC16_LO_DS: u32 = 64;
+/// half16ds* (M + A) >> 2
+pub const R_PPC64_PLTGOT16_DS: u32 = 65;
+/// half16ds #lo(M + A) >> 2
+pub const R_PPC64_PLTGOT16_LO_DS: u32 = 66;
+
+// PowerPC64 values for `Rel*::r_type` defined for the TLS access ABI.
+/// none (sym+add)@tls
+pub const R_PPC64_TLS: u32 = 67;
+/// doubleword64 (sym+add)@dtpmod
+pub const R_PPC64_DTPMOD64: u32 = 68;
+/// half16* (sym+add)@tprel
+pub const R_PPC64_TPREL16: u32 = 69;
+/// half16 (sym+add)@tprel@l
+pub const R_PPC64_TPREL16_LO: u32 = 70;
+/// half16 (sym+add)@tprel@h
+pub const R_PPC64_TPREL16_HI: u32 = 71;
+/// half16 (sym+add)@tprel@ha
+pub const R_PPC64_TPREL16_HA: u32 = 72;
+/// doubleword64 (sym+add)@tprel
+pub const R_PPC64_TPREL64: u32 = 73;
+/// half16* (sym+add)@dtprel
+pub const R_PPC64_DTPREL16: u32 = 74;
+/// half16 (sym+add)@dtprel@l
+pub const R_PPC64_DTPREL16_LO: u32 = 75;
+/// half16 (sym+add)@dtprel@h
+pub const R_PPC64_DTPREL16_HI: u32 = 76;
+/// half16 (sym+add)@dtprel@ha
+pub const R_PPC64_DTPREL16_HA: u32 = 77;
+/// doubleword64 (sym+add)@dtprel
+pub const R_PPC64_DTPREL64: u32 = 78;
+/// half16* (sym+add)@got@tlsgd
+pub const R_PPC64_GOT_TLSGD16: u32 = 79;
+/// half16 (sym+add)@got@tlsgd@l
+pub const R_PPC64_GOT_TLSGD16_LO: u32 = 80;
+/// half16 (sym+add)@got@tlsgd@h
+pub const R_PPC64_GOT_TLSGD16_HI: u32 = 81;
+/// half16 (sym+add)@got@tlsgd@ha
+pub const R_PPC64_GOT_TLSGD16_HA: u32 = 82;
+/// half16* (sym+add)@got@tlsld
+pub const R_PPC64_GOT_TLSLD16: u32 = 83;
+/// half16 (sym+add)@got@tlsld@l
+pub const R_PPC64_GOT_TLSLD16_LO: u32 = 84;
+/// half16 (sym+add)@got@tlsld@h
+pub const R_PPC64_GOT_TLSLD16_HI: u32 = 85;
+/// half16 (sym+add)@got@tlsld@ha
+pub const R_PPC64_GOT_TLSLD16_HA: u32 = 86;
+/// half16ds* (sym+add)@got@tprel
+pub const R_PPC64_GOT_TPREL16_DS: u32 = 87;
+/// half16ds (sym+add)@got@tprel@l
+pub const R_PPC64_GOT_TPREL16_LO_DS: u32 = 88;
+/// half16 (sym+add)@got@tprel@h
+pub const R_PPC64_GOT_TPREL16_HI: u32 = 89;
+/// half16 (sym+add)@got@tprel@ha
+pub const R_PPC64_GOT_TPREL16_HA: u32 = 90;
+/// half16ds* (sym+add)@got@dtprel
+pub const R_PPC64_GOT_DTPREL16_DS: u32 = 91;
+/// half16ds (sym+add)@got@dtprel@l
+pub const R_PPC64_GOT_DTPREL16_LO_DS: u32 = 92;
+/// half16 (sym+add)@got@dtprel@h
+pub const R_PPC64_GOT_DTPREL16_HI: u32 = 93;
+/// half16 (sym+add)@got@dtprel@ha
+pub const R_PPC64_GOT_DTPREL16_HA: u32 = 94;
+/// half16ds* (sym+add)@tprel
+pub const R_PPC64_TPREL16_DS: u32 = 95;
+/// half16ds (sym+add)@tprel@l
+pub const R_PPC64_TPREL16_LO_DS: u32 = 96;
+/// half16 (sym+add)@tprel@higher
+pub const R_PPC64_TPREL16_HIGHER: u32 = 97;
+/// half16 (sym+add)@tprel@highera
+pub const R_PPC64_TPREL16_HIGHERA: u32 = 98;
+/// half16 (sym+add)@tprel@highest
+pub const R_PPC64_TPREL16_HIGHEST: u32 = 99;
+/// half16 (sym+add)@tprel@highesta
+pub const R_PPC64_TPREL16_HIGHESTA: u32 = 100;
+/// half16ds* (sym+add)@dtprel
+pub const R_PPC64_DTPREL16_DS: u32 = 101;
+/// half16ds (sym+add)@dtprel@l
+pub const R_PPC64_DTPREL16_LO_DS: u32 = 102;
+/// half16 (sym+add)@dtprel@higher
+pub const R_PPC64_DTPREL16_HIGHER: u32 = 103;
+/// half16 (sym+add)@dtprel@highera
+pub const R_PPC64_DTPREL16_HIGHERA: u32 = 104;
+/// half16 (sym+add)@dtprel@highest
+pub const R_PPC64_DTPREL16_HIGHEST: u32 = 105;
+/// half16 (sym+add)@dtprel@highesta
+pub const R_PPC64_DTPREL16_HIGHESTA: u32 = 106;
+/// none (sym+add)@tlsgd
+pub const R_PPC64_TLSGD: u32 = 107;
+/// none (sym+add)@tlsld
+pub const R_PPC64_TLSLD: u32 = 108;
+/// none
+pub const R_PPC64_TOCSAVE: u32 = 109;
+
+// Added when HA and HI relocs were changed to report overflows.
+#[allow(missing_docs)]
+pub const R_PPC64_ADDR16_HIGH: u32 = 110;
+#[allow(missing_docs)]
+pub const R_PPC64_ADDR16_HIGHA: u32 = 111;
+#[allow(missing_docs)]
+pub const R_PPC64_TPREL16_HIGH: u32 = 112;
+#[allow(missing_docs)]
+pub const R_PPC64_TPREL16_HIGHA: u32 = 113;
+#[allow(missing_docs)]
+pub const R_PPC64_DTPREL16_HIGH: u32 = 114;
+#[allow(missing_docs)]
+pub const R_PPC64_DTPREL16_HIGHA: u32 = 115;
+
+/// GNU extension to support local ifunc.
+#[allow(missing_docs)]
+pub const R_PPC64_JMP_IREL: u32 = 247;
+/// GNU extension to support local ifunc.
+#[allow(missing_docs)]
+pub const R_PPC64_IRELATIVE: u32 = 248;
+/// half16 (sym+add-.)
+pub const R_PPC64_REL16: u32 = 249;
+/// half16 (sym+add-.)@l
+pub const R_PPC64_REL16_LO: u32 = 250;
+/// half16 (sym+add-.)@h
+pub const R_PPC64_REL16_HI: u32 = 251;
+/// half16 (sym+add-.)@ha
+pub const R_PPC64_REL16_HA: u32 = 252;
+
+// PowerPC64 values for `FileHeader64::e_flags.
+/// PowerPC64 bits specifying ABI.
+///
+/// 1 for original function descriptor using ABI,
+/// 2 for revised ABI without function descriptors,
+/// 0 for unspecified or not using any features affected by the differences.
+pub const EF_PPC64_ABI: u32 = 3;
+
+// PowerPC64 values for `Dyn64::d_tag.
+#[allow(missing_docs)]
+pub const DT_PPC64_GLINK: u32 = DT_LOPROC + 0;
+#[allow(missing_docs)]
+pub const DT_PPC64_OPD: u32 = DT_LOPROC + 1;
+#[allow(missing_docs)]
+pub const DT_PPC64_OPDSZ: u32 = DT_LOPROC + 2;
+#[allow(missing_docs)]
+pub const DT_PPC64_OPT: u32 = DT_LOPROC + 3;
+
+// PowerPC64 bits for `DT_PPC64_OPT` entry.
+#[allow(missing_docs)]
+pub const PPC64_OPT_TLS: u32 = 1;
+#[allow(missing_docs)]
+pub const PPC64_OPT_MULTI_TOC: u32 = 2;
+#[allow(missing_docs)]
+pub const PPC64_OPT_LOCALENTRY: u32 = 4;
+
+// PowerPC64 values for `Sym64::st_other.
+#[allow(missing_docs)]
+pub const STO_PPC64_LOCAL_BIT: u8 = 5;
+#[allow(missing_docs)]
+pub const STO_PPC64_LOCAL_MASK: u8 = 7 << STO_PPC64_LOCAL_BIT;
+
+// ARM specific declarations.
+
+// ARM values for `FileHeader*::e_flags`.
+#[allow(missing_docs)]
+pub const EF_ARM_RELEXEC: u32 = 0x01;
+#[allow(missing_docs)]
+pub const EF_ARM_HASENTRY: u32 = 0x02;
+#[allow(missing_docs)]
+pub const EF_ARM_INTERWORK: u32 = 0x04;
+#[allow(missing_docs)]
+pub const EF_ARM_APCS_26: u32 = 0x08;
+#[allow(missing_docs)]
+pub const EF_ARM_APCS_FLOAT: u32 = 0x10;
+#[allow(missing_docs)]
+pub const EF_ARM_PIC: u32 = 0x20;
+/// 8-bit structure alignment is in use
+pub const EF_ARM_ALIGN8: u32 = 0x40;
+#[allow(missing_docs)]
+pub const EF_ARM_NEW_ABI: u32 = 0x80;
+#[allow(missing_docs)]
+pub const EF_ARM_OLD_ABI: u32 = 0x100;
+#[allow(missing_docs)]
+pub const EF_ARM_SOFT_FLOAT: u32 = 0x200;
+#[allow(missing_docs)]
+pub const EF_ARM_VFP_FLOAT: u32 = 0x400;
+#[allow(missing_docs)]
+pub const EF_ARM_MAVERICK_FLOAT: u32 = 0x800;
+
+/// NB conflicts with EF_ARM_SOFT_FLOAT
+pub const EF_ARM_ABI_FLOAT_SOFT: u32 = 0x200;
+/// NB conflicts with EF_ARM_VFP_FLOAT
+pub const EF_ARM_ABI_FLOAT_HARD: u32 = 0x400;
+
+// Other constants defined in the ARM ELF spec. version B-01.
+// NB. These conflict with values defined above.
+#[allow(missing_docs)]
+pub const EF_ARM_SYMSARESORTED: u32 = 0x04;
+#[allow(missing_docs)]
+pub const EF_ARM_DYNSYMSUSESEGIDX: u32 = 0x08;
+#[allow(missing_docs)]
+pub const EF_ARM_MAPSYMSFIRST: u32 = 0x10;
+
+// Constants defined in AAELF.
+#[allow(missing_docs)]
+pub const EF_ARM_BE8: u32 = 0x0080_0000;
+#[allow(missing_docs)]
+pub const EF_ARM_LE8: u32 = 0x0040_0000;
+
+#[allow(missing_docs)]
+pub const EF_ARM_EABIMASK: u32 = 0xff00_0000;
+#[allow(missing_docs)]
+pub const EF_ARM_EABI_UNKNOWN: u32 = 0x0000_0000;
+#[allow(missing_docs)]
+pub const EF_ARM_EABI_VER1: u32 = 0x0100_0000;
+#[allow(missing_docs)]
+pub const EF_ARM_EABI_VER2: u32 = 0x0200_0000;
+#[allow(missing_docs)]
+pub const EF_ARM_EABI_VER3: u32 = 0x0300_0000;
+#[allow(missing_docs)]
+pub const EF_ARM_EABI_VER4: u32 = 0x0400_0000;
+#[allow(missing_docs)]
+pub const EF_ARM_EABI_VER5: u32 = 0x0500_0000;
+
+// ARM Thumb values for `st_type` component of `Sym*::st_info`.
+/// A Thumb function.
+pub const STT_ARM_TFUNC: u8 = STT_LOPROC;
+/// A Thumb label.
+pub const STT_ARM_16BIT: u8 = STT_HIPROC;
+
+// ARM values for `SectionHeader*::sh_flags`.
+/// Section contains an entry point
+pub const SHF_ARM_ENTRYSECT: u32 = 0x1000_0000;
+/// Section may be multiply defined in the input to a link step.
+pub const SHF_ARM_COMDEF: u32 = 0x8000_0000;
+
+// ARM values for `ProgramHeader*::p_flags`.
+/// Segment contains the location addressed by the static base.
+pub const PF_ARM_SB: u32 = 0x1000_0000;
+/// Position-independent segment.
+pub const PF_ARM_PI: u32 = 0x2000_0000;
+/// Absolute segment.
+pub const PF_ARM_ABS: u32 = 0x4000_0000;
+
+// ARM values for `ProgramHeader*::p_type`.
+/// ARM unwind segment.
+pub const PT_ARM_EXIDX: u32 = PT_LOPROC + 1;
+
+// ARM values for `SectionHeader*::sh_type`.
+/// ARM unwind section.
+pub const SHT_ARM_EXIDX: u32 = SHT_LOPROC + 1;
+/// Preemption details.
+pub const SHT_ARM_PREEMPTMAP: u32 = SHT_LOPROC + 2;
+/// ARM attributes section.
+pub const SHT_ARM_ATTRIBUTES: u32 = SHT_LOPROC + 3;
+
+// AArch64 values for `Rel*::r_type`.
+
+/// No relocation.
+pub const R_AARCH64_NONE: u32 = 0;
+
+// ILP32 AArch64 relocs.
+/// Direct 32 bit.
+pub const R_AARCH64_P32_ABS32: u32 = 1;
+/// Copy symbol at runtime.
+pub const R_AARCH64_P32_COPY: u32 = 180;
+/// Create GOT entry.
+pub const R_AARCH64_P32_GLOB_DAT: u32 = 181;
+/// Create PLT entry.
+pub const R_AARCH64_P32_JUMP_SLOT: u32 = 182;
+/// Adjust by program base.
+pub const R_AARCH64_P32_RELATIVE: u32 = 183;
+/// Module number, 32 bit.
+pub const R_AARCH64_P32_TLS_DTPMOD: u32 = 184;
+/// Module-relative offset, 32 bit.
+pub const R_AARCH64_P32_TLS_DTPREL: u32 = 185;
+/// TP-relative offset, 32 bit.
+pub const R_AARCH64_P32_TLS_TPREL: u32 = 186;
+/// TLS Descriptor.
+pub const R_AARCH64_P32_TLSDESC: u32 = 187;
+/// STT_GNU_IFUNC relocation.
+pub const R_AARCH64_P32_IRELATIVE: u32 = 188;
+
+// LP64 AArch64 relocs.
+/// Direct 64 bit.
+pub const R_AARCH64_ABS64: u32 = 257;
+/// Direct 32 bit.
+pub const R_AARCH64_ABS32: u32 = 258;
+/// Direct 16-bit.
+pub const R_AARCH64_ABS16: u32 = 259;
+/// PC-relative 64-bit.
+pub const R_AARCH64_PREL64: u32 = 260;
+/// PC-relative 32-bit.
+pub const R_AARCH64_PREL32: u32 = 261;
+/// PC-relative 16-bit.
+pub const R_AARCH64_PREL16: u32 = 262;
+/// Dir. MOVZ imm. from bits 15:0.
+pub const R_AARCH64_MOVW_UABS_G0: u32 = 263;
+/// Likewise for MOVK; no check.
+pub const R_AARCH64_MOVW_UABS_G0_NC: u32 = 264;
+/// Dir. MOVZ imm. from bits 31:16.
+pub const R_AARCH64_MOVW_UABS_G1: u32 = 265;
+/// Likewise for MOVK; no check.
+pub const R_AARCH64_MOVW_UABS_G1_NC: u32 = 266;
+/// Dir. MOVZ imm. from bits 47:32.
+pub const R_AARCH64_MOVW_UABS_G2: u32 = 267;
+/// Likewise for MOVK; no check.
+pub const R_AARCH64_MOVW_UABS_G2_NC: u32 = 268;
+/// Dir. MOV{K,Z} imm. from 63:48.
+pub const R_AARCH64_MOVW_UABS_G3: u32 = 269;
+/// Dir. MOV{N,Z} imm. from 15:0.
+pub const R_AARCH64_MOVW_SABS_G0: u32 = 270;
+/// Dir. MOV{N,Z} imm. from 31:16.
+pub const R_AARCH64_MOVW_SABS_G1: u32 = 271;
+/// Dir. MOV{N,Z} imm. from 47:32.
+pub const R_AARCH64_MOVW_SABS_G2: u32 = 272;
+/// PC-rel. LD imm. from bits 20:2.
+pub const R_AARCH64_LD_PREL_LO19: u32 = 273;
+/// PC-rel. ADR imm. from bits 20:0.
+pub const R_AARCH64_ADR_PREL_LO21: u32 = 274;
+/// Page-rel. ADRP imm. from 32:12.
+pub const R_AARCH64_ADR_PREL_PG_HI21: u32 = 275;
+/// Likewise; no overflow check.
+pub const R_AARCH64_ADR_PREL_PG_HI21_NC: u32 = 276;
+/// Dir. ADD imm. from bits 11:0.
+pub const R_AARCH64_ADD_ABS_LO12_NC: u32 = 277;
+/// Likewise for LD/ST; no check.
+pub const R_AARCH64_LDST8_ABS_LO12_NC: u32 = 278;
+/// PC-rel. TBZ/TBNZ imm. from 15:2.
+pub const R_AARCH64_TSTBR14: u32 = 279;
+/// PC-rel. cond. br. imm. from 20:2.
+pub const R_AARCH64_CONDBR19: u32 = 280;
+/// PC-rel. B imm. from bits 27:2.
+pub const R_AARCH64_JUMP26: u32 = 282;
+/// Likewise for CALL.
+pub const R_AARCH64_CALL26: u32 = 283;
+/// Dir. ADD imm. from bits 11:1.
+pub const R_AARCH64_LDST16_ABS_LO12_NC: u32 = 284;
+/// Likewise for bits 11:2.
+pub const R_AARCH64_LDST32_ABS_LO12_NC: u32 = 285;
+/// Likewise for bits 11:3.
+pub const R_AARCH64_LDST64_ABS_LO12_NC: u32 = 286;
+/// PC-rel. MOV{N,Z} imm. from 15:0.
+pub const R_AARCH64_MOVW_PREL_G0: u32 = 287;
+/// Likewise for MOVK; no check.
+pub const R_AARCH64_MOVW_PREL_G0_NC: u32 = 288;
+/// PC-rel. MOV{N,Z} imm. from 31:16.
+pub const R_AARCH64_MOVW_PREL_G1: u32 = 289;
+/// Likewise for MOVK; no check.
+pub const R_AARCH64_MOVW_PREL_G1_NC: u32 = 290;
+/// PC-rel. MOV{N,Z} imm. from 47:32.
+pub const R_AARCH64_MOVW_PREL_G2: u32 = 291;
+/// Likewise for MOVK; no check.
+pub const R_AARCH64_MOVW_PREL_G2_NC: u32 = 292;
+/// PC-rel. MOV{N,Z} imm. from 63:48.
+pub const R_AARCH64_MOVW_PREL_G3: u32 = 293;
+/// Dir. ADD imm. from bits 11:4.
+pub const R_AARCH64_LDST128_ABS_LO12_NC: u32 = 299;
+/// GOT-rel. off. MOV{N,Z} imm. 15:0.
+pub const R_AARCH64_MOVW_GOTOFF_G0: u32 = 300;
+/// Likewise for MOVK; no check.
+pub const R_AARCH64_MOVW_GOTOFF_G0_NC: u32 = 301;
+/// GOT-rel. o. MOV{N,Z} imm. 31:16.
+pub const R_AARCH64_MOVW_GOTOFF_G1: u32 = 302;
+/// Likewise for MOVK; no check.
+pub const R_AARCH64_MOVW_GOTOFF_G1_NC: u32 = 303;
+/// GOT-rel. o. MOV{N,Z} imm. 47:32.
+pub const R_AARCH64_MOVW_GOTOFF_G2: u32 = 304;
+/// Likewise for MOVK; no check.
+pub const R_AARCH64_MOVW_GOTOFF_G2_NC: u32 = 305;
+/// GOT-rel. o. MOV{N,Z} imm. 63:48.
+pub const R_AARCH64_MOVW_GOTOFF_G3: u32 = 306;
+/// GOT-relative 64-bit.
+pub const R_AARCH64_GOTREL64: u32 = 307;
+/// GOT-relative 32-bit.
+pub const R_AARCH64_GOTREL32: u32 = 308;
+/// PC-rel. GOT off. load imm. 20:2.
+pub const R_AARCH64_GOT_LD_PREL19: u32 = 309;
+/// GOT-rel. off. LD/ST imm. 14:3.
+pub const R_AARCH64_LD64_GOTOFF_LO15: u32 = 310;
+/// P-page-rel. GOT off. ADRP 32:12.
+pub const R_AARCH64_ADR_GOT_PAGE: u32 = 311;
+/// Dir. GOT off. LD/ST imm. 11:3.
+pub const R_AARCH64_LD64_GOT_LO12_NC: u32 = 312;
+/// GOT-page-rel. GOT off. LD/ST 14:3
+pub const R_AARCH64_LD64_GOTPAGE_LO15: u32 = 313;
+/// PC-relative ADR imm. 20:0.
+pub const R_AARCH64_TLSGD_ADR_PREL21: u32 = 512;
+/// page-rel. ADRP imm. 32:12.
+pub const R_AARCH64_TLSGD_ADR_PAGE21: u32 = 513;
+/// direct ADD imm. from 11:0.
+pub const R_AARCH64_TLSGD_ADD_LO12_NC: u32 = 514;
+/// GOT-rel. MOV{N,Z} 31:16.
+pub const R_AARCH64_TLSGD_MOVW_G1: u32 = 515;
+/// GOT-rel. MOVK imm. 15:0.
+pub const R_AARCH64_TLSGD_MOVW_G0_NC: u32 = 516;
+/// Like 512; local dynamic model.
+pub const R_AARCH64_TLSLD_ADR_PREL21: u32 = 517;
+/// Like 513; local dynamic model.
+pub const R_AARCH64_TLSLD_ADR_PAGE21: u32 = 518;
+/// Like 514; local dynamic model.
+pub const R_AARCH64_TLSLD_ADD_LO12_NC: u32 = 519;
+/// Like 515; local dynamic model.
+pub const R_AARCH64_TLSLD_MOVW_G1: u32 = 520;
+/// Like 516; local dynamic model.
+pub const R_AARCH64_TLSLD_MOVW_G0_NC: u32 = 521;
+/// TLS PC-rel. load imm. 20:2.
+pub const R_AARCH64_TLSLD_LD_PREL19: u32 = 522;
+/// TLS DTP-rel. MOV{N,Z} 47:32.
+pub const R_AARCH64_TLSLD_MOVW_DTPREL_G2: u32 = 523;
+/// TLS DTP-rel. MOV{N,Z} 31:16.
+pub const R_AARCH64_TLSLD_MOVW_DTPREL_G1: u32 = 524;
+/// Likewise; MOVK; no check.
+pub const R_AARCH64_TLSLD_MOVW_DTPREL_G1_NC: u32 = 525;
+/// TLS DTP-rel. MOV{N,Z} 15:0.
+pub const R_AARCH64_TLSLD_MOVW_DTPREL_G0: u32 = 526;
+/// Likewise; MOVK; no check.
+pub const R_AARCH64_TLSLD_MOVW_DTPREL_G0_NC: u32 = 527;
+/// DTP-rel. ADD imm. from 23:12.
+pub const R_AARCH64_TLSLD_ADD_DTPREL_HI12: u32 = 528;
+/// DTP-rel. ADD imm. from 11:0.
+pub const R_AARCH64_TLSLD_ADD_DTPREL_LO12: u32 = 529;
+/// Likewise; no ovfl. check.
+pub const R_AARCH64_TLSLD_ADD_DTPREL_LO12_NC: u32 = 530;
+/// DTP-rel. LD/ST imm. 11:0.
+pub const R_AARCH64_TLSLD_LDST8_DTPREL_LO12: u32 = 531;
+/// Likewise; no check.
+pub const R_AARCH64_TLSLD_LDST8_DTPREL_LO12_NC: u32 = 532;
+/// DTP-rel. LD/ST imm. 11:1.
+pub const R_AARCH64_TLSLD_LDST16_DTPREL_LO12: u32 = 533;
+/// Likewise; no check.
+pub const R_AARCH64_TLSLD_LDST16_DTPREL_LO12_NC: u32 = 534;
+/// DTP-rel. LD/ST imm. 11:2.
+pub const R_AARCH64_TLSLD_LDST32_DTPREL_LO12: u32 = 535;
+/// Likewise; no check.
+pub const R_AARCH64_TLSLD_LDST32_DTPREL_LO12_NC: u32 = 536;
+/// DTP-rel. LD/ST imm. 11:3.
+pub const R_AARCH64_TLSLD_LDST64_DTPREL_LO12: u32 = 537;
+/// Likewise; no check.
+pub const R_AARCH64_TLSLD_LDST64_DTPREL_LO12_NC: u32 = 538;
+/// GOT-rel. MOV{N,Z} 31:16.
+pub const R_AARCH64_TLSIE_MOVW_GOTTPREL_G1: u32 = 539;
+/// GOT-rel. MOVK 15:0.
+pub const R_AARCH64_TLSIE_MOVW_GOTTPREL_G0_NC: u32 = 540;
+/// Page-rel. ADRP 32:12.
+pub const R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21: u32 = 541;
+/// Direct LD off. 11:3.
+pub const R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC: u32 = 542;
+/// PC-rel. load imm. 20:2.
+pub const R_AARCH64_TLSIE_LD_GOTTPREL_PREL19: u32 = 543;
+/// TLS TP-rel. MOV{N,Z} 47:32.
+pub const R_AARCH64_TLSLE_MOVW_TPREL_G2: u32 = 544;
+/// TLS TP-rel. MOV{N,Z} 31:16.
+pub const R_AARCH64_TLSLE_MOVW_TPREL_G1: u32 = 545;
+/// Likewise; MOVK; no check.
+pub const R_AARCH64_TLSLE_MOVW_TPREL_G1_NC: u32 = 546;
+/// TLS TP-rel. MOV{N,Z} 15:0.
+pub const R_AARCH64_TLSLE_MOVW_TPREL_G0: u32 = 547;
+/// Likewise; MOVK; no check.
+pub const R_AARCH64_TLSLE_MOVW_TPREL_G0_NC: u32 = 548;
+/// TP-rel. ADD imm. 23:12.
+pub const R_AARCH64_TLSLE_ADD_TPREL_HI12: u32 = 549;
+/// TP-rel. ADD imm. 11:0.
+pub const R_AARCH64_TLSLE_ADD_TPREL_LO12: u32 = 550;
+/// Likewise; no ovfl. check.
+pub const R_AARCH64_TLSLE_ADD_TPREL_LO12_NC: u32 = 551;
+/// TP-rel. LD/ST off. 11:0.
+pub const R_AARCH64_TLSLE_LDST8_TPREL_LO12: u32 = 552;
+/// Likewise; no ovfl. check.
+pub const R_AARCH64_TLSLE_LDST8_TPREL_LO12_NC: u32 = 553;
+/// TP-rel. LD/ST off. 11:1.
+pub const R_AARCH64_TLSLE_LDST16_TPREL_LO12: u32 = 554;
+/// Likewise; no check.
+pub const R_AARCH64_TLSLE_LDST16_TPREL_LO12_NC: u32 = 555;
+/// TP-rel. LD/ST off. 11:2.
+pub const R_AARCH64_TLSLE_LDST32_TPREL_LO12: u32 = 556;
+/// Likewise; no check.
+pub const R_AARCH64_TLSLE_LDST32_TPREL_LO12_NC: u32 = 557;
+/// TP-rel. LD/ST off. 11:3.
+pub const R_AARCH64_TLSLE_LDST64_TPREL_LO12: u32 = 558;
+/// Likewise; no check.
+pub const R_AARCH64_TLSLE_LDST64_TPREL_LO12_NC: u32 = 559;
+/// PC-rel. load immediate 20:2.
+pub const R_AARCH64_TLSDESC_LD_PREL19: u32 = 560;
+/// PC-rel. ADR immediate 20:0.
+pub const R_AARCH64_TLSDESC_ADR_PREL21: u32 = 561;
+/// Page-rel. ADRP imm. 32:12.
+pub const R_AARCH64_TLSDESC_ADR_PAGE21: u32 = 562;
+/// Direct LD off. from 11:3.
+pub const R_AARCH64_TLSDESC_LD64_LO12: u32 = 563;
+/// Direct ADD imm. from 11:0.
+pub const R_AARCH64_TLSDESC_ADD_LO12: u32 = 564;
+/// GOT-rel. MOV{N,Z} imm. 31:16.
+pub const R_AARCH64_TLSDESC_OFF_G1: u32 = 565;
+/// GOT-rel. MOVK imm. 15:0; no ck.
+pub const R_AARCH64_TLSDESC_OFF_G0_NC: u32 = 566;
+/// Relax LDR.
+pub const R_AARCH64_TLSDESC_LDR: u32 = 567;
+/// Relax ADD.
+pub const R_AARCH64_TLSDESC_ADD: u32 = 568;
+/// Relax BLR.
+pub const R_AARCH64_TLSDESC_CALL: u32 = 569;
+/// TP-rel. LD/ST off. 11:4.
+pub const R_AARCH64_TLSLE_LDST128_TPREL_LO12: u32 = 570;
+/// Likewise; no check.
+pub const R_AARCH64_TLSLE_LDST128_TPREL_LO12_NC: u32 = 571;
+/// DTP-rel. LD/ST imm. 11:4.
+pub const R_AARCH64_TLSLD_LDST128_DTPREL_LO12: u32 = 572;
+/// Likewise; no check.
+pub const R_AARCH64_TLSLD_LDST128_DTPREL_LO12_NC: u32 = 573;
+/// Copy symbol at runtime.
+pub const R_AARCH64_COPY: u32 = 1024;
+/// Create GOT entry.
+pub const R_AARCH64_GLOB_DAT: u32 = 1025;
+/// Create PLT entry.
+pub const R_AARCH64_JUMP_SLOT: u32 = 1026;
+/// Adjust by program base.
+pub const R_AARCH64_RELATIVE: u32 = 1027;
+/// Module number, 64 bit.
+pub const R_AARCH64_TLS_DTPMOD: u32 = 1028;
+/// Module-relative offset, 64 bit.
+pub const R_AARCH64_TLS_DTPREL: u32 = 1029;
+/// TP-relative offset, 64 bit.
+pub const R_AARCH64_TLS_TPREL: u32 = 1030;
+/// TLS Descriptor.
+pub const R_AARCH64_TLSDESC: u32 = 1031;
+/// STT_GNU_IFUNC relocation.
+pub const R_AARCH64_IRELATIVE: u32 = 1032;
+
+// AVR values for `Rel*::r_type`.
+
+/// Direct 32 bit
+pub const R_AVR_32: u32 = 1;
+/// Direct 16 bit
+pub const R_AVR_16: u32 = 4;
+
+// MSP430 values for `Rel*::r_type`.
+
+/// Direct 32 bit
+pub const R_MSP430_32: u32 = 1;
+/// Direct 16 bit
+pub const R_MSP430_16_BYTE: u32 = 5;
+
+// Hexagon values for `Rel*::r_type`.
+
+/// Direct 32 bit
+pub const R_HEX_32: u32 = 6;
+
+// ARM values for `Rel*::r_type`.
+
+/// No reloc
+pub const R_ARM_NONE: u32 = 0;
+/// Deprecated PC relative 26 bit branch.
+pub const R_ARM_PC24: u32 = 1;
+/// Direct 32 bit
+pub const R_ARM_ABS32: u32 = 2;
+/// PC relative 32 bit
+pub const R_ARM_REL32: u32 = 3;
+#[allow(missing_docs)]
+pub const R_ARM_PC13: u32 = 4;
+/// Direct 16 bit
+pub const R_ARM_ABS16: u32 = 5;
+/// Direct 12 bit
+pub const R_ARM_ABS12: u32 = 6;
+/// Direct & 0x7C (LDR, STR).
+pub const R_ARM_THM_ABS5: u32 = 7;
+/// Direct 8 bit
+pub const R_ARM_ABS8: u32 = 8;
+#[allow(missing_docs)]
+pub const R_ARM_SBREL32: u32 = 9;
+/// PC relative 24 bit (Thumb32 BL).
+pub const R_ARM_THM_PC22: u32 = 10;
+/// PC relative & 0x3FC (Thumb16 LDR, ADD, ADR).
+pub const R_ARM_THM_PC8: u32 = 11;
+#[allow(missing_docs)]
+pub const R_ARM_AMP_VCALL9: u32 = 12;
+/// Obsolete static relocation.
+pub const R_ARM_SWI24: u32 = 13;
+/// Dynamic relocation.
+pub const R_ARM_TLS_DESC: u32 = 13;
+/// Reserved.
+pub const R_ARM_THM_SWI8: u32 = 14;
+/// Reserved.
+pub const R_ARM_XPC25: u32 = 15;
+/// Reserved.
+pub const R_ARM_THM_XPC22: u32 = 16;
+/// ID of module containing symbol
+pub const R_ARM_TLS_DTPMOD32: u32 = 17;
+/// Offset in TLS block
+pub const R_ARM_TLS_DTPOFF32: u32 = 18;
+/// Offset in static TLS block
+pub const R_ARM_TLS_TPOFF32: u32 = 19;
+/// Copy symbol at runtime
+pub const R_ARM_COPY: u32 = 20;
+/// Create GOT entry
+pub const R_ARM_GLOB_DAT: u32 = 21;
+/// Create PLT entry
+pub const R_ARM_JUMP_SLOT: u32 = 22;
+/// Adjust by program base
+pub const R_ARM_RELATIVE: u32 = 23;
+/// 32 bit offset to GOT
+pub const R_ARM_GOTOFF: u32 = 24;
+/// 32 bit PC relative offset to GOT
+pub const R_ARM_GOTPC: u32 = 25;
+/// 32 bit GOT entry
+pub const R_ARM_GOT32: u32 = 26;
+/// Deprecated, 32 bit PLT address.
+pub const R_ARM_PLT32: u32 = 27;
+/// PC relative 24 bit (BL, BLX).
+pub const R_ARM_CALL: u32 = 28;
+/// PC relative 24 bit (B, BL<cond>).
+pub const R_ARM_JUMP24: u32 = 29;
+/// PC relative 24 bit (Thumb32 B.W).
+pub const R_ARM_THM_JUMP24: u32 = 30;
+/// Adjust by program base.
+pub const R_ARM_BASE_ABS: u32 = 31;
+/// Obsolete.
+pub const R_ARM_ALU_PCREL_7_0: u32 = 32;
+/// Obsolete.
+pub const R_ARM_ALU_PCREL_15_8: u32 = 33;
+/// Obsolete.
+pub const R_ARM_ALU_PCREL_23_15: u32 = 34;
+/// Deprecated, prog. base relative.
+pub const R_ARM_LDR_SBREL_11_0: u32 = 35;
+/// Deprecated, prog. base relative.
+pub const R_ARM_ALU_SBREL_19_12: u32 = 36;
+/// Deprecated, prog. base relative.
+pub const R_ARM_ALU_SBREL_27_20: u32 = 37;
+#[allow(missing_docs)]
+pub const R_ARM_TARGET1: u32 = 38;
+/// Program base relative.
+pub const R_ARM_SBREL31: u32 = 39;
+#[allow(missing_docs)]
+pub const R_ARM_V4BX: u32 = 40;
+#[allow(missing_docs)]
+pub const R_ARM_TARGET2: u32 = 41;
+/// 32 bit PC relative.
+pub const R_ARM_PREL31: u32 = 42;
+/// Direct 16-bit (MOVW).
+pub const R_ARM_MOVW_ABS_NC: u32 = 43;
+/// Direct high 16-bit (MOVT).
+pub const R_ARM_MOVT_ABS: u32 = 44;
+/// PC relative 16-bit (MOVW).
+pub const R_ARM_MOVW_PREL_NC: u32 = 45;
+/// PC relative (MOVT).
+pub const R_ARM_MOVT_PREL: u32 = 46;
+/// Direct 16 bit (Thumb32 MOVW).
+pub const R_ARM_THM_MOVW_ABS_NC: u32 = 47;
+/// Direct high 16 bit (Thumb32 MOVT).
+pub const R_ARM_THM_MOVT_ABS: u32 = 48;
+/// PC relative 16 bit (Thumb32 MOVW).
+pub const R_ARM_THM_MOVW_PREL_NC: u32 = 49;
+/// PC relative high 16 bit (Thumb32 MOVT).
+pub const R_ARM_THM_MOVT_PREL: u32 = 50;
+/// PC relative 20 bit (Thumb32 B<cond>.W).
+pub const R_ARM_THM_JUMP19: u32 = 51;
+/// PC relative X & 0x7E (Thumb16 CBZ, CBNZ).
+pub const R_ARM_THM_JUMP6: u32 = 52;
+/// PC relative 12 bit (Thumb32 ADR.W).
+pub const R_ARM_THM_ALU_PREL_11_0: u32 = 53;
+/// PC relative 12 bit (Thumb32 LDR{D,SB,H,SH}).
+pub const R_ARM_THM_PC12: u32 = 54;
+/// Direct 32-bit.
+pub const R_ARM_ABS32_NOI: u32 = 55;
+/// PC relative 32-bit.
+pub const R_ARM_REL32_NOI: u32 = 56;
+/// PC relative (ADD, SUB).
+pub const R_ARM_ALU_PC_G0_NC: u32 = 57;
+/// PC relative (ADD, SUB).
+pub const R_ARM_ALU_PC_G0: u32 = 58;
+/// PC relative (ADD, SUB).
+pub const R_ARM_ALU_PC_G1_NC: u32 = 59;
+/// PC relative (ADD, SUB).
+pub const R_ARM_ALU_PC_G1: u32 = 60;
+/// PC relative (ADD, SUB).
+pub const R_ARM_ALU_PC_G2: u32 = 61;
+/// PC relative (LDR,STR,LDRB,STRB).
+pub const R_ARM_LDR_PC_G1: u32 = 62;
+/// PC relative (LDR,STR,LDRB,STRB).
+pub const R_ARM_LDR_PC_G2: u32 = 63;
+/// PC relative (STR{D,H}, LDR{D,SB,H,SH}).
+pub const R_ARM_LDRS_PC_G0: u32 = 64;
+/// PC relative (STR{D,H}, LDR{D,SB,H,SH}).
+pub const R_ARM_LDRS_PC_G1: u32 = 65;
+/// PC relative (STR{D,H}, LDR{D,SB,H,SH}).
+pub const R_ARM_LDRS_PC_G2: u32 = 66;
+/// PC relative (LDC, STC).
+pub const R_ARM_LDC_PC_G0: u32 = 67;
+/// PC relative (LDC, STC).
+pub const R_ARM_LDC_PC_G1: u32 = 68;
+/// PC relative (LDC, STC).
+pub const R_ARM_LDC_PC_G2: u32 = 69;
+/// Program base relative (ADD,SUB).
+pub const R_ARM_ALU_SB_G0_NC: u32 = 70;
+/// Program base relative (ADD,SUB).
+pub const R_ARM_ALU_SB_G0: u32 = 71;
+/// Program base relative (ADD,SUB).
+pub const R_ARM_ALU_SB_G1_NC: u32 = 72;
+/// Program base relative (ADD,SUB).
+pub const R_ARM_ALU_SB_G1: u32 = 73;
+/// Program base relative (ADD,SUB).
+pub const R_ARM_ALU_SB_G2: u32 = 74;
+/// Program base relative (LDR, STR, LDRB, STRB).
+pub const R_ARM_LDR_SB_G0: u32 = 75;
+/// Program base relative (LDR, STR, LDRB, STRB).
+pub const R_ARM_LDR_SB_G1: u32 = 76;
+/// Program base relative (LDR, STR, LDRB, STRB).
+pub const R_ARM_LDR_SB_G2: u32 = 77;
+/// Program base relative (LDR, STR, LDRB, STRB).
+pub const R_ARM_LDRS_SB_G0: u32 = 78;
+/// Program base relative (LDR, STR, LDRB, STRB).
+pub const R_ARM_LDRS_SB_G1: u32 = 79;
+/// Program base relative (LDR, STR, LDRB, STRB).
+pub const R_ARM_LDRS_SB_G2: u32 = 80;
+/// Program base relative (LDC,STC).
+pub const R_ARM_LDC_SB_G0: u32 = 81;
+/// Program base relative (LDC,STC).
+pub const R_ARM_LDC_SB_G1: u32 = 82;
+/// Program base relative (LDC,STC).
+pub const R_ARM_LDC_SB_G2: u32 = 83;
+/// Program base relative 16 bit (MOVW).
+pub const R_ARM_MOVW_BREL_NC: u32 = 84;
+/// Program base relative high 16 bit (MOVT).
+pub const R_ARM_MOVT_BREL: u32 = 85;
+/// Program base relative 16 bit (MOVW).
+pub const R_ARM_MOVW_BREL: u32 = 86;
+/// Program base relative 16 bit (Thumb32 MOVW).
+pub const R_ARM_THM_MOVW_BREL_NC: u32 = 87;
+/// Program base relative high 16 bit (Thumb32 MOVT).
+pub const R_ARM_THM_MOVT_BREL: u32 = 88;
+/// Program base relative 16 bit (Thumb32 MOVW).
+pub const R_ARM_THM_MOVW_BREL: u32 = 89;
+#[allow(missing_docs)]
+pub const R_ARM_TLS_GOTDESC: u32 = 90;
+#[allow(missing_docs)]
+pub const R_ARM_TLS_CALL: u32 = 91;
+/// TLS relaxation.
+pub const R_ARM_TLS_DESCSEQ: u32 = 92;
+#[allow(missing_docs)]
+pub const R_ARM_THM_TLS_CALL: u32 = 93;
+#[allow(missing_docs)]
+pub const R_ARM_PLT32_ABS: u32 = 94;
+/// GOT entry.
+pub const R_ARM_GOT_ABS: u32 = 95;
+/// PC relative GOT entry.
+pub const R_ARM_GOT_PREL: u32 = 96;
+/// GOT entry relative to GOT origin (LDR).
+pub const R_ARM_GOT_BREL12: u32 = 97;
+/// 12 bit, GOT entry relative to GOT origin (LDR, STR).
+pub const R_ARM_GOTOFF12: u32 = 98;
+#[allow(missing_docs)]
+pub const R_ARM_GOTRELAX: u32 = 99;
+#[allow(missing_docs)]
+pub const R_ARM_GNU_VTENTRY: u32 = 100;
+#[allow(missing_docs)]
+pub const R_ARM_GNU_VTINHERIT: u32 = 101;
+/// PC relative & 0xFFE (Thumb16 B).
+pub const R_ARM_THM_PC11: u32 = 102;
+/// PC relative & 0x1FE (Thumb16 B/B<cond>).
+pub const R_ARM_THM_PC9: u32 = 103;
+/// PC-rel 32 bit for global dynamic thread local data
+pub const R_ARM_TLS_GD32: u32 = 104;
+/// PC-rel 32 bit for local dynamic thread local data
+pub const R_ARM_TLS_LDM32: u32 = 105;
+/// 32 bit offset relative to TLS block
+pub const R_ARM_TLS_LDO32: u32 = 106;
+/// PC-rel 32 bit for GOT entry of static TLS block offset
+pub const R_ARM_TLS_IE32: u32 = 107;
+/// 32 bit offset relative to static TLS block
+pub const R_ARM_TLS_LE32: u32 = 108;
+/// 12 bit relative to TLS block (LDR, STR).
+pub const R_ARM_TLS_LDO12: u32 = 109;
+/// 12 bit relative to static TLS block (LDR, STR).
+pub const R_ARM_TLS_LE12: u32 = 110;
+/// 12 bit GOT entry relative to GOT origin (LDR).
+pub const R_ARM_TLS_IE12GP: u32 = 111;
+/// Obsolete.
+pub const R_ARM_ME_TOO: u32 = 128;
+#[allow(missing_docs)]
+pub const R_ARM_THM_TLS_DESCSEQ: u32 = 129;
+#[allow(missing_docs)]
+pub const R_ARM_THM_TLS_DESCSEQ16: u32 = 129;
+#[allow(missing_docs)]
+pub const R_ARM_THM_TLS_DESCSEQ32: u32 = 130;
+/// GOT entry relative to GOT origin, 12 bit (Thumb32 LDR).
+pub const R_ARM_THM_GOT_BREL12: u32 = 131;
+#[allow(missing_docs)]
+pub const R_ARM_IRELATIVE: u32 = 160;
+#[allow(missing_docs)]
+pub const R_ARM_RXPC25: u32 = 249;
+#[allow(missing_docs)]
+pub const R_ARM_RSBREL32: u32 = 250;
+#[allow(missing_docs)]
+pub const R_ARM_THM_RPC22: u32 = 251;
+#[allow(missing_docs)]
+pub const R_ARM_RREL32: u32 = 252;
+#[allow(missing_docs)]
+pub const R_ARM_RABS22: u32 = 253;
+#[allow(missing_docs)]
+pub const R_ARM_RPC24: u32 = 254;
+#[allow(missing_docs)]
+pub const R_ARM_RBASE: u32 = 255;
+
+// C-SKY values for `Rel*::r_type`.
+/// no reloc
+pub const R_CKCORE_NONE: u32 = 0;
+/// direct 32 bit (S + A)
+pub const R_CKCORE_ADDR32: u32 = 1;
+/// disp ((S + A - P) >> 2) & 0xff
+pub const R_CKCORE_PCRELIMM8BY4: u32 = 2;
+/// disp ((S + A - P) >> 1) & 0x7ff
+pub const R_CKCORE_PCRELIMM11BY2: u32 = 3;
+/// 32-bit rel (S + A - P)
+pub const R_CKCORE_PCREL32: u32 = 5;
+/// disp ((S + A - P) >>1) & 0x7ff
+pub const R_CKCORE_PCRELJSR_IMM11BY2: u32 = 6;
+/// 32 bit adjust program base(B + A)
+pub const R_CKCORE_RELATIVE: u32 = 9;
+/// 32 bit adjust by program base
+pub const R_CKCORE_COPY: u32 = 10;
+/// off between got and sym (S)
+pub const R_CKCORE_GLOB_DAT: u32 = 11;
+/// PLT entry (S)
+pub const R_CKCORE_JUMP_SLOT: u32 = 12;
+/// offset to GOT (S + A - GOT)
+pub const R_CKCORE_GOTOFF: u32 = 13;
+/// PC offset to GOT (GOT + A - P)
+pub const R_CKCORE_GOTPC: u32 = 14;
+/// 32 bit GOT entry (G)
+pub const R_CKCORE_GOT32: u32 = 15;
+/// 32 bit PLT entry (G)
+pub const R_CKCORE_PLT32: u32 = 16;
+/// GOT entry in GLOB_DAT (GOT + G)
+pub const R_CKCORE_ADDRGOT: u32 = 17;
+/// PLT entry in GLOB_DAT (GOT + G)
+pub const R_CKCORE_ADDRPLT: u32 = 18;
+/// ((S + A - P) >> 1) & 0x3ff_ffff
+pub const R_CKCORE_PCREL_IMM26BY2: u32 = 19;
+/// disp ((S + A - P) >> 1) & 0xffff
+pub const R_CKCORE_PCREL_IMM16BY2: u32 = 20;
+/// disp ((S + A - P) >> 2) & 0xffff
+pub const R_CKCORE_PCREL_IMM16BY4: u32 = 21;
+/// disp ((S + A - P) >> 1) & 0x3ff
+pub const R_CKCORE_PCREL_IMM10BY2: u32 = 22;
+/// disp ((S + A - P) >> 2) & 0x3ff
+pub const R_CKCORE_PCREL_IMM10BY4: u32 = 23;
+/// high & low 16 bit ADDR, ((S + A) >> 16) & 0xffff
+pub const R_CKCORE_ADDR_HI16: u32 = 24;
+/// (S + A) & 0xffff
+pub const R_CKCORE_ADDR_LO16: u32 = 25;
+/// high & low 16 bit GOTPC, ((GOT + A - P) >> 16) & 0xffff
+pub const R_CKCORE_GOTPC_HI16: u32 = 26;
+/// (GOT + A - P) & 0xffff
+pub const R_CKCORE_GOTPC_LO16: u32 = 27;
+/// high & low 16 bit GOTOFF, ((S + A - GOT) >> 16) & 0xffff
+pub const R_CKCORE_GOTOFF_HI16: u32 = 28;
+/// (S + A - GOT) & 0xffff
+pub const R_CKCORE_GOTOFF_LO16: u32 = 29;
+/// 12 bit disp GOT entry (G)
+pub const R_CKCORE_GOT12: u32 = 30;
+/// high & low 16 bit GOT, (G >> 16) & 0xffff
+pub const R_CKCORE_GOT_HI16: u32 = 31;
+/// (G & 0xffff)
+pub const R_CKCORE_GOT_LO16: u32 = 32;
+/// 12 bit disp PLT entry (G)
+pub const R_CKCORE_PLT12: u32 = 33;
+/// high & low 16 bit PLT, (G >> 16) & 0xffff
+pub const R_CKCORE_PLT_HI16: u32 = 34;
+/// G & 0xffff
+pub const R_CKCORE_PLT_LO16: u32 = 35;
+/// high & low 16 bit ADDRGOT, (GOT + G * 4) & 0xffff
+pub const R_CKCORE_ADDRGOT_HI16: u32 = 36;
+/// (GOT + G * 4) & 0xffff
+pub const R_CKCORE_ADDRGOT_LO16: u32 = 37;
+/// high & low 16 bit ADDRPLT, ((GOT + G * 4) >> 16) & 0xFFFF
+pub const R_CKCORE_ADDRPLT_HI16: u32 = 38;
+/// (GOT+G*4) & 0xffff
+pub const R_CKCORE_ADDRPLT_LO16: u32 = 39;
+/// disp ((S+A-P) >>1) & x3ff_ffff
+pub const R_CKCORE_PCREL_JSR_IMM26BY2: u32 = 40;
+/// (S+A-BTEXT) & 0xffff
+pub const R_CKCORE_TOFFSET_LO16: u32 = 41;
+/// (S+A-BTEXT) & 0xffff
+pub const R_CKCORE_DOFFSET_LO16: u32 = 42;
+/// disp ((S+A-P) >>1) & 0x3ffff
+pub const R_CKCORE_PCREL_IMM18BY2: u32 = 43;
+/// disp (S+A-BDATA) & 0x3ffff
+pub const R_CKCORE_DOFFSET_IMM18: u32 = 44;
+/// disp ((S+A-BDATA)>>1) & 0x3ffff
+pub const R_CKCORE_DOFFSET_IMM18BY2: u32 = 45;
+/// disp ((S+A-BDATA)>>2) & 0x3ffff
+pub const R_CKCORE_DOFFSET_IMM18BY4: u32 = 46;
+/// disp (G >> 2)
+pub const R_CKCORE_GOT_IMM18BY4: u32 = 48;
+/// disp (G >> 2)
+pub const R_CKCORE_PLT_IMM18BY4: u32 = 49;
+/// disp ((S+A-P) >>2) & 0x7f
+pub const R_CKCORE_PCREL_IMM7BY4: u32 = 50;
+/// 32 bit offset to TLS block
+pub const R_CKCORE_TLS_LE32: u32 = 51;
+#[allow(missing_docs)]
+pub const R_CKCORE_TLS_IE32: u32 = 52;
+#[allow(missing_docs)]
+pub const R_CKCORE_TLS_GD32: u32 = 53;
+#[allow(missing_docs)]
+pub const R_CKCORE_TLS_LDM32: u32 = 54;
+#[allow(missing_docs)]
+pub const R_CKCORE_TLS_LDO32: u32 = 55;
+#[allow(missing_docs)]
+pub const R_CKCORE_TLS_DTPMOD32: u32 = 56;
+#[allow(missing_docs)]
+pub const R_CKCORE_TLS_DTPOFF32: u32 = 57;
+#[allow(missing_docs)]
+pub const R_CKCORE_TLS_TPOFF32: u32 = 58;
+
+// C-SKY values for `FileHeader*::e_flags`.
+#[allow(missing_docs)]
+pub const EF_CSKY_ABIMASK: u32 = 0xF000_0000;
+#[allow(missing_docs)]
+pub const EF_CSKY_OTHER: u32 = 0x0FFF_0000;
+#[allow(missing_docs)]
+pub const EF_CSKY_PROCESSOR: u32 = 0x0000_FFFF;
+
+#[allow(missing_docs)]
+pub const EF_CSKY_ABIV1: u32 = 0x1000_0000;
+#[allow(missing_docs)]
+pub const EF_CSKY_ABIV2: u32 = 0x2000_0000;
+
+// C-SKY values for `SectionHeader*::sh_type`.
+/// C-SKY attributes section.
+pub const SHT_CSKY_ATTRIBUTES: u32 = SHT_LOPROC + 1;
+
+// IA-64 specific declarations.
+
+// IA-64 values for `FileHeader64::e_flags`.
+/// os-specific flags
+pub const EF_IA_64_MASKOS: u32 = 0x0000_000f;
+/// 64-bit ABI
+pub const EF_IA_64_ABI64: u32 = 0x0000_0010;
+/// arch. version mask
+pub const EF_IA_64_ARCH: u32 = 0xff00_0000;
+
+// IA-64 values for `ProgramHeader64::p_type`.
+/// arch extension bits
+pub const PT_IA_64_ARCHEXT: u32 = PT_LOPROC + 0;
+/// ia64 unwind bits
+pub const PT_IA_64_UNWIND: u32 = PT_LOPROC + 1;
+#[allow(missing_docs)]
+pub const PT_IA_64_HP_OPT_ANOT: u32 = PT_LOOS + 0x12;
+#[allow(missing_docs)]
+pub const PT_IA_64_HP_HSL_ANOT: u32 = PT_LOOS + 0x13;
+#[allow(missing_docs)]
+pub const PT_IA_64_HP_STACK: u32 = PT_LOOS + 0x14;
+
+// IA-64 values for `ProgramHeader64::p_flags`.
+/// spec insns w/o recovery
+pub const PF_IA_64_NORECOV: u32 = 0x8000_0000;
+
+// IA-64 values for `SectionHeader64::sh_type`.
+/// extension bits
+pub const SHT_IA_64_EXT: u32 = SHT_LOPROC + 0;
+/// unwind bits
+pub const SHT_IA_64_UNWIND: u32 = SHT_LOPROC + 1;
+
+// IA-64 values for `SectionHeader64::sh_flags`.
+/// section near gp
+pub const SHF_IA_64_SHORT: u32 = 0x1000_0000;
+/// spec insns w/o recovery
+pub const SHF_IA_64_NORECOV: u32 = 0x2000_0000;
+
+// IA-64 values for `Dyn64::d_tag`.
+#[allow(missing_docs)]
+pub const DT_IA_64_PLT_RESERVE: u32 = DT_LOPROC + 0;
+
+// IA-64 values for `Rel*::r_type`.
+/// none
+pub const R_IA64_NONE: u32 = 0x00;
+/// symbol + addend, add imm14
+pub const R_IA64_IMM14: u32 = 0x21;
+/// symbol + addend, add imm22
+pub const R_IA64_IMM22: u32 = 0x22;
+/// symbol + addend, mov imm64
+pub const R_IA64_IMM64: u32 = 0x23;
+/// symbol + addend, data4 MSB
+pub const R_IA64_DIR32MSB: u32 = 0x24;
+/// symbol + addend, data4 LSB
+pub const R_IA64_DIR32LSB: u32 = 0x25;
+/// symbol + addend, data8 MSB
+pub const R_IA64_DIR64MSB: u32 = 0x26;
+/// symbol + addend, data8 LSB
+pub const R_IA64_DIR64LSB: u32 = 0x27;
+/// @gprel(sym + add), add imm22
+pub const R_IA64_GPREL22: u32 = 0x2a;
+/// @gprel(sym + add), mov imm64
+pub const R_IA64_GPREL64I: u32 = 0x2b;
+/// @gprel(sym + add), data4 MSB
+pub const R_IA64_GPREL32MSB: u32 = 0x2c;
+/// @gprel(sym + add), data4 LSB
+pub const R_IA64_GPREL32LSB: u32 = 0x2d;
+/// @gprel(sym + add), data8 MSB
+pub const R_IA64_GPREL64MSB: u32 = 0x2e;
+/// @gprel(sym + add), data8 LSB
+pub const R_IA64_GPREL64LSB: u32 = 0x2f;
+/// @ltoff(sym + add), add imm22
+pub const R_IA64_LTOFF22: u32 = 0x32;
+/// @ltoff(sym + add), mov imm64
+pub const R_IA64_LTOFF64I: u32 = 0x33;
+/// @pltoff(sym + add), add imm22
+pub const R_IA64_PLTOFF22: u32 = 0x3a;
+/// @pltoff(sym + add), mov imm64
+pub const R_IA64_PLTOFF64I: u32 = 0x3b;
+/// @pltoff(sym + add), data8 MSB
+pub const R_IA64_PLTOFF64MSB: u32 = 0x3e;
+/// @pltoff(sym + add), data8 LSB
+pub const R_IA64_PLTOFF64LSB: u32 = 0x3f;
+/// @fptr(sym + add), mov imm64
+pub const R_IA64_FPTR64I: u32 = 0x43;
+/// @fptr(sym + add), data4 MSB
+pub const R_IA64_FPTR32MSB: u32 = 0x44;
+/// @fptr(sym + add), data4 LSB
+pub const R_IA64_FPTR32LSB: u32 = 0x45;
+/// @fptr(sym + add), data8 MSB
+pub const R_IA64_FPTR64MSB: u32 = 0x46;
+/// @fptr(sym + add), data8 LSB
+pub const R_IA64_FPTR64LSB: u32 = 0x47;
+/// @pcrel(sym + add), brl
+pub const R_IA64_PCREL60B: u32 = 0x48;
+/// @pcrel(sym + add), ptb, call
+pub const R_IA64_PCREL21B: u32 = 0x49;
+/// @pcrel(sym + add), chk.s
+pub const R_IA64_PCREL21M: u32 = 0x4a;
+/// @pcrel(sym + add), fchkf
+pub const R_IA64_PCREL21F: u32 = 0x4b;
+/// @pcrel(sym + add), data4 MSB
+pub const R_IA64_PCREL32MSB: u32 = 0x4c;
+/// @pcrel(sym + add), data4 LSB
+pub const R_IA64_PCREL32LSB: u32 = 0x4d;
+/// @pcrel(sym + add), data8 MSB
+pub const R_IA64_PCREL64MSB: u32 = 0x4e;
+/// @pcrel(sym + add), data8 LSB
+pub const R_IA64_PCREL64LSB: u32 = 0x4f;
+/// @ltoff(@fptr(s+a)), imm22
+pub const R_IA64_LTOFF_FPTR22: u32 = 0x52;
+/// @ltoff(@fptr(s+a)), imm64
+pub const R_IA64_LTOFF_FPTR64I: u32 = 0x53;
+/// @ltoff(@fptr(s+a)), data4 MSB
+pub const R_IA64_LTOFF_FPTR32MSB: u32 = 0x54;
+/// @ltoff(@fptr(s+a)), data4 LSB
+pub const R_IA64_LTOFF_FPTR32LSB: u32 = 0x55;
+/// @ltoff(@fptr(s+a)), data8 MSB
+pub const R_IA64_LTOFF_FPTR64MSB: u32 = 0x56;
+/// @ltoff(@fptr(s+a)), data8 LSB
+pub const R_IA64_LTOFF_FPTR64LSB: u32 = 0x57;
+/// @segrel(sym + add), data4 MSB
+pub const R_IA64_SEGREL32MSB: u32 = 0x5c;
+/// @segrel(sym + add), data4 LSB
+pub const R_IA64_SEGREL32LSB: u32 = 0x5d;
+/// @segrel(sym + add), data8 MSB
+pub const R_IA64_SEGREL64MSB: u32 = 0x5e;
+/// @segrel(sym + add), data8 LSB
+pub const R_IA64_SEGREL64LSB: u32 = 0x5f;
+/// @secrel(sym + add), data4 MSB
+pub const R_IA64_SECREL32MSB: u32 = 0x64;
+/// @secrel(sym + add), data4 LSB
+pub const R_IA64_SECREL32LSB: u32 = 0x65;
+/// @secrel(sym + add), data8 MSB
+pub const R_IA64_SECREL64MSB: u32 = 0x66;
+/// @secrel(sym + add), data8 LSB
+pub const R_IA64_SECREL64LSB: u32 = 0x67;
+/// data 4 + REL
+pub const R_IA64_REL32MSB: u32 = 0x6c;
+/// data 4 + REL
+pub const R_IA64_REL32LSB: u32 = 0x6d;
+/// data 8 + REL
+pub const R_IA64_REL64MSB: u32 = 0x6e;
+/// data 8 + REL
+pub const R_IA64_REL64LSB: u32 = 0x6f;
+/// symbol + addend, data4 MSB
+pub const R_IA64_LTV32MSB: u32 = 0x74;
+/// symbol + addend, data4 LSB
+pub const R_IA64_LTV32LSB: u32 = 0x75;
+/// symbol + addend, data8 MSB
+pub const R_IA64_LTV64MSB: u32 = 0x76;
+/// symbol + addend, data8 LSB
+pub const R_IA64_LTV64LSB: u32 = 0x77;
+/// @pcrel(sym + add), 21bit inst
+pub const R_IA64_PCREL21BI: u32 = 0x79;
+/// @pcrel(sym + add), 22bit inst
+pub const R_IA64_PCREL22: u32 = 0x7a;
+/// @pcrel(sym + add), 64bit inst
+pub const R_IA64_PCREL64I: u32 = 0x7b;
+/// dynamic reloc, imported PLT, MSB
+pub const R_IA64_IPLTMSB: u32 = 0x80;
+/// dynamic reloc, imported PLT, LSB
+pub const R_IA64_IPLTLSB: u32 = 0x81;
+/// copy relocation
+pub const R_IA64_COPY: u32 = 0x84;
+/// Addend and symbol difference
+pub const R_IA64_SUB: u32 = 0x85;
+/// LTOFF22, relaxable.
+pub const R_IA64_LTOFF22X: u32 = 0x86;
+/// Use of LTOFF22X.
+pub const R_IA64_LDXMOV: u32 = 0x87;
+/// @tprel(sym + add), imm14
+pub const R_IA64_TPREL14: u32 = 0x91;
+/// @tprel(sym + add), imm22
+pub const R_IA64_TPREL22: u32 = 0x92;
+/// @tprel(sym + add), imm64
+pub const R_IA64_TPREL64I: u32 = 0x93;
+/// @tprel(sym + add), data8 MSB
+pub const R_IA64_TPREL64MSB: u32 = 0x96;
+/// @tprel(sym + add), data8 LSB
+pub const R_IA64_TPREL64LSB: u32 = 0x97;
+/// @ltoff(@tprel(s+a)), imm2
+pub const R_IA64_LTOFF_TPREL22: u32 = 0x9a;
+/// @dtpmod(sym + add), data8 MSB
+pub const R_IA64_DTPMOD64MSB: u32 = 0xa6;
+/// @dtpmod(sym + add), data8 LSB
+pub const R_IA64_DTPMOD64LSB: u32 = 0xa7;
+/// @ltoff(@dtpmod(sym + add)), imm22
+pub const R_IA64_LTOFF_DTPMOD22: u32 = 0xaa;
+/// @dtprel(sym + add), imm14
+pub const R_IA64_DTPREL14: u32 = 0xb1;
+/// @dtprel(sym + add), imm22
+pub const R_IA64_DTPREL22: u32 = 0xb2;
+/// @dtprel(sym + add), imm64
+pub const R_IA64_DTPREL64I: u32 = 0xb3;
+/// @dtprel(sym + add), data4 MSB
+pub const R_IA64_DTPREL32MSB: u32 = 0xb4;
+/// @dtprel(sym + add), data4 LSB
+pub const R_IA64_DTPREL32LSB: u32 = 0xb5;
+/// @dtprel(sym + add), data8 MSB
+pub const R_IA64_DTPREL64MSB: u32 = 0xb6;
+/// @dtprel(sym + add), data8 LSB
+pub const R_IA64_DTPREL64LSB: u32 = 0xb7;
+/// @ltoff(@dtprel(s+a)), imm22
+pub const R_IA64_LTOFF_DTPREL22: u32 = 0xba;
+
+// SH specific declarations.
+
+// SH values `FileHeader*::e_flags`.
+#[allow(missing_docs)]
+pub const EF_SH_MACH_MASK: u32 = 0x1f;
+#[allow(missing_docs)]
+pub const EF_SH_UNKNOWN: u32 = 0x0;
+#[allow(missing_docs)]
+pub const EF_SH1: u32 = 0x1;
+#[allow(missing_docs)]
+pub const EF_SH2: u32 = 0x2;
+#[allow(missing_docs)]
+pub const EF_SH3: u32 = 0x3;
+#[allow(missing_docs)]
+pub const EF_SH_DSP: u32 = 0x4;
+#[allow(missing_docs)]
+pub const EF_SH3_DSP: u32 = 0x5;
+#[allow(missing_docs)]
+pub const EF_SH4AL_DSP: u32 = 0x6;
+#[allow(missing_docs)]
+pub const EF_SH3E: u32 = 0x8;
+#[allow(missing_docs)]
+pub const EF_SH4: u32 = 0x9;
+#[allow(missing_docs)]
+pub const EF_SH2E: u32 = 0xb;
+#[allow(missing_docs)]
+pub const EF_SH4A: u32 = 0xc;
+#[allow(missing_docs)]
+pub const EF_SH2A: u32 = 0xd;
+#[allow(missing_docs)]
+pub const EF_SH4_NOFPU: u32 = 0x10;
+#[allow(missing_docs)]
+pub const EF_SH4A_NOFPU: u32 = 0x11;
+#[allow(missing_docs)]
+pub const EF_SH4_NOMMU_NOFPU: u32 = 0x12;
+#[allow(missing_docs)]
+pub const EF_SH2A_NOFPU: u32 = 0x13;
+#[allow(missing_docs)]
+pub const EF_SH3_NOMMU: u32 = 0x14;
+#[allow(missing_docs)]
+pub const EF_SH2A_SH4_NOFPU: u32 = 0x15;
+#[allow(missing_docs)]
+pub const EF_SH2A_SH3_NOFPU: u32 = 0x16;
+#[allow(missing_docs)]
+pub const EF_SH2A_SH4: u32 = 0x17;
+#[allow(missing_docs)]
+pub const EF_SH2A_SH3E: u32 = 0x18;
+
+// SH values `Rel*::r_type`.
+#[allow(missing_docs)]
+pub const R_SH_NONE: u32 = 0;
+#[allow(missing_docs)]
+pub const R_SH_DIR32: u32 = 1;
+#[allow(missing_docs)]
+pub const R_SH_REL32: u32 = 2;
+#[allow(missing_docs)]
+pub const R_SH_DIR8WPN: u32 = 3;
+#[allow(missing_docs)]
+pub const R_SH_IND12W: u32 = 4;
+#[allow(missing_docs)]
+pub const R_SH_DIR8WPL: u32 = 5;
+#[allow(missing_docs)]
+pub const R_SH_DIR8WPZ: u32 = 6;
+#[allow(missing_docs)]
+pub const R_SH_DIR8BP: u32 = 7;
+#[allow(missing_docs)]
+pub const R_SH_DIR8W: u32 = 8;
+#[allow(missing_docs)]
+pub const R_SH_DIR8L: u32 = 9;
+#[allow(missing_docs)]
+pub const R_SH_SWITCH16: u32 = 25;
+#[allow(missing_docs)]
+pub const R_SH_SWITCH32: u32 = 26;
+#[allow(missing_docs)]
+pub const R_SH_USES: u32 = 27;
+#[allow(missing_docs)]
+pub const R_SH_COUNT: u32 = 28;
+#[allow(missing_docs)]
+pub const R_SH_ALIGN: u32 = 29;
+#[allow(missing_docs)]
+pub const R_SH_CODE: u32 = 30;
+#[allow(missing_docs)]
+pub const R_SH_DATA: u32 = 31;
+#[allow(missing_docs)]
+pub const R_SH_LABEL: u32 = 32;
+#[allow(missing_docs)]
+pub const R_SH_SWITCH8: u32 = 33;
+#[allow(missing_docs)]
+pub const R_SH_GNU_VTINHERIT: u32 = 34;
+#[allow(missing_docs)]
+pub const R_SH_GNU_VTENTRY: u32 = 35;
+#[allow(missing_docs)]
+pub const R_SH_TLS_GD_32: u32 = 144;
+#[allow(missing_docs)]
+pub const R_SH_TLS_LD_32: u32 = 145;
+#[allow(missing_docs)]
+pub const R_SH_TLS_LDO_32: u32 = 146;
+#[allow(missing_docs)]
+pub const R_SH_TLS_IE_32: u32 = 147;
+#[allow(missing_docs)]
+pub const R_SH_TLS_LE_32: u32 = 148;
+#[allow(missing_docs)]
+pub const R_SH_TLS_DTPMOD32: u32 = 149;
+#[allow(missing_docs)]
+pub const R_SH_TLS_DTPOFF32: u32 = 150;
+#[allow(missing_docs)]
+pub const R_SH_TLS_TPOFF32: u32 = 151;
+#[allow(missing_docs)]
+pub const R_SH_GOT32: u32 = 160;
+#[allow(missing_docs)]
+pub const R_SH_PLT32: u32 = 161;
+#[allow(missing_docs)]
+pub const R_SH_COPY: u32 = 162;
+#[allow(missing_docs)]
+pub const R_SH_GLOB_DAT: u32 = 163;
+#[allow(missing_docs)]
+pub const R_SH_JMP_SLOT: u32 = 164;
+#[allow(missing_docs)]
+pub const R_SH_RELATIVE: u32 = 165;
+#[allow(missing_docs)]
+pub const R_SH_GOTOFF: u32 = 166;
+#[allow(missing_docs)]
+pub const R_SH_GOTPC: u32 = 167;
+
+// S/390 specific definitions.
+
+// S/390 values `FileHeader*::e_flags`.
+
+/// High GPRs kernel facility needed.
+pub const EF_S390_HIGH_GPRS: u32 = 0x0000_0001;
+
+// S/390 values `Rel*::r_type`.
+
+/// No reloc.
+pub const R_390_NONE: u32 = 0;
+/// Direct 8 bit.
+pub const R_390_8: u32 = 1;
+/// Direct 12 bit.
+pub const R_390_12: u32 = 2;
+/// Direct 16 bit.
+pub const R_390_16: u32 = 3;
+/// Direct 32 bit.
+pub const R_390_32: u32 = 4;
+/// PC relative 32 bit.
+pub const R_390_PC32: u32 = 5;
+/// 12 bit GOT offset.
+pub const R_390_GOT12: u32 = 6;
+/// 32 bit GOT offset.
+pub const R_390_GOT32: u32 = 7;
+/// 32 bit PC relative PLT address.
+pub const R_390_PLT32: u32 = 8;
+/// Copy symbol at runtime.
+pub const R_390_COPY: u32 = 9;
+/// Create GOT entry.
+pub const R_390_GLOB_DAT: u32 = 10;
+/// Create PLT entry.
+pub const R_390_JMP_SLOT: u32 = 11;
+/// Adjust by program base.
+pub const R_390_RELATIVE: u32 = 12;
+/// 32 bit offset to GOT.
+pub const R_390_GOTOFF32: u32 = 13;
+/// 32 bit PC relative offset to GOT.
+pub const R_390_GOTPC: u32 = 14;
+/// 16 bit GOT offset.
+pub const R_390_GOT16: u32 = 15;
+/// PC relative 16 bit.
+pub const R_390_PC16: u32 = 16;
+/// PC relative 16 bit shifted by 1.
+pub const R_390_PC16DBL: u32 = 17;
+/// 16 bit PC rel. PLT shifted by 1.
+pub const R_390_PLT16DBL: u32 = 18;
+/// PC relative 32 bit shifted by 1.
+pub const R_390_PC32DBL: u32 = 19;
+/// 32 bit PC rel. PLT shifted by 1.
+pub const R_390_PLT32DBL: u32 = 20;
+/// 32 bit PC rel. GOT shifted by 1.
+pub const R_390_GOTPCDBL: u32 = 21;
+/// Direct 64 bit.
+pub const R_390_64: u32 = 22;
+/// PC relative 64 bit.
+pub const R_390_PC64: u32 = 23;
+/// 64 bit GOT offset.
+pub const R_390_GOT64: u32 = 24;
+/// 64 bit PC relative PLT address.
+pub const R_390_PLT64: u32 = 25;
+/// 32 bit PC rel. to GOT entry >> 1.
+pub const R_390_GOTENT: u32 = 26;
+/// 16 bit offset to GOT.
+pub const R_390_GOTOFF16: u32 = 27;
+/// 64 bit offset to GOT.
+pub const R_390_GOTOFF64: u32 = 28;
+/// 12 bit offset to jump slot.
+pub const R_390_GOTPLT12: u32 = 29;
+/// 16 bit offset to jump slot.
+pub const R_390_GOTPLT16: u32 = 30;
+/// 32 bit offset to jump slot.
+pub const R_390_GOTPLT32: u32 = 31;
+/// 64 bit offset to jump slot.
+pub const R_390_GOTPLT64: u32 = 32;
+/// 32 bit rel. offset to jump slot.
+pub const R_390_GOTPLTENT: u32 = 33;
+/// 16 bit offset from GOT to PLT.
+pub const R_390_PLTOFF16: u32 = 34;
+/// 32 bit offset from GOT to PLT.
+pub const R_390_PLTOFF32: u32 = 35;
+/// 16 bit offset from GOT to PLT.
+pub const R_390_PLTOFF64: u32 = 36;
+/// Tag for load insn in TLS code.
+pub const R_390_TLS_LOAD: u32 = 37;
+/// Tag for function call in general dynamic TLS code.
+pub const R_390_TLS_GDCALL: u32 = 38;
+/// Tag for function call in local dynamic TLS code.
+pub const R_390_TLS_LDCALL: u32 = 39;
+/// Direct 32 bit for general dynamic thread local data.
+pub const R_390_TLS_GD32: u32 = 40;
+/// Direct 64 bit for general dynamic thread local data.
+pub const R_390_TLS_GD64: u32 = 41;
+/// 12 bit GOT offset for static TLS block offset.
+pub const R_390_TLS_GOTIE12: u32 = 42;
+/// 32 bit GOT offset for static TLS block offset.
+pub const R_390_TLS_GOTIE32: u32 = 43;
+/// 64 bit GOT offset for static TLS block offset.
+pub const R_390_TLS_GOTIE64: u32 = 44;
+/// Direct 32 bit for local dynamic thread local data in LE code.
+pub const R_390_TLS_LDM32: u32 = 45;
+/// Direct 64 bit for local dynamic thread local data in LE code.
+pub const R_390_TLS_LDM64: u32 = 46;
+/// 32 bit address of GOT entry for negated static TLS block offset.
+pub const R_390_TLS_IE32: u32 = 47;
+/// 64 bit address of GOT entry for negated static TLS block offset.
+pub const R_390_TLS_IE64: u32 = 48;
+/// 32 bit rel. offset to GOT entry for negated static TLS block offset.
+pub const R_390_TLS_IEENT: u32 = 49;
+/// 32 bit negated offset relative to static TLS block.
+pub const R_390_TLS_LE32: u32 = 50;
+/// 64 bit negated offset relative to static TLS block.
+pub const R_390_TLS_LE64: u32 = 51;
+/// 32 bit offset relative to TLS block.
+pub const R_390_TLS_LDO32: u32 = 52;
+/// 64 bit offset relative to TLS block.
+pub const R_390_TLS_LDO64: u32 = 53;
+/// ID of module containing symbol.
+pub const R_390_TLS_DTPMOD: u32 = 54;
+/// Offset in TLS block.
+pub const R_390_TLS_DTPOFF: u32 = 55;
+/// Negated offset in static TLS block.
+pub const R_390_TLS_TPOFF: u32 = 56;
+/// Direct 20 bit.
+pub const R_390_20: u32 = 57;
+/// 20 bit GOT offset.
+pub const R_390_GOT20: u32 = 58;
+/// 20 bit offset to jump slot.
+pub const R_390_GOTPLT20: u32 = 59;
+/// 20 bit GOT offset for static TLS block offset.
+pub const R_390_TLS_GOTIE20: u32 = 60;
+/// STT_GNU_IFUNC relocation.
+pub const R_390_IRELATIVE: u32 = 61;
+
+// CRIS values `Rel*::r_type`.
+#[allow(missing_docs)]
+pub const R_CRIS_NONE: u32 = 0;
+#[allow(missing_docs)]
+pub const R_CRIS_8: u32 = 1;
+#[allow(missing_docs)]
+pub const R_CRIS_16: u32 = 2;
+#[allow(missing_docs)]
+pub const R_CRIS_32: u32 = 3;
+#[allow(missing_docs)]
+pub const R_CRIS_8_PCREL: u32 = 4;
+#[allow(missing_docs)]
+pub const R_CRIS_16_PCREL: u32 = 5;
+#[allow(missing_docs)]
+pub const R_CRIS_32_PCREL: u32 = 6;
+#[allow(missing_docs)]
+pub const R_CRIS_GNU_VTINHERIT: u32 = 7;
+#[allow(missing_docs)]
+pub const R_CRIS_GNU_VTENTRY: u32 = 8;
+#[allow(missing_docs)]
+pub const R_CRIS_COPY: u32 = 9;
+#[allow(missing_docs)]
+pub const R_CRIS_GLOB_DAT: u32 = 10;
+#[allow(missing_docs)]
+pub const R_CRIS_JUMP_SLOT: u32 = 11;
+#[allow(missing_docs)]
+pub const R_CRIS_RELATIVE: u32 = 12;
+#[allow(missing_docs)]
+pub const R_CRIS_16_GOT: u32 = 13;
+#[allow(missing_docs)]
+pub const R_CRIS_32_GOT: u32 = 14;
+#[allow(missing_docs)]
+pub const R_CRIS_16_GOTPLT: u32 = 15;
+#[allow(missing_docs)]
+pub const R_CRIS_32_GOTPLT: u32 = 16;
+#[allow(missing_docs)]
+pub const R_CRIS_32_GOTREL: u32 = 17;
+#[allow(missing_docs)]
+pub const R_CRIS_32_PLT_GOTREL: u32 = 18;
+#[allow(missing_docs)]
+pub const R_CRIS_32_PLT_PCREL: u32 = 19;
+
+// AMD x86-64 values `Rel*::r_type`.
+/// No reloc
+pub const R_X86_64_NONE: u32 = 0;
+/// Direct 64 bit
+pub const R_X86_64_64: u32 = 1;
+/// PC relative 32 bit signed
+pub const R_X86_64_PC32: u32 = 2;
+/// 32 bit GOT entry
+pub const R_X86_64_GOT32: u32 = 3;
+/// 32 bit PLT address
+pub const R_X86_64_PLT32: u32 = 4;
+/// Copy symbol at runtime
+pub const R_X86_64_COPY: u32 = 5;
+/// Create GOT entry
+pub const R_X86_64_GLOB_DAT: u32 = 6;
+/// Create PLT entry
+pub const R_X86_64_JUMP_SLOT: u32 = 7;
+/// Adjust by program base
+pub const R_X86_64_RELATIVE: u32 = 8;
+/// 32 bit signed PC relative offset to GOT
+pub const R_X86_64_GOTPCREL: u32 = 9;
+/// Direct 32 bit zero extended
+pub const R_X86_64_32: u32 = 10;
+/// Direct 32 bit sign extended
+pub const R_X86_64_32S: u32 = 11;
+/// Direct 16 bit zero extended
+pub const R_X86_64_16: u32 = 12;
+/// 16 bit sign extended pc relative
+pub const R_X86_64_PC16: u32 = 13;
+/// Direct 8 bit sign extended
+pub const R_X86_64_8: u32 = 14;
+/// 8 bit sign extended pc relative
+pub const R_X86_64_PC8: u32 = 15;
+/// ID of module containing symbol
+pub const R_X86_64_DTPMOD64: u32 = 16;
+/// Offset in module's TLS block
+pub const R_X86_64_DTPOFF64: u32 = 17;
+/// Offset in initial TLS block
+pub const R_X86_64_TPOFF64: u32 = 18;
+/// 32 bit signed PC relative offset to two GOT entries for GD symbol
+pub const R_X86_64_TLSGD: u32 = 19;
+/// 32 bit signed PC relative offset to two GOT entries for LD symbol
+pub const R_X86_64_TLSLD: u32 = 20;
+/// Offset in TLS block
+pub const R_X86_64_DTPOFF32: u32 = 21;
+/// 32 bit signed PC relative offset to GOT entry for IE symbol
+pub const R_X86_64_GOTTPOFF: u32 = 22;
+/// Offset in initial TLS block
+pub const R_X86_64_TPOFF32: u32 = 23;
+/// PC relative 64 bit
+pub const R_X86_64_PC64: u32 = 24;
+/// 64 bit offset to GOT
+pub const R_X86_64_GOTOFF64: u32 = 25;
+/// 32 bit signed pc relative offset to GOT
+pub const R_X86_64_GOTPC32: u32 = 26;
+/// 64-bit GOT entry offset
+pub const R_X86_64_GOT64: u32 = 27;
+/// 64-bit PC relative offset to GOT entry
+pub const R_X86_64_GOTPCREL64: u32 = 28;
+/// 64-bit PC relative offset to GOT
+pub const R_X86_64_GOTPC64: u32 = 29;
+/// like GOT64, says PLT entry needed
+pub const R_X86_64_GOTPLT64: u32 = 30;
+/// 64-bit GOT relative offset to PLT entry
+pub const R_X86_64_PLTOFF64: u32 = 31;
+/// Size of symbol plus 32-bit addend
+pub const R_X86_64_SIZE32: u32 = 32;
+/// Size of symbol plus 64-bit addend
+pub const R_X86_64_SIZE64: u32 = 33;
+/// GOT offset for TLS descriptor.
+pub const R_X86_64_GOTPC32_TLSDESC: u32 = 34;
+/// Marker for call through TLS descriptor.
+pub const R_X86_64_TLSDESC_CALL: u32 = 35;
+/// TLS descriptor.
+pub const R_X86_64_TLSDESC: u32 = 36;
+/// Adjust indirectly by program base
+pub const R_X86_64_IRELATIVE: u32 = 37;
+/// 64-bit adjust by program base
+pub const R_X86_64_RELATIVE64: u32 = 38;
+// 39 Reserved was R_X86_64_PC32_BND
+// 40 Reserved was R_X86_64_PLT32_BND
+/// Load from 32 bit signed pc relative offset to GOT entry without REX prefix, relaxable.
+pub const R_X86_64_GOTPCRELX: u32 = 41;
+/// Load from 32 bit signed pc relative offset to GOT entry with REX prefix, relaxable.
+pub const R_X86_64_REX_GOTPCRELX: u32 = 42;
+
+// AMD x86-64 values `SectionHeader*::sh_type`.
+/// Unwind information.
+pub const SHT_X86_64_UNWIND: u32 = 0x7000_0001;
+
+// AM33 values `Rel*::r_type`.
+/// No reloc.
+pub const R_MN10300_NONE: u32 = 0;
+/// Direct 32 bit.
+pub const R_MN10300_32: u32 = 1;
+/// Direct 16 bit.
+pub const R_MN10300_16: u32 = 2;
+/// Direct 8 bit.
+pub const R_MN10300_8: u32 = 3;
+/// PC-relative 32-bit.
+pub const R_MN10300_PCREL32: u32 = 4;
+/// PC-relative 16-bit signed.
+pub const R_MN10300_PCREL16: u32 = 5;
+/// PC-relative 8-bit signed.
+pub const R_MN10300_PCREL8: u32 = 6;
+/// Ancient C++ vtable garbage...
+pub const R_MN10300_GNU_VTINHERIT: u32 = 7;
+/// ... collection annotation.
+pub const R_MN10300_GNU_VTENTRY: u32 = 8;
+/// Direct 24 bit.
+pub const R_MN10300_24: u32 = 9;
+/// 32-bit PCrel offset to GOT.
+pub const R_MN10300_GOTPC32: u32 = 10;
+/// 16-bit PCrel offset to GOT.
+pub const R_MN10300_GOTPC16: u32 = 11;
+/// 32-bit offset from GOT.
+pub const R_MN10300_GOTOFF32: u32 = 12;
+/// 24-bit offset from GOT.
+pub const R_MN10300_GOTOFF24: u32 = 13;
+/// 16-bit offset from GOT.
+pub const R_MN10300_GOTOFF16: u32 = 14;
+/// 32-bit PCrel to PLT entry.
+pub const R_MN10300_PLT32: u32 = 15;
+/// 16-bit PCrel to PLT entry.
+pub const R_MN10300_PLT16: u32 = 16;
+/// 32-bit offset to GOT entry.
+pub const R_MN10300_GOT32: u32 = 17;
+/// 24-bit offset to GOT entry.
+pub const R_MN10300_GOT24: u32 = 18;
+/// 16-bit offset to GOT entry.
+pub const R_MN10300_GOT16: u32 = 19;
+/// Copy symbol at runtime.
+pub const R_MN10300_COPY: u32 = 20;
+/// Create GOT entry.
+pub const R_MN10300_GLOB_DAT: u32 = 21;
+/// Create PLT entry.
+pub const R_MN10300_JMP_SLOT: u32 = 22;
+/// Adjust by program base.
+pub const R_MN10300_RELATIVE: u32 = 23;
+/// 32-bit offset for global dynamic.
+pub const R_MN10300_TLS_GD: u32 = 24;
+/// 32-bit offset for local dynamic.
+pub const R_MN10300_TLS_LD: u32 = 25;
+/// Module-relative offset.
+pub const R_MN10300_TLS_LDO: u32 = 26;
+/// GOT offset for static TLS block offset.
+pub const R_MN10300_TLS_GOTIE: u32 = 27;
+/// GOT address for static TLS block offset.
+pub const R_MN10300_TLS_IE: u32 = 28;
+/// Offset relative to static TLS block.
+pub const R_MN10300_TLS_LE: u32 = 29;
+/// ID of module containing symbol.
+pub const R_MN10300_TLS_DTPMOD: u32 = 30;
+/// Offset in module TLS block.
+pub const R_MN10300_TLS_DTPOFF: u32 = 31;
+/// Offset in static TLS block.
+pub const R_MN10300_TLS_TPOFF: u32 = 32;
+/// Adjustment for next reloc as needed by linker relaxation.
+pub const R_MN10300_SYM_DIFF: u32 = 33;
+/// Alignment requirement for linker relaxation.
+pub const R_MN10300_ALIGN: u32 = 34;
+
+// M32R values `Rel32::r_type`.
+/// No reloc.
+pub const R_M32R_NONE: u32 = 0;
+/// Direct 16 bit.
+pub const R_M32R_16: u32 = 1;
+/// Direct 32 bit.
+pub const R_M32R_32: u32 = 2;
+/// Direct 24 bit.
+pub const R_M32R_24: u32 = 3;
+/// PC relative 10 bit shifted.
+pub const R_M32R_10_PCREL: u32 = 4;
+/// PC relative 18 bit shifted.
+pub const R_M32R_18_PCREL: u32 = 5;
+/// PC relative 26 bit shifted.
+pub const R_M32R_26_PCREL: u32 = 6;
+/// High 16 bit with unsigned low.
+pub const R_M32R_HI16_ULO: u32 = 7;
+/// High 16 bit with signed low.
+pub const R_M32R_HI16_SLO: u32 = 8;
+/// Low 16 bit.
+pub const R_M32R_LO16: u32 = 9;
+/// 16 bit offset in SDA.
+pub const R_M32R_SDA16: u32 = 10;
+#[allow(missing_docs)]
+pub const R_M32R_GNU_VTINHERIT: u32 = 11;
+#[allow(missing_docs)]
+pub const R_M32R_GNU_VTENTRY: u32 = 12;
+// M32R values `Rela32::r_type`.
+/// Direct 16 bit.
+pub const R_M32R_16_RELA: u32 = 33;
+/// Direct 32 bit.
+pub const R_M32R_32_RELA: u32 = 34;
+/// Direct 24 bit.
+pub const R_M32R_24_RELA: u32 = 35;
+/// PC relative 10 bit shifted.
+pub const R_M32R_10_PCREL_RELA: u32 = 36;
+/// PC relative 18 bit shifted.
+pub const R_M32R_18_PCREL_RELA: u32 = 37;
+/// PC relative 26 bit shifted.
+pub const R_M32R_26_PCREL_RELA: u32 = 38;
+/// High 16 bit with unsigned low
+pub const R_M32R_HI16_ULO_RELA: u32 = 39;
+/// High 16 bit with signed low
+pub const R_M32R_HI16_SLO_RELA: u32 = 40;
+/// Low 16 bit
+pub const R_M32R_LO16_RELA: u32 = 41;
+/// 16 bit offset in SDA
+pub const R_M32R_SDA16_RELA: u32 = 42;
+#[allow(missing_docs)]
+pub const R_M32R_RELA_GNU_VTINHERIT: u32 = 43;
+#[allow(missing_docs)]
+pub const R_M32R_RELA_GNU_VTENTRY: u32 = 44;
+/// PC relative 32 bit.
+pub const R_M32R_REL32: u32 = 45;
+
+/// 24 bit GOT entry
+pub const R_M32R_GOT24: u32 = 48;
+/// 26 bit PC relative to PLT shifted
+pub const R_M32R_26_PLTREL: u32 = 49;
+/// Copy symbol at runtime
+pub const R_M32R_COPY: u32 = 50;
+/// Create GOT entry
+pub const R_M32R_GLOB_DAT: u32 = 51;
+/// Create PLT entry
+pub const R_M32R_JMP_SLOT: u32 = 52;
+/// Adjust by program base
+pub const R_M32R_RELATIVE: u32 = 53;
+/// 24 bit offset to GOT
+pub const R_M32R_GOTOFF: u32 = 54;
+/// 24 bit PC relative offset to GOT
+pub const R_M32R_GOTPC24: u32 = 55;
+/// High 16 bit GOT entry with unsigned low
+pub const R_M32R_GOT16_HI_ULO: u32 = 56;
+/// High 16 bit GOT entry with signed low
+pub const R_M32R_GOT16_HI_SLO: u32 = 57;
+/// Low 16 bit GOT entry
+pub const R_M32R_GOT16_LO: u32 = 58;
+/// High 16 bit PC relative offset to GOT with unsigned low
+pub const R_M32R_GOTPC_HI_ULO: u32 = 59;
+/// High 16 bit PC relative offset to GOT with signed low
+pub const R_M32R_GOTPC_HI_SLO: u32 = 60;
+/// Low 16 bit PC relative offset to GOT
+pub const R_M32R_GOTPC_LO: u32 = 61;
+/// High 16 bit offset to GOT with unsigned low
+pub const R_M32R_GOTOFF_HI_ULO: u32 = 62;
+/// High 16 bit offset to GOT with signed low
+pub const R_M32R_GOTOFF_HI_SLO: u32 = 63;
+/// Low 16 bit offset to GOT
+pub const R_M32R_GOTOFF_LO: u32 = 64;
+/// Keep this the last entry.
+pub const R_M32R_NUM: u32 = 256;
+
+// MicroBlaze values `Rel*::r_type`.
+/// No reloc.
+pub const R_MICROBLAZE_NONE: u32 = 0;
+/// Direct 32 bit.
+pub const R_MICROBLAZE_32: u32 = 1;
+/// PC relative 32 bit.
+pub const R_MICROBLAZE_32_PCREL: u32 = 2;
+/// PC relative 64 bit.
+pub const R_MICROBLAZE_64_PCREL: u32 = 3;
+/// Low 16 bits of PCREL32.
+pub const R_MICROBLAZE_32_PCREL_LO: u32 = 4;
+/// Direct 64 bit.
+pub const R_MICROBLAZE_64: u32 = 5;
+/// Low 16 bit.
+pub const R_MICROBLAZE_32_LO: u32 = 6;
+/// Read-only small data area.
+pub const R_MICROBLAZE_SRO32: u32 = 7;
+/// Read-write small data area.
+pub const R_MICROBLAZE_SRW32: u32 = 8;
+/// No reloc.
+pub const R_MICROBLAZE_64_NONE: u32 = 9;
+/// Symbol Op Symbol relocation.
+pub const R_MICROBLAZE_32_SYM_OP_SYM: u32 = 10;
+/// GNU C++ vtable hierarchy.
+pub const R_MICROBLAZE_GNU_VTINHERIT: u32 = 11;
+/// GNU C++ vtable member usage.
+pub const R_MICROBLAZE_GNU_VTENTRY: u32 = 12;
+/// PC-relative GOT offset.
+pub const R_MICROBLAZE_GOTPC_64: u32 = 13;
+/// GOT entry offset.
+pub const R_MICROBLAZE_GOT_64: u32 = 14;
+/// PLT offset (PC-relative).
+pub const R_MICROBLAZE_PLT_64: u32 = 15;
+/// Adjust by program base.
+pub const R_MICROBLAZE_REL: u32 = 16;
+/// Create PLT entry.
+pub const R_MICROBLAZE_JUMP_SLOT: u32 = 17;
+/// Create GOT entry.
+pub const R_MICROBLAZE_GLOB_DAT: u32 = 18;
+/// 64 bit offset to GOT.
+pub const R_MICROBLAZE_GOTOFF_64: u32 = 19;
+/// 32 bit offset to GOT.
+pub const R_MICROBLAZE_GOTOFF_32: u32 = 20;
+/// Runtime copy.
+pub const R_MICROBLAZE_COPY: u32 = 21;
+/// TLS Reloc.
+pub const R_MICROBLAZE_TLS: u32 = 22;
+/// TLS General Dynamic.
+pub const R_MICROBLAZE_TLSGD: u32 = 23;
+/// TLS Local Dynamic.
+pub const R_MICROBLAZE_TLSLD: u32 = 24;
+/// TLS Module ID.
+pub const R_MICROBLAZE_TLSDTPMOD32: u32 = 25;
+/// TLS Offset Within TLS Block.
+pub const R_MICROBLAZE_TLSDTPREL32: u32 = 26;
+/// TLS Offset Within TLS Block.
+pub const R_MICROBLAZE_TLSDTPREL64: u32 = 27;
+/// TLS Offset From Thread Pointer.
+pub const R_MICROBLAZE_TLSGOTTPREL32: u32 = 28;
+/// TLS Offset From Thread Pointer.
+pub const R_MICROBLAZE_TLSTPREL32: u32 = 29;
+
+// Nios II values `Dyn::d_tag`.
+/// Address of _gp.
+pub const DT_NIOS2_GP: u32 = 0x7000_0002;
+
+// Nios II values `Rel*::r_type`.
+/// No reloc.
+pub const R_NIOS2_NONE: u32 = 0;
+/// Direct signed 16 bit.
+pub const R_NIOS2_S16: u32 = 1;
+/// Direct unsigned 16 bit.
+pub const R_NIOS2_U16: u32 = 2;
+/// PC relative 16 bit.
+pub const R_NIOS2_PCREL16: u32 = 3;
+/// Direct call.
+pub const R_NIOS2_CALL26: u32 = 4;
+/// 5 bit constant expression.
+pub const R_NIOS2_IMM5: u32 = 5;
+/// 5 bit expression, shift 22.
+pub const R_NIOS2_CACHE_OPX: u32 = 6;
+/// 6 bit constant expression.
+pub const R_NIOS2_IMM6: u32 = 7;
+/// 8 bit constant expression.
+pub const R_NIOS2_IMM8: u32 = 8;
+/// High 16 bit.
+pub const R_NIOS2_HI16: u32 = 9;
+/// Low 16 bit.
+pub const R_NIOS2_LO16: u32 = 10;
+/// High 16 bit, adjusted.
+pub const R_NIOS2_HIADJ16: u32 = 11;
+/// 32 bit symbol value + addend.
+pub const R_NIOS2_BFD_RELOC_32: u32 = 12;
+/// 16 bit symbol value + addend.
+pub const R_NIOS2_BFD_RELOC_16: u32 = 13;
+/// 8 bit symbol value + addend.
+pub const R_NIOS2_BFD_RELOC_8: u32 = 14;
+/// 16 bit GP pointer offset.
+pub const R_NIOS2_GPREL: u32 = 15;
+/// GNU C++ vtable hierarchy.
+pub const R_NIOS2_GNU_VTINHERIT: u32 = 16;
+/// GNU C++ vtable member usage.
+pub const R_NIOS2_GNU_VTENTRY: u32 = 17;
+/// Unconditional branch.
+pub const R_NIOS2_UJMP: u32 = 18;
+/// Conditional branch.
+pub const R_NIOS2_CJMP: u32 = 19;
+/// Indirect call through register.
+pub const R_NIOS2_CALLR: u32 = 20;
+/// Alignment requirement for linker relaxation.
+pub const R_NIOS2_ALIGN: u32 = 21;
+/// 16 bit GOT entry.
+pub const R_NIOS2_GOT16: u32 = 22;
+/// 16 bit GOT entry for function.
+pub const R_NIOS2_CALL16: u32 = 23;
+/// %lo of offset to GOT pointer.
+pub const R_NIOS2_GOTOFF_LO: u32 = 24;
+/// %hiadj of offset to GOT pointer.
+pub const R_NIOS2_GOTOFF_HA: u32 = 25;
+/// %lo of PC relative offset.
+pub const R_NIOS2_PCREL_LO: u32 = 26;
+/// %hiadj of PC relative offset.
+pub const R_NIOS2_PCREL_HA: u32 = 27;
+/// 16 bit GOT offset for TLS GD.
+pub const R_NIOS2_TLS_GD16: u32 = 28;
+/// 16 bit GOT offset for TLS LDM.
+pub const R_NIOS2_TLS_LDM16: u32 = 29;
+/// 16 bit module relative offset.
+pub const R_NIOS2_TLS_LDO16: u32 = 30;
+/// 16 bit GOT offset for TLS IE.
+pub const R_NIOS2_TLS_IE16: u32 = 31;
+/// 16 bit LE TP-relative offset.
+pub const R_NIOS2_TLS_LE16: u32 = 32;
+/// Module number.
+pub const R_NIOS2_TLS_DTPMOD: u32 = 33;
+/// Module-relative offset.
+pub const R_NIOS2_TLS_DTPREL: u32 = 34;
+/// TP-relative offset.
+pub const R_NIOS2_TLS_TPREL: u32 = 35;
+/// Copy symbol at runtime.
+pub const R_NIOS2_COPY: u32 = 36;
+/// Create GOT entry.
+pub const R_NIOS2_GLOB_DAT: u32 = 37;
+/// Create PLT entry.
+pub const R_NIOS2_JUMP_SLOT: u32 = 38;
+/// Adjust by program base.
+pub const R_NIOS2_RELATIVE: u32 = 39;
+/// 16 bit offset to GOT pointer.
+pub const R_NIOS2_GOTOFF: u32 = 40;
+/// Direct call in .noat section.
+pub const R_NIOS2_CALL26_NOAT: u32 = 41;
+/// %lo() of GOT entry.
+pub const R_NIOS2_GOT_LO: u32 = 42;
+/// %hiadj() of GOT entry.
+pub const R_NIOS2_GOT_HA: u32 = 43;
+/// %lo() of function GOT entry.
+pub const R_NIOS2_CALL_LO: u32 = 44;
+/// %hiadj() of function GOT entry.
+pub const R_NIOS2_CALL_HA: u32 = 45;
+
+// TILEPro values `Rel*::r_type`.
+/// No reloc
+pub const R_TILEPRO_NONE: u32 = 0;
+/// Direct 32 bit
+pub const R_TILEPRO_32: u32 = 1;
+/// Direct 16 bit
+pub const R_TILEPRO_16: u32 = 2;
+/// Direct 8 bit
+pub const R_TILEPRO_8: u32 = 3;
+/// PC relative 32 bit
+pub const R_TILEPRO_32_PCREL: u32 = 4;
+/// PC relative 16 bit
+pub const R_TILEPRO_16_PCREL: u32 = 5;
+/// PC relative 8 bit
+pub const R_TILEPRO_8_PCREL: u32 = 6;
+/// Low 16 bit
+pub const R_TILEPRO_LO16: u32 = 7;
+/// High 16 bit
+pub const R_TILEPRO_HI16: u32 = 8;
+/// High 16 bit, adjusted
+pub const R_TILEPRO_HA16: u32 = 9;
+/// Copy relocation
+pub const R_TILEPRO_COPY: u32 = 10;
+/// Create GOT entry
+pub const R_TILEPRO_GLOB_DAT: u32 = 11;
+/// Create PLT entry
+pub const R_TILEPRO_JMP_SLOT: u32 = 12;
+/// Adjust by program base
+pub const R_TILEPRO_RELATIVE: u32 = 13;
+/// X1 pipe branch offset
+pub const R_TILEPRO_BROFF_X1: u32 = 14;
+/// X1 pipe jump offset
+pub const R_TILEPRO_JOFFLONG_X1: u32 = 15;
+/// X1 pipe jump offset to PLT
+pub const R_TILEPRO_JOFFLONG_X1_PLT: u32 = 16;
+/// X0 pipe 8-bit
+pub const R_TILEPRO_IMM8_X0: u32 = 17;
+/// Y0 pipe 8-bit
+pub const R_TILEPRO_IMM8_Y0: u32 = 18;
+/// X1 pipe 8-bit
+pub const R_TILEPRO_IMM8_X1: u32 = 19;
+/// Y1 pipe 8-bit
+pub const R_TILEPRO_IMM8_Y1: u32 = 20;
+/// X1 pipe mtspr
+pub const R_TILEPRO_MT_IMM15_X1: u32 = 21;
+/// X1 pipe mfspr
+pub const R_TILEPRO_MF_IMM15_X1: u32 = 22;
+/// X0 pipe 16-bit
+pub const R_TILEPRO_IMM16_X0: u32 = 23;
+/// X1 pipe 16-bit
+pub const R_TILEPRO_IMM16_X1: u32 = 24;
+/// X0 pipe low 16-bit
+pub const R_TILEPRO_IMM16_X0_LO: u32 = 25;
+/// X1 pipe low 16-bit
+pub const R_TILEPRO_IMM16_X1_LO: u32 = 26;
+/// X0 pipe high 16-bit
+pub const R_TILEPRO_IMM16_X0_HI: u32 = 27;
+/// X1 pipe high 16-bit
+pub const R_TILEPRO_IMM16_X1_HI: u32 = 28;
+/// X0 pipe high 16-bit, adjusted
+pub const R_TILEPRO_IMM16_X0_HA: u32 = 29;
+/// X1 pipe high 16-bit, adjusted
+pub const R_TILEPRO_IMM16_X1_HA: u32 = 30;
+/// X0 pipe PC relative 16 bit
+pub const R_TILEPRO_IMM16_X0_PCREL: u32 = 31;
+/// X1 pipe PC relative 16 bit
+pub const R_TILEPRO_IMM16_X1_PCREL: u32 = 32;
+/// X0 pipe PC relative low 16 bit
+pub const R_TILEPRO_IMM16_X0_LO_PCREL: u32 = 33;
+/// X1 pipe PC relative low 16 bit
+pub const R_TILEPRO_IMM16_X1_LO_PCREL: u32 = 34;
+/// X0 pipe PC relative high 16 bit
+pub const R_TILEPRO_IMM16_X0_HI_PCREL: u32 = 35;
+/// X1 pipe PC relative high 16 bit
+pub const R_TILEPRO_IMM16_X1_HI_PCREL: u32 = 36;
+/// X0 pipe PC relative ha() 16 bit
+pub const R_TILEPRO_IMM16_X0_HA_PCREL: u32 = 37;
+/// X1 pipe PC relative ha() 16 bit
+pub const R_TILEPRO_IMM16_X1_HA_PCREL: u32 = 38;
+/// X0 pipe 16-bit GOT offset
+pub const R_TILEPRO_IMM16_X0_GOT: u32 = 39;
+/// X1 pipe 16-bit GOT offset
+pub const R_TILEPRO_IMM16_X1_GOT: u32 = 40;
+/// X0 pipe low 16-bit GOT offset
+pub const R_TILEPRO_IMM16_X0_GOT_LO: u32 = 41;
+/// X1 pipe low 16-bit GOT offset
+pub const R_TILEPRO_IMM16_X1_GOT_LO: u32 = 42;
+/// X0 pipe high 16-bit GOT offset
+pub const R_TILEPRO_IMM16_X0_GOT_HI: u32 = 43;
+/// X1 pipe high 16-bit GOT offset
+pub const R_TILEPRO_IMM16_X1_GOT_HI: u32 = 44;
+/// X0 pipe ha() 16-bit GOT offset
+pub const R_TILEPRO_IMM16_X0_GOT_HA: u32 = 45;
+/// X1 pipe ha() 16-bit GOT offset
+pub const R_TILEPRO_IMM16_X1_GOT_HA: u32 = 46;
+/// X0 pipe mm "start"
+pub const R_TILEPRO_MMSTART_X0: u32 = 47;
+/// X0 pipe mm "end"
+pub const R_TILEPRO_MMEND_X0: u32 = 48;
+/// X1 pipe mm "start"
+pub const R_TILEPRO_MMSTART_X1: u32 = 49;
+/// X1 pipe mm "end"
+pub const R_TILEPRO_MMEND_X1: u32 = 50;
+/// X0 pipe shift amount
+pub const R_TILEPRO_SHAMT_X0: u32 = 51;
+/// X1 pipe shift amount
+pub const R_TILEPRO_SHAMT_X1: u32 = 52;
+/// Y0 pipe shift amount
+pub const R_TILEPRO_SHAMT_Y0: u32 = 53;
+/// Y1 pipe shift amount
+pub const R_TILEPRO_SHAMT_Y1: u32 = 54;
+/// X1 pipe destination 8-bit
+pub const R_TILEPRO_DEST_IMM8_X1: u32 = 55;
+// Relocs 56-59 are currently not defined.
+/// "jal" for TLS GD
+pub const R_TILEPRO_TLS_GD_CALL: u32 = 60;
+/// X0 pipe "addi" for TLS GD
+pub const R_TILEPRO_IMM8_X0_TLS_GD_ADD: u32 = 61;
+/// X1 pipe "addi" for TLS GD
+pub const R_TILEPRO_IMM8_X1_TLS_GD_ADD: u32 = 62;
+/// Y0 pipe "addi" for TLS GD
+pub const R_TILEPRO_IMM8_Y0_TLS_GD_ADD: u32 = 63;
+/// Y1 pipe "addi" for TLS GD
+pub const R_TILEPRO_IMM8_Y1_TLS_GD_ADD: u32 = 64;
+/// "lw_tls" for TLS IE
+pub const R_TILEPRO_TLS_IE_LOAD: u32 = 65;
+/// X0 pipe 16-bit TLS GD offset
+pub const R_TILEPRO_IMM16_X0_TLS_GD: u32 = 66;
+/// X1 pipe 16-bit TLS GD offset
+pub const R_TILEPRO_IMM16_X1_TLS_GD: u32 = 67;
+/// X0 pipe low 16-bit TLS GD offset
+pub const R_TILEPRO_IMM16_X0_TLS_GD_LO: u32 = 68;
+/// X1 pipe low 16-bit TLS GD offset
+pub const R_TILEPRO_IMM16_X1_TLS_GD_LO: u32 = 69;
+/// X0 pipe high 16-bit TLS GD offset
+pub const R_TILEPRO_IMM16_X0_TLS_GD_HI: u32 = 70;
+/// X1 pipe high 16-bit TLS GD offset
+pub const R_TILEPRO_IMM16_X1_TLS_GD_HI: u32 = 71;
+/// X0 pipe ha() 16-bit TLS GD offset
+pub const R_TILEPRO_IMM16_X0_TLS_GD_HA: u32 = 72;
+/// X1 pipe ha() 16-bit TLS GD offset
+pub const R_TILEPRO_IMM16_X1_TLS_GD_HA: u32 = 73;
+/// X0 pipe 16-bit TLS IE offset
+pub const R_TILEPRO_IMM16_X0_TLS_IE: u32 = 74;
+/// X1 pipe 16-bit TLS IE offset
+pub const R_TILEPRO_IMM16_X1_TLS_IE: u32 = 75;
+/// X0 pipe low 16-bit TLS IE offset
+pub const R_TILEPRO_IMM16_X0_TLS_IE_LO: u32 = 76;
+/// X1 pipe low 16-bit TLS IE offset
+pub const R_TILEPRO_IMM16_X1_TLS_IE_LO: u32 = 77;
+/// X0 pipe high 16-bit TLS IE offset
+pub const R_TILEPRO_IMM16_X0_TLS_IE_HI: u32 = 78;
+/// X1 pipe high 16-bit TLS IE offset
+pub const R_TILEPRO_IMM16_X1_TLS_IE_HI: u32 = 79;
+/// X0 pipe ha() 16-bit TLS IE offset
+pub const R_TILEPRO_IMM16_X0_TLS_IE_HA: u32 = 80;
+/// X1 pipe ha() 16-bit TLS IE offset
+pub const R_TILEPRO_IMM16_X1_TLS_IE_HA: u32 = 81;
+/// ID of module containing symbol
+pub const R_TILEPRO_TLS_DTPMOD32: u32 = 82;
+/// Offset in TLS block
+pub const R_TILEPRO_TLS_DTPOFF32: u32 = 83;
+/// Offset in static TLS block
+pub const R_TILEPRO_TLS_TPOFF32: u32 = 84;
+/// X0 pipe 16-bit TLS LE offset
+pub const R_TILEPRO_IMM16_X0_TLS_LE: u32 = 85;
+/// X1 pipe 16-bit TLS LE offset
+pub const R_TILEPRO_IMM16_X1_TLS_LE: u32 = 86;
+/// X0 pipe low 16-bit TLS LE offset
+pub const R_TILEPRO_IMM16_X0_TLS_LE_LO: u32 = 87;
+/// X1 pipe low 16-bit TLS LE offset
+pub const R_TILEPRO_IMM16_X1_TLS_LE_LO: u32 = 88;
+/// X0 pipe high 16-bit TLS LE offset
+pub const R_TILEPRO_IMM16_X0_TLS_LE_HI: u32 = 89;
+/// X1 pipe high 16-bit TLS LE offset
+pub const R_TILEPRO_IMM16_X1_TLS_LE_HI: u32 = 90;
+/// X0 pipe ha() 16-bit TLS LE offset
+pub const R_TILEPRO_IMM16_X0_TLS_LE_HA: u32 = 91;
+/// X1 pipe ha() 16-bit TLS LE offset
+pub const R_TILEPRO_IMM16_X1_TLS_LE_HA: u32 = 92;
+
+/// GNU C++ vtable hierarchy
+pub const R_TILEPRO_GNU_VTINHERIT: u32 = 128;
+/// GNU C++ vtable member usage
+pub const R_TILEPRO_GNU_VTENTRY: u32 = 129;
+
+// TILE-Gx values `Rel*::r_type`.
+/// No reloc
+pub const R_TILEGX_NONE: u32 = 0;
+/// Direct 64 bit
+pub const R_TILEGX_64: u32 = 1;
+/// Direct 32 bit
+pub const R_TILEGX_32: u32 = 2;
+/// Direct 16 bit
+pub const R_TILEGX_16: u32 = 3;
+/// Direct 8 bit
+pub const R_TILEGX_8: u32 = 4;
+/// PC relative 64 bit
+pub const R_TILEGX_64_PCREL: u32 = 5;
+/// PC relative 32 bit
+pub const R_TILEGX_32_PCREL: u32 = 6;
+/// PC relative 16 bit
+pub const R_TILEGX_16_PCREL: u32 = 7;
+/// PC relative 8 bit
+pub const R_TILEGX_8_PCREL: u32 = 8;
+/// hword 0 16-bit
+pub const R_TILEGX_HW0: u32 = 9;
+/// hword 1 16-bit
+pub const R_TILEGX_HW1: u32 = 10;
+/// hword 2 16-bit
+pub const R_TILEGX_HW2: u32 = 11;
+/// hword 3 16-bit
+pub const R_TILEGX_HW3: u32 = 12;
+/// last hword 0 16-bit
+pub const R_TILEGX_HW0_LAST: u32 = 13;
+/// last hword 1 16-bit
+pub const R_TILEGX_HW1_LAST: u32 = 14;
+/// last hword 2 16-bit
+pub const R_TILEGX_HW2_LAST: u32 = 15;
+/// Copy relocation
+pub const R_TILEGX_COPY: u32 = 16;
+/// Create GOT entry
+pub const R_TILEGX_GLOB_DAT: u32 = 17;
+/// Create PLT entry
+pub const R_TILEGX_JMP_SLOT: u32 = 18;
+/// Adjust by program base
+pub const R_TILEGX_RELATIVE: u32 = 19;
+/// X1 pipe branch offset
+pub const R_TILEGX_BROFF_X1: u32 = 20;
+/// X1 pipe jump offset
+pub const R_TILEGX_JUMPOFF_X1: u32 = 21;
+/// X1 pipe jump offset to PLT
+pub const R_TILEGX_JUMPOFF_X1_PLT: u32 = 22;
+/// X0 pipe 8-bit
+pub const R_TILEGX_IMM8_X0: u32 = 23;
+/// Y0 pipe 8-bit
+pub const R_TILEGX_IMM8_Y0: u32 = 24;
+/// X1 pipe 8-bit
+pub const R_TILEGX_IMM8_X1: u32 = 25;
+/// Y1 pipe 8-bit
+pub const R_TILEGX_IMM8_Y1: u32 = 26;
+/// X1 pipe destination 8-bit
+pub const R_TILEGX_DEST_IMM8_X1: u32 = 27;
+/// X1 pipe mtspr
+pub const R_TILEGX_MT_IMM14_X1: u32 = 28;
+/// X1 pipe mfspr
+pub const R_TILEGX_MF_IMM14_X1: u32 = 29;
+/// X0 pipe mm "start"
+pub const R_TILEGX_MMSTART_X0: u32 = 30;
+/// X0 pipe mm "end"
+pub const R_TILEGX_MMEND_X0: u32 = 31;
+/// X0 pipe shift amount
+pub const R_TILEGX_SHAMT_X0: u32 = 32;
+/// X1 pipe shift amount
+pub const R_TILEGX_SHAMT_X1: u32 = 33;
+/// Y0 pipe shift amount
+pub const R_TILEGX_SHAMT_Y0: u32 = 34;
+/// Y1 pipe shift amount
+pub const R_TILEGX_SHAMT_Y1: u32 = 35;
+/// X0 pipe hword 0
+pub const R_TILEGX_IMM16_X0_HW0: u32 = 36;
+/// X1 pipe hword 0
+pub const R_TILEGX_IMM16_X1_HW0: u32 = 37;
+/// X0 pipe hword 1
+pub const R_TILEGX_IMM16_X0_HW1: u32 = 38;
+/// X1 pipe hword 1
+pub const R_TILEGX_IMM16_X1_HW1: u32 = 39;
+/// X0 pipe hword 2
+pub const R_TILEGX_IMM16_X0_HW2: u32 = 40;
+/// X1 pipe hword 2
+pub const R_TILEGX_IMM16_X1_HW2: u32 = 41;
+/// X0 pipe hword 3
+pub const R_TILEGX_IMM16_X0_HW3: u32 = 42;
+/// X1 pipe hword 3
+pub const R_TILEGX_IMM16_X1_HW3: u32 = 43;
+/// X0 pipe last hword 0
+pub const R_TILEGX_IMM16_X0_HW0_LAST: u32 = 44;
+/// X1 pipe last hword 0
+pub const R_TILEGX_IMM16_X1_HW0_LAST: u32 = 45;
+/// X0 pipe last hword 1
+pub const R_TILEGX_IMM16_X0_HW1_LAST: u32 = 46;
+/// X1 pipe last hword 1
+pub const R_TILEGX_IMM16_X1_HW1_LAST: u32 = 47;
+/// X0 pipe last hword 2
+pub const R_TILEGX_IMM16_X0_HW2_LAST: u32 = 48;
+/// X1 pipe last hword 2
+pub const R_TILEGX_IMM16_X1_HW2_LAST: u32 = 49;
+/// X0 pipe PC relative hword 0
+pub const R_TILEGX_IMM16_X0_HW0_PCREL: u32 = 50;
+/// X1 pipe PC relative hword 0
+pub const R_TILEGX_IMM16_X1_HW0_PCREL: u32 = 51;
+/// X0 pipe PC relative hword 1
+pub const R_TILEGX_IMM16_X0_HW1_PCREL: u32 = 52;
+/// X1 pipe PC relative hword 1
+pub const R_TILEGX_IMM16_X1_HW1_PCREL: u32 = 53;
+/// X0 pipe PC relative hword 2
+pub const R_TILEGX_IMM16_X0_HW2_PCREL: u32 = 54;
+/// X1 pipe PC relative hword 2
+pub const R_TILEGX_IMM16_X1_HW2_PCREL: u32 = 55;
+/// X0 pipe PC relative hword 3
+pub const R_TILEGX_IMM16_X0_HW3_PCREL: u32 = 56;
+/// X1 pipe PC relative hword 3
+pub const R_TILEGX_IMM16_X1_HW3_PCREL: u32 = 57;
+/// X0 pipe PC-rel last hword 0
+pub const R_TILEGX_IMM16_X0_HW0_LAST_PCREL: u32 = 58;
+/// X1 pipe PC-rel last hword 0
+pub const R_TILEGX_IMM16_X1_HW0_LAST_PCREL: u32 = 59;
+/// X0 pipe PC-rel last hword 1
+pub const R_TILEGX_IMM16_X0_HW1_LAST_PCREL: u32 = 60;
+/// X1 pipe PC-rel last hword 1
+pub const R_TILEGX_IMM16_X1_HW1_LAST_PCREL: u32 = 61;
+/// X0 pipe PC-rel last hword 2
+pub const R_TILEGX_IMM16_X0_HW2_LAST_PCREL: u32 = 62;
+/// X1 pipe PC-rel last hword 2
+pub const R_TILEGX_IMM16_X1_HW2_LAST_PCREL: u32 = 63;
+/// X0 pipe hword 0 GOT offset
+pub const R_TILEGX_IMM16_X0_HW0_GOT: u32 = 64;
+/// X1 pipe hword 0 GOT offset
+pub const R_TILEGX_IMM16_X1_HW0_GOT: u32 = 65;
+/// X0 pipe PC-rel PLT hword 0
+pub const R_TILEGX_IMM16_X0_HW0_PLT_PCREL: u32 = 66;
+/// X1 pipe PC-rel PLT hword 0
+pub const R_TILEGX_IMM16_X1_HW0_PLT_PCREL: u32 = 67;
+/// X0 pipe PC-rel PLT hword 1
+pub const R_TILEGX_IMM16_X0_HW1_PLT_PCREL: u32 = 68;
+/// X1 pipe PC-rel PLT hword 1
+pub const R_TILEGX_IMM16_X1_HW1_PLT_PCREL: u32 = 69;
+/// X0 pipe PC-rel PLT hword 2
+pub const R_TILEGX_IMM16_X0_HW2_PLT_PCREL: u32 = 70;
+/// X1 pipe PC-rel PLT hword 2
+pub const R_TILEGX_IMM16_X1_HW2_PLT_PCREL: u32 = 71;
+/// X0 pipe last hword 0 GOT offset
+pub const R_TILEGX_IMM16_X0_HW0_LAST_GOT: u32 = 72;
+/// X1 pipe last hword 0 GOT offset
+pub const R_TILEGX_IMM16_X1_HW0_LAST_GOT: u32 = 73;
+/// X0 pipe last hword 1 GOT offset
+pub const R_TILEGX_IMM16_X0_HW1_LAST_GOT: u32 = 74;
+/// X1 pipe last hword 1 GOT offset
+pub const R_TILEGX_IMM16_X1_HW1_LAST_GOT: u32 = 75;
+/// X0 pipe PC-rel PLT hword 3
+pub const R_TILEGX_IMM16_X0_HW3_PLT_PCREL: u32 = 76;
+/// X1 pipe PC-rel PLT hword 3
+pub const R_TILEGX_IMM16_X1_HW3_PLT_PCREL: u32 = 77;
+/// X0 pipe hword 0 TLS GD offset
+pub const R_TILEGX_IMM16_X0_HW0_TLS_GD: u32 = 78;
+/// X1 pipe hword 0 TLS GD offset
+pub const R_TILEGX_IMM16_X1_HW0_TLS_GD: u32 = 79;
+/// X0 pipe hword 0 TLS LE offset
+pub const R_TILEGX_IMM16_X0_HW0_TLS_LE: u32 = 80;
+/// X1 pipe hword 0 TLS LE offset
+pub const R_TILEGX_IMM16_X1_HW0_TLS_LE: u32 = 81;
+/// X0 pipe last hword 0 LE off
+pub const R_TILEGX_IMM16_X0_HW0_LAST_TLS_LE: u32 = 82;
+/// X1 pipe last hword 0 LE off
+pub const R_TILEGX_IMM16_X1_HW0_LAST_TLS_LE: u32 = 83;
+/// X0 pipe last hword 1 LE off
+pub const R_TILEGX_IMM16_X0_HW1_LAST_TLS_LE: u32 = 84;
+/// X1 pipe last hword 1 LE off
+pub const R_TILEGX_IMM16_X1_HW1_LAST_TLS_LE: u32 = 85;
+/// X0 pipe last hword 0 GD off
+pub const R_TILEGX_IMM16_X0_HW0_LAST_TLS_GD: u32 = 86;
+/// X1 pipe last hword 0 GD off
+pub const R_TILEGX_IMM16_X1_HW0_LAST_TLS_GD: u32 = 87;
+/// X0 pipe last hword 1 GD off
+pub const R_TILEGX_IMM16_X0_HW1_LAST_TLS_GD: u32 = 88;
+/// X1 pipe last hword 1 GD off
+pub const R_TILEGX_IMM16_X1_HW1_LAST_TLS_GD: u32 = 89;
+// Relocs 90-91 are currently not defined.
+/// X0 pipe hword 0 TLS IE offset
+pub const R_TILEGX_IMM16_X0_HW0_TLS_IE: u32 = 92;
+/// X1 pipe hword 0 TLS IE offset
+pub const R_TILEGX_IMM16_X1_HW0_TLS_IE: u32 = 93;
+/// X0 pipe PC-rel PLT last hword 0
+pub const R_TILEGX_IMM16_X0_HW0_LAST_PLT_PCREL: u32 = 94;
+/// X1 pipe PC-rel PLT last hword 0
+pub const R_TILEGX_IMM16_X1_HW0_LAST_PLT_PCREL: u32 = 95;
+/// X0 pipe PC-rel PLT last hword 1
+pub const R_TILEGX_IMM16_X0_HW1_LAST_PLT_PCREL: u32 = 96;
+/// X1 pipe PC-rel PLT last hword 1
+pub const R_TILEGX_IMM16_X1_HW1_LAST_PLT_PCREL: u32 = 97;
+/// X0 pipe PC-rel PLT last hword 2
+pub const R_TILEGX_IMM16_X0_HW2_LAST_PLT_PCREL: u32 = 98;
+/// X1 pipe PC-rel PLT last hword 2
+pub const R_TILEGX_IMM16_X1_HW2_LAST_PLT_PCREL: u32 = 99;
+/// X0 pipe last hword 0 IE off
+pub const R_TILEGX_IMM16_X0_HW0_LAST_TLS_IE: u32 = 100;
+/// X1 pipe last hword 0 IE off
+pub const R_TILEGX_IMM16_X1_HW0_LAST_TLS_IE: u32 = 101;
+/// X0 pipe last hword 1 IE off
+pub const R_TILEGX_IMM16_X0_HW1_LAST_TLS_IE: u32 = 102;
+/// X1 pipe last hword 1 IE off
+pub const R_TILEGX_IMM16_X1_HW1_LAST_TLS_IE: u32 = 103;
+// Relocs 104-105 are currently not defined.
+/// 64-bit ID of symbol's module
+pub const R_TILEGX_TLS_DTPMOD64: u32 = 106;
+/// 64-bit offset in TLS block
+pub const R_TILEGX_TLS_DTPOFF64: u32 = 107;
+/// 64-bit offset in static TLS block
+pub const R_TILEGX_TLS_TPOFF64: u32 = 108;
+/// 32-bit ID of symbol's module
+pub const R_TILEGX_TLS_DTPMOD32: u32 = 109;
+/// 32-bit offset in TLS block
+pub const R_TILEGX_TLS_DTPOFF32: u32 = 110;
+/// 32-bit offset in static TLS block
+pub const R_TILEGX_TLS_TPOFF32: u32 = 111;
+/// "jal" for TLS GD
+pub const R_TILEGX_TLS_GD_CALL: u32 = 112;
+/// X0 pipe "addi" for TLS GD
+pub const R_TILEGX_IMM8_X0_TLS_GD_ADD: u32 = 113;
+/// X1 pipe "addi" for TLS GD
+pub const R_TILEGX_IMM8_X1_TLS_GD_ADD: u32 = 114;
+/// Y0 pipe "addi" for TLS GD
+pub const R_TILEGX_IMM8_Y0_TLS_GD_ADD: u32 = 115;
+/// Y1 pipe "addi" for TLS GD
+pub const R_TILEGX_IMM8_Y1_TLS_GD_ADD: u32 = 116;
+/// "ld_tls" for TLS IE
+pub const R_TILEGX_TLS_IE_LOAD: u32 = 117;
+/// X0 pipe "addi" for TLS GD/IE
+pub const R_TILEGX_IMM8_X0_TLS_ADD: u32 = 118;
+/// X1 pipe "addi" for TLS GD/IE
+pub const R_TILEGX_IMM8_X1_TLS_ADD: u32 = 119;
+/// Y0 pipe "addi" for TLS GD/IE
+pub const R_TILEGX_IMM8_Y0_TLS_ADD: u32 = 120;
+/// Y1 pipe "addi" for TLS GD/IE
+pub const R_TILEGX_IMM8_Y1_TLS_ADD: u32 = 121;
+
+/// GNU C++ vtable hierarchy
+pub const R_TILEGX_GNU_VTINHERIT: u32 = 128;
+/// GNU C++ vtable member usage
+pub const R_TILEGX_GNU_VTENTRY: u32 = 129;
+
+// RISC-V values `FileHeader*::e_flags`.
+#[allow(missing_docs)]
+pub const EF_RISCV_RVC: u32 = 0x0001;
+#[allow(missing_docs)]
+pub const EF_RISCV_FLOAT_ABI: u32 = 0x0006;
+#[allow(missing_docs)]
+pub const EF_RISCV_FLOAT_ABI_SOFT: u32 = 0x0000;
+#[allow(missing_docs)]
+pub const EF_RISCV_FLOAT_ABI_SINGLE: u32 = 0x0002;
+#[allow(missing_docs)]
+pub const EF_RISCV_FLOAT_ABI_DOUBLE: u32 = 0x0004;
+#[allow(missing_docs)]
+pub const EF_RISCV_FLOAT_ABI_QUAD: u32 = 0x0006;
+
+// RISC-V values `Rel*::r_type`.
+#[allow(missing_docs)]
+pub const R_RISCV_NONE: u32 = 0;
+#[allow(missing_docs)]
+pub const R_RISCV_32: u32 = 1;
+#[allow(missing_docs)]
+pub const R_RISCV_64: u32 = 2;
+#[allow(missing_docs)]
+pub const R_RISCV_RELATIVE: u32 = 3;
+#[allow(missing_docs)]
+pub const R_RISCV_COPY: u32 = 4;
+#[allow(missing_docs)]
+pub const R_RISCV_JUMP_SLOT: u32 = 5;
+#[allow(missing_docs)]
+pub const R_RISCV_TLS_DTPMOD32: u32 = 6;
+#[allow(missing_docs)]
+pub const R_RISCV_TLS_DTPMOD64: u32 = 7;
+#[allow(missing_docs)]
+pub const R_RISCV_TLS_DTPREL32: u32 = 8;
+#[allow(missing_docs)]
+pub const R_RISCV_TLS_DTPREL64: u32 = 9;
+#[allow(missing_docs)]
+pub const R_RISCV_TLS_TPREL32: u32 = 10;
+#[allow(missing_docs)]
+pub const R_RISCV_TLS_TPREL64: u32 = 11;
+#[allow(missing_docs)]
+pub const R_RISCV_BRANCH: u32 = 16;
+#[allow(missing_docs)]
+pub const R_RISCV_JAL: u32 = 17;
+#[allow(missing_docs)]
+pub const R_RISCV_CALL: u32 = 18;
+#[allow(missing_docs)]
+pub const R_RISCV_CALL_PLT: u32 = 19;
+#[allow(missing_docs)]
+pub const R_RISCV_GOT_HI20: u32 = 20;
+#[allow(missing_docs)]
+pub const R_RISCV_TLS_GOT_HI20: u32 = 21;
+#[allow(missing_docs)]
+pub const R_RISCV_TLS_GD_HI20: u32 = 22;
+#[allow(missing_docs)]
+pub const R_RISCV_PCREL_HI20: u32 = 23;
+#[allow(missing_docs)]
+pub const R_RISCV_PCREL_LO12_I: u32 = 24;
+#[allow(missing_docs)]
+pub const R_RISCV_PCREL_LO12_S: u32 = 25;
+#[allow(missing_docs)]
+pub const R_RISCV_HI20: u32 = 26;
+#[allow(missing_docs)]
+pub const R_RISCV_LO12_I: u32 = 27;
+#[allow(missing_docs)]
+pub const R_RISCV_LO12_S: u32 = 28;
+#[allow(missing_docs)]
+pub const R_RISCV_TPREL_HI20: u32 = 29;
+#[allow(missing_docs)]
+pub const R_RISCV_TPREL_LO12_I: u32 = 30;
+#[allow(missing_docs)]
+pub const R_RISCV_TPREL_LO12_S: u32 = 31;
+#[allow(missing_docs)]
+pub const R_RISCV_TPREL_ADD: u32 = 32;
+#[allow(missing_docs)]
+pub const R_RISCV_ADD8: u32 = 33;
+#[allow(missing_docs)]
+pub const R_RISCV_ADD16: u32 = 34;
+#[allow(missing_docs)]
+pub const R_RISCV_ADD32: u32 = 35;
+#[allow(missing_docs)]
+pub const R_RISCV_ADD64: u32 = 36;
+#[allow(missing_docs)]
+pub const R_RISCV_SUB8: u32 = 37;
+#[allow(missing_docs)]
+pub const R_RISCV_SUB16: u32 = 38;
+#[allow(missing_docs)]
+pub const R_RISCV_SUB32: u32 = 39;
+#[allow(missing_docs)]
+pub const R_RISCV_SUB64: u32 = 40;
+#[allow(missing_docs)]
+pub const R_RISCV_GNU_VTINHERIT: u32 = 41;
+#[allow(missing_docs)]
+pub const R_RISCV_GNU_VTENTRY: u32 = 42;
+#[allow(missing_docs)]
+pub const R_RISCV_ALIGN: u32 = 43;
+#[allow(missing_docs)]
+pub const R_RISCV_RVC_BRANCH: u32 = 44;
+#[allow(missing_docs)]
+pub const R_RISCV_RVC_JUMP: u32 = 45;
+#[allow(missing_docs)]
+pub const R_RISCV_RVC_LUI: u32 = 46;
+#[allow(missing_docs)]
+pub const R_RISCV_GPREL_I: u32 = 47;
+#[allow(missing_docs)]
+pub const R_RISCV_GPREL_S: u32 = 48;
+#[allow(missing_docs)]
+pub const R_RISCV_TPREL_I: u32 = 49;
+#[allow(missing_docs)]
+pub const R_RISCV_TPREL_S: u32 = 50;
+#[allow(missing_docs)]
+pub const R_RISCV_RELAX: u32 = 51;
+#[allow(missing_docs)]
+pub const R_RISCV_SUB6: u32 = 52;
+#[allow(missing_docs)]
+pub const R_RISCV_SET6: u32 = 53;
+#[allow(missing_docs)]
+pub const R_RISCV_SET8: u32 = 54;
+#[allow(missing_docs)]
+pub const R_RISCV_SET16: u32 = 55;
+#[allow(missing_docs)]
+pub const R_RISCV_SET32: u32 = 56;
+#[allow(missing_docs)]
+pub const R_RISCV_32_PCREL: u32 = 57;
+
+// BPF values `Rel*::r_type`.
+/// No reloc
+pub const R_BPF_NONE: u32 = 0;
+#[allow(missing_docs)]
+pub const R_BPF_64_64: u32 = 1;
+#[allow(missing_docs)]
+pub const R_BPF_64_32: u32 = 10;
+
+// Imagination Meta values `Rel*::r_type`.
+
+#[allow(missing_docs)]
+pub const R_METAG_HIADDR16: u32 = 0;
+#[allow(missing_docs)]
+pub const R_METAG_LOADDR16: u32 = 1;
+/// 32bit absolute address
+pub const R_METAG_ADDR32: u32 = 2;
+/// No reloc
+pub const R_METAG_NONE: u32 = 3;
+#[allow(missing_docs)]
+pub const R_METAG_RELBRANCH: u32 = 4;
+#[allow(missing_docs)]
+pub const R_METAG_GETSETOFF: u32 = 5;
+
+// Backward compatability
+#[allow(missing_docs)]
+pub const R_METAG_REG32OP1: u32 = 6;
+#[allow(missing_docs)]
+pub const R_METAG_REG32OP2: u32 = 7;
+#[allow(missing_docs)]
+pub const R_METAG_REG32OP3: u32 = 8;
+#[allow(missing_docs)]
+pub const R_METAG_REG16OP1: u32 = 9;
+#[allow(missing_docs)]
+pub const R_METAG_REG16OP2: u32 = 10;
+#[allow(missing_docs)]
+pub const R_METAG_REG16OP3: u32 = 11;
+#[allow(missing_docs)]
+pub const R_METAG_REG32OP4: u32 = 12;
+
+#[allow(missing_docs)]
+pub const R_METAG_HIOG: u32 = 13;
+#[allow(missing_docs)]
+pub const R_METAG_LOOG: u32 = 14;
+
+#[allow(missing_docs)]
+pub const R_METAG_REL8: u32 = 15;
+#[allow(missing_docs)]
+pub const R_METAG_REL16: u32 = 16;
+
+#[allow(missing_docs)]
+pub const R_METAG_GNU_VTINHERIT: u32 = 30;
+#[allow(missing_docs)]
+pub const R_METAG_GNU_VTENTRY: u32 = 31;
+
+// PIC relocations
+#[allow(missing_docs)]
+pub const R_METAG_HI16_GOTOFF: u32 = 32;
+#[allow(missing_docs)]
+pub const R_METAG_LO16_GOTOFF: u32 = 33;
+#[allow(missing_docs)]
+pub const R_METAG_GETSET_GOTOFF: u32 = 34;
+#[allow(missing_docs)]
+pub const R_METAG_GETSET_GOT: u32 = 35;
+#[allow(missing_docs)]
+pub const R_METAG_HI16_GOTPC: u32 = 36;
+#[allow(missing_docs)]
+pub const R_METAG_LO16_GOTPC: u32 = 37;
+#[allow(missing_docs)]
+pub const R_METAG_HI16_PLT: u32 = 38;
+#[allow(missing_docs)]
+pub const R_METAG_LO16_PLT: u32 = 39;
+#[allow(missing_docs)]
+pub const R_METAG_RELBRANCH_PLT: u32 = 40;
+#[allow(missing_docs)]
+pub const R_METAG_GOTOFF: u32 = 41;
+#[allow(missing_docs)]
+pub const R_METAG_PLT: u32 = 42;
+#[allow(missing_docs)]
+pub const R_METAG_COPY: u32 = 43;
+#[allow(missing_docs)]
+pub const R_METAG_JMP_SLOT: u32 = 44;
+#[allow(missing_docs)]
+pub const R_METAG_RELATIVE: u32 = 45;
+#[allow(missing_docs)]
+pub const R_METAG_GLOB_DAT: u32 = 46;
+
+// TLS relocations
+#[allow(missing_docs)]
+pub const R_METAG_TLS_GD: u32 = 47;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_LDM: u32 = 48;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_LDO_HI16: u32 = 49;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_LDO_LO16: u32 = 50;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_LDO: u32 = 51;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_IE: u32 = 52;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_IENONPIC: u32 = 53;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_IENONPIC_HI16: u32 = 54;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_IENONPIC_LO16: u32 = 55;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_TPOFF: u32 = 56;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_DTPMOD: u32 = 57;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_DTPOFF: u32 = 58;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_LE: u32 = 59;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_LE_HI16: u32 = 60;
+#[allow(missing_docs)]
+pub const R_METAG_TLS_LE_LO16: u32 = 61;
+
+// NDS32 values `Rel*::r_type`.
+#[allow(missing_docs)]
+pub const R_NDS32_NONE: u32 = 0;
+#[allow(missing_docs)]
+pub const R_NDS32_32_RELA: u32 = 20;
+#[allow(missing_docs)]
+pub const R_NDS32_COPY: u32 = 39;
+#[allow(missing_docs)]
+pub const R_NDS32_GLOB_DAT: u32 = 40;
+#[allow(missing_docs)]
+pub const R_NDS32_JMP_SLOT: u32 = 41;
+#[allow(missing_docs)]
+pub const R_NDS32_RELATIVE: u32 = 42;
+#[allow(missing_docs)]
+pub const R_NDS32_TLS_TPOFF: u32 = 102;
+#[allow(missing_docs)]
+pub const R_NDS32_TLS_DESC: u32 = 119;
+
+unsafe_impl_endian_pod!(
+ FileHeader32,
+ FileHeader64,
+ SectionHeader32,
+ SectionHeader64,
+ CompressionHeader32,
+ CompressionHeader64,
+ Sym32,
+ Sym64,
+ Syminfo32,
+ Syminfo64,
+ Rel32,
+ Rel64,
+ Rela32,
+ Rela64,
+ ProgramHeader32,
+ ProgramHeader64,
+ Dyn32,
+ Dyn64,
+ Versym,
+ Verdef,
+ Verdaux,
+ Verneed,
+ Vernaux,
+ NoteHeader32,
+ NoteHeader64,
+ HashHeader,
+ GnuHashHeader,
+);
diff --git a/vendor/object-0.26.2/src/endian.rs b/vendor/object-0.26.2/src/endian.rs
new file mode 100644
index 000000000..1287aa654
--- /dev/null
+++ b/vendor/object-0.26.2/src/endian.rs
@@ -0,0 +1,771 @@
+//! Types for compile-time and run-time endianness.
+
+use crate::pod::Pod;
+use core::fmt::{self, Debug};
+use core::marker::PhantomData;
+
+/// A trait for using an endianness specification.
+///
+/// Provides methods for converting between the specified endianness and
+/// the native endianness of the target machine.
+///
+/// This trait does not require that the endianness is known at compile time.
+pub trait Endian: Debug + Default + Clone + Copy + PartialEq + Eq + 'static {
+ /// Construct a specification for the endianness of some values.
+ ///
+ /// Returns `None` if the type does not support specifying the given endianness.
+ fn from_big_endian(big_endian: bool) -> Option<Self>;
+
+ /// Construct a specification for the endianness of some values.
+ ///
+ /// Returns `None` if the type does not support specifying the given endianness.
+ fn from_little_endian(little_endian: bool) -> Option<Self> {
+ Self::from_big_endian(!little_endian)
+ }
+
+ /// Return true for big endian byte order.
+ fn is_big_endian(self) -> bool;
+
+ /// Return true for little endian byte order.
+ #[inline]
+ fn is_little_endian(self) -> bool {
+ !self.is_big_endian()
+ }
+
+ /// Converts an unsigned 16 bit integer to native endian.
+ #[inline]
+ fn read_u16(self, n: u16) -> u16 {
+ if self.is_big_endian() {
+ u16::from_be(n)
+ } else {
+ u16::from_le(n)
+ }
+ }
+
+ /// Converts an unsigned 32 bit integer to native endian.
+ #[inline]
+ fn read_u32(self, n: u32) -> u32 {
+ if self.is_big_endian() {
+ u32::from_be(n)
+ } else {
+ u32::from_le(n)
+ }
+ }
+
+ /// Converts an unsigned 64 bit integer to native endian.
+ #[inline]
+ fn read_u64(self, n: u64) -> u64 {
+ if self.is_big_endian() {
+ u64::from_be(n)
+ } else {
+ u64::from_le(n)
+ }
+ }
+
+ /// Converts a signed 16 bit integer to native endian.
+ #[inline]
+ fn read_i16(self, n: i16) -> i16 {
+ if self.is_big_endian() {
+ i16::from_be(n)
+ } else {
+ i16::from_le(n)
+ }
+ }
+
+ /// Converts a signed 32 bit integer to native endian.
+ #[inline]
+ fn read_i32(self, n: i32) -> i32 {
+ if self.is_big_endian() {
+ i32::from_be(n)
+ } else {
+ i32::from_le(n)
+ }
+ }
+
+ /// Converts a signed 64 bit integer to native endian.
+ #[inline]
+ fn read_i64(self, n: i64) -> i64 {
+ if self.is_big_endian() {
+ i64::from_be(n)
+ } else {
+ i64::from_le(n)
+ }
+ }
+
+ /// Converts an unaligned unsigned 16 bit integer to native endian.
+ #[inline]
+ fn read_u16_bytes(self, n: [u8; 2]) -> u16 {
+ if self.is_big_endian() {
+ u16::from_be_bytes(n)
+ } else {
+ u16::from_le_bytes(n)
+ }
+ }
+
+ /// Converts an unaligned unsigned 32 bit integer to native endian.
+ #[inline]
+ fn read_u32_bytes(self, n: [u8; 4]) -> u32 {
+ if self.is_big_endian() {
+ u32::from_be_bytes(n)
+ } else {
+ u32::from_le_bytes(n)
+ }
+ }
+
+ /// Converts an unaligned unsigned 64 bit integer to native endian.
+ #[inline]
+ fn read_u64_bytes(self, n: [u8; 8]) -> u64 {
+ if self.is_big_endian() {
+ u64::from_be_bytes(n)
+ } else {
+ u64::from_le_bytes(n)
+ }
+ }
+
+ /// Converts an unaligned signed 16 bit integer to native endian.
+ #[inline]
+ fn read_i16_bytes(self, n: [u8; 2]) -> i16 {
+ if self.is_big_endian() {
+ i16::from_be_bytes(n)
+ } else {
+ i16::from_le_bytes(n)
+ }
+ }
+
+ /// Converts an unaligned signed 32 bit integer to native endian.
+ #[inline]
+ fn read_i32_bytes(self, n: [u8; 4]) -> i32 {
+ if self.is_big_endian() {
+ i32::from_be_bytes(n)
+ } else {
+ i32::from_le_bytes(n)
+ }
+ }
+
+ /// Converts an unaligned signed 64 bit integer to native endian.
+ #[inline]
+ fn read_i64_bytes(self, n: [u8; 8]) -> i64 {
+ if self.is_big_endian() {
+ i64::from_be_bytes(n)
+ } else {
+ i64::from_le_bytes(n)
+ }
+ }
+
+ /// Converts an unsigned 16 bit integer from native endian.
+ #[inline]
+ fn write_u16(self, n: u16) -> u16 {
+ if self.is_big_endian() {
+ u16::to_be(n)
+ } else {
+ u16::to_le(n)
+ }
+ }
+
+ /// Converts an unsigned 32 bit integer from native endian.
+ #[inline]
+ fn write_u32(self, n: u32) -> u32 {
+ if self.is_big_endian() {
+ u32::to_be(n)
+ } else {
+ u32::to_le(n)
+ }
+ }
+
+ /// Converts an unsigned 64 bit integer from native endian.
+ #[inline]
+ fn write_u64(self, n: u64) -> u64 {
+ if self.is_big_endian() {
+ u64::to_be(n)
+ } else {
+ u64::to_le(n)
+ }
+ }
+
+ /// Converts a signed 16 bit integer from native endian.
+ #[inline]
+ fn write_i16(self, n: i16) -> i16 {
+ if self.is_big_endian() {
+ i16::to_be(n)
+ } else {
+ i16::to_le(n)
+ }
+ }
+
+ /// Converts a signed 32 bit integer from native endian.
+ #[inline]
+ fn write_i32(self, n: i32) -> i32 {
+ if self.is_big_endian() {
+ i32::to_be(n)
+ } else {
+ i32::to_le(n)
+ }
+ }
+
+ /// Converts a signed 64 bit integer from native endian.
+ #[inline]
+ fn write_i64(self, n: i64) -> i64 {
+ if self.is_big_endian() {
+ i64::to_be(n)
+ } else {
+ i64::to_le(n)
+ }
+ }
+
+ /// Converts an unaligned unsigned 16 bit integer from native endian.
+ #[inline]
+ fn write_u16_bytes(self, n: u16) -> [u8; 2] {
+ if self.is_big_endian() {
+ u16::to_be_bytes(n)
+ } else {
+ u16::to_le_bytes(n)
+ }
+ }
+
+ /// Converts an unaligned unsigned 32 bit integer from native endian.
+ #[inline]
+ fn write_u32_bytes(self, n: u32) -> [u8; 4] {
+ if self.is_big_endian() {
+ u32::to_be_bytes(n)
+ } else {
+ u32::to_le_bytes(n)
+ }
+ }
+
+ /// Converts an unaligned unsigned 64 bit integer from native endian.
+ #[inline]
+ fn write_u64_bytes(self, n: u64) -> [u8; 8] {
+ if self.is_big_endian() {
+ u64::to_be_bytes(n)
+ } else {
+ u64::to_le_bytes(n)
+ }
+ }
+
+ /// Converts an unaligned signed 16 bit integer from native endian.
+ #[inline]
+ fn write_i16_bytes(self, n: i16) -> [u8; 2] {
+ if self.is_big_endian() {
+ i16::to_be_bytes(n)
+ } else {
+ i16::to_le_bytes(n)
+ }
+ }
+
+ /// Converts an unaligned signed 32 bit integer from native endian.
+ #[inline]
+ fn write_i32_bytes(self, n: i32) -> [u8; 4] {
+ if self.is_big_endian() {
+ i32::to_be_bytes(n)
+ } else {
+ i32::to_le_bytes(n)
+ }
+ }
+
+ /// Converts an unaligned signed 64 bit integer from native endian.
+ #[inline]
+ fn write_i64_bytes(self, n: i64) -> [u8; 8] {
+ if self.is_big_endian() {
+ i64::to_be_bytes(n)
+ } else {
+ i64::to_le_bytes(n)
+ }
+ }
+}
+
+/// An endianness that is selectable at run-time.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum Endianness {
+ /// Little endian byte order.
+ Little,
+ /// Big endian byte order.
+ Big,
+}
+
+impl Default for Endianness {
+ #[cfg(target_endian = "little")]
+ #[inline]
+ fn default() -> Endianness {
+ Endianness::Little
+ }
+
+ #[cfg(target_endian = "big")]
+ #[inline]
+ fn default() -> Endianness {
+ Endianness::Big
+ }
+}
+
+impl Endian for Endianness {
+ #[inline]
+ fn from_big_endian(big_endian: bool) -> Option<Self> {
+ Some(if big_endian {
+ Endianness::Big
+ } else {
+ Endianness::Little
+ })
+ }
+
+ #[inline]
+ fn is_big_endian(self) -> bool {
+ self != Endianness::Little
+ }
+}
+
+/// Compile-time little endian byte order.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct LittleEndian;
+
+impl Default for LittleEndian {
+ #[inline]
+ fn default() -> LittleEndian {
+ LittleEndian
+ }
+}
+
+impl Endian for LittleEndian {
+ #[inline]
+ fn from_big_endian(big_endian: bool) -> Option<Self> {
+ if big_endian {
+ None
+ } else {
+ Some(LittleEndian)
+ }
+ }
+
+ #[inline]
+ fn is_big_endian(self) -> bool {
+ false
+ }
+}
+
+/// Compile-time big endian byte order.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct BigEndian;
+
+impl Default for BigEndian {
+ #[inline]
+ fn default() -> BigEndian {
+ BigEndian
+ }
+}
+
+impl Endian for BigEndian {
+ #[inline]
+ fn from_big_endian(big_endian: bool) -> Option<Self> {
+ if big_endian {
+ Some(BigEndian)
+ } else {
+ None
+ }
+ }
+
+ #[inline]
+ fn is_big_endian(self) -> bool {
+ true
+ }
+}
+
+/// The native endianness for the target platform.
+#[cfg(target_endian = "little")]
+pub type NativeEndian = LittleEndian;
+
+#[cfg(target_endian = "little")]
+#[allow(non_upper_case_globals)]
+#[doc(hidden)]
+pub const NativeEndian: LittleEndian = LittleEndian;
+
+/// The native endianness for the target platform.
+#[cfg(target_endian = "big")]
+pub type NativeEndian = BigEndian;
+
+#[cfg(target_endian = "big")]
+#[allow(non_upper_case_globals)]
+#[doc(hidden)]
+pub const NativeEndian: BigEndian = BigEndian;
+
+macro_rules! unsafe_impl_endian_pod {
+ ($($struct_name:ident),+ $(,)?) => {
+ $(
+ unsafe impl<E: Endian> Pod for $struct_name<E> { }
+ )+
+ }
+}
+
+#[cfg(not(feature = "unaligned"))]
+mod aligned {
+ use super::{fmt, Endian, PhantomData, Pod};
+
+ /// A `u16` value with an externally specified endianness of type `E`.
+ #[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+ #[repr(transparent)]
+ pub struct U16<E: Endian>(u16, PhantomData<E>);
+
+ impl<E: Endian> U16<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: u16) -> Self {
+ Self(e.write_u16(n), PhantomData)
+ }
+
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> u16 {
+ e.read_u16(self.0)
+ }
+
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: u16) {
+ self.0 = e.write_u16(n);
+ }
+ }
+
+ /// A `u32` value with an externally specified endianness of type `E`.
+ #[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+ #[repr(transparent)]
+ pub struct U32<E: Endian>(u32, PhantomData<E>);
+
+ impl<E: Endian> U32<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: u32) -> Self {
+ Self(e.write_u32(n), PhantomData)
+ }
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> u32 {
+ e.read_u32(self.0)
+ }
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: u32) {
+ self.0 = e.write_u32(n);
+ }
+ }
+
+ /// A `u64` value with an externally specified endianness of type `E`.
+ #[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+ #[repr(transparent)]
+ pub struct U64<E: Endian>(u64, PhantomData<E>);
+
+ impl<E: Endian> U64<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: u64) -> Self {
+ Self(e.write_u64(n), PhantomData)
+ }
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> u64 {
+ e.read_u64(self.0)
+ }
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: u64) {
+ self.0 = e.write_u64(n);
+ }
+ }
+
+ /// An `i16` value with an externally specified endianness of type `E`.
+ #[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+ #[repr(transparent)]
+ pub struct I16<E: Endian>(i16, PhantomData<E>);
+
+ impl<E: Endian> I16<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: i16) -> Self {
+ Self(e.write_i16(n), PhantomData)
+ }
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> i16 {
+ e.read_i16(self.0)
+ }
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: i16) {
+ self.0 = e.write_i16(n);
+ }
+ }
+
+ /// An `i32` value with an externally specified endianness of type `E`.
+ #[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+ #[repr(transparent)]
+ pub struct I32<E: Endian>(i32, PhantomData<E>);
+
+ impl<E: Endian> I32<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: i32) -> Self {
+ Self(e.write_i32(n), PhantomData)
+ }
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> i32 {
+ e.read_i32(self.0)
+ }
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: i32) {
+ self.0 = e.write_i32(n);
+ }
+ }
+
+ /// An `i64` value with an externally specified endianness of type `E`.
+ #[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+ #[repr(transparent)]
+ pub struct I64<E: Endian>(i64, PhantomData<E>);
+
+ impl<E: Endian> I64<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: i64) -> Self {
+ Self(e.write_i64(n), PhantomData)
+ }
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> i64 {
+ e.read_i64(self.0)
+ }
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: i64) {
+ self.0 = e.write_i64(n);
+ }
+ }
+
+ impl<E: Endian> fmt::Debug for U16<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "U16({:x})", self.0)
+ }
+ }
+
+ impl<E: Endian> fmt::Debug for U32<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "U32({:x})", self.0)
+ }
+ }
+
+ impl<E: Endian> fmt::Debug for U64<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "U64({:x})", self.0)
+ }
+ }
+
+ impl<E: Endian> fmt::Debug for I16<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "I16({:x})", self.0)
+ }
+ }
+
+ impl<E: Endian> fmt::Debug for I32<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "I32({:x})", self.0)
+ }
+ }
+
+ impl<E: Endian> fmt::Debug for I64<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "I64({:x})", self.0)
+ }
+ }
+
+ unsafe_impl_endian_pod!(U16, U32, U64, I16, I32, I64);
+}
+
+#[cfg(not(feature = "unaligned"))]
+pub use aligned::*;
+
+/// A `u16` value with an externally specified endianness of type `E`.
+#[cfg(feature = "unaligned")]
+pub type U16<E> = U16Bytes<E>;
+
+/// A `u32` value with an externally specified endianness of type `E`.
+#[cfg(feature = "unaligned")]
+pub type U32<E> = U32Bytes<E>;
+
+/// A `u64` value with an externally specified endianness of type `E`.
+#[cfg(feature = "unaligned")]
+pub type U64<E> = U64Bytes<E>;
+
+/// An `i16` value with an externally specified endianness of type `E`.
+#[cfg(feature = "unaligned")]
+pub type I16<E> = I16Bytes<E>;
+
+/// An `i32` value with an externally specified endianness of type `E`.
+#[cfg(feature = "unaligned")]
+pub type I32<E> = I32Bytes<E>;
+
+/// An `i64` value with an externally specified endianness of type `E`.
+#[cfg(feature = "unaligned")]
+pub type I64<E> = I64Bytes<E>;
+
+/// An unaligned `u16` value with an externally specified endianness of type `E`.
+#[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct U16Bytes<E: Endian>([u8; 2], PhantomData<E>);
+
+impl<E: Endian> U16Bytes<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: u16) -> Self {
+ Self(e.write_u16_bytes(n), PhantomData)
+ }
+
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> u16 {
+ e.read_u16_bytes(self.0)
+ }
+
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: u16) {
+ self.0 = e.write_u16_bytes(n);
+ }
+}
+
+/// An unaligned `u32` value with an externally specified endianness of type `E`.
+#[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct U32Bytes<E: Endian>([u8; 4], PhantomData<E>);
+
+impl<E: Endian> U32Bytes<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: u32) -> Self {
+ Self(e.write_u32_bytes(n), PhantomData)
+ }
+
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> u32 {
+ e.read_u32_bytes(self.0)
+ }
+
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: u32) {
+ self.0 = e.write_u32_bytes(n);
+ }
+}
+
+/// An unaligned `u64` value with an externally specified endianness of type `E`.
+#[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct U64Bytes<E: Endian>([u8; 8], PhantomData<E>);
+
+impl<E: Endian> U64Bytes<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: u64) -> Self {
+ Self(e.write_u64_bytes(n), PhantomData)
+ }
+
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> u64 {
+ e.read_u64_bytes(self.0)
+ }
+
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: u64) {
+ self.0 = e.write_u64_bytes(n);
+ }
+}
+
+/// An unaligned `i16` value with an externally specified endianness of type `E`.
+#[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct I16Bytes<E: Endian>([u8; 2], PhantomData<E>);
+
+impl<E: Endian> I16Bytes<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: i16) -> Self {
+ Self(e.write_i16_bytes(n), PhantomData)
+ }
+
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> i16 {
+ e.read_i16_bytes(self.0)
+ }
+
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: i16) {
+ self.0 = e.write_i16_bytes(n);
+ }
+}
+
+/// An unaligned `i32` value with an externally specified endianness of type `E`.
+#[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct I32Bytes<E: Endian>([u8; 4], PhantomData<E>);
+
+impl<E: Endian> I32Bytes<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: i32) -> Self {
+ Self(e.write_i32_bytes(n), PhantomData)
+ }
+
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> i32 {
+ e.read_i32_bytes(self.0)
+ }
+
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: i32) {
+ self.0 = e.write_i32_bytes(n);
+ }
+}
+
+/// An unaligned `i64` value with an externally specified endianness of type `E`.
+#[derive(Default, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[repr(transparent)]
+pub struct I64Bytes<E: Endian>([u8; 8], PhantomData<E>);
+
+impl<E: Endian> I64Bytes<E> {
+ /// Construct a new value given a native endian value.
+ pub fn new(e: E, n: i64) -> Self {
+ Self(e.write_i64_bytes(n), PhantomData)
+ }
+
+ /// Return the value as a native endian value.
+ pub fn get(self, e: E) -> i64 {
+ e.read_i64_bytes(self.0)
+ }
+
+ /// Set the value given a native endian value.
+ pub fn set(&mut self, e: E, n: i64) {
+ self.0 = e.write_i64_bytes(n);
+ }
+}
+
+impl<E: Endian> fmt::Debug for U16Bytes<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "U16({:x}, {:x})", self.0[0], self.0[1],)
+ }
+}
+
+impl<E: Endian> fmt::Debug for U32Bytes<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "U32({:x}, {:x}, {:x}, {:x})",
+ self.0[0], self.0[1], self.0[2], self.0[3],
+ )
+ }
+}
+
+impl<E: Endian> fmt::Debug for U64Bytes<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "U64({:x}, {:x}, {:x}, {:x}, {:x}, {:x}, {:x}, {:x})",
+ self.0[0], self.0[1], self.0[2], self.0[3], self.0[4], self.0[5], self.0[6], self.0[7],
+ )
+ }
+}
+
+impl<E: Endian> fmt::Debug for I16Bytes<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(f, "I16({:x}, {:x})", self.0[0], self.0[1],)
+ }
+}
+
+impl<E: Endian> fmt::Debug for I32Bytes<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "I32({:x}, {:x}, {:x}, {:x})",
+ self.0[0], self.0[1], self.0[2], self.0[3],
+ )
+ }
+}
+
+impl<E: Endian> fmt::Debug for I64Bytes<E> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(
+ f,
+ "I64({:x}, {:x}, {:x}, {:x}, {:x}, {:x}, {:x}, {:x})",
+ self.0[0], self.0[1], self.0[2], self.0[3], self.0[4], self.0[5], self.0[6], self.0[7],
+ )
+ }
+}
+
+unsafe_impl_endian_pod!(U16Bytes, U32Bytes, U64Bytes, I16Bytes, I32Bytes, I64Bytes);
diff --git a/vendor/object-0.26.2/src/lib.rs b/vendor/object-0.26.2/src/lib.rs
new file mode 100644
index 000000000..e62ad5ce5
--- /dev/null
+++ b/vendor/object-0.26.2/src/lib.rs
@@ -0,0 +1,103 @@
+//! # `object`
+//!
+//! The `object` crate provides a unified interface to working with object files
+//! across platforms. It supports reading object files and executable files,
+//! and writing object files.
+//!
+//! ## Raw struct definitions
+//!
+//! Raw structs are defined for: [ELF](elf), [Mach-O](macho), [PE/COFF](pe), [archive].
+//! Types and traits for zerocopy support are defined in [pod] and [endian].
+//!
+//! ## Unified read API
+//!
+//! The [read::Object] trait defines the unified interace. This trait is implemented
+//! by [read::File], which allows reading any file format, as well as implementations
+//! for each file format: [ELF](read::elf::ElfFile), [Mach-O](read::macho::MachOFile),
+//! [COFF](read::coff::CoffFile), [PE](read::pe::PeFile), [Wasm](read::wasm::WasmFile).
+//!
+//! ## Low level read API
+//!
+//! In addition to the unified read API, the various `read` modules define helpers that
+//! operate on the raw structs. These also provide traits that abstract over the differences
+//! between 32-bit and 64-bit versions of the file format.
+//!
+//! ## Unified write API
+//!
+//! [write::Object] allows building an object and then writing it out.
+//!
+//! ## Example for unified read API
+//! ```no_run
+//! use object::{Object, ObjectSection};
+//! use std::error::Error;
+//! use std::fs;
+//!
+//! /// Reads a file and displays the content of the ".boot" section.
+//! fn main() -> Result<(), Box<dyn Error>> {
+//! let bin_data = fs::read("./multiboot2-binary.elf")?;
+//! let obj_file = object::File::parse(&*bin_data)?;
+//! if let Some(section) = obj_file.section_by_name(".boot") {
+//! println!("{:#x?}", section.data()?);
+//! } else {
+//! eprintln!("section not available");
+//! }
+//! Ok(())
+//! }
+//! ```
+
+#![deny(missing_docs)]
+#![deny(missing_debug_implementations)]
+#![no_std]
+// Style.
+#![allow(clippy::collapsible_if)]
+#![allow(clippy::comparison_chain)]
+#![allow(clippy::match_like_matches_macro)]
+#![allow(clippy::single_match)]
+#![allow(clippy::type_complexity)]
+// Occurs due to fallible iteration.
+#![allow(clippy::should_implement_trait)]
+// Unit errors are converted to other types by callers.
+#![allow(clippy::result_unit_err)]
+// Clippy is wrong.
+#![allow(clippy::transmute_ptr_to_ptr)]
+
+#[cfg(feature = "cargo-all")]
+compile_error!("'--all-features' is not supported; use '--features all' instead");
+
+#[cfg(feature = "read_core")]
+#[allow(unused_imports)]
+#[macro_use]
+extern crate alloc;
+
+#[cfg(feature = "std")]
+#[allow(unused_imports)]
+#[macro_use]
+extern crate std;
+
+mod common;
+pub use common::*;
+
+#[macro_use]
+pub mod endian;
+pub use endian::*;
+
+#[macro_use]
+pub mod pod;
+pub use pod::*;
+
+#[cfg(feature = "read_core")]
+pub mod read;
+#[cfg(feature = "read_core")]
+pub use read::*;
+
+#[cfg(feature = "write_core")]
+pub mod write;
+
+#[cfg(feature = "archive")]
+pub mod archive;
+#[cfg(feature = "elf")]
+pub mod elf;
+#[cfg(feature = "macho")]
+pub mod macho;
+#[cfg(any(feature = "coff", feature = "pe"))]
+pub mod pe;
diff --git a/vendor/object-0.26.2/src/macho.rs b/vendor/object-0.26.2/src/macho.rs
new file mode 100644
index 000000000..9d81f7d61
--- /dev/null
+++ b/vendor/object-0.26.2/src/macho.rs
@@ -0,0 +1,3254 @@
+//! Mach-O definitions.
+//!
+//! These definitions are independent of read/write support, although we do implement
+//! some traits useful for those.
+//!
+//! This module is based heavily on header files from MacOSX11.1.sdk.
+
+#![allow(missing_docs)]
+
+use crate::endian::{BigEndian, Endian, U64Bytes, U16, U32, U64};
+use crate::pod::Pod;
+
+// Definitions from "/usr/include/mach/machine.h".
+
+/*
+ * Capability bits used in the definition of cpu_type.
+ */
+
+/// mask for architecture bits
+pub const CPU_ARCH_MASK: u32 = 0xff00_0000;
+/// 64 bit ABI
+pub const CPU_ARCH_ABI64: u32 = 0x0100_0000;
+/// ABI for 64-bit hardware with 32-bit types; LP32
+pub const CPU_ARCH_ABI64_32: u32 = 0x0200_0000;
+
+/*
+ * Machine types known by all.
+ */
+
+pub const CPU_TYPE_ANY: u32 = !0;
+
+pub const CPU_TYPE_VAX: u32 = 1;
+pub const CPU_TYPE_MC680X0: u32 = 6;
+pub const CPU_TYPE_X86: u32 = 7;
+pub const CPU_TYPE_X86_64: u32 = CPU_TYPE_X86 | CPU_ARCH_ABI64;
+pub const CPU_TYPE_MIPS: u32 = 8;
+pub const CPU_TYPE_MC98000: u32 = 10;
+pub const CPU_TYPE_HPPA: u32 = 11;
+pub const CPU_TYPE_ARM: u32 = 12;
+pub const CPU_TYPE_ARM64: u32 = CPU_TYPE_ARM | CPU_ARCH_ABI64;
+pub const CPU_TYPE_ARM64_32: u32 = CPU_TYPE_ARM | CPU_ARCH_ABI64_32;
+pub const CPU_TYPE_MC88000: u32 = 13;
+pub const CPU_TYPE_SPARC: u32 = 14;
+pub const CPU_TYPE_I860: u32 = 15;
+pub const CPU_TYPE_ALPHA: u32 = 16;
+pub const CPU_TYPE_POWERPC: u32 = 18;
+pub const CPU_TYPE_POWERPC64: u32 = CPU_TYPE_POWERPC | CPU_ARCH_ABI64;
+
+/*
+ * Capability bits used in the definition of cpu_subtype.
+ */
+/// mask for feature flags
+pub const CPU_SUBTYPE_MASK: u32 = 0xff00_0000;
+/// 64 bit libraries
+pub const CPU_SUBTYPE_LIB64: u32 = 0x8000_0000;
+/// pointer authentication with versioned ABI
+pub const CPU_SUBTYPE_PTRAUTH_ABI: u32 = 0x8000_0000;
+
+/// When selecting a slice, ANY will pick the slice with the best
+/// grading for the selected cpu_type_t, unlike the "ALL" subtypes,
+/// which are the slices that can run on any hardware for that cpu type.
+pub const CPU_SUBTYPE_ANY: u32 = !0;
+
+/*
+ * Object files that are hand-crafted to run on any
+ * implementation of an architecture are tagged with
+ * CPU_SUBTYPE_MULTIPLE. This functions essentially the same as
+ * the "ALL" subtype of an architecture except that it allows us
+ * to easily find object files that may need to be modified
+ * whenever a new implementation of an architecture comes out.
+ *
+ * It is the responsibility of the implementor to make sure the
+ * software handles unsupported implementations elegantly.
+ */
+pub const CPU_SUBTYPE_MULTIPLE: u32 = !0;
+pub const CPU_SUBTYPE_LITTLE_ENDIAN: u32 = 0;
+pub const CPU_SUBTYPE_BIG_ENDIAN: u32 = 1;
+
+/*
+ * VAX subtypes (these do *not* necessary conform to the actual cpu
+ * ID assigned by DEC available via the SID register).
+ */
+
+pub const CPU_SUBTYPE_VAX_ALL: u32 = 0;
+pub const CPU_SUBTYPE_VAX780: u32 = 1;
+pub const CPU_SUBTYPE_VAX785: u32 = 2;
+pub const CPU_SUBTYPE_VAX750: u32 = 3;
+pub const CPU_SUBTYPE_VAX730: u32 = 4;
+pub const CPU_SUBTYPE_UVAXI: u32 = 5;
+pub const CPU_SUBTYPE_UVAXII: u32 = 6;
+pub const CPU_SUBTYPE_VAX8200: u32 = 7;
+pub const CPU_SUBTYPE_VAX8500: u32 = 8;
+pub const CPU_SUBTYPE_VAX8600: u32 = 9;
+pub const CPU_SUBTYPE_VAX8650: u32 = 10;
+pub const CPU_SUBTYPE_VAX8800: u32 = 11;
+pub const CPU_SUBTYPE_UVAXIII: u32 = 12;
+
+/*
+ * 680x0 subtypes
+ *
+ * The subtype definitions here are unusual for historical reasons.
+ * NeXT used to consider 68030 code as generic 68000 code. For
+ * backwards compatability:
+ *
+ * CPU_SUBTYPE_MC68030 symbol has been preserved for source code
+ * compatability.
+ *
+ * CPU_SUBTYPE_MC680x0_ALL has been defined to be the same
+ * subtype as CPU_SUBTYPE_MC68030 for binary comatability.
+ *
+ * CPU_SUBTYPE_MC68030_ONLY has been added to allow new object
+ * files to be tagged as containing 68030-specific instructions.
+ */
+
+pub const CPU_SUBTYPE_MC680X0_ALL: u32 = 1;
+// compat
+pub const CPU_SUBTYPE_MC68030: u32 = 1;
+pub const CPU_SUBTYPE_MC68040: u32 = 2;
+pub const CPU_SUBTYPE_MC68030_ONLY: u32 = 3;
+
+/*
+ * I386 subtypes
+ */
+
+#[inline]
+pub const fn cpu_subtype_intel(f: u32, m: u32) -> u32 {
+ f + (m << 4)
+}
+
+pub const CPU_SUBTYPE_I386_ALL: u32 = cpu_subtype_intel(3, 0);
+pub const CPU_SUBTYPE_386: u32 = cpu_subtype_intel(3, 0);
+pub const CPU_SUBTYPE_486: u32 = cpu_subtype_intel(4, 0);
+pub const CPU_SUBTYPE_486SX: u32 = cpu_subtype_intel(4, 8);
+pub const CPU_SUBTYPE_586: u32 = cpu_subtype_intel(5, 0);
+pub const CPU_SUBTYPE_PENT: u32 = cpu_subtype_intel(5, 0);
+pub const CPU_SUBTYPE_PENTPRO: u32 = cpu_subtype_intel(6, 1);
+pub const CPU_SUBTYPE_PENTII_M3: u32 = cpu_subtype_intel(6, 3);
+pub const CPU_SUBTYPE_PENTII_M5: u32 = cpu_subtype_intel(6, 5);
+pub const CPU_SUBTYPE_CELERON: u32 = cpu_subtype_intel(7, 6);
+pub const CPU_SUBTYPE_CELERON_MOBILE: u32 = cpu_subtype_intel(7, 7);
+pub const CPU_SUBTYPE_PENTIUM_3: u32 = cpu_subtype_intel(8, 0);
+pub const CPU_SUBTYPE_PENTIUM_3_M: u32 = cpu_subtype_intel(8, 1);
+pub const CPU_SUBTYPE_PENTIUM_3_XEON: u32 = cpu_subtype_intel(8, 2);
+pub const CPU_SUBTYPE_PENTIUM_M: u32 = cpu_subtype_intel(9, 0);
+pub const CPU_SUBTYPE_PENTIUM_4: u32 = cpu_subtype_intel(10, 0);
+pub const CPU_SUBTYPE_PENTIUM_4_M: u32 = cpu_subtype_intel(10, 1);
+pub const CPU_SUBTYPE_ITANIUM: u32 = cpu_subtype_intel(11, 0);
+pub const CPU_SUBTYPE_ITANIUM_2: u32 = cpu_subtype_intel(11, 1);
+pub const CPU_SUBTYPE_XEON: u32 = cpu_subtype_intel(12, 0);
+pub const CPU_SUBTYPE_XEON_MP: u32 = cpu_subtype_intel(12, 1);
+
+#[inline]
+pub const fn cpu_subtype_intel_family(x: u32) -> u32 {
+ x & 15
+}
+pub const CPU_SUBTYPE_INTEL_FAMILY_MAX: u32 = 15;
+
+#[inline]
+pub const fn cpu_subtype_intel_model(x: u32) -> u32 {
+ x >> 4
+}
+pub const CPU_SUBTYPE_INTEL_MODEL_ALL: u32 = 0;
+
+/*
+ * X86 subtypes.
+ */
+
+pub const CPU_SUBTYPE_X86_ALL: u32 = 3;
+pub const CPU_SUBTYPE_X86_64_ALL: u32 = 3;
+pub const CPU_SUBTYPE_X86_ARCH1: u32 = 4;
+/// Haswell feature subset
+pub const CPU_SUBTYPE_X86_64_H: u32 = 8;
+
+/*
+ * Mips subtypes.
+ */
+
+pub const CPU_SUBTYPE_MIPS_ALL: u32 = 0;
+pub const CPU_SUBTYPE_MIPS_R2300: u32 = 1;
+pub const CPU_SUBTYPE_MIPS_R2600: u32 = 2;
+pub const CPU_SUBTYPE_MIPS_R2800: u32 = 3;
+/// pmax
+pub const CPU_SUBTYPE_MIPS_R2000A: u32 = 4;
+pub const CPU_SUBTYPE_MIPS_R2000: u32 = 5;
+/// 3max
+pub const CPU_SUBTYPE_MIPS_R3000A: u32 = 6;
+pub const CPU_SUBTYPE_MIPS_R3000: u32 = 7;
+
+/*
+ * MC98000 (PowerPC) subtypes
+ */
+pub const CPU_SUBTYPE_MC98000_ALL: u32 = 0;
+pub const CPU_SUBTYPE_MC98601: u32 = 1;
+
+/*
+ * HPPA subtypes for Hewlett-Packard HP-PA family of
+ * risc processors. Port by NeXT to 700 series.
+ */
+
+pub const CPU_SUBTYPE_HPPA_ALL: u32 = 0;
+pub const CPU_SUBTYPE_HPPA_7100LC: u32 = 1;
+
+/*
+ * MC88000 subtypes.
+ */
+pub const CPU_SUBTYPE_MC88000_ALL: u32 = 0;
+pub const CPU_SUBTYPE_MC88100: u32 = 1;
+pub const CPU_SUBTYPE_MC88110: u32 = 2;
+
+/*
+ * SPARC subtypes
+ */
+pub const CPU_SUBTYPE_SPARC_ALL: u32 = 0;
+
+/*
+ * I860 subtypes
+ */
+pub const CPU_SUBTYPE_I860_ALL: u32 = 0;
+pub const CPU_SUBTYPE_I860_860: u32 = 1;
+
+/*
+ * PowerPC subtypes
+ */
+pub const CPU_SUBTYPE_POWERPC_ALL: u32 = 0;
+pub const CPU_SUBTYPE_POWERPC_601: u32 = 1;
+pub const CPU_SUBTYPE_POWERPC_602: u32 = 2;
+pub const CPU_SUBTYPE_POWERPC_603: u32 = 3;
+pub const CPU_SUBTYPE_POWERPC_603E: u32 = 4;
+pub const CPU_SUBTYPE_POWERPC_603EV: u32 = 5;
+pub const CPU_SUBTYPE_POWERPC_604: u32 = 6;
+pub const CPU_SUBTYPE_POWERPC_604E: u32 = 7;
+pub const CPU_SUBTYPE_POWERPC_620: u32 = 8;
+pub const CPU_SUBTYPE_POWERPC_750: u32 = 9;
+pub const CPU_SUBTYPE_POWERPC_7400: u32 = 10;
+pub const CPU_SUBTYPE_POWERPC_7450: u32 = 11;
+pub const CPU_SUBTYPE_POWERPC_970: u32 = 100;
+
+/*
+ * ARM subtypes
+ */
+pub const CPU_SUBTYPE_ARM_ALL: u32 = 0;
+pub const CPU_SUBTYPE_ARM_V4T: u32 = 5;
+pub const CPU_SUBTYPE_ARM_V6: u32 = 6;
+pub const CPU_SUBTYPE_ARM_V5TEJ: u32 = 7;
+pub const CPU_SUBTYPE_ARM_XSCALE: u32 = 8;
+/// ARMv7-A and ARMv7-R
+pub const CPU_SUBTYPE_ARM_V7: u32 = 9;
+/// Cortex A9
+pub const CPU_SUBTYPE_ARM_V7F: u32 = 10;
+/// Swift
+pub const CPU_SUBTYPE_ARM_V7S: u32 = 11;
+pub const CPU_SUBTYPE_ARM_V7K: u32 = 12;
+pub const CPU_SUBTYPE_ARM_V8: u32 = 13;
+/// Not meant to be run under xnu
+pub const CPU_SUBTYPE_ARM_V6M: u32 = 14;
+/// Not meant to be run under xnu
+pub const CPU_SUBTYPE_ARM_V7M: u32 = 15;
+/// Not meant to be run under xnu
+pub const CPU_SUBTYPE_ARM_V7EM: u32 = 16;
+/// Not meant to be run under xnu
+pub const CPU_SUBTYPE_ARM_V8M: u32 = 17;
+
+/*
+ * ARM64 subtypes
+ */
+pub const CPU_SUBTYPE_ARM64_ALL: u32 = 0;
+pub const CPU_SUBTYPE_ARM64_V8: u32 = 1;
+pub const CPU_SUBTYPE_ARM64E: u32 = 2;
+
+/*
+ * ARM64_32 subtypes
+ */
+pub const CPU_SUBTYPE_ARM64_32_ALL: u32 = 0;
+pub const CPU_SUBTYPE_ARM64_32_V8: u32 = 1;
+
+// Definitions from "/usr/include/mach/vm_prot.h".
+
+/// read permission
+pub const VM_PROT_READ: u32 = 0x01;
+/// write permission
+pub const VM_PROT_WRITE: u32 = 0x02;
+/// execute permission
+pub const VM_PROT_EXECUTE: u32 = 0x04;
+
+// Definitions from https://opensource.apple.com/source/dyld/dyld-210.2.3/launch-cache/dyld_cache_format.h.auto.html
+
+/// The dyld cache header, containing only the fields which are present
+/// in all versions of dyld caches (dyld-95.3 and up).
+/// Many more fields exist in later dyld versions, but we currently do
+/// not need to parse those.
+/// Corresponds to struct dyld_cache_header from dyld_cache_format.h.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DyldCacheHeader<E: Endian> {
+ /// e.g. "dyld_v0 i386"
+ pub magic: [u8; 16],
+ /// file offset to first dyld_cache_mapping_info
+ pub mapping_offset: U32<E>,
+ /// number of dyld_cache_mapping_info entries
+ pub mapping_count: U32<E>,
+ /// file offset to first dyld_cache_image_info
+ pub images_offset: U32<E>,
+ /// number of dyld_cache_image_info entries
+ pub images_count: U32<E>,
+ /// base address of dyld when cache was built
+ pub dyld_base_address: U64<E>,
+}
+
+/// Corresponds to struct dyld_cache_mapping_info from dyld_cache_format.h.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DyldCacheMappingInfo<E: Endian> {
+ ///
+ pub address: U64<E>,
+ ///
+ pub size: U64<E>,
+ ///
+ pub file_offset: U64<E>,
+ ///
+ pub max_prot: U32<E>,
+ ///
+ pub init_prot: U32<E>,
+}
+
+/// Corresponds to struct dyld_cache_image_info from dyld_cache_format.h.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DyldCacheImageInfo<E: Endian> {
+ ///
+ pub address: U64<E>,
+ ///
+ pub mod_time: U64<E>,
+ ///
+ pub inode: U64<E>,
+ ///
+ pub path_file_offset: U32<E>,
+ ///
+ pub pad: U32<E>,
+}
+
+// Definitions from "/usr/include/mach-o/loader.h".
+
+/*
+ * This header file describes the structures of the file format for "fat"
+ * architecture specific file (wrapper design). At the begining of the file
+ * there is one `FatHeader` structure followed by a number of `FatArch*`
+ * structures. For each architecture in the file, specified by a pair of
+ * cputype and cpusubtype, the `FatHeader` describes the file offset, file
+ * size and alignment in the file of the architecture specific member.
+ * The padded bytes in the file to place each member on it's specific alignment
+ * are defined to be read as zeros and can be left as "holes" if the file system
+ * can support them as long as they read as zeros.
+ *
+ * All structures defined here are always written and read to/from disk
+ * in big-endian order.
+ */
+
+pub const FAT_MAGIC: u32 = 0xcafe_babe;
+/// NXSwapLong(FAT_MAGIC)
+pub const FAT_CIGAM: u32 = 0xbeba_feca;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct FatHeader {
+ /// FAT_MAGIC or FAT_MAGIC_64
+ pub magic: U32<BigEndian>,
+ /// number of structs that follow
+ pub nfat_arch: U32<BigEndian>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct FatArch32 {
+ /// cpu specifier (int)
+ pub cputype: U32<BigEndian>,
+ /// machine specifier (int)
+ pub cpusubtype: U32<BigEndian>,
+ /// file offset to this object file
+ pub offset: U32<BigEndian>,
+ /// size of this object file
+ pub size: U32<BigEndian>,
+ /// alignment as a power of 2
+ pub align: U32<BigEndian>,
+}
+
+/*
+ * The support for the 64-bit fat file format described here is a work in
+ * progress and not yet fully supported in all the Apple Developer Tools.
+ *
+ * When a slice is greater than 4mb or an offset to a slice is greater than 4mb
+ * then the 64-bit fat file format is used.
+ */
+pub const FAT_MAGIC_64: u32 = 0xcafe_babf;
+/// NXSwapLong(FAT_MAGIC_64)
+pub const FAT_CIGAM_64: u32 = 0xbfba_feca;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct FatArch64 {
+ /// cpu specifier (int)
+ pub cputype: U32<BigEndian>,
+ /// machine specifier (int)
+ pub cpusubtype: U32<BigEndian>,
+ /// file offset to this object file
+ pub offset: U64<BigEndian>,
+ /// size of this object file
+ pub size: U64<BigEndian>,
+ /// alignment as a power of 2
+ pub align: U32<BigEndian>,
+ /// reserved
+ pub reserved: U32<BigEndian>,
+}
+
+// Definitions from "/usr/include/mach-o/loader.h".
+
+/// The 32-bit mach header.
+///
+/// Appears at the very beginning of the object file for 32-bit architectures.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct MachHeader32<E: Endian> {
+ /// mach magic number identifier
+ pub magic: U32<BigEndian>,
+ /// cpu specifier
+ pub cputype: U32<E>,
+ /// machine specifier
+ pub cpusubtype: U32<E>,
+ /// type of file
+ pub filetype: U32<E>,
+ /// number of load commands
+ pub ncmds: U32<E>,
+ /// the size of all the load commands
+ pub sizeofcmds: U32<E>,
+ /// flags
+ pub flags: U32<E>,
+}
+
+// Values for `MachHeader32::magic`.
+/// the mach magic number
+pub const MH_MAGIC: u32 = 0xfeed_face;
+/// NXSwapInt(MH_MAGIC)
+pub const MH_CIGAM: u32 = 0xcefa_edfe;
+
+/// The 64-bit mach header.
+///
+/// Appears at the very beginning of object files for 64-bit architectures.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct MachHeader64<E: Endian> {
+ /// mach magic number identifier
+ pub magic: U32<BigEndian>,
+ /// cpu specifier
+ pub cputype: U32<E>,
+ /// machine specifier
+ pub cpusubtype: U32<E>,
+ /// type of file
+ pub filetype: U32<E>,
+ /// number of load commands
+ pub ncmds: U32<E>,
+ /// the size of all the load commands
+ pub sizeofcmds: U32<E>,
+ /// flags
+ pub flags: U32<E>,
+ /// reserved
+ pub reserved: U32<E>,
+}
+
+// Values for `MachHeader64::magic`.
+/// the 64-bit mach magic number
+pub const MH_MAGIC_64: u32 = 0xfeed_facf;
+/// NXSwapInt(MH_MAGIC_64)
+pub const MH_CIGAM_64: u32 = 0xcffa_edfe;
+
+/*
+ * The layout of the file depends on the filetype. For all but the MH_OBJECT
+ * file type the segments are padded out and aligned on a segment alignment
+ * boundary for efficient demand pageing. The MH_EXECUTE, MH_FVMLIB, MH_DYLIB,
+ * MH_DYLINKER and MH_BUNDLE file types also have the headers included as part
+ * of their first segment.
+ *
+ * The file type MH_OBJECT is a compact format intended as output of the
+ * assembler and input (and possibly output) of the link editor (the .o
+ * format). All sections are in one unnamed segment with no segment padding.
+ * This format is used as an executable format when the file is so small the
+ * segment padding greatly increases its size.
+ *
+ * The file type MH_PRELOAD is an executable format intended for things that
+ * are not executed under the kernel (proms, stand alones, kernels, etc). The
+ * format can be executed under the kernel but may demand paged it and not
+ * preload it before execution.
+ *
+ * A core file is in MH_CORE format and can be any in an arbritray legal
+ * Mach-O file.
+ */
+
+// Values for `MachHeader*::filetype`.
+/// relocatable object file
+pub const MH_OBJECT: u32 = 0x1;
+/// demand paged executable file
+pub const MH_EXECUTE: u32 = 0x2;
+/// fixed VM shared library file
+pub const MH_FVMLIB: u32 = 0x3;
+/// core file
+pub const MH_CORE: u32 = 0x4;
+/// preloaded executable file
+pub const MH_PRELOAD: u32 = 0x5;
+/// dynamically bound shared library
+pub const MH_DYLIB: u32 = 0x6;
+/// dynamic link editor
+pub const MH_DYLINKER: u32 = 0x7;
+/// dynamically bound bundle file
+pub const MH_BUNDLE: u32 = 0x8;
+/// shared library stub for static linking only, no section contents
+pub const MH_DYLIB_STUB: u32 = 0x9;
+/// companion file with only debug sections
+pub const MH_DSYM: u32 = 0xa;
+/// x86_64 kexts
+pub const MH_KEXT_BUNDLE: u32 = 0xb;
+/// set of mach-o's
+pub const MH_FILESET: u32 = 0xc;
+
+// Values for `MachHeader*::flags`.
+/// the object file has no undefined references
+pub const MH_NOUNDEFS: u32 = 0x1;
+/// the object file is the output of an incremental link against a base file and can't be link edited again
+pub const MH_INCRLINK: u32 = 0x2;
+/// the object file is input for the dynamic linker and can't be staticly link edited again
+pub const MH_DYLDLINK: u32 = 0x4;
+/// the object file's undefined references are bound by the dynamic linker when loaded.
+pub const MH_BINDATLOAD: u32 = 0x8;
+/// the file has its dynamic undefined references prebound.
+pub const MH_PREBOUND: u32 = 0x10;
+/// the file has its read-only and read-write segments split
+pub const MH_SPLIT_SEGS: u32 = 0x20;
+/// the shared library init routine is to be run lazily via catching memory faults to its writeable segments (obsolete)
+pub const MH_LAZY_INIT: u32 = 0x40;
+/// the image is using two-level name space bindings
+pub const MH_TWOLEVEL: u32 = 0x80;
+/// the executable is forcing all images to use flat name space bindings
+pub const MH_FORCE_FLAT: u32 = 0x100;
+/// this umbrella guarantees no multiple defintions of symbols in its sub-images so the two-level namespace hints can always be used.
+pub const MH_NOMULTIDEFS: u32 = 0x200;
+/// do not have dyld notify the prebinding agent about this executable
+pub const MH_NOFIXPREBINDING: u32 = 0x400;
+/// the binary is not prebound but can have its prebinding redone. only used when MH_PREBOUND is not set.
+pub const MH_PREBINDABLE: u32 = 0x800;
+/// indicates that this binary binds to all two-level namespace modules of its dependent libraries. only used when MH_PREBINDABLE and MH_TWOLEVEL are both set.
+pub const MH_ALLMODSBOUND: u32 = 0x1000;
+/// safe to divide up the sections into sub-sections via symbols for dead code stripping
+pub const MH_SUBSECTIONS_VIA_SYMBOLS: u32 = 0x2000;
+/// the binary has been canonicalized via the unprebind operation
+pub const MH_CANONICAL: u32 = 0x4000;
+/// the final linked image contains external weak symbols
+pub const MH_WEAK_DEFINES: u32 = 0x8000;
+/// the final linked image uses weak symbols
+pub const MH_BINDS_TO_WEAK: u32 = 0x10000;
+/// When this bit is set, all stacks in the task will be given stack execution privilege. Only used in MH_EXECUTE filetypes.
+pub const MH_ALLOW_STACK_EXECUTION: u32 = 0x20000;
+/// When this bit is set, the binary declares it is safe for use in processes with uid zero
+pub const MH_ROOT_SAFE: u32 = 0x40000;
+/// When this bit is set, the binary declares it is safe for use in processes when issetugid() is true
+pub const MH_SETUID_SAFE: u32 = 0x80000;
+/// When this bit is set on a dylib, the static linker does not need to examine dependent dylibs to see if any are re-exported
+pub const MH_NO_REEXPORTED_DYLIBS: u32 = 0x10_0000;
+/// When this bit is set, the OS will load the main executable at a random address. Only used in MH_EXECUTE filetypes.
+pub const MH_PIE: u32 = 0x20_0000;
+/// Only for use on dylibs. When linking against a dylib that has this bit set, the static linker will automatically not create a LC_LOAD_DYLIB load command to the dylib if no symbols are being referenced from the dylib.
+pub const MH_DEAD_STRIPPABLE_DYLIB: u32 = 0x40_0000;
+/// Contains a section of type S_THREAD_LOCAL_VARIABLES
+pub const MH_HAS_TLV_DESCRIPTORS: u32 = 0x80_0000;
+/// When this bit is set, the OS will run the main executable with a non-executable heap even on platforms (e.g. i386) that don't require it. Only used in MH_EXECUTE filetypes.
+pub const MH_NO_HEAP_EXECUTION: u32 = 0x100_0000;
+/// The code was linked for use in an application extension.
+pub const MH_APP_EXTENSION_SAFE: u32 = 0x0200_0000;
+/// The external symbols listed in the nlist symbol table do not include all the symbols listed in the dyld info.
+pub const MH_NLIST_OUTOFSYNC_WITH_DYLDINFO: u32 = 0x0400_0000;
+/// Allow LC_MIN_VERSION_MACOS and LC_BUILD_VERSION load commands with
+/// the platforms macOS, iOSMac, iOSSimulator, tvOSSimulator and watchOSSimulator.
+pub const MH_SIM_SUPPORT: u32 = 0x0800_0000;
+/// Only for use on dylibs. When this bit is set, the dylib is part of the dyld
+/// shared cache, rather than loose in the filesystem.
+pub const MH_DYLIB_IN_CACHE: u32 = 0x8000_0000;
+
+/// Common fields at the start of every load command.
+///
+/// The load commands directly follow the mach_header. The total size of all
+/// of the commands is given by the sizeofcmds field in the mach_header. All
+/// load commands must have as their first two fields `cmd` and `cmdsize`. The `cmd`
+/// field is filled in with a constant for that command type. Each command type
+/// has a structure specifically for it. The `cmdsize` field is the size in bytes
+/// of the particular load command structure plus anything that follows it that
+/// is a part of the load command (i.e. section structures, strings, etc.). To
+/// advance to the next load command the `cmdsize` can be added to the offset or
+/// pointer of the current load command. The `cmdsize` for 32-bit architectures
+/// MUST be a multiple of 4 bytes and for 64-bit architectures MUST be a multiple
+/// of 8 bytes (these are forever the maximum alignment of any load commands).
+/// The padded bytes must be zero. All tables in the object file must also
+/// follow these rules so the file can be memory mapped. Otherwise the pointers
+/// to these tables will not work well or at all on some machines. With all
+/// padding zeroed like objects will compare byte for byte.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct LoadCommand<E: Endian> {
+ /// Type of load command.
+ ///
+ /// One of the `LC_*` constants.
+ pub cmd: U32<E>,
+ /// Total size of command in bytes.
+ pub cmdsize: U32<E>,
+}
+
+/*
+ * After MacOS X 10.1 when a new load command is added that is required to be
+ * understood by the dynamic linker for the image to execute properly the
+ * LC_REQ_DYLD bit will be or'ed into the load command constant. If the dynamic
+ * linker sees such a load command it it does not understand will issue a
+ * "unknown load command required for execution" error and refuse to use the
+ * image. Other load commands without this bit that are not understood will
+ * simply be ignored.
+ */
+pub const LC_REQ_DYLD: u32 = 0x8000_0000;
+
+/* Constants for the cmd field of all load commands, the type */
+/// segment of this file to be mapped
+pub const LC_SEGMENT: u32 = 0x1;
+/// link-edit stab symbol table info
+pub const LC_SYMTAB: u32 = 0x2;
+/// link-edit gdb symbol table info (obsolete)
+pub const LC_SYMSEG: u32 = 0x3;
+/// thread
+pub const LC_THREAD: u32 = 0x4;
+/// unix thread (includes a stack)
+pub const LC_UNIXTHREAD: u32 = 0x5;
+/// load a specified fixed VM shared library
+pub const LC_LOADFVMLIB: u32 = 0x6;
+/// fixed VM shared library identification
+pub const LC_IDFVMLIB: u32 = 0x7;
+/// object identification info (obsolete)
+pub const LC_IDENT: u32 = 0x8;
+/// fixed VM file inclusion (internal use)
+pub const LC_FVMFILE: u32 = 0x9;
+/// prepage command (internal use)
+pub const LC_PREPAGE: u32 = 0xa;
+/// dynamic link-edit symbol table info
+pub const LC_DYSYMTAB: u32 = 0xb;
+/// load a dynamically linked shared library
+pub const LC_LOAD_DYLIB: u32 = 0xc;
+/// dynamically linked shared lib ident
+pub const LC_ID_DYLIB: u32 = 0xd;
+/// load a dynamic linker
+pub const LC_LOAD_DYLINKER: u32 = 0xe;
+/// dynamic linker identification
+pub const LC_ID_DYLINKER: u32 = 0xf;
+/// modules prebound for a dynamically linked shared library
+pub const LC_PREBOUND_DYLIB: u32 = 0x10;
+/// image routines
+pub const LC_ROUTINES: u32 = 0x11;
+/// sub framework
+pub const LC_SUB_FRAMEWORK: u32 = 0x12;
+/// sub umbrella
+pub const LC_SUB_UMBRELLA: u32 = 0x13;
+/// sub client
+pub const LC_SUB_CLIENT: u32 = 0x14;
+/// sub library
+pub const LC_SUB_LIBRARY: u32 = 0x15;
+/// two-level namespace lookup hints
+pub const LC_TWOLEVEL_HINTS: u32 = 0x16;
+/// prebind checksum
+pub const LC_PREBIND_CKSUM: u32 = 0x17;
+/// load a dynamically linked shared library that is allowed to be missing
+/// (all symbols are weak imported).
+pub const LC_LOAD_WEAK_DYLIB: u32 = 0x18 | LC_REQ_DYLD;
+/// 64-bit segment of this file to be mapped
+pub const LC_SEGMENT_64: u32 = 0x19;
+/// 64-bit image routines
+pub const LC_ROUTINES_64: u32 = 0x1a;
+/// the uuid
+pub const LC_UUID: u32 = 0x1b;
+/// runpath additions
+pub const LC_RPATH: u32 = 0x1c | LC_REQ_DYLD;
+/// local of code signature
+pub const LC_CODE_SIGNATURE: u32 = 0x1d;
+/// local of info to split segments
+pub const LC_SEGMENT_SPLIT_INFO: u32 = 0x1e;
+/// load and re-export dylib
+pub const LC_REEXPORT_DYLIB: u32 = 0x1f | LC_REQ_DYLD;
+/// delay load of dylib until first use
+pub const LC_LAZY_LOAD_DYLIB: u32 = 0x20;
+/// encrypted segment information
+pub const LC_ENCRYPTION_INFO: u32 = 0x21;
+/// compressed dyld information
+pub const LC_DYLD_INFO: u32 = 0x22;
+/// compressed dyld information only
+pub const LC_DYLD_INFO_ONLY: u32 = 0x22 | LC_REQ_DYLD;
+/// load upward dylib
+pub const LC_LOAD_UPWARD_DYLIB: u32 = 0x23 | LC_REQ_DYLD;
+/// build for MacOSX min OS version
+pub const LC_VERSION_MIN_MACOSX: u32 = 0x24;
+/// build for iPhoneOS min OS version
+pub const LC_VERSION_MIN_IPHONEOS: u32 = 0x25;
+/// compressed table of function start addresses
+pub const LC_FUNCTION_STARTS: u32 = 0x26;
+/// string for dyld to treat like environment variable
+pub const LC_DYLD_ENVIRONMENT: u32 = 0x27;
+/// replacement for LC_UNIXTHREAD
+pub const LC_MAIN: u32 = 0x28 | LC_REQ_DYLD;
+/// table of non-instructions in __text
+pub const LC_DATA_IN_CODE: u32 = 0x29;
+/// source version used to build binary
+pub const LC_SOURCE_VERSION: u32 = 0x2A;
+/// Code signing DRs copied from linked dylibs
+pub const LC_DYLIB_CODE_SIGN_DRS: u32 = 0x2B;
+/// 64-bit encrypted segment information
+pub const LC_ENCRYPTION_INFO_64: u32 = 0x2C;
+/// linker options in MH_OBJECT files
+pub const LC_LINKER_OPTION: u32 = 0x2D;
+/// optimization hints in MH_OBJECT files
+pub const LC_LINKER_OPTIMIZATION_HINT: u32 = 0x2E;
+/// build for AppleTV min OS version
+pub const LC_VERSION_MIN_TVOS: u32 = 0x2F;
+/// build for Watch min OS version
+pub const LC_VERSION_MIN_WATCHOS: u32 = 0x30;
+/// arbitrary data included within a Mach-O file
+pub const LC_NOTE: u32 = 0x31;
+/// build for platform min OS version
+pub const LC_BUILD_VERSION: u32 = 0x32;
+/// used with `LinkeditDataCommand`, payload is trie
+pub const LC_DYLD_EXPORTS_TRIE: u32 = 0x33 | LC_REQ_DYLD;
+/// used with `LinkeditDataCommand`
+pub const LC_DYLD_CHAINED_FIXUPS: u32 = 0x34 | LC_REQ_DYLD;
+/// used with `FilesetEntryCommand`
+pub const LC_FILESET_ENTRY: u32 = 0x35 | LC_REQ_DYLD;
+
+/// A variable length string in a load command.
+///
+/// The strings are stored just after the load command structure and
+/// the offset is from the start of the load command structure. The size
+/// of the string is reflected in the `cmdsize` field of the load command.
+/// Once again any padded bytes to bring the `cmdsize` field to a multiple
+/// of 4 bytes must be zero.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct LcStr<E: Endian> {
+ /// offset to the string
+ pub offset: U32<E>,
+}
+
+/// 32-bit segment load command.
+///
+/// The segment load command indicates that a part of this file is to be
+/// mapped into the task's address space. The size of this segment in memory,
+/// vmsize, maybe equal to or larger than the amount to map from this file,
+/// filesize. The file is mapped starting at fileoff to the beginning of
+/// the segment in memory, vmaddr. The rest of the memory of the segment,
+/// if any, is allocated zero fill on demand. The segment's maximum virtual
+/// memory protection and initial virtual memory protection are specified
+/// by the maxprot and initprot fields. If the segment has sections then the
+/// `Section32` structures directly follow the segment command and their size is
+/// reflected in `cmdsize`.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SegmentCommand32<E: Endian> {
+ /// LC_SEGMENT
+ pub cmd: U32<E>,
+ /// includes sizeof section structs
+ pub cmdsize: U32<E>,
+ /// segment name
+ pub segname: [u8; 16],
+ /// memory address of this segment
+ pub vmaddr: U32<E>,
+ /// memory size of this segment
+ pub vmsize: U32<E>,
+ /// file offset of this segment
+ pub fileoff: U32<E>,
+ /// amount to map from the file
+ pub filesize: U32<E>,
+ /// maximum VM protection
+ pub maxprot: U32<E>,
+ /// initial VM protection
+ pub initprot: U32<E>,
+ /// number of sections in segment
+ pub nsects: U32<E>,
+ /// flags
+ pub flags: U32<E>,
+}
+
+/// 64-bit segment load command.
+///
+/// The 64-bit segment load command indicates that a part of this file is to be
+/// mapped into a 64-bit task's address space. If the 64-bit segment has
+/// sections then `Section64` structures directly follow the 64-bit segment
+/// command and their size is reflected in `cmdsize`.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SegmentCommand64<E: Endian> {
+ /// LC_SEGMENT_64
+ pub cmd: U32<E>,
+ /// includes sizeof section_64 structs
+ pub cmdsize: U32<E>,
+ /// segment name
+ pub segname: [u8; 16],
+ /// memory address of this segment
+ pub vmaddr: U64<E>,
+ /// memory size of this segment
+ pub vmsize: U64<E>,
+ /// file offset of this segment
+ pub fileoff: U64<E>,
+ /// amount to map from the file
+ pub filesize: U64<E>,
+ /// maximum VM protection
+ pub maxprot: U32<E>,
+ /// initial VM protection
+ pub initprot: U32<E>,
+ /// number of sections in segment
+ pub nsects: U32<E>,
+ /// flags
+ pub flags: U32<E>,
+}
+
+// Values for `SegmentCommand*::flags`.
+/// the file contents for this segment is for the high part of the VM space, the low part is zero filled (for stacks in core files)
+pub const SG_HIGHVM: u32 = 0x1;
+/// this segment is the VM that is allocated by a fixed VM library, for overlap checking in the link editor
+pub const SG_FVMLIB: u32 = 0x2;
+/// this segment has nothing that was relocated in it and nothing relocated to it, that is it maybe safely replaced without relocation
+pub const SG_NORELOC: u32 = 0x4;
+/// This segment is protected. If the segment starts at file offset 0, the first page of the segment is not protected. All other pages of the segment are protected.
+pub const SG_PROTECTED_VERSION_1: u32 = 0x8;
+/// This segment is made read-only after fixups
+pub const SG_READ_ONLY: u32 = 0x10;
+
+/*
+ * A segment is made up of zero or more sections. Non-MH_OBJECT files have
+ * all of their segments with the proper sections in each, and padded to the
+ * specified segment alignment when produced by the link editor. The first
+ * segment of a MH_EXECUTE and MH_FVMLIB format file contains the mach_header
+ * and load commands of the object file before its first section. The zero
+ * fill sections are always last in their segment (in all formats). This
+ * allows the zeroed segment padding to be mapped into memory where zero fill
+ * sections might be. The gigabyte zero fill sections, those with the section
+ * type S_GB_ZEROFILL, can only be in a segment with sections of this type.
+ * These segments are then placed after all other segments.
+ *
+ * The MH_OBJECT format has all of its sections in one segment for
+ * compactness. There is no padding to a specified segment boundary and the
+ * mach_header and load commands are not part of the segment.
+ *
+ * Sections with the same section name, sectname, going into the same segment,
+ * segname, are combined by the link editor. The resulting section is aligned
+ * to the maximum alignment of the combined sections and is the new section's
+ * alignment. The combined sections are aligned to their original alignment in
+ * the combined section. Any padded bytes to get the specified alignment are
+ * zeroed.
+ *
+ * The format of the relocation entries referenced by the reloff and nreloc
+ * fields of the section structure for mach object files is described in the
+ * header file <reloc.h>.
+ */
+/// 32-bit section.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Section32<E: Endian> {
+ /// name of this section
+ pub sectname: [u8; 16],
+ /// segment this section goes in
+ pub segname: [u8; 16],
+ /// memory address of this section
+ pub addr: U32<E>,
+ /// size in bytes of this section
+ pub size: U32<E>,
+ /// file offset of this section
+ pub offset: U32<E>,
+ /// section alignment (power of 2)
+ pub align: U32<E>,
+ /// file offset of relocation entries
+ pub reloff: U32<E>,
+ /// number of relocation entries
+ pub nreloc: U32<E>,
+ /// flags (section type and attributes)
+ pub flags: U32<E>,
+ /// reserved (for offset or index)
+ pub reserved1: U32<E>,
+ /// reserved (for count or sizeof)
+ pub reserved2: U32<E>,
+}
+
+/// 64-bit section.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Section64<E: Endian> {
+ /// name of this section
+ pub sectname: [u8; 16],
+ /// segment this section goes in
+ pub segname: [u8; 16],
+ /// memory address of this section
+ pub addr: U64<E>,
+ /// size in bytes of this section
+ pub size: U64<E>,
+ /// file offset of this section
+ pub offset: U32<E>,
+ /// section alignment (power of 2)
+ pub align: U32<E>,
+ /// file offset of relocation entries
+ pub reloff: U32<E>,
+ /// number of relocation entries
+ pub nreloc: U32<E>,
+ /// flags (section type and attributes)
+ pub flags: U32<E>,
+ /// reserved (for offset or index)
+ pub reserved1: U32<E>,
+ /// reserved (for count or sizeof)
+ pub reserved2: U32<E>,
+ /// reserved
+ pub reserved3: U32<E>,
+}
+
+/*
+ * The flags field of a section structure is separated into two parts a section
+ * type and section attributes. The section types are mutually exclusive (it
+ * can only have one type) but the section attributes are not (it may have more
+ * than one attribute).
+ */
+/// 256 section types
+pub const SECTION_TYPE: u32 = 0x0000_00ff;
+/// 24 section attributes
+pub const SECTION_ATTRIBUTES: u32 = 0xffff_ff00;
+
+/* Constants for the type of a section */
+/// regular section
+pub const S_REGULAR: u32 = 0x0;
+/// zero fill on demand section
+pub const S_ZEROFILL: u32 = 0x1;
+/// section with only literal C strings
+pub const S_CSTRING_LITERALS: u32 = 0x2;
+/// section with only 4 byte literals
+pub const S_4BYTE_LITERALS: u32 = 0x3;
+/// section with only 8 byte literals
+pub const S_8BYTE_LITERALS: u32 = 0x4;
+/// section with only pointers to literals
+pub const S_LITERAL_POINTERS: u32 = 0x5;
+/*
+ * For the two types of symbol pointers sections and the symbol stubs section
+ * they have indirect symbol table entries. For each of the entries in the
+ * section the indirect symbol table entries, in corresponding order in the
+ * indirect symbol table, start at the index stored in the reserved1 field
+ * of the section structure. Since the indirect symbol table entries
+ * correspond to the entries in the section the number of indirect symbol table
+ * entries is inferred from the size of the section divided by the size of the
+ * entries in the section. For symbol pointers sections the size of the entries
+ * in the section is 4 bytes and for symbol stubs sections the byte size of the
+ * stubs is stored in the reserved2 field of the section structure.
+ */
+/// section with only non-lazy symbol pointers
+pub const S_NON_LAZY_SYMBOL_POINTERS: u32 = 0x6;
+/// section with only lazy symbol pointers
+pub const S_LAZY_SYMBOL_POINTERS: u32 = 0x7;
+/// section with only symbol stubs, byte size of stub in the reserved2 field
+pub const S_SYMBOL_STUBS: u32 = 0x8;
+/// section with only function pointers for initialization
+pub const S_MOD_INIT_FUNC_POINTERS: u32 = 0x9;
+/// section with only function pointers for termination
+pub const S_MOD_TERM_FUNC_POINTERS: u32 = 0xa;
+/// section contains symbols that are to be coalesced
+pub const S_COALESCED: u32 = 0xb;
+/// zero fill on demand section (that can be larger than 4 gigabytes)
+pub const S_GB_ZEROFILL: u32 = 0xc;
+/// section with only pairs of function pointers for interposing
+pub const S_INTERPOSING: u32 = 0xd;
+/// section with only 16 byte literals
+pub const S_16BYTE_LITERALS: u32 = 0xe;
+/// section contains DTrace Object Format
+pub const S_DTRACE_DOF: u32 = 0xf;
+/// section with only lazy symbol pointers to lazy loaded dylibs
+pub const S_LAZY_DYLIB_SYMBOL_POINTERS: u32 = 0x10;
+/*
+ * Section types to support thread local variables
+ */
+/// template of initial values for TLVs
+pub const S_THREAD_LOCAL_REGULAR: u32 = 0x11;
+/// template of initial values for TLVs
+pub const S_THREAD_LOCAL_ZEROFILL: u32 = 0x12;
+/// TLV descriptors
+pub const S_THREAD_LOCAL_VARIABLES: u32 = 0x13;
+/// pointers to TLV descriptors
+pub const S_THREAD_LOCAL_VARIABLE_POINTERS: u32 = 0x14;
+/// functions to call to initialize TLV values
+pub const S_THREAD_LOCAL_INIT_FUNCTION_POINTERS: u32 = 0x15;
+/// 32-bit offsets to initializers
+pub const S_INIT_FUNC_OFFSETS: u32 = 0x16;
+
+/*
+ * Constants for the section attributes part of the flags field of a section
+ * structure.
+ */
+/// User setable attributes
+pub const SECTION_ATTRIBUTES_USR: u32 = 0xff00_0000;
+/// section contains only true machine instructions
+pub const S_ATTR_PURE_INSTRUCTIONS: u32 = 0x8000_0000;
+/// section contains coalesced symbols that are not to be in a ranlib table of contents
+pub const S_ATTR_NO_TOC: u32 = 0x4000_0000;
+/// ok to strip static symbols in this section in files with the MH_DYLDLINK flag
+pub const S_ATTR_STRIP_STATIC_SYMS: u32 = 0x2000_0000;
+/// no dead stripping
+pub const S_ATTR_NO_DEAD_STRIP: u32 = 0x1000_0000;
+/// blocks are live if they reference live blocks
+pub const S_ATTR_LIVE_SUPPORT: u32 = 0x0800_0000;
+/// Used with i386 code stubs written on by dyld
+pub const S_ATTR_SELF_MODIFYING_CODE: u32 = 0x0400_0000;
+/*
+ * If a segment contains any sections marked with S_ATTR_DEBUG then all
+ * sections in that segment must have this attribute. No section other than
+ * a section marked with this attribute may reference the contents of this
+ * section. A section with this attribute may contain no symbols and must have
+ * a section type S_REGULAR. The static linker will not copy section contents
+ * from sections with this attribute into its output file. These sections
+ * generally contain DWARF debugging info.
+ */
+/// a debug section
+pub const S_ATTR_DEBUG: u32 = 0x0200_0000;
+/// system setable attributes
+pub const SECTION_ATTRIBUTES_SYS: u32 = 0x00ff_ff00;
+/// section contains some machine instructions
+pub const S_ATTR_SOME_INSTRUCTIONS: u32 = 0x0000_0400;
+/// section has external relocation entries
+pub const S_ATTR_EXT_RELOC: u32 = 0x0000_0200;
+/// section has local relocation entries
+pub const S_ATTR_LOC_RELOC: u32 = 0x0000_0100;
+
+/*
+ * The names of segments and sections in them are mostly meaningless to the
+ * link-editor. But there are few things to support traditional UNIX
+ * executables that require the link-editor and assembler to use some names
+ * agreed upon by convention.
+ *
+ * The initial protection of the "__TEXT" segment has write protection turned
+ * off (not writeable).
+ *
+ * The link-editor will allocate common symbols at the end of the "__common"
+ * section in the "__DATA" segment. It will create the section and segment
+ * if needed.
+ */
+
+/* The currently known segment names and the section names in those segments */
+
+/// the pagezero segment which has no protections and catches NULL references for MH_EXECUTE files
+pub const SEG_PAGEZERO: &str = "__PAGEZERO";
+
+/// the tradition UNIX text segment
+pub const SEG_TEXT: &str = "__TEXT";
+/// the real text part of the text section no headers, and no padding
+pub const SECT_TEXT: &str = "__text";
+/// the fvmlib initialization section
+pub const SECT_FVMLIB_INIT0: &str = "__fvmlib_init0";
+/// the section following the fvmlib initialization section
+pub const SECT_FVMLIB_INIT1: &str = "__fvmlib_init1";
+
+/// the tradition UNIX data segment
+pub const SEG_DATA: &str = "__DATA";
+/// the real initialized data section no padding, no bss overlap
+pub const SECT_DATA: &str = "__data";
+/// the real uninitialized data section no padding
+pub const SECT_BSS: &str = "__bss";
+/// the section common symbols are allocated in by the link editor
+pub const SECT_COMMON: &str = "__common";
+
+/// objective-C runtime segment
+pub const SEG_OBJC: &str = "__OBJC";
+/// symbol table
+pub const SECT_OBJC_SYMBOLS: &str = "__symbol_table";
+/// module information
+pub const SECT_OBJC_MODULES: &str = "__module_info";
+/// string table
+pub const SECT_OBJC_STRINGS: &str = "__selector_strs";
+/// string table
+pub const SECT_OBJC_REFS: &str = "__selector_refs";
+
+/// the icon segment
+pub const SEG_ICON: &str = "__ICON";
+/// the icon headers
+pub const SECT_ICON_HEADER: &str = "__header";
+/// the icons in tiff format
+pub const SECT_ICON_TIFF: &str = "__tiff";
+
+/// the segment containing all structs created and maintained by the link editor. Created with -seglinkedit option to ld(1) for MH_EXECUTE and FVMLIB file types only
+pub const SEG_LINKEDIT: &str = "__LINKEDIT";
+
+/// the segment overlapping with linkedit containing linking information
+pub const SEG_LINKINFO: &str = "__LINKINFO";
+
+/// the unix stack segment
+pub const SEG_UNIXSTACK: &str = "__UNIXSTACK";
+
+/// the segment for the self (dyld) modifing code stubs that has read, write and execute permissions
+pub const SEG_IMPORT: &str = "__IMPORT";
+
+/*
+ * Fixed virtual memory shared libraries are identified by two things. The
+ * target pathname (the name of the library as found for execution), and the
+ * minor version number. The address of where the headers are loaded is in
+ * header_addr. (THIS IS OBSOLETE and no longer supported).
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Fvmlib<E: Endian> {
+ /// library's target pathname
+ pub name: LcStr<E>,
+ /// library's minor version number
+ pub minor_version: U32<E>,
+ /// library's header address
+ pub header_addr: U32<E>,
+}
+
+/*
+ * A fixed virtual shared library (filetype == MH_FVMLIB in the mach header)
+ * contains a `FvmlibCommand` (cmd == LC_IDFVMLIB) to identify the library.
+ * An object that uses a fixed virtual shared library also contains a
+ * `FvmlibCommand` (cmd == LC_LOADFVMLIB) for each library it uses.
+ * (THIS IS OBSOLETE and no longer supported).
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct FvmlibCommand<E: Endian> {
+ /// LC_IDFVMLIB or LC_LOADFVMLIB
+ pub cmd: U32<E>,
+ /// includes pathname string
+ pub cmdsize: U32<E>,
+ /// the library identification
+ pub fvmlib: Fvmlib<E>,
+}
+
+/*
+ * Dynamicly linked shared libraries are identified by two things. The
+ * pathname (the name of the library as found for execution), and the
+ * compatibility version number. The pathname must match and the compatibility
+ * number in the user of the library must be greater than or equal to the
+ * library being used. The time stamp is used to record the time a library was
+ * built and copied into user so it can be use to determined if the library used
+ * at runtime is exactly the same as used to built the program.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Dylib<E: Endian> {
+ /// library's path name
+ pub name: LcStr<E>,
+ /// library's build time stamp
+ pub timestamp: U32<E>,
+ /// library's current version number
+ pub current_version: U32<E>,
+ /// library's compatibility vers number
+ pub compatibility_version: U32<E>,
+}
+
+/*
+ * A dynamically linked shared library (filetype == MH_DYLIB in the mach header)
+ * contains a `DylibCommand` (cmd == LC_ID_DYLIB) to identify the library.
+ * An object that uses a dynamically linked shared library also contains a
+ * `DylibCommand` (cmd == LC_LOAD_DYLIB, LC_LOAD_WEAK_DYLIB, or
+ * LC_REEXPORT_DYLIB) for each library it uses.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DylibCommand<E: Endian> {
+ /// LC_ID_DYLIB, LC_LOAD_{,WEAK_}DYLIB, LC_REEXPORT_DYLIB
+ pub cmd: U32<E>,
+ /// includes pathname string
+ pub cmdsize: U32<E>,
+ /// the library identification
+ pub dylib: Dylib<E>,
+}
+
+/*
+ * A dynamically linked shared library may be a subframework of an umbrella
+ * framework. If so it will be linked with "-umbrella umbrella_name" where
+ * Where "umbrella_name" is the name of the umbrella framework. A subframework
+ * can only be linked against by its umbrella framework or other subframeworks
+ * that are part of the same umbrella framework. Otherwise the static link
+ * editor produces an error and states to link against the umbrella framework.
+ * The name of the umbrella framework for subframeworks is recorded in the
+ * following structure.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SubFrameworkCommand<E: Endian> {
+ /// LC_SUB_FRAMEWORK
+ pub cmd: U32<E>,
+ /// includes umbrella string
+ pub cmdsize: U32<E>,
+ /// the umbrella framework name
+ pub umbrella: LcStr<E>,
+}
+
+/*
+ * For dynamically linked shared libraries that are subframework of an umbrella
+ * framework they can allow clients other than the umbrella framework or other
+ * subframeworks in the same umbrella framework. To do this the subframework
+ * is built with "-allowable_client client_name" and an LC_SUB_CLIENT load
+ * command is created for each -allowable_client flag. The client_name is
+ * usually a framework name. It can also be a name used for bundles clients
+ * where the bundle is built with "-client_name client_name".
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SubClientCommand<E: Endian> {
+ /// LC_SUB_CLIENT
+ pub cmd: U32<E>,
+ /// includes client string
+ pub cmdsize: U32<E>,
+ /// the client name
+ pub client: LcStr<E>,
+}
+
+/*
+ * A dynamically linked shared library may be a sub_umbrella of an umbrella
+ * framework. If so it will be linked with "-sub_umbrella umbrella_name" where
+ * Where "umbrella_name" is the name of the sub_umbrella framework. When
+ * staticly linking when -twolevel_namespace is in effect a twolevel namespace
+ * umbrella framework will only cause its subframeworks and those frameworks
+ * listed as sub_umbrella frameworks to be implicited linked in. Any other
+ * dependent dynamic libraries will not be linked it when -twolevel_namespace
+ * is in effect. The primary library recorded by the static linker when
+ * resolving a symbol in these libraries will be the umbrella framework.
+ * Zero or more sub_umbrella frameworks may be use by an umbrella framework.
+ * The name of a sub_umbrella framework is recorded in the following structure.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SubUmbrellaCommand<E: Endian> {
+ /// LC_SUB_UMBRELLA
+ pub cmd: U32<E>,
+ /// includes sub_umbrella string
+ pub cmdsize: U32<E>,
+ /// the sub_umbrella framework name
+ pub sub_umbrella: LcStr<E>,
+}
+
+/*
+ * A dynamically linked shared library may be a sub_library of another shared
+ * library. If so it will be linked with "-sub_library library_name" where
+ * Where "library_name" is the name of the sub_library shared library. When
+ * staticly linking when -twolevel_namespace is in effect a twolevel namespace
+ * shared library will only cause its subframeworks and those frameworks
+ * listed as sub_umbrella frameworks and libraries listed as sub_libraries to
+ * be implicited linked in. Any other dependent dynamic libraries will not be
+ * linked it when -twolevel_namespace is in effect. The primary library
+ * recorded by the static linker when resolving a symbol in these libraries
+ * will be the umbrella framework (or dynamic library). Zero or more sub_library
+ * shared libraries may be use by an umbrella framework or (or dynamic library).
+ * The name of a sub_library framework is recorded in the following structure.
+ * For example /usr/lib/libobjc_profile.A.dylib would be recorded as "libobjc".
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SubLibraryCommand<E: Endian> {
+ /// LC_SUB_LIBRARY
+ pub cmd: U32<E>,
+ /// includes sub_library string
+ pub cmdsize: U32<E>,
+ /// the sub_library name
+ pub sub_library: LcStr<E>,
+}
+
+/*
+ * A program (filetype == MH_EXECUTE) that is
+ * prebound to its dynamic libraries has one of these for each library that
+ * the static linker used in prebinding. It contains a bit vector for the
+ * modules in the library. The bits indicate which modules are bound (1) and
+ * which are not (0) from the library. The bit for module 0 is the low bit
+ * of the first byte. So the bit for the Nth module is:
+ * (linked_modules[N/8] >> N%8) & 1
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct PreboundDylibCommand<E: Endian> {
+ /// LC_PREBOUND_DYLIB
+ pub cmd: U32<E>,
+ /// includes strings
+ pub cmdsize: U32<E>,
+ /// library's path name
+ pub name: LcStr<E>,
+ /// number of modules in library
+ pub nmodules: U32<E>,
+ /// bit vector of linked modules
+ pub linked_modules: LcStr<E>,
+}
+
+/*
+ * A program that uses a dynamic linker contains a `DylinkerCommand` to identify
+ * the name of the dynamic linker (LC_LOAD_DYLINKER). And a dynamic linker
+ * contains a `DylinkerCommand` to identify the dynamic linker (LC_ID_DYLINKER).
+ * A file can have at most one of these.
+ * This struct is also used for the LC_DYLD_ENVIRONMENT load command and
+ * contains string for dyld to treat like environment variable.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DylinkerCommand<E: Endian> {
+ /// LC_ID_DYLINKER, LC_LOAD_DYLINKER or LC_DYLD_ENVIRONMENT
+ pub cmd: U32<E>,
+ /// includes pathname string
+ pub cmdsize: U32<E>,
+ /// dynamic linker's path name
+ pub name: LcStr<E>,
+}
+
+/*
+ * Thread commands contain machine-specific data structures suitable for
+ * use in the thread state primitives. The machine specific data structures
+ * follow the struct `ThreadCommand` as follows.
+ * Each flavor of machine specific data structure is preceded by an uint32_t
+ * constant for the flavor of that data structure, an uint32_t that is the
+ * count of uint32_t's of the size of the state data structure and then
+ * the state data structure follows. This triple may be repeated for many
+ * flavors. The constants for the flavors, counts and state data structure
+ * definitions are expected to be in the header file <machine/thread_status.h>.
+ * These machine specific data structures sizes must be multiples of
+ * 4 bytes. The `cmdsize` reflects the total size of the `ThreadCommand`
+ * and all of the sizes of the constants for the flavors, counts and state
+ * data structures.
+ *
+ * For executable objects that are unix processes there will be one
+ * `ThreadCommand` (cmd == LC_UNIXTHREAD) created for it by the link-editor.
+ * This is the same as a LC_THREAD, except that a stack is automatically
+ * created (based on the shell's limit for the stack size). Command arguments
+ * and environment variables are copied onto that stack.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ThreadCommand<E: Endian> {
+ /// LC_THREAD or LC_UNIXTHREAD
+ pub cmd: U32<E>,
+ /// total size of this command
+ pub cmdsize: U32<E>,
+ /* uint32_t flavor flavor of thread state */
+ /* uint32_t count count of uint32_t's in thread state */
+ /* struct XXX_thread_state state thread state for this flavor */
+ /* ... */
+}
+
+/*
+ * The routines command contains the address of the dynamic shared library
+ * initialization routine and an index into the module table for the module
+ * that defines the routine. Before any modules are used from the library the
+ * dynamic linker fully binds the module that defines the initialization routine
+ * and then calls it. This gets called before any module initialization
+ * routines (used for C++ static constructors) in the library.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct RoutinesCommand32<E: Endian> {
+ /* for 32-bit architectures */
+ /// LC_ROUTINES
+ pub cmd: U32<E>,
+ /// total size of this command
+ pub cmdsize: U32<E>,
+ /// address of initialization routine
+ pub init_address: U32<E>,
+ /// index into the module table that the init routine is defined in
+ pub init_module: U32<E>,
+ pub reserved1: U32<E>,
+ pub reserved2: U32<E>,
+ pub reserved3: U32<E>,
+ pub reserved4: U32<E>,
+ pub reserved5: U32<E>,
+ pub reserved6: U32<E>,
+}
+
+/*
+ * The 64-bit routines command. Same use as above.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct RoutinesCommand64<E: Endian> {
+ /* for 64-bit architectures */
+ /// LC_ROUTINES_64
+ pub cmd: U32<E>,
+ /// total size of this command
+ pub cmdsize: U32<E>,
+ /// address of initialization routine
+ pub init_address: U64<E>,
+ /// index into the module table that the init routine is defined in
+ pub init_module: U64<E>,
+ pub reserved1: U64<E>,
+ pub reserved2: U64<E>,
+ pub reserved3: U64<E>,
+ pub reserved4: U64<E>,
+ pub reserved5: U64<E>,
+ pub reserved6: U64<E>,
+}
+
+/*
+ * The `SymtabCommand` contains the offsets and sizes of the link-edit 4.3BSD
+ * "stab" style symbol table information as described in the header files
+ * <nlist.h> and <stab.h>.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SymtabCommand<E: Endian> {
+ /// LC_SYMTAB
+ pub cmd: U32<E>,
+ /// sizeof(struct SymtabCommand)
+ pub cmdsize: U32<E>,
+ /// symbol table offset
+ pub symoff: U32<E>,
+ /// number of symbol table entries
+ pub nsyms: U32<E>,
+ /// string table offset
+ pub stroff: U32<E>,
+ /// string table size in bytes
+ pub strsize: U32<E>,
+}
+
+/*
+ * This is the second set of the symbolic information which is used to support
+ * the data structures for the dynamically link editor.
+ *
+ * The original set of symbolic information in the `SymtabCommand` which contains
+ * the symbol and string tables must also be present when this load command is
+ * present. When this load command is present the symbol table is organized
+ * into three groups of symbols:
+ * local symbols (static and debugging symbols) - grouped by module
+ * defined external symbols - grouped by module (sorted by name if not lib)
+ * undefined external symbols (sorted by name if MH_BINDATLOAD is not set,
+ * and in order the were seen by the static
+ * linker if MH_BINDATLOAD is set)
+ * In this load command there are offsets and counts to each of the three groups
+ * of symbols.
+ *
+ * This load command contains a the offsets and sizes of the following new
+ * symbolic information tables:
+ * table of contents
+ * module table
+ * reference symbol table
+ * indirect symbol table
+ * The first three tables above (the table of contents, module table and
+ * reference symbol table) are only present if the file is a dynamically linked
+ * shared library. For executable and object modules, which are files
+ * containing only one module, the information that would be in these three
+ * tables is determined as follows:
+ * table of contents - the defined external symbols are sorted by name
+ * module table - the file contains only one module so everything in the
+ * file is part of the module.
+ * reference symbol table - is the defined and undefined external symbols
+ *
+ * For dynamically linked shared library files this load command also contains
+ * offsets and sizes to the pool of relocation entries for all sections
+ * separated into two groups:
+ * external relocation entries
+ * local relocation entries
+ * For executable and object modules the relocation entries continue to hang
+ * off the section structures.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DysymtabCommand<E: Endian> {
+ /// LC_DYSYMTAB
+ pub cmd: U32<E>,
+ /// sizeof(struct DysymtabCommand)
+ pub cmdsize: U32<E>,
+
+ /*
+ * The symbols indicated by symoff and nsyms of the LC_SYMTAB load command
+ * are grouped into the following three groups:
+ * local symbols (further grouped by the module they are from)
+ * defined external symbols (further grouped by the module they are from)
+ * undefined symbols
+ *
+ * The local symbols are used only for debugging. The dynamic binding
+ * process may have to use them to indicate to the debugger the local
+ * symbols for a module that is being bound.
+ *
+ * The last two groups are used by the dynamic binding process to do the
+ * binding (indirectly through the module table and the reference symbol
+ * table when this is a dynamically linked shared library file).
+ */
+ /// index to local symbols
+ pub ilocalsym: U32<E>,
+ /// number of local symbols
+ pub nlocalsym: U32<E>,
+
+ /// index to externally defined symbols
+ pub iextdefsym: U32<E>,
+ /// number of externally defined symbols
+ pub nextdefsym: U32<E>,
+
+ /// index to undefined symbols
+ pub iundefsym: U32<E>,
+ /// number of undefined symbols
+ pub nundefsym: U32<E>,
+
+ /*
+ * For the for the dynamic binding process to find which module a symbol
+ * is defined in the table of contents is used (analogous to the ranlib
+ * structure in an archive) which maps defined external symbols to modules
+ * they are defined in. This exists only in a dynamically linked shared
+ * library file. For executable and object modules the defined external
+ * symbols are sorted by name and is use as the table of contents.
+ */
+ /// file offset to table of contents
+ pub tocoff: U32<E>,
+ /// number of entries in table of contents
+ pub ntoc: U32<E>,
+
+ /*
+ * To support dynamic binding of "modules" (whole object files) the symbol
+ * table must reflect the modules that the file was created from. This is
+ * done by having a module table that has indexes and counts into the merged
+ * tables for each module. The module structure that these two entries
+ * refer to is described below. This exists only in a dynamically linked
+ * shared library file. For executable and object modules the file only
+ * contains one module so everything in the file belongs to the module.
+ */
+ /// file offset to module table
+ pub modtaboff: U32<E>,
+ /// number of module table entries
+ pub nmodtab: U32<E>,
+
+ /*
+ * To support dynamic module binding the module structure for each module
+ * indicates the external references (defined and undefined) each module
+ * makes. For each module there is an offset and a count into the
+ * reference symbol table for the symbols that the module references.
+ * This exists only in a dynamically linked shared library file. For
+ * executable and object modules the defined external symbols and the
+ * undefined external symbols indicates the external references.
+ */
+ /// offset to referenced symbol table
+ pub extrefsymoff: U32<E>,
+ /// number of referenced symbol table entries
+ pub nextrefsyms: U32<E>,
+
+ /*
+ * The sections that contain "symbol pointers" and "routine stubs" have
+ * indexes and (implied counts based on the size of the section and fixed
+ * size of the entry) into the "indirect symbol" table for each pointer
+ * and stub. For every section of these two types the index into the
+ * indirect symbol table is stored in the section header in the field
+ * reserved1. An indirect symbol table entry is simply a 32bit index into
+ * the symbol table to the symbol that the pointer or stub is referring to.
+ * The indirect symbol table is ordered to match the entries in the section.
+ */
+ /// file offset to the indirect symbol table
+ pub indirectsymoff: U32<E>,
+ /// number of indirect symbol table entries
+ pub nindirectsyms: U32<E>,
+
+ /*
+ * To support relocating an individual module in a library file quickly the
+ * external relocation entries for each module in the library need to be
+ * accessed efficiently. Since the relocation entries can't be accessed
+ * through the section headers for a library file they are separated into
+ * groups of local and external entries further grouped by module. In this
+ * case the presents of this load command who's extreloff, nextrel,
+ * locreloff and nlocrel fields are non-zero indicates that the relocation
+ * entries of non-merged sections are not referenced through the section
+ * structures (and the reloff and nreloc fields in the section headers are
+ * set to zero).
+ *
+ * Since the relocation entries are not accessed through the section headers
+ * this requires the r_address field to be something other than a section
+ * offset to identify the item to be relocated. In this case r_address is
+ * set to the offset from the vmaddr of the first LC_SEGMENT command.
+ * For MH_SPLIT_SEGS images r_address is set to the the offset from the
+ * vmaddr of the first read-write LC_SEGMENT command.
+ *
+ * The relocation entries are grouped by module and the module table
+ * entries have indexes and counts into them for the group of external
+ * relocation entries for that the module.
+ *
+ * For sections that are merged across modules there must not be any
+ * remaining external relocation entries for them (for merged sections
+ * remaining relocation entries must be local).
+ */
+ /// offset to external relocation entries
+ pub extreloff: U32<E>,
+ /// number of external relocation entries
+ pub nextrel: U32<E>,
+
+ /*
+ * All the local relocation entries are grouped together (they are not
+ * grouped by their module since they are only used if the object is moved
+ * from it staticly link edited address).
+ */
+ /// offset to local relocation entries
+ pub locreloff: U32<E>,
+ /// number of local relocation entries
+ pub nlocrel: U32<E>,
+}
+
+/*
+ * An indirect symbol table entry is simply a 32bit index into the symbol table
+ * to the symbol that the pointer or stub is refering to. Unless it is for a
+ * non-lazy symbol pointer section for a defined symbol which strip(1) as
+ * removed. In which case it has the value INDIRECT_SYMBOL_LOCAL. If the
+ * symbol was also absolute INDIRECT_SYMBOL_ABS is or'ed with that.
+ */
+pub const INDIRECT_SYMBOL_LOCAL: u32 = 0x8000_0000;
+pub const INDIRECT_SYMBOL_ABS: u32 = 0x4000_0000;
+
+/* a table of contents entry */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DylibTableOfContents<E: Endian> {
+ /// the defined external symbol (index into the symbol table)
+ pub symbol_index: U32<E>,
+ /// index into the module table this symbol is defined in
+ pub module_index: U32<E>,
+}
+
+/* a module table entry */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DylibModule32<E: Endian> {
+ /// the module name (index into string table)
+ pub module_name: U32<E>,
+
+ /// index into externally defined symbols
+ pub iextdefsym: U32<E>,
+ /// number of externally defined symbols
+ pub nextdefsym: U32<E>,
+ /// index into reference symbol table
+ pub irefsym: U32<E>,
+ /// number of reference symbol table entries
+ pub nrefsym: U32<E>,
+ /// index into symbols for local symbols
+ pub ilocalsym: U32<E>,
+ /// number of local symbols
+ pub nlocalsym: U32<E>,
+
+ /// index into external relocation entries
+ pub iextrel: U32<E>,
+ /// number of external relocation entries
+ pub nextrel: U32<E>,
+
+ /// low 16 bits are the index into the init section, high 16 bits are the index into the term section
+ pub iinit_iterm: U32<E>,
+ /// low 16 bits are the number of init section entries, high 16 bits are the number of term section entries
+ pub ninit_nterm: U32<E>,
+
+ /// for this module address of the start of the (__OBJC,__module_info) section
+ pub objc_module_info_addr: U32<E>,
+ /// for this module size of the (__OBJC,__module_info) section
+ pub objc_module_info_size: U32<E>,
+}
+
+/* a 64-bit module table entry */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DylibModule64<E: Endian> {
+ /// the module name (index into string table)
+ pub module_name: U32<E>,
+
+ /// index into externally defined symbols
+ pub iextdefsym: U32<E>,
+ /// number of externally defined symbols
+ pub nextdefsym: U32<E>,
+ /// index into reference symbol table
+ pub irefsym: U32<E>,
+ /// number of reference symbol table entries
+ pub nrefsym: U32<E>,
+ /// index into symbols for local symbols
+ pub ilocalsym: U32<E>,
+ /// number of local symbols
+ pub nlocalsym: U32<E>,
+
+ /// index into external relocation entries
+ pub iextrel: U32<E>,
+ /// number of external relocation entries
+ pub nextrel: U32<E>,
+
+ /// low 16 bits are the index into the init section, high 16 bits are the index into the term section
+ pub iinit_iterm: U32<E>,
+ /// low 16 bits are the number of init section entries, high 16 bits are the number of term section entries
+ pub ninit_nterm: U32<E>,
+
+ /// for this module size of the (__OBJC,__module_info) section
+ pub objc_module_info_size: U32<E>,
+ /// for this module address of the start of the (__OBJC,__module_info) section
+ pub objc_module_info_addr: U64<E>,
+}
+
+/*
+ * The entries in the reference symbol table are used when loading the module
+ * (both by the static and dynamic link editors) and if the module is unloaded
+ * or replaced. Therefore all external symbols (defined and undefined) are
+ * listed in the module's reference table. The flags describe the type of
+ * reference that is being made. The constants for the flags are defined in
+ * <mach-o/nlist.h> as they are also used for symbol table entries.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DylibReference<E: Endian> {
+ /* TODO:
+ uint32_t isym:24, /* index into the symbol table */
+ flags:8; /* flags to indicate the type of reference */
+ */
+ pub bitfield: U32<E>,
+}
+
+/*
+ * The TwolevelHintsCommand contains the offset and number of hints in the
+ * two-level namespace lookup hints table.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct TwolevelHintsCommand<E: Endian> {
+ /// LC_TWOLEVEL_HINTS
+ pub cmd: U32<E>,
+ /// sizeof(struct TwolevelHintsCommand)
+ pub cmdsize: U32<E>,
+ /// offset to the hint table
+ pub offset: U32<E>,
+ /// number of hints in the hint table
+ pub nhints: U32<E>,
+}
+
+/*
+ * The entries in the two-level namespace lookup hints table are TwolevelHint
+ * structs. These provide hints to the dynamic link editor where to start
+ * looking for an undefined symbol in a two-level namespace image. The
+ * isub_image field is an index into the sub-images (sub-frameworks and
+ * sub-umbrellas list) that made up the two-level image that the undefined
+ * symbol was found in when it was built by the static link editor. If
+ * isub-image is 0 the the symbol is expected to be defined in library and not
+ * in the sub-images. If isub-image is non-zero it is an index into the array
+ * of sub-images for the umbrella with the first index in the sub-images being
+ * 1. The array of sub-images is the ordered list of sub-images of the umbrella
+ * that would be searched for a symbol that has the umbrella recorded as its
+ * primary library. The table of contents index is an index into the
+ * library's table of contents. This is used as the starting point of the
+ * binary search or a directed linear search.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct TwolevelHint<E: Endian> {
+ /* TODO:
+ uint32_t
+ isub_image:8, /* index into the sub images */
+ itoc:24; /* index into the table of contents */
+ */
+ pub bitfield: U32<E>,
+}
+
+/*
+ * The PrebindCksumCommand contains the value of the original check sum for
+ * prebound files or zero. When a prebound file is first created or modified
+ * for other than updating its prebinding information the value of the check sum
+ * is set to zero. When the file has it prebinding re-done and if the value of
+ * the check sum is zero the original check sum is calculated and stored in
+ * cksum field of this load command in the output file. If when the prebinding
+ * is re-done and the cksum field is non-zero it is left unchanged from the
+ * input file.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct PrebindCksumCommand<E: Endian> {
+ /// LC_PREBIND_CKSUM
+ pub cmd: U32<E>,
+ /// sizeof(struct PrebindCksumCommand)
+ pub cmdsize: U32<E>,
+ /// the check sum or zero
+ pub cksum: U32<E>,
+}
+
+/*
+ * The uuid load command contains a single 128-bit unique random number that
+ * identifies an object produced by the static link editor.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct UuidCommand<E: Endian> {
+ /// LC_UUID
+ pub cmd: U32<E>,
+ /// sizeof(struct UuidCommand)
+ pub cmdsize: U32<E>,
+ /// the 128-bit uuid
+ pub uuid: [u8; 16],
+}
+
+/*
+ * The RpathCommand contains a path which at runtime should be added to
+ * the current run path used to find @rpath prefixed dylibs.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct RpathCommand<E: Endian> {
+ /// LC_RPATH
+ pub cmd: U32<E>,
+ /// includes string
+ pub cmdsize: U32<E>,
+ /// path to add to run path
+ pub path: LcStr<E>,
+}
+
+/*
+ * The LinkeditDataCommand contains the offsets and sizes of a blob
+ * of data in the __LINKEDIT segment.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct LinkeditDataCommand<E: Endian> {
+ /// `LC_CODE_SIGNATURE`, `LC_SEGMENT_SPLIT_INFO`, `LC_FUNCTION_STARTS`,
+ /// `LC_DATA_IN_CODE`, `LC_DYLIB_CODE_SIGN_DRS`, `LC_LINKER_OPTIMIZATION_HINT`,
+ /// `LC_DYLD_EXPORTS_TRIE`, or `LC_DYLD_CHAINED_FIXUPS`.
+ pub cmd: U32<E>,
+ /// sizeof(struct LinkeditDataCommand)
+ pub cmdsize: U32<E>,
+ /// file offset of data in __LINKEDIT segment
+ pub dataoff: U32<E>,
+ /// file size of data in __LINKEDIT segment
+ pub datasize: U32<E>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct FilesetEntryCommand<E: Endian> {
+ // LC_FILESET_ENTRY
+ pub cmd: U32<E>,
+ /// includes id string
+ pub cmdsize: U32<E>,
+ /// memory address of the dylib
+ pub vmaddr: U64<E>,
+ /// file offset of the dylib
+ pub fileoff: U64<E>,
+ /// contained entry id
+ pub entry_id: LcStr<E>,
+ /// entry_id is 32-bits long, so this is the reserved padding
+ pub reserved: U32<E>,
+}
+
+/*
+ * The EncryptionInfoCommand32 contains the file offset and size of an
+ * of an encrypted segment.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct EncryptionInfoCommand32<E: Endian> {
+ /// LC_ENCRYPTION_INFO
+ pub cmd: U32<E>,
+ /// sizeof(struct EncryptionInfoCommand32)
+ pub cmdsize: U32<E>,
+ /// file offset of encrypted range
+ pub cryptoff: U32<E>,
+ /// file size of encrypted range
+ pub cryptsize: U32<E>,
+ /// which enryption system, 0 means not-encrypted yet
+ pub cryptid: U32<E>,
+}
+
+/*
+ * The EncryptionInfoCommand64 contains the file offset and size of an
+ * of an encrypted segment (for use in x86_64 targets).
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct EncryptionInfoCommand64<E: Endian> {
+ /// LC_ENCRYPTION_INFO_64
+ pub cmd: U32<E>,
+ /// sizeof(struct EncryptionInfoCommand64)
+ pub cmdsize: U32<E>,
+ /// file offset of encrypted range
+ pub cryptoff: U32<E>,
+ /// file size of encrypted range
+ pub cryptsize: U32<E>,
+ /// which enryption system, 0 means not-encrypted yet
+ pub cryptid: U32<E>,
+ /// padding to make this struct's size a multiple of 8 bytes
+ pub pad: U32<E>,
+}
+
+/*
+ * The VersionMinCommand contains the min OS version on which this
+ * binary was built to run.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct VersionMinCommand<E: Endian> {
+ /// LC_VERSION_MIN_MACOSX or LC_VERSION_MIN_IPHONEOS or LC_VERSION_MIN_WATCHOS or LC_VERSION_MIN_TVOS
+ pub cmd: U32<E>,
+ /// sizeof(struct VersionMinCommand)
+ pub cmdsize: U32<E>,
+ /// X.Y.Z is encoded in nibbles xxxx.yy.zz
+ pub version: U32<E>,
+ /// X.Y.Z is encoded in nibbles xxxx.yy.zz
+ pub sdk: U32<E>,
+}
+
+/*
+ * The BuildVersionCommand contains the min OS version on which this
+ * binary was built to run for its platform. The list of known platforms and
+ * tool values following it.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct BuildVersionCommand<E: Endian> {
+ /// LC_BUILD_VERSION
+ pub cmd: U32<E>,
+ /// sizeof(struct BuildVersionCommand) plus ntools * sizeof(struct BuildToolVersion)
+ pub cmdsize: U32<E>,
+ /// platform
+ pub platform: U32<E>,
+ /// X.Y.Z is encoded in nibbles xxxx.yy.zz
+ pub minos: U32<E>,
+ /// X.Y.Z is encoded in nibbles xxxx.yy.zz
+ pub sdk: U32<E>,
+ /// number of tool entries following this
+ pub ntools: U32<E>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct BuildToolVersion<E: Endian> {
+ /// enum for the tool
+ pub tool: U32<E>,
+ /// version number of the tool
+ pub version: U32<E>,
+}
+
+/* Known values for the platform field above. */
+pub const PLATFORM_MACOS: u32 = 1;
+pub const PLATFORM_IOS: u32 = 2;
+pub const PLATFORM_TVOS: u32 = 3;
+pub const PLATFORM_WATCHOS: u32 = 4;
+pub const PLATFORM_BRIDGEOS: u32 = 5;
+pub const PLATFORM_MACCATALYST: u32 = 6;
+pub const PLATFORM_IOSSIMULATOR: u32 = 7;
+pub const PLATFORM_TVOSSIMULATOR: u32 = 8;
+pub const PLATFORM_WATCHOSSIMULATOR: u32 = 9;
+pub const PLATFORM_DRIVERKIT: u32 = 10;
+
+/* Known values for the tool field above. */
+pub const TOOL_CLANG: u32 = 1;
+pub const TOOL_SWIFT: u32 = 2;
+pub const TOOL_LD: u32 = 3;
+
+/*
+ * The DyldInfoCommand contains the file offsets and sizes of
+ * the new compressed form of the information dyld needs to
+ * load the image. This information is used by dyld on Mac OS X
+ * 10.6 and later. All information pointed to by this command
+ * is encoded using byte streams, so no endian swapping is needed
+ * to interpret it.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DyldInfoCommand<E: Endian> {
+ /// LC_DYLD_INFO or LC_DYLD_INFO_ONLY
+ pub cmd: U32<E>,
+ /// sizeof(struct DyldInfoCommand)
+ pub cmdsize: U32<E>,
+
+ /*
+ * Dyld rebases an image whenever dyld loads it at an address different
+ * from its preferred address. The rebase information is a stream
+ * of byte sized opcodes whose symbolic names start with REBASE_OPCODE_.
+ * Conceptually the rebase information is a table of tuples:
+ * <seg-index, seg-offset, type>
+ * The opcodes are a compressed way to encode the table by only
+ * encoding when a column changes. In addition simple patterns
+ * like "every n'th offset for m times" can be encoded in a few
+ * bytes.
+ */
+ /// file offset to rebase info
+ pub rebase_off: U32<E>,
+ /// size of rebase info
+ pub rebase_size: U32<E>,
+
+ /*
+ * Dyld binds an image during the loading process, if the image
+ * requires any pointers to be initialized to symbols in other images.
+ * The bind information is a stream of byte sized
+ * opcodes whose symbolic names start with BIND_OPCODE_.
+ * Conceptually the bind information is a table of tuples:
+ * <seg-index, seg-offset, type, symbol-library-ordinal, symbol-name, addend>
+ * The opcodes are a compressed way to encode the table by only
+ * encoding when a column changes. In addition simple patterns
+ * like for runs of pointers initialzed to the same value can be
+ * encoded in a few bytes.
+ */
+ /// file offset to binding info
+ pub bind_off: U32<E>,
+ /// size of binding info
+ pub bind_size: U32<E>,
+
+ /*
+ * Some C++ programs require dyld to unique symbols so that all
+ * images in the process use the same copy of some code/data.
+ * This step is done after binding. The content of the weak_bind
+ * info is an opcode stream like the bind_info. But it is sorted
+ * alphabetically by symbol name. This enable dyld to walk
+ * all images with weak binding information in order and look
+ * for collisions. If there are no collisions, dyld does
+ * no updating. That means that some fixups are also encoded
+ * in the bind_info. For instance, all calls to "operator new"
+ * are first bound to libstdc++.dylib using the information
+ * in bind_info. Then if some image overrides operator new
+ * that is detected when the weak_bind information is processed
+ * and the call to operator new is then rebound.
+ */
+ /// file offset to weak binding info
+ pub weak_bind_off: U32<E>,
+ /// size of weak binding info
+ pub weak_bind_size: U32<E>,
+
+ /*
+ * Some uses of external symbols do not need to be bound immediately.
+ * Instead they can be lazily bound on first use. The lazy_bind
+ * are contains a stream of BIND opcodes to bind all lazy symbols.
+ * Normal use is that dyld ignores the lazy_bind section when
+ * loading an image. Instead the static linker arranged for the
+ * lazy pointer to initially point to a helper function which
+ * pushes the offset into the lazy_bind area for the symbol
+ * needing to be bound, then jumps to dyld which simply adds
+ * the offset to lazy_bind_off to get the information on what
+ * to bind.
+ */
+ /// file offset to lazy binding info
+ pub lazy_bind_off: U32<E>,
+ /// size of lazy binding infs
+ pub lazy_bind_size: U32<E>,
+
+ /*
+ * The symbols exported by a dylib are encoded in a trie. This
+ * is a compact representation that factors out common prefixes.
+ * It also reduces LINKEDIT pages in RAM because it encodes all
+ * information (name, address, flags) in one small, contiguous range.
+ * The export area is a stream of nodes. The first node sequentially
+ * is the start node for the trie.
+ *
+ * Nodes for a symbol start with a uleb128 that is the length of
+ * the exported symbol information for the string so far.
+ * If there is no exported symbol, the node starts with a zero byte.
+ * If there is exported info, it follows the length.
+ *
+ * First is a uleb128 containing flags. Normally, it is followed by
+ * a uleb128 encoded offset which is location of the content named
+ * by the symbol from the mach_header for the image. If the flags
+ * is EXPORT_SYMBOL_FLAGS_REEXPORT, then following the flags is
+ * a uleb128 encoded library ordinal, then a zero terminated
+ * UTF8 string. If the string is zero length, then the symbol
+ * is re-export from the specified dylib with the same name.
+ * If the flags is EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER, then following
+ * the flags is two uleb128s: the stub offset and the resolver offset.
+ * The stub is used by non-lazy pointers. The resolver is used
+ * by lazy pointers and must be called to get the actual address to use.
+ *
+ * After the optional exported symbol information is a byte of
+ * how many edges (0-255) that this node has leaving it,
+ * followed by each edge.
+ * Each edge is a zero terminated UTF8 of the addition chars
+ * in the symbol, followed by a uleb128 offset for the node that
+ * edge points to.
+ *
+ */
+ /// file offset to lazy binding info
+ pub export_off: U32<E>,
+ /// size of lazy binding infs
+ pub export_size: U32<E>,
+}
+
+/*
+ * The following are used to encode rebasing information
+ */
+pub const REBASE_TYPE_POINTER: u8 = 1;
+pub const REBASE_TYPE_TEXT_ABSOLUTE32: u8 = 2;
+pub const REBASE_TYPE_TEXT_PCREL32: u8 = 3;
+
+pub const REBASE_OPCODE_MASK: u8 = 0xF0;
+pub const REBASE_IMMEDIATE_MASK: u8 = 0x0F;
+pub const REBASE_OPCODE_DONE: u8 = 0x00;
+pub const REBASE_OPCODE_SET_TYPE_IMM: u8 = 0x10;
+pub const REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: u8 = 0x20;
+pub const REBASE_OPCODE_ADD_ADDR_ULEB: u8 = 0x30;
+pub const REBASE_OPCODE_ADD_ADDR_IMM_SCALED: u8 = 0x40;
+pub const REBASE_OPCODE_DO_REBASE_IMM_TIMES: u8 = 0x50;
+pub const REBASE_OPCODE_DO_REBASE_ULEB_TIMES: u8 = 0x60;
+pub const REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB: u8 = 0x70;
+pub const REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB: u8 = 0x80;
+
+/*
+ * The following are used to encode binding information
+ */
+pub const BIND_TYPE_POINTER: u8 = 1;
+pub const BIND_TYPE_TEXT_ABSOLUTE32: u8 = 2;
+pub const BIND_TYPE_TEXT_PCREL32: u8 = 3;
+
+pub const BIND_SPECIAL_DYLIB_SELF: i8 = 0;
+pub const BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE: i8 = -1;
+pub const BIND_SPECIAL_DYLIB_FLAT_LOOKUP: i8 = -2;
+pub const BIND_SPECIAL_DYLIB_WEAK_LOOKUP: i8 = -3;
+
+pub const BIND_SYMBOL_FLAGS_WEAK_IMPORT: u8 = 0x1;
+pub const BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION: u8 = 0x8;
+
+pub const BIND_OPCODE_MASK: u8 = 0xF0;
+pub const BIND_IMMEDIATE_MASK: u8 = 0x0F;
+pub const BIND_OPCODE_DONE: u8 = 0x00;
+pub const BIND_OPCODE_SET_DYLIB_ORDINAL_IMM: u8 = 0x10;
+pub const BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB: u8 = 0x20;
+pub const BIND_OPCODE_SET_DYLIB_SPECIAL_IMM: u8 = 0x30;
+pub const BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM: u8 = 0x40;
+pub const BIND_OPCODE_SET_TYPE_IMM: u8 = 0x50;
+pub const BIND_OPCODE_SET_ADDEND_SLEB: u8 = 0x60;
+pub const BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB: u8 = 0x70;
+pub const BIND_OPCODE_ADD_ADDR_ULEB: u8 = 0x80;
+pub const BIND_OPCODE_DO_BIND: u8 = 0x90;
+pub const BIND_OPCODE_DO_BIND_ADD_ADDR_ULEB: u8 = 0xA0;
+pub const BIND_OPCODE_DO_BIND_ADD_ADDR_IMM_SCALED: u8 = 0xB0;
+pub const BIND_OPCODE_DO_BIND_ULEB_TIMES_SKIPPING_ULEB: u8 = 0xC0;
+pub const BIND_OPCODE_THREADED: u8 = 0xD0;
+pub const BIND_SUBOPCODE_THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB: u8 = 0x00;
+pub const BIND_SUBOPCODE_THREADED_APPLY: u8 = 0x01;
+
+/*
+ * The following are used on the flags byte of a terminal node
+ * in the export information.
+ */
+pub const EXPORT_SYMBOL_FLAGS_KIND_MASK: u32 = 0x03;
+pub const EXPORT_SYMBOL_FLAGS_KIND_REGULAR: u32 = 0x00;
+pub const EXPORT_SYMBOL_FLAGS_KIND_THREAD_LOCAL: u32 = 0x01;
+pub const EXPORT_SYMBOL_FLAGS_KIND_ABSOLUTE: u32 = 0x02;
+pub const EXPORT_SYMBOL_FLAGS_WEAK_DEFINITION: u32 = 0x04;
+pub const EXPORT_SYMBOL_FLAGS_REEXPORT: u32 = 0x08;
+pub const EXPORT_SYMBOL_FLAGS_STUB_AND_RESOLVER: u32 = 0x10;
+
+/*
+ * The LinkerOptionCommand contains linker options embedded in object files.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct LinkerOptionCommand<E: Endian> {
+ /// LC_LINKER_OPTION only used in MH_OBJECT filetypes
+ pub cmd: U32<E>,
+ pub cmdsize: U32<E>,
+ /// number of strings
+ pub count: U32<E>,
+ /* concatenation of zero terminated UTF8 strings.
+ Zero filled at end to align */
+}
+
+/*
+ * The SymsegCommand contains the offset and size of the GNU style
+ * symbol table information as described in the header file <symseg.h>.
+ * The symbol roots of the symbol segments must also be aligned properly
+ * in the file. So the requirement of keeping the offsets aligned to a
+ * multiple of a 4 bytes translates to the length field of the symbol
+ * roots also being a multiple of a long. Also the padding must again be
+ * zeroed. (THIS IS OBSOLETE and no longer supported).
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SymsegCommand<E: Endian> {
+ /// LC_SYMSEG
+ pub cmd: U32<E>,
+ /// sizeof(struct SymsegCommand)
+ pub cmdsize: U32<E>,
+ /// symbol segment offset
+ pub offset: U32<E>,
+ /// symbol segment size in bytes
+ pub size: U32<E>,
+}
+
+/*
+ * The IdentCommand contains a free format string table following the
+ * IdentCommand structure. The strings are null terminated and the size of
+ * the command is padded out with zero bytes to a multiple of 4 bytes/
+ * (THIS IS OBSOLETE and no longer supported).
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct IdentCommand<E: Endian> {
+ /// LC_IDENT
+ pub cmd: U32<E>,
+ /// strings that follow this command
+ pub cmdsize: U32<E>,
+}
+
+/*
+ * The FvmfileCommand contains a reference to a file to be loaded at the
+ * specified virtual address. (Presently, this command is reserved for
+ * internal use. The kernel ignores this command when loading a program into
+ * memory).
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct FvmfileCommand<E: Endian> {
+ /// LC_FVMFILE
+ pub cmd: U32<E>,
+ /// includes pathname string
+ pub cmdsize: U32<E>,
+ /// files pathname
+ pub name: LcStr<E>,
+ /// files virtual address
+ pub header_addr: U32<E>,
+}
+
+/*
+ * The EntryPointCommand is a replacement for thread_command.
+ * It is used for main executables to specify the location (file offset)
+ * of main(). If -stack_size was used at link time, the stacksize
+ * field will contain the stack size need for the main thread.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct EntryPointCommand<E: Endian> {
+ /// LC_MAIN only used in MH_EXECUTE filetypes
+ pub cmd: U32<E>,
+ /// 24
+ pub cmdsize: U32<E>,
+ /// file (__TEXT) offset of main()
+ pub entryoff: U64<E>,
+ /// if not zero, initial stack size
+ pub stacksize: U64<E>,
+}
+
+/*
+ * The SourceVersionCommand is an optional load command containing
+ * the version of the sources used to build the binary.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct SourceVersionCommand<E: Endian> {
+ /// LC_SOURCE_VERSION
+ pub cmd: U32<E>,
+ /// 16
+ pub cmdsize: U32<E>,
+ /// A.B.C.D.E packed as a24.b10.c10.d10.e10
+ pub version: U64<E>,
+}
+
+/*
+ * The LC_DATA_IN_CODE load commands uses a LinkeditDataCommand
+ * to point to an array of DataInCodeEntry entries. Each entry
+ * describes a range of data in a code section.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct DataInCodeEntry<E: Endian> {
+ /// from mach_header to start of data range
+ pub offset: U32<E>,
+ /// number of bytes in data range
+ pub length: U16<E>,
+ /// a DICE_KIND_* value
+ pub kind: U16<E>,
+}
+pub const DICE_KIND_DATA: u32 = 0x0001;
+pub const DICE_KIND_JUMP_TABLE8: u32 = 0x0002;
+pub const DICE_KIND_JUMP_TABLE16: u32 = 0x0003;
+pub const DICE_KIND_JUMP_TABLE32: u32 = 0x0004;
+pub const DICE_KIND_ABS_JUMP_TABLE32: u32 = 0x0005;
+
+/*
+ * Sections of type S_THREAD_LOCAL_VARIABLES contain an array
+ * of TlvDescriptor structures.
+ */
+/* TODO:
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct TlvDescriptor<E: Endian>
+{
+ void* (*thunk)(struct TlvDescriptor*);
+ unsigned long key;
+ unsigned long offset;
+}
+*/
+
+/*
+ * LC_NOTE commands describe a region of arbitrary data included in a Mach-O
+ * file. Its initial use is to record extra data in MH_CORE files.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct NoteCommand<E: Endian> {
+ /// LC_NOTE
+ pub cmd: U32<E>,
+ /// sizeof(struct NoteCommand)
+ pub cmdsize: U32<E>,
+ /// owner name for this LC_NOTE
+ pub data_owner: [u8; 16],
+ /// file offset of this data
+ pub offset: U64<E>,
+ /// length of data region
+ pub size: U64<E>,
+}
+
+// Definitions from "/usr/include/mach-o/nlist.h".
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Nlist32<E: Endian> {
+ /// index into the string table
+ pub n_strx: U32<E>,
+ /// type flag, see below
+ pub n_type: u8,
+ /// section number or NO_SECT
+ pub n_sect: u8,
+ /// see <mach-o/stab.h>
+ pub n_desc: U16<E>,
+ /// value of this symbol (or stab offset)
+ pub n_value: U32<E>,
+}
+
+/*
+ * This is the symbol table entry structure for 64-bit architectures.
+ */
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Nlist64<E: Endian> {
+ /// index into the string table
+ pub n_strx: U32<E>,
+ /// type flag, see below
+ pub n_type: u8,
+ /// section number or NO_SECT
+ pub n_sect: u8,
+ /// see <mach-o/stab.h>
+ pub n_desc: U16<E>,
+ /// value of this symbol (or stab offset)
+ // Note: 4 byte alignment has been observed in practice.
+ pub n_value: U64Bytes<E>,
+}
+
+/*
+ * Symbols with a index into the string table of zero (n_un.n_strx == 0) are
+ * defined to have a null, "", name. Therefore all string indexes to non null
+ * names must not have a zero string index. This is bit historical information
+ * that has never been well documented.
+ */
+
+/*
+ * The n_type field really contains four fields:
+ * unsigned char N_STAB:3,
+ * N_PEXT:1,
+ * N_TYPE:3,
+ * N_EXT:1;
+ * which are used via the following masks.
+ */
+/// if any of these bits set, a symbolic debugging entry
+pub const N_STAB: u8 = 0xe0;
+/// private external symbol bit
+pub const N_PEXT: u8 = 0x10;
+/// mask for the type bits
+pub const N_TYPE: u8 = 0x0e;
+/// external symbol bit, set for external symbols
+pub const N_EXT: u8 = 0x01;
+
+/*
+ * Only symbolic debugging entries have some of the N_STAB bits set and if any
+ * of these bits are set then it is a symbolic debugging entry (a stab). In
+ * which case then the values of the n_type field (the entire field) are given
+ * in <mach-o/stab.h>
+ */
+
+/*
+ * Values for N_TYPE bits of the n_type field.
+ */
+/// undefined, n_sect == NO_SECT
+pub const N_UNDF: u8 = 0x0;
+/// absolute, n_sect == NO_SECT
+pub const N_ABS: u8 = 0x2;
+/// defined in section number n_sect
+pub const N_SECT: u8 = 0xe;
+/// prebound undefined (defined in a dylib)
+pub const N_PBUD: u8 = 0xc;
+/// indirect
+pub const N_INDR: u8 = 0xa;
+
+/*
+ * If the type is N_INDR then the symbol is defined to be the same as another
+ * symbol. In this case the n_value field is an index into the string table
+ * of the other symbol's name. When the other symbol is defined then they both
+ * take on the defined type and value.
+ */
+
+/*
+ * If the type is N_SECT then the n_sect field contains an ordinal of the
+ * section the symbol is defined in. The sections are numbered from 1 and
+ * refer to sections in order they appear in the load commands for the file
+ * they are in. This means the same ordinal may very well refer to different
+ * sections in different files.
+ *
+ * The n_value field for all symbol table entries (including N_STAB's) gets
+ * updated by the link editor based on the value of it's n_sect field and where
+ * the section n_sect references gets relocated. If the value of the n_sect
+ * field is NO_SECT then it's n_value field is not changed by the link editor.
+ */
+/// symbol is not in any section
+pub const NO_SECT: u8 = 0;
+/// 1 thru 255 inclusive
+pub const MAX_SECT: u8 = 255;
+
+/*
+ * Common symbols are represented by undefined (N_UNDF) external (N_EXT) types
+ * who's values (n_value) are non-zero. In which case the value of the n_value
+ * field is the size (in bytes) of the common symbol. The n_sect field is set
+ * to NO_SECT. The alignment of a common symbol may be set as a power of 2
+ * between 2^1 and 2^15 as part of the n_desc field using the macros below. If
+ * the alignment is not set (a value of zero) then natural alignment based on
+ * the size is used.
+ */
+/* TODO:
+#define GET_COMM_ALIGN(n_desc) (((n_desc) >> 8) & 0x0f)
+#define SET_COMM_ALIGN(n_desc,align) \
+ (n_desc) = (((n_desc) & 0xf0ff) | (((align) & 0x0f) << 8))
+ */
+
+/*
+ * To support the lazy binding of undefined symbols in the dynamic link-editor,
+ * the undefined symbols in the symbol table (the nlist structures) are marked
+ * with the indication if the undefined reference is a lazy reference or
+ * non-lazy reference. If both a non-lazy reference and a lazy reference is
+ * made to the same symbol the non-lazy reference takes precedence. A reference
+ * is lazy only when all references to that symbol are made through a symbol
+ * pointer in a lazy symbol pointer section.
+ *
+ * The implementation of marking nlist structures in the symbol table for
+ * undefined symbols will be to use some of the bits of the n_desc field as a
+ * reference type. The mask REFERENCE_TYPE will be applied to the n_desc field
+ * of an nlist structure for an undefined symbol to determine the type of
+ * undefined reference (lazy or non-lazy).
+ *
+ * The constants for the REFERENCE FLAGS are propagated to the reference table
+ * in a shared library file. In that case the constant for a defined symbol,
+ * REFERENCE_FLAG_DEFINED, is also used.
+ */
+/* Reference type bits of the n_desc field of undefined symbols */
+pub const REFERENCE_TYPE: u16 = 0x7;
+/* types of references */
+pub const REFERENCE_FLAG_UNDEFINED_NON_LAZY: u16 = 0;
+pub const REFERENCE_FLAG_UNDEFINED_LAZY: u16 = 1;
+pub const REFERENCE_FLAG_DEFINED: u16 = 2;
+pub const REFERENCE_FLAG_PRIVATE_DEFINED: u16 = 3;
+pub const REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY: u16 = 4;
+pub const REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY: u16 = 5;
+
+/*
+ * To simplify stripping of objects that use are used with the dynamic link
+ * editor, the static link editor marks the symbols defined an object that are
+ * referenced by a dynamicly bound object (dynamic shared libraries, bundles).
+ * With this marking strip knows not to strip these symbols.
+ */
+pub const REFERENCED_DYNAMICALLY: u16 = 0x0010;
+
+/*
+ * For images created by the static link editor with the -twolevel_namespace
+ * option in effect the flags field of the mach header is marked with
+ * MH_TWOLEVEL. And the binding of the undefined references of the image are
+ * determined by the static link editor. Which library an undefined symbol is
+ * bound to is recorded by the static linker in the high 8 bits of the n_desc
+ * field using the SET_LIBRARY_ORDINAL macro below. The ordinal recorded
+ * references the libraries listed in the Mach-O's LC_LOAD_DYLIB,
+ * LC_LOAD_WEAK_DYLIB, LC_REEXPORT_DYLIB, LC_LOAD_UPWARD_DYLIB, and
+ * LC_LAZY_LOAD_DYLIB, etc. load commands in the order they appear in the
+ * headers. The library ordinals start from 1.
+ * For a dynamic library that is built as a two-level namespace image the
+ * undefined references from module defined in another use the same nlist struct
+ * an in that case SELF_LIBRARY_ORDINAL is used as the library ordinal. For
+ * defined symbols in all images they also must have the library ordinal set to
+ * SELF_LIBRARY_ORDINAL. The EXECUTABLE_ORDINAL refers to the executable
+ * image for references from plugins that refer to the executable that loads
+ * them.
+ *
+ * The DYNAMIC_LOOKUP_ORDINAL is for undefined symbols in a two-level namespace
+ * image that are looked up by the dynamic linker with flat namespace semantics.
+ * This ordinal was added as a feature in Mac OS X 10.3 by reducing the
+ * value of MAX_LIBRARY_ORDINAL by one. So it is legal for existing binaries
+ * or binaries built with older tools to have 0xfe (254) dynamic libraries. In
+ * this case the ordinal value 0xfe (254) must be treated as a library ordinal
+ * for compatibility.
+ */
+/* TODO:
+#define GET_LIBRARY_ORDINAL(n_desc) (((n_desc) >> 8) & 0xff)
+#define SET_LIBRARY_ORDINAL(n_desc,ordinal) \
+ (n_desc) = (((n_desc) & 0x00ff) | (((ordinal) & 0xff) << 8))
+ */
+pub const SELF_LIBRARY_ORDINAL: u8 = 0x0;
+pub const MAX_LIBRARY_ORDINAL: u8 = 0xfd;
+pub const DYNAMIC_LOOKUP_ORDINAL: u8 = 0xfe;
+pub const EXECUTABLE_ORDINAL: u8 = 0xff;
+
+/*
+ * The bit 0x0020 of the n_desc field is used for two non-overlapping purposes
+ * and has two different symbolic names, N_NO_DEAD_STRIP and N_DESC_DISCARDED.
+ */
+
+/*
+ * The N_NO_DEAD_STRIP bit of the n_desc field only ever appears in a
+ * relocatable .o file (MH_OBJECT filetype). And is used to indicate to the
+ * static link editor it is never to dead strip the symbol.
+ */
+/// symbol is not to be dead stripped
+pub const N_NO_DEAD_STRIP: u16 = 0x0020;
+
+/*
+ * The N_DESC_DISCARDED bit of the n_desc field never appears in linked image.
+ * But is used in very rare cases by the dynamic link editor to mark an in
+ * memory symbol as discared and longer used for linking.
+ */
+/// symbol is discarded
+pub const N_DESC_DISCARDED: u16 = 0x0020;
+
+/*
+ * The N_WEAK_REF bit of the n_desc field indicates to the dynamic linker that
+ * the undefined symbol is allowed to be missing and is to have the address of
+ * zero when missing.
+ */
+/// symbol is weak referenced
+pub const N_WEAK_REF: u16 = 0x0040;
+
+/*
+ * The N_WEAK_DEF bit of the n_desc field indicates to the static and dynamic
+ * linkers that the symbol definition is weak, allowing a non-weak symbol to
+ * also be used which causes the weak definition to be discared. Currently this
+ * is only supported for symbols in coalesed sections.
+ */
+/// coalesed symbol is a weak definition
+pub const N_WEAK_DEF: u16 = 0x0080;
+
+/*
+ * The N_REF_TO_WEAK bit of the n_desc field indicates to the dynamic linker
+ * that the undefined symbol should be resolved using flat namespace searching.
+ */
+/// reference to a weak symbol
+pub const N_REF_TO_WEAK: u16 = 0x0080;
+
+/*
+ * The N_ARM_THUMB_DEF bit of the n_desc field indicates that the symbol is
+ * a defintion of a Thumb function.
+ */
+/// symbol is a Thumb function (ARM)
+pub const N_ARM_THUMB_DEF: u16 = 0x0008;
+
+/*
+ * The N_SYMBOL_RESOLVER bit of the n_desc field indicates that the
+ * that the function is actually a resolver function and should
+ * be called to get the address of the real function to use.
+ * This bit is only available in .o files (MH_OBJECT filetype)
+ */
+pub const N_SYMBOL_RESOLVER: u16 = 0x0100;
+
+/*
+ * The N_ALT_ENTRY bit of the n_desc field indicates that the
+ * symbol is pinned to the previous content.
+ */
+pub const N_ALT_ENTRY: u16 = 0x0200;
+
+// Definitions from "/usr/include/mach-o/stab.h".
+
+/*
+ * This file gives definitions supplementing <nlist.h> for permanent symbol
+ * table entries of Mach-O files. Modified from the BSD definitions. The
+ * modifications from the original definitions were changing what the values of
+ * what was the n_other field (an unused field) which is now the n_sect field.
+ * These modifications are required to support symbols in an arbitrary number of
+ * sections not just the three sections (text, data and bss) in a BSD file.
+ * The values of the defined constants have NOT been changed.
+ *
+ * These must have one of the N_STAB bits on. The n_value fields are subject
+ * to relocation according to the value of their n_sect field. So for types
+ * that refer to things in sections the n_sect field must be filled in with the
+ * proper section ordinal. For types that are not to have their n_value field
+ * relocatated the n_sect field must be NO_SECT.
+ */
+
+/*
+ * Symbolic debugger symbols. The comments give the conventional use for
+ *
+ * .stabs "n_name", n_type, n_sect, n_desc, n_value
+ *
+ * where n_type is the defined constant and not listed in the comment. Other
+ * fields not listed are zero. n_sect is the section ordinal the entry is
+ * refering to.
+ */
+/// global symbol: name,,NO_SECT,type,0
+pub const N_GSYM: u8 = 0x20;
+/// procedure name (f77 kludge): name,,NO_SECT,0,0
+pub const N_FNAME: u8 = 0x22;
+/// procedure: name,,n_sect,linenumber,address
+pub const N_FUN: u8 = 0x24;
+/// static symbol: name,,n_sect,type,address
+pub const N_STSYM: u8 = 0x26;
+/// .lcomm symbol: name,,n_sect,type,address
+pub const N_LCSYM: u8 = 0x28;
+/// begin nsect sym: 0,,n_sect,0,address
+pub const N_BNSYM: u8 = 0x2e;
+/// AST file path: name,,NO_SECT,0,0
+pub const N_AST: u8 = 0x32;
+/// emitted with gcc2_compiled and in gcc source
+pub const N_OPT: u8 = 0x3c;
+/// register sym: name,,NO_SECT,type,register
+pub const N_RSYM: u8 = 0x40;
+/// src line: 0,,n_sect,linenumber,address
+pub const N_SLINE: u8 = 0x44;
+/// end nsect sym: 0,,n_sect,0,address
+pub const N_ENSYM: u8 = 0x4e;
+/// structure elt: name,,NO_SECT,type,struct_offset
+pub const N_SSYM: u8 = 0x60;
+/// source file name: name,,n_sect,0,address
+pub const N_SO: u8 = 0x64;
+/// object file name: name,,0,0,st_mtime
+pub const N_OSO: u8 = 0x66;
+/// local sym: name,,NO_SECT,type,offset
+pub const N_LSYM: u8 = 0x80;
+/// include file beginning: name,,NO_SECT,0,sum
+pub const N_BINCL: u8 = 0x82;
+/// #included file name: name,,n_sect,0,address
+pub const N_SOL: u8 = 0x84;
+/// compiler parameters: name,,NO_SECT,0,0
+pub const N_PARAMS: u8 = 0x86;
+/// compiler version: name,,NO_SECT,0,0
+pub const N_VERSION: u8 = 0x88;
+/// compiler -O level: name,,NO_SECT,0,0
+pub const N_OLEVEL: u8 = 0x8A;
+/// parameter: name,,NO_SECT,type,offset
+pub const N_PSYM: u8 = 0xa0;
+/// include file end: name,,NO_SECT,0,0
+pub const N_EINCL: u8 = 0xa2;
+/// alternate entry: name,,n_sect,linenumber,address
+pub const N_ENTRY: u8 = 0xa4;
+/// left bracket: 0,,NO_SECT,nesting level,address
+pub const N_LBRAC: u8 = 0xc0;
+/// deleted include file: name,,NO_SECT,0,sum
+pub const N_EXCL: u8 = 0xc2;
+/// right bracket: 0,,NO_SECT,nesting level,address
+pub const N_RBRAC: u8 = 0xe0;
+/// begin common: name,,NO_SECT,0,0
+pub const N_BCOMM: u8 = 0xe2;
+/// end common: name,,n_sect,0,0
+pub const N_ECOMM: u8 = 0xe4;
+/// end common (local name): 0,,n_sect,0,address
+pub const N_ECOML: u8 = 0xe8;
+/// second stab entry with length information
+pub const N_LENG: u8 = 0xfe;
+
+/*
+ * for the berkeley pascal compiler, pc(1):
+ */
+/// global pascal symbol: name,,NO_SECT,subtype,line
+pub const N_PC: u8 = 0x30;
+
+// Definitions from "/usr/include/mach-o/reloc.h".
+
+/// A relocation entry.
+///
+/// Mach-O relocations have plain and scattered variants, with the
+/// meaning of the fields depending on the variant.
+///
+/// This type provides functions for determining whether the relocation
+/// is scattered, and for accessing the fields of each variant.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Relocation<E: Endian> {
+ pub r_word0: U32<E>,
+ pub r_word1: U32<E>,
+}
+
+impl<E: Endian> Relocation<E> {
+ /// Determine whether this is a scattered relocation.
+ #[inline]
+ pub fn r_scattered(self, endian: E, cputype: u32) -> bool {
+ if cputype == CPU_TYPE_X86_64 {
+ false
+ } else {
+ self.r_word0.get(endian) & R_SCATTERED != 0
+ }
+ }
+
+ /// Return the fields of a plain relocation.
+ pub fn info(self, endian: E) -> RelocationInfo {
+ let r_address = self.r_word0.get(endian);
+ let r_word1 = self.r_word1.get(endian);
+ if endian.is_little_endian() {
+ RelocationInfo {
+ r_address,
+ r_symbolnum: r_word1 & 0x00ff_ffff,
+ r_pcrel: ((r_word1 >> 24) & 0x1) != 0,
+ r_length: ((r_word1 >> 25) & 0x3) as u8,
+ r_extern: ((r_word1 >> 27) & 0x1) != 0,
+ r_type: (r_word1 >> 28) as u8,
+ }
+ } else {
+ RelocationInfo {
+ r_address,
+ r_symbolnum: r_word1 >> 8,
+ r_pcrel: ((r_word1 >> 7) & 0x1) != 0,
+ r_length: ((r_word1 >> 5) & 0x3) as u8,
+ r_extern: ((r_word1 >> 4) & 0x1) != 0,
+ r_type: (r_word1 & 0xf) as u8,
+ }
+ }
+ }
+
+ /// Return the fields of a scattered relocation.
+ pub fn scattered_info(self, endian: E) -> ScatteredRelocationInfo {
+ let r_word0 = self.r_word0.get(endian);
+ let r_value = self.r_word1.get(endian);
+ ScatteredRelocationInfo {
+ r_address: r_word0 & 0x00ff_ffff,
+ r_type: ((r_word0 >> 24) & 0xf) as u8,
+ r_length: ((r_word0 >> 28) & 0x3) as u8,
+ r_pcrel: ((r_word0 >> 30) & 0x1) != 0,
+ r_value,
+ }
+ }
+}
+
+/*
+ * Format of a relocation entry of a Mach-O file. Modified from the 4.3BSD
+ * format. The modifications from the original format were changing the value
+ * of the r_symbolnum field for "local" (r_extern == 0) relocation entries.
+ * This modification is required to support symbols in an arbitrary number of
+ * sections not just the three sections (text, data and bss) in a 4.3BSD file.
+ * Also the last 4 bits have had the r_type tag added to them.
+ */
+
+#[derive(Debug, Clone, Copy)]
+pub struct RelocationInfo {
+ /// offset in the section to what is being relocated
+ pub r_address: u32,
+ /// symbol index if r_extern == 1 or section ordinal if r_extern == 0
+ pub r_symbolnum: u32,
+ /// was relocated pc relative already
+ pub r_pcrel: bool,
+ /// 0=byte, 1=word, 2=long, 3=quad
+ pub r_length: u8,
+ /// does not include value of sym referenced
+ pub r_extern: bool,
+ /// if not 0, machine specific relocation type
+ pub r_type: u8,
+}
+
+impl RelocationInfo {
+ /// Combine the fields into a `Relocation`.
+ pub fn relocation<E: Endian>(self, endian: E) -> Relocation<E> {
+ let r_word0 = U32::new(endian, self.r_address);
+ let r_word1 = U32::new(
+ endian,
+ if endian.is_little_endian() {
+ self.r_symbolnum & 0x00ff_ffff
+ | u32::from(self.r_pcrel) << 24
+ | u32::from(self.r_length & 0x3) << 25
+ | u32::from(self.r_extern) << 27
+ | u32::from(self.r_type) << 28
+ } else {
+ self.r_symbolnum >> 8
+ | u32::from(self.r_pcrel) << 7
+ | u32::from(self.r_length & 0x3) << 5
+ | u32::from(self.r_extern) << 4
+ | u32::from(self.r_type) & 0xf
+ },
+ );
+ Relocation { r_word0, r_word1 }
+ }
+}
+
+/// absolute relocation type for Mach-O files
+pub const R_ABS: u8 = 0;
+
+/*
+ * The r_address is not really the address as it's name indicates but an offset.
+ * In 4.3BSD a.out objects this offset is from the start of the "segment" for
+ * which relocation entry is for (text or data). For Mach-O object files it is
+ * also an offset but from the start of the "section" for which the relocation
+ * entry is for. See comments in <mach-o/loader.h> about the r_address feild
+ * in images for used with the dynamic linker.
+ *
+ * In 4.3BSD a.out objects if r_extern is zero then r_symbolnum is an ordinal
+ * for the segment the symbol being relocated is in. These ordinals are the
+ * symbol types N_TEXT, N_DATA, N_BSS or N_ABS. In Mach-O object files these
+ * ordinals refer to the sections in the object file in the order their section
+ * structures appear in the headers of the object file they are in. The first
+ * section has the ordinal 1, the second 2, and so on. This means that the
+ * same ordinal in two different object files could refer to two different
+ * sections. And further could have still different ordinals when combined
+ * by the link-editor. The value R_ABS is used for relocation entries for
+ * absolute symbols which need no further relocation.
+ */
+
+/*
+ * For RISC machines some of the references are split across two instructions
+ * and the instruction does not contain the complete value of the reference.
+ * In these cases a second, or paired relocation entry, follows each of these
+ * relocation entries, using a PAIR r_type, which contains the other part of the
+ * reference not contained in the instruction. This other part is stored in the
+ * pair's r_address field. The exact number of bits of the other part of the
+ * reference store in the r_address field is dependent on the particular
+ * relocation type for the particular architecture.
+ */
+
+/*
+ * To make scattered loading by the link editor work correctly "local"
+ * relocation entries can't be used when the item to be relocated is the value
+ * of a symbol plus an offset (where the resulting expresion is outside the
+ * block the link editor is moving, a blocks are divided at symbol addresses).
+ * In this case. where the item is a symbol value plus offset, the link editor
+ * needs to know more than just the section the symbol was defined. What is
+ * needed is the actual value of the symbol without the offset so it can do the
+ * relocation correctly based on where the value of the symbol got relocated to
+ * not the value of the expression (with the offset added to the symbol value).
+ * So for the NeXT 2.0 release no "local" relocation entries are ever used when
+ * there is a non-zero offset added to a symbol. The "external" and "local"
+ * relocation entries remain unchanged.
+ *
+ * The implemention is quite messy given the compatibility with the existing
+ * relocation entry format. The ASSUMPTION is that a section will never be
+ * bigger than 2**24 - 1 (0x00ffffff or 16,777,215) bytes. This assumption
+ * allows the r_address (which is really an offset) to fit in 24 bits and high
+ * bit of the r_address field in the relocation_info structure to indicate
+ * it is really a scattered_relocation_info structure. Since these are only
+ * used in places where "local" relocation entries are used and not where
+ * "external" relocation entries are used the r_extern field has been removed.
+ *
+ * For scattered loading to work on a RISC machine where some of the references
+ * are split across two instructions the link editor needs to be assured that
+ * each reference has a unique 32 bit reference (that more than one reference is
+ * NOT sharing the same high 16 bits for example) so it move each referenced
+ * item independent of each other. Some compilers guarantees this but the
+ * compilers don't so scattered loading can be done on those that do guarantee
+ * this.
+ */
+
+/// Bit set in `Relocation::r_word0` for scattered relocations.
+pub const R_SCATTERED: u32 = 0x8000_0000;
+
+#[derive(Debug, Clone, Copy)]
+pub struct ScatteredRelocationInfo {
+ /// offset in the section to what is being relocated
+ pub r_address: u32,
+ /// if not 0, machine specific relocation type
+ pub r_type: u8,
+ /// 0=byte, 1=word, 2=long, 3=quad
+ pub r_length: u8,
+ /// was relocated pc relative already
+ pub r_pcrel: bool,
+ /// the value the item to be relocated is refering to (without any offset added)
+ pub r_value: u32,
+}
+
+impl ScatteredRelocationInfo {
+ /// Combine the fields into a `Relocation`.
+ pub fn relocation<E: Endian>(self, endian: E) -> Relocation<E> {
+ let r_word0 = U32::new(
+ endian,
+ self.r_address & 0x00ff_ffff
+ | u32::from(self.r_type & 0xf) << 24
+ | u32::from(self.r_length & 0x3) << 28
+ | u32::from(self.r_pcrel) << 30
+ | R_SCATTERED,
+ );
+ let r_word1 = U32::new(endian, self.r_value);
+ Relocation { r_word0, r_word1 }
+ }
+}
+
+/*
+ * Relocation types used in a generic implementation. Relocation entries for
+ * normal things use the generic relocation as discribed above and their r_type
+ * is GENERIC_RELOC_VANILLA (a value of zero).
+ *
+ * Another type of generic relocation, GENERIC_RELOC_SECTDIFF, is to support
+ * the difference of two symbols defined in different sections. That is the
+ * expression "symbol1 - symbol2 + constant" is a relocatable expression when
+ * both symbols are defined in some section. For this type of relocation the
+ * both relocations entries are scattered relocation entries. The value of
+ * symbol1 is stored in the first relocation entry's r_value field and the
+ * value of symbol2 is stored in the pair's r_value field.
+ *
+ * A special case for a prebound lazy pointer is needed to beable to set the
+ * value of the lazy pointer back to its non-prebound state. This is done
+ * using the GENERIC_RELOC_PB_LA_PTR r_type. This is a scattered relocation
+ * entry where the r_value feild is the value of the lazy pointer not prebound.
+ */
+/// generic relocation as discribed above
+pub const GENERIC_RELOC_VANILLA: u8 = 0;
+/// Only follows a GENERIC_RELOC_SECTDIFF
+pub const GENERIC_RELOC_PAIR: u8 = 1;
+pub const GENERIC_RELOC_SECTDIFF: u8 = 2;
+/// prebound lazy pointer
+pub const GENERIC_RELOC_PB_LA_PTR: u8 = 3;
+pub const GENERIC_RELOC_LOCAL_SECTDIFF: u8 = 4;
+/// thread local variables
+pub const GENERIC_RELOC_TLV: u8 = 5;
+
+// Definitions from "/usr/include/mach-o/arm/reloc.h".
+
+/*
+ * Relocation types used in the arm implementation. Relocation entries for
+ * things other than instructions use the same generic relocation as discribed
+ * in <mach-o/reloc.h> and their r_type is ARM_RELOC_VANILLA, one of the
+ * *_SECTDIFF or the *_PB_LA_PTR types. The rest of the relocation types are
+ * for instructions. Since they are for instructions the r_address field
+ * indicates the 32 bit instruction that the relocation is to be preformed on.
+ */
+/// generic relocation as discribed above
+pub const ARM_RELOC_VANILLA: u8 = 0;
+/// the second relocation entry of a pair
+pub const ARM_RELOC_PAIR: u8 = 1;
+/// a PAIR follows with subtract symbol value
+pub const ARM_RELOC_SECTDIFF: u8 = 2;
+/// like ARM_RELOC_SECTDIFF, but the symbol referenced was local.
+pub const ARM_RELOC_LOCAL_SECTDIFF: u8 = 3;
+/// prebound lazy pointer
+pub const ARM_RELOC_PB_LA_PTR: u8 = 4;
+/// 24 bit branch displacement (to a word address)
+pub const ARM_RELOC_BR24: u8 = 5;
+/// 22 bit branch displacement (to a half-word address)
+pub const ARM_THUMB_RELOC_BR22: u8 = 6;
+/// obsolete - a thumb 32-bit branch instruction possibly needing page-spanning branch workaround
+pub const ARM_THUMB_32BIT_BRANCH: u8 = 7;
+
+/*
+ * For these two r_type relocations they always have a pair following them
+ * and the r_length bits are used differently. The encoding of the
+ * r_length is as follows:
+ * low bit of r_length:
+ * 0 - :lower16: for movw instructions
+ * 1 - :upper16: for movt instructions
+ * high bit of r_length:
+ * 0 - arm instructions
+ * 1 - thumb instructions
+ * the other half of the relocated expression is in the following pair
+ * relocation entry in the the low 16 bits of r_address field.
+ */
+pub const ARM_RELOC_HALF: u8 = 8;
+pub const ARM_RELOC_HALF_SECTDIFF: u8 = 9;
+
+// Definitions from "/usr/include/mach-o/arm64/reloc.h".
+
+/*
+ * Relocation types used in the arm64 implementation.
+ */
+/// for pointers
+pub const ARM64_RELOC_UNSIGNED: u8 = 0;
+/// must be followed by a ARM64_RELOC_UNSIGNED
+pub const ARM64_RELOC_SUBTRACTOR: u8 = 1;
+/// a B/BL instruction with 26-bit displacement
+pub const ARM64_RELOC_BRANCH26: u8 = 2;
+/// pc-rel distance to page of target
+pub const ARM64_RELOC_PAGE21: u8 = 3;
+/// offset within page, scaled by r_length
+pub const ARM64_RELOC_PAGEOFF12: u8 = 4;
+/// pc-rel distance to page of GOT slot
+pub const ARM64_RELOC_GOT_LOAD_PAGE21: u8 = 5;
+/// offset within page of GOT slot, scaled by r_length
+pub const ARM64_RELOC_GOT_LOAD_PAGEOFF12: u8 = 6;
+/// for pointers to GOT slots
+pub const ARM64_RELOC_POINTER_TO_GOT: u8 = 7;
+/// pc-rel distance to page of TLVP slot
+pub const ARM64_RELOC_TLVP_LOAD_PAGE21: u8 = 8;
+/// offset within page of TLVP slot, scaled by r_length
+pub const ARM64_RELOC_TLVP_LOAD_PAGEOFF12: u8 = 9;
+/// must be followed by PAGE21 or PAGEOFF12
+pub const ARM64_RELOC_ADDEND: u8 = 10;
+
+// An arm64e authenticated pointer.
+//
+// Represents a pointer to a symbol (like ARM64_RELOC_UNSIGNED).
+// Additionally, the resulting pointer is signed. The signature is
+// specified in the target location: the addend is restricted to the lower
+// 32 bits (instead of the full 64 bits for ARM64_RELOC_UNSIGNED):
+//
+// |63|62|61-51|50-49| 48 |47 - 32|31 - 0|
+// | 1| 0| 0 | key | addr | discriminator | addend |
+//
+// The key is one of:
+// IA: 00 IB: 01
+// DA: 10 DB: 11
+//
+// The discriminator field is used as extra signature diversification.
+//
+// The addr field indicates whether the target address should be blended
+// into the discriminator.
+//
+pub const ARM64_RELOC_AUTHENTICATED_POINTER: u8 = 11;
+
+// Definitions from "/usr/include/mach-o/ppc/reloc.h".
+
+/*
+ * Relocation types used in the ppc implementation. Relocation entries for
+ * things other than instructions use the same generic relocation as discribed
+ * above and their r_type is RELOC_VANILLA. The rest of the relocation types
+ * are for instructions. Since they are for instructions the r_address field
+ * indicates the 32 bit instruction that the relocation is to be preformed on.
+ * The fields r_pcrel and r_length are ignored for non-RELOC_VANILLA r_types
+ * except for PPC_RELOC_BR14.
+ *
+ * For PPC_RELOC_BR14 if the r_length is the unused value 3, then the branch was
+ * statically predicted setting or clearing the Y-bit based on the sign of the
+ * displacement or the opcode. If this is the case the static linker must flip
+ * the value of the Y-bit if the sign of the displacement changes for non-branch
+ * always conditions.
+ */
+/// generic relocation as discribed above
+pub const PPC_RELOC_VANILLA: u8 = 0;
+/// the second relocation entry of a pair
+pub const PPC_RELOC_PAIR: u8 = 1;
+/// 14 bit branch displacement (to a word address)
+pub const PPC_RELOC_BR14: u8 = 2;
+/// 24 bit branch displacement (to a word address)
+pub const PPC_RELOC_BR24: u8 = 3;
+/// a PAIR follows with the low half
+pub const PPC_RELOC_HI16: u8 = 4;
+/// a PAIR follows with the high half
+pub const PPC_RELOC_LO16: u8 = 5;
+/// Same as the RELOC_HI16 except the low 16 bits and the high 16 bits are added together
+/// with the low 16 bits sign extened first. This means if bit 15 of the low 16 bits is
+/// set the high 16 bits stored in the instruction will be adjusted.
+pub const PPC_RELOC_HA16: u8 = 6;
+/// Same as the LO16 except that the low 2 bits are not stored in the instruction and are
+/// always zero. This is used in double word load/store instructions.
+pub const PPC_RELOC_LO14: u8 = 7;
+/// a PAIR follows with subtract symbol value
+pub const PPC_RELOC_SECTDIFF: u8 = 8;
+/// prebound lazy pointer
+pub const PPC_RELOC_PB_LA_PTR: u8 = 9;
+/// section difference forms of above. a PAIR
+pub const PPC_RELOC_HI16_SECTDIFF: u8 = 10;
+/// follows these with subtract symbol value
+pub const PPC_RELOC_LO16_SECTDIFF: u8 = 11;
+pub const PPC_RELOC_HA16_SECTDIFF: u8 = 12;
+pub const PPC_RELOC_JBSR: u8 = 13;
+pub const PPC_RELOC_LO14_SECTDIFF: u8 = 14;
+/// like PPC_RELOC_SECTDIFF, but the symbol referenced was local.
+pub const PPC_RELOC_LOCAL_SECTDIFF: u8 = 15;
+
+// Definitions from "/usr/include/mach-o/x86_64/reloc.h".
+
+/*
+ * Relocations for x86_64 are a bit different than for other architectures in
+ * Mach-O: Scattered relocations are not used. Almost all relocations produced
+ * by the compiler are external relocations. An external relocation has the
+ * r_extern bit set to 1 and the r_symbolnum field contains the symbol table
+ * index of the target label.
+ *
+ * When the assembler is generating relocations, if the target label is a local
+ * label (begins with 'L'), then the previous non-local label in the same
+ * section is used as the target of the external relocation. An addend is used
+ * with the distance from that non-local label to the target label. Only when
+ * there is no previous non-local label in the section is an internal
+ * relocation used.
+ *
+ * The addend (i.e. the 4 in _foo+4) is encoded in the instruction (Mach-O does
+ * not have RELA relocations). For PC-relative relocations, the addend is
+ * stored directly in the instruction. This is different from other Mach-O
+ * architectures, which encode the addend minus the current section offset.
+ *
+ * The relocation types are:
+ *
+ * X86_64_RELOC_UNSIGNED // for absolute addresses
+ * X86_64_RELOC_SIGNED // for signed 32-bit displacement
+ * X86_64_RELOC_BRANCH // a CALL/JMP instruction with 32-bit displacement
+ * X86_64_RELOC_GOT_LOAD // a MOVQ load of a GOT entry
+ * X86_64_RELOC_GOT // other GOT references
+ * X86_64_RELOC_SUBTRACTOR // must be followed by a X86_64_RELOC_UNSIGNED
+ *
+ * The following are sample assembly instructions, followed by the relocation
+ * and section content they generate in an object file:
+ *
+ * call _foo
+ * r_type=X86_64_RELOC_BRANCH, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
+ * E8 00 00 00 00
+ *
+ * call _foo+4
+ * r_type=X86_64_RELOC_BRANCH, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
+ * E8 04 00 00 00
+ *
+ * movq _foo@GOTPCREL(%rip), %rax
+ * r_type=X86_64_RELOC_GOT_LOAD, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
+ * 48 8B 05 00 00 00 00
+ *
+ * pushq _foo@GOTPCREL(%rip)
+ * r_type=X86_64_RELOC_GOT, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
+ * FF 35 00 00 00 00
+ *
+ * movl _foo(%rip), %eax
+ * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
+ * 8B 05 00 00 00 00
+ *
+ * movl _foo+4(%rip), %eax
+ * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
+ * 8B 05 04 00 00 00
+ *
+ * movb $0x12, _foo(%rip)
+ * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
+ * C6 05 FF FF FF FF 12
+ *
+ * movl $0x12345678, _foo(%rip)
+ * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_foo
+ * C7 05 FC FF FF FF 78 56 34 12
+ *
+ * .quad _foo
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
+ * 00 00 00 00 00 00 00 00
+ *
+ * .quad _foo+4
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
+ * 04 00 00 00 00 00 00 00
+ *
+ * .quad _foo - _bar
+ * r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_bar
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
+ * 00 00 00 00 00 00 00 00
+ *
+ * .quad _foo - _bar + 4
+ * r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_bar
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
+ * 04 00 00 00 00 00 00 00
+ *
+ * .long _foo - _bar
+ * r_type=X86_64_RELOC_SUBTRACTOR, r_length=2, r_extern=1, r_pcrel=0, r_symbolnum=_bar
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=2, r_extern=1, r_pcrel=0, r_symbolnum=_foo
+ * 00 00 00 00
+ *
+ * lea L1(%rip), %rax
+ * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=1, r_pcrel=1, r_symbolnum=_prev
+ * 48 8d 05 12 00 00 00
+ * // assumes _prev is the first non-local label 0x12 bytes before L1
+ *
+ * lea L0(%rip), %rax
+ * r_type=X86_64_RELOC_SIGNED, r_length=2, r_extern=0, r_pcrel=1, r_symbolnum=3
+ * 48 8d 05 56 00 00 00
+ * // assumes L0 is in third section and there is no previous non-local label.
+ * // The rip-relative-offset of 0x00000056 is L0-address_of_next_instruction.
+ * // address_of_next_instruction is the address of the relocation + 4.
+ *
+ * add $6,L0(%rip)
+ * r_type=X86_64_RELOC_SIGNED_1, r_length=2, r_extern=0, r_pcrel=1, r_symbolnum=3
+ * 83 05 18 00 00 00 06
+ * // assumes L0 is in third section and there is no previous non-local label.
+ * // The rip-relative-offset of 0x00000018 is L0-address_of_next_instruction.
+ * // address_of_next_instruction is the address of the relocation + 4 + 1.
+ * // The +1 comes from SIGNED_1. This is used because the relocation is not
+ * // at the end of the instruction.
+ *
+ * .quad L1
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
+ * 12 00 00 00 00 00 00 00
+ * // assumes _prev is the first non-local label 0x12 bytes before L1
+ *
+ * .quad L0
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=0, r_pcrel=0, r_symbolnum=3
+ * 56 00 00 00 00 00 00 00
+ * // assumes L0 is in third section, has an address of 0x00000056 in .o
+ * // file, and there is no previous non-local label
+ *
+ * .quad _foo - .
+ * r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
+ * EE FF FF FF FF FF FF FF
+ * // assumes _prev is the first non-local label 0x12 bytes before this
+ * // .quad
+ *
+ * .quad _foo - L1
+ * r_type=X86_64_RELOC_SUBTRACTOR, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_prev
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_extern=1, r_pcrel=0, r_symbolnum=_foo
+ * EE FF FF FF FF FF FF FF
+ * // assumes _prev is the first non-local label 0x12 bytes before L1
+ *
+ * .quad L1 - _prev
+ * // No relocations. This is an assembly time constant.
+ * 12 00 00 00 00 00 00 00
+ * // assumes _prev is the first non-local label 0x12 bytes before L1
+ *
+ *
+ *
+ * In final linked images, there are only two valid relocation kinds:
+ *
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_pcrel=0, r_extern=1, r_symbolnum=sym_index
+ * This tells dyld to add the address of a symbol to a pointer sized (8-byte)
+ * piece of data (i.e on disk the 8-byte piece of data contains the addend). The
+ * r_symbolnum contains the index into the symbol table of the target symbol.
+ *
+ * r_type=X86_64_RELOC_UNSIGNED, r_length=3, r_pcrel=0, r_extern=0, r_symbolnum=0
+ * This tells dyld to adjust the pointer sized (8-byte) piece of data by the amount
+ * the containing image was loaded from its base address (e.g. slide).
+ *
+ */
+/// for absolute addresses
+pub const X86_64_RELOC_UNSIGNED: u8 = 0;
+/// for signed 32-bit displacement
+pub const X86_64_RELOC_SIGNED: u8 = 1;
+/// a CALL/JMP instruction with 32-bit displacement
+pub const X86_64_RELOC_BRANCH: u8 = 2;
+/// a MOVQ load of a GOT entry
+pub const X86_64_RELOC_GOT_LOAD: u8 = 3;
+/// other GOT references
+pub const X86_64_RELOC_GOT: u8 = 4;
+/// must be followed by a X86_64_RELOC_UNSIGNED
+pub const X86_64_RELOC_SUBTRACTOR: u8 = 5;
+/// for signed 32-bit displacement with a -1 addend
+pub const X86_64_RELOC_SIGNED_1: u8 = 6;
+/// for signed 32-bit displacement with a -2 addend
+pub const X86_64_RELOC_SIGNED_2: u8 = 7;
+/// for signed 32-bit displacement with a -4 addend
+pub const X86_64_RELOC_SIGNED_4: u8 = 8;
+/// for thread local variables
+pub const X86_64_RELOC_TLV: u8 = 9;
+
+unsafe_impl_pod!(FatHeader, FatArch32, FatArch64,);
+unsafe_impl_endian_pod!(
+ DyldCacheHeader,
+ DyldCacheMappingInfo,
+ DyldCacheImageInfo,
+ MachHeader32,
+ MachHeader64,
+ LoadCommand,
+ LcStr,
+ SegmentCommand32,
+ SegmentCommand64,
+ Section32,
+ Section64,
+ Fvmlib,
+ FvmlibCommand,
+ Dylib,
+ DylibCommand,
+ SubFrameworkCommand,
+ SubClientCommand,
+ SubUmbrellaCommand,
+ SubLibraryCommand,
+ PreboundDylibCommand,
+ DylinkerCommand,
+ ThreadCommand,
+ RoutinesCommand32,
+ RoutinesCommand64,
+ SymtabCommand,
+ DysymtabCommand,
+ DylibTableOfContents,
+ DylibModule32,
+ DylibModule64,
+ DylibReference,
+ TwolevelHintsCommand,
+ TwolevelHint,
+ PrebindCksumCommand,
+ UuidCommand,
+ RpathCommand,
+ LinkeditDataCommand,
+ FilesetEntryCommand,
+ EncryptionInfoCommand32,
+ EncryptionInfoCommand64,
+ VersionMinCommand,
+ BuildVersionCommand,
+ BuildToolVersion,
+ DyldInfoCommand,
+ LinkerOptionCommand,
+ SymsegCommand,
+ IdentCommand,
+ FvmfileCommand,
+ EntryPointCommand,
+ SourceVersionCommand,
+ DataInCodeEntry,
+ //TlvDescriptor,
+ NoteCommand,
+ Nlist32,
+ Nlist64,
+ Relocation,
+);
diff --git a/vendor/object-0.26.2/src/pe.rs b/vendor/object-0.26.2/src/pe.rs
new file mode 100644
index 000000000..46daf533f
--- /dev/null
+++ b/vendor/object-0.26.2/src/pe.rs
@@ -0,0 +1,2958 @@
+//! PE/COFF definitions.
+//!
+//! These definitions are independent of read/write support, although we do implement
+//! some traits useful for those.
+//!
+//! This module is based heavily on "winnt.h" (10.0.17763.0).
+
+#![allow(missing_docs)]
+
+use crate::endian::{LittleEndian as LE, U16Bytes, U32Bytes, I32, U16, U32, U64};
+use crate::pod::Pod;
+
+/// MZ
+pub const IMAGE_DOS_SIGNATURE: u16 = 0x5A4D;
+/// NE
+pub const IMAGE_OS2_SIGNATURE: u16 = 0x454E;
+/// LE
+pub const IMAGE_OS2_SIGNATURE_LE: u16 = 0x454C;
+/// LE
+pub const IMAGE_VXD_SIGNATURE: u16 = 0x454C;
+/// PE00
+pub const IMAGE_NT_SIGNATURE: u32 = 0x0000_4550;
+
+/// DOS .EXE header
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageDosHeader {
+ /// Magic number
+ pub e_magic: U16<LE>,
+ /// Bytes on last page of file
+ pub e_cblp: U16<LE>,
+ /// Pages in file
+ pub e_cp: U16<LE>,
+ /// Relocations
+ pub e_crlc: U16<LE>,
+ /// Size of header in paragraphs
+ pub e_cparhdr: U16<LE>,
+ /// Minimum extra paragraphs needed
+ pub e_minalloc: U16<LE>,
+ /// Maximum extra paragraphs needed
+ pub e_maxalloc: U16<LE>,
+ /// Initial (relative) SS value
+ pub e_ss: U16<LE>,
+ /// Initial SP value
+ pub e_sp: U16<LE>,
+ /// Checksum
+ pub e_csum: U16<LE>,
+ /// Initial IP value
+ pub e_ip: U16<LE>,
+ /// Initial (relative) CS value
+ pub e_cs: U16<LE>,
+ /// File address of relocation table
+ pub e_lfarlc: U16<LE>,
+ /// Overlay number
+ pub e_ovno: U16<LE>,
+ /// Reserved words
+ pub e_res: [U16<LE>; 4],
+ /// OEM identifier (for e_oeminfo)
+ pub e_oemid: U16<LE>,
+ /// OEM information; e_oemid specific
+ pub e_oeminfo: U16<LE>,
+ /// Reserved words
+ pub e_res2: [U16<LE>; 10],
+ /// File address of new exe header
+ pub e_lfanew: U32<LE>,
+}
+
+/// OS/2 .EXE header
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageOs2Header {
+ /// Magic number
+ pub ne_magic: U16<LE>,
+ /// Version number
+ pub ne_ver: i8,
+ /// Revision number
+ pub ne_rev: i8,
+ /// Offset of Entry Table
+ pub ne_enttab: U16<LE>,
+ /// Number of bytes in Entry Table
+ pub ne_cbenttab: U16<LE>,
+ /// Checksum of whole file
+ pub ne_crc: I32<LE>,
+ /// Flag word
+ pub ne_flags: U16<LE>,
+ /// Automatic data segment number
+ pub ne_autodata: U16<LE>,
+ /// Initial heap allocation
+ pub ne_heap: U16<LE>,
+ /// Initial stack allocation
+ pub ne_stack: U16<LE>,
+ /// Initial CS:IP setting
+ pub ne_csip: I32<LE>,
+ /// Initial SS:SP setting
+ pub ne_sssp: I32<LE>,
+ /// Count of file segments
+ pub ne_cseg: U16<LE>,
+ /// Entries in Module Reference Table
+ pub ne_cmod: U16<LE>,
+ /// Size of non-resident name table
+ pub ne_cbnrestab: U16<LE>,
+ /// Offset of Segment Table
+ pub ne_segtab: U16<LE>,
+ /// Offset of Resource Table
+ pub ne_rsrctab: U16<LE>,
+ /// Offset of resident name table
+ pub ne_restab: U16<LE>,
+ /// Offset of Module Reference Table
+ pub ne_modtab: U16<LE>,
+ /// Offset of Imported Names Table
+ pub ne_imptab: U16<LE>,
+ /// Offset of Non-resident Names Table
+ pub ne_nrestab: I32<LE>,
+ /// Count of movable entries
+ pub ne_cmovent: U16<LE>,
+ /// Segment alignment shift count
+ pub ne_align: U16<LE>,
+ /// Count of resource segments
+ pub ne_cres: U16<LE>,
+ /// Target Operating system
+ pub ne_exetyp: u8,
+ /// Other .EXE flags
+ pub ne_flagsothers: u8,
+ /// offset to return thunks
+ pub ne_pretthunks: U16<LE>,
+ /// offset to segment ref. bytes
+ pub ne_psegrefbytes: U16<LE>,
+ /// Minimum code swap area size
+ pub ne_swaparea: U16<LE>,
+ /// Expected Windows version number
+ pub ne_expver: U16<LE>,
+}
+
+/// Windows VXD header
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageVxdHeader {
+ /// Magic number
+ pub e32_magic: U16<LE>,
+ /// The byte ordering for the VXD
+ pub e32_border: u8,
+ /// The word ordering for the VXD
+ pub e32_worder: u8,
+ /// The EXE format level for now = 0
+ pub e32_level: U32<LE>,
+ /// The CPU type
+ pub e32_cpu: U16<LE>,
+ /// The OS type
+ pub e32_os: U16<LE>,
+ /// Module version
+ pub e32_ver: U32<LE>,
+ /// Module flags
+ pub e32_mflags: U32<LE>,
+ /// Module # pages
+ pub e32_mpages: U32<LE>,
+ /// Object # for instruction pointer
+ pub e32_startobj: U32<LE>,
+ /// Extended instruction pointer
+ pub e32_eip: U32<LE>,
+ /// Object # for stack pointer
+ pub e32_stackobj: U32<LE>,
+ /// Extended stack pointer
+ pub e32_esp: U32<LE>,
+ /// VXD page size
+ pub e32_pagesize: U32<LE>,
+ /// Last page size in VXD
+ pub e32_lastpagesize: U32<LE>,
+ /// Fixup section size
+ pub e32_fixupsize: U32<LE>,
+ /// Fixup section checksum
+ pub e32_fixupsum: U32<LE>,
+ /// Loader section size
+ pub e32_ldrsize: U32<LE>,
+ /// Loader section checksum
+ pub e32_ldrsum: U32<LE>,
+ /// Object table offset
+ pub e32_objtab: U32<LE>,
+ /// Number of objects in module
+ pub e32_objcnt: U32<LE>,
+ /// Object page map offset
+ pub e32_objmap: U32<LE>,
+ /// Object iterated data map offset
+ pub e32_itermap: U32<LE>,
+ /// Offset of Resource Table
+ pub e32_rsrctab: U32<LE>,
+ /// Number of resource entries
+ pub e32_rsrccnt: U32<LE>,
+ /// Offset of resident name table
+ pub e32_restab: U32<LE>,
+ /// Offset of Entry Table
+ pub e32_enttab: U32<LE>,
+ /// Offset of Module Directive Table
+ pub e32_dirtab: U32<LE>,
+ /// Number of module directives
+ pub e32_dircnt: U32<LE>,
+ /// Offset of Fixup Page Table
+ pub e32_fpagetab: U32<LE>,
+ /// Offset of Fixup Record Table
+ pub e32_frectab: U32<LE>,
+ /// Offset of Import Module Name Table
+ pub e32_impmod: U32<LE>,
+ /// Number of entries in Import Module Name Table
+ pub e32_impmodcnt: U32<LE>,
+ /// Offset of Import Procedure Name Table
+ pub e32_impproc: U32<LE>,
+ /// Offset of Per-Page Checksum Table
+ pub e32_pagesum: U32<LE>,
+ /// Offset of Enumerated Data Pages
+ pub e32_datapage: U32<LE>,
+ /// Number of preload pages
+ pub e32_preload: U32<LE>,
+ /// Offset of Non-resident Names Table
+ pub e32_nrestab: U32<LE>,
+ /// Size of Non-resident Name Table
+ pub e32_cbnrestab: U32<LE>,
+ /// Non-resident Name Table Checksum
+ pub e32_nressum: U32<LE>,
+ /// Object # for automatic data object
+ pub e32_autodata: U32<LE>,
+ /// Offset of the debugging information
+ pub e32_debuginfo: U32<LE>,
+ /// The length of the debugging info. in bytes
+ pub e32_debuglen: U32<LE>,
+ /// Number of instance pages in preload section of VXD file
+ pub e32_instpreload: U32<LE>,
+ /// Number of instance pages in demand load section of VXD file
+ pub e32_instdemand: U32<LE>,
+ /// Size of heap - for 16-bit apps
+ pub e32_heapsize: U32<LE>,
+ /// Reserved words
+ pub e32_res3: [u8; 12],
+ pub e32_winresoff: U32<LE>,
+ pub e32_winreslen: U32<LE>,
+ /// Device ID for VxD
+ pub e32_devid: U16<LE>,
+ /// DDK version for VxD
+ pub e32_ddkver: U16<LE>,
+}
+
+//
+// File header format.
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageFileHeader {
+ pub machine: U16<LE>,
+ pub number_of_sections: U16<LE>,
+ pub time_date_stamp: U32<LE>,
+ pub pointer_to_symbol_table: U32<LE>,
+ pub number_of_symbols: U32<LE>,
+ pub size_of_optional_header: U16<LE>,
+ pub characteristics: U16<LE>,
+}
+
+pub const IMAGE_SIZEOF_FILE_HEADER: usize = 20;
+
+/// Relocation info stripped from file.
+pub const IMAGE_FILE_RELOCS_STRIPPED: u16 = 0x0001;
+/// File is executable (i.e. no unresolved external references).
+pub const IMAGE_FILE_EXECUTABLE_IMAGE: u16 = 0x0002;
+/// Line nunbers stripped from file.
+pub const IMAGE_FILE_LINE_NUMS_STRIPPED: u16 = 0x0004;
+/// Local symbols stripped from file.
+pub const IMAGE_FILE_LOCAL_SYMS_STRIPPED: u16 = 0x0008;
+/// Aggressively trim working set
+pub const IMAGE_FILE_AGGRESIVE_WS_TRIM: u16 = 0x0010;
+/// App can handle >2gb addresses
+pub const IMAGE_FILE_LARGE_ADDRESS_AWARE: u16 = 0x0020;
+/// Bytes of machine word are reversed.
+pub const IMAGE_FILE_BYTES_REVERSED_LO: u16 = 0x0080;
+/// 32 bit word machine.
+pub const IMAGE_FILE_32BIT_MACHINE: u16 = 0x0100;
+/// Debugging info stripped from file in .DBG file
+pub const IMAGE_FILE_DEBUG_STRIPPED: u16 = 0x0200;
+/// If Image is on removable media, copy and run from the swap file.
+pub const IMAGE_FILE_REMOVABLE_RUN_FROM_SWAP: u16 = 0x0400;
+/// If Image is on Net, copy and run from the swap file.
+pub const IMAGE_FILE_NET_RUN_FROM_SWAP: u16 = 0x0800;
+/// System File.
+pub const IMAGE_FILE_SYSTEM: u16 = 0x1000;
+/// File is a DLL.
+pub const IMAGE_FILE_DLL: u16 = 0x2000;
+/// File should only be run on a UP machine
+pub const IMAGE_FILE_UP_SYSTEM_ONLY: u16 = 0x4000;
+/// Bytes of machine word are reversed.
+pub const IMAGE_FILE_BYTES_REVERSED_HI: u16 = 0x8000;
+
+pub const IMAGE_FILE_MACHINE_UNKNOWN: u16 = 0;
+/// Useful for indicating we want to interact with the host and not a WoW guest.
+pub const IMAGE_FILE_MACHINE_TARGET_HOST: u16 = 0x0001;
+/// Intel 386.
+pub const IMAGE_FILE_MACHINE_I386: u16 = 0x014c;
+/// MIPS little-endian, 0x160 big-endian
+pub const IMAGE_FILE_MACHINE_R3000: u16 = 0x0162;
+/// MIPS little-endian
+pub const IMAGE_FILE_MACHINE_R4000: u16 = 0x0166;
+/// MIPS little-endian
+pub const IMAGE_FILE_MACHINE_R10000: u16 = 0x0168;
+/// MIPS little-endian WCE v2
+pub const IMAGE_FILE_MACHINE_WCEMIPSV2: u16 = 0x0169;
+/// Alpha_AXP
+pub const IMAGE_FILE_MACHINE_ALPHA: u16 = 0x0184;
+/// SH3 little-endian
+pub const IMAGE_FILE_MACHINE_SH3: u16 = 0x01a2;
+pub const IMAGE_FILE_MACHINE_SH3DSP: u16 = 0x01a3;
+/// SH3E little-endian
+pub const IMAGE_FILE_MACHINE_SH3E: u16 = 0x01a4;
+/// SH4 little-endian
+pub const IMAGE_FILE_MACHINE_SH4: u16 = 0x01a6;
+/// SH5
+pub const IMAGE_FILE_MACHINE_SH5: u16 = 0x01a8;
+/// ARM Little-Endian
+pub const IMAGE_FILE_MACHINE_ARM: u16 = 0x01c0;
+/// ARM Thumb/Thumb-2 Little-Endian
+pub const IMAGE_FILE_MACHINE_THUMB: u16 = 0x01c2;
+/// ARM Thumb-2 Little-Endian
+pub const IMAGE_FILE_MACHINE_ARMNT: u16 = 0x01c4;
+pub const IMAGE_FILE_MACHINE_AM33: u16 = 0x01d3;
+/// IBM PowerPC Little-Endian
+pub const IMAGE_FILE_MACHINE_POWERPC: u16 = 0x01F0;
+pub const IMAGE_FILE_MACHINE_POWERPCFP: u16 = 0x01f1;
+/// Intel 64
+pub const IMAGE_FILE_MACHINE_IA64: u16 = 0x0200;
+/// MIPS
+pub const IMAGE_FILE_MACHINE_MIPS16: u16 = 0x0266;
+/// ALPHA64
+pub const IMAGE_FILE_MACHINE_ALPHA64: u16 = 0x0284;
+/// MIPS
+pub const IMAGE_FILE_MACHINE_MIPSFPU: u16 = 0x0366;
+/// MIPS
+pub const IMAGE_FILE_MACHINE_MIPSFPU16: u16 = 0x0466;
+pub const IMAGE_FILE_MACHINE_AXP64: u16 = IMAGE_FILE_MACHINE_ALPHA64;
+/// Infineon
+pub const IMAGE_FILE_MACHINE_TRICORE: u16 = 0x0520;
+pub const IMAGE_FILE_MACHINE_CEF: u16 = 0x0CEF;
+/// EFI Byte Code
+pub const IMAGE_FILE_MACHINE_EBC: u16 = 0x0EBC;
+/// AMD64 (K8)
+pub const IMAGE_FILE_MACHINE_AMD64: u16 = 0x8664;
+/// M32R little-endian
+pub const IMAGE_FILE_MACHINE_M32R: u16 = 0x9041;
+/// ARM64 Little-Endian
+pub const IMAGE_FILE_MACHINE_ARM64: u16 = 0xAA64;
+pub const IMAGE_FILE_MACHINE_CEE: u16 = 0xC0EE;
+/// RISCV32
+pub const IMAGE_FILE_MACHINE_RISCV32: u16 = 0x5032;
+/// RISCV64
+pub const IMAGE_FILE_MACHINE_RISCV64: u16 = 0x5064;
+/// RISCV128
+pub const IMAGE_FILE_MACHINE_RISCV128: u16 = 0x5128;
+
+//
+// Directory format.
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageDataDirectory {
+ pub virtual_address: U32<LE>,
+ pub size: U32<LE>,
+}
+
+pub const IMAGE_NUMBEROF_DIRECTORY_ENTRIES: usize = 16;
+
+//
+// Optional header format.
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageOptionalHeader32 {
+ // Standard fields.
+ pub magic: U16<LE>,
+ pub major_linker_version: u8,
+ pub minor_linker_version: u8,
+ pub size_of_code: U32<LE>,
+ pub size_of_initialized_data: U32<LE>,
+ pub size_of_uninitialized_data: U32<LE>,
+ pub address_of_entry_point: U32<LE>,
+ pub base_of_code: U32<LE>,
+ pub base_of_data: U32<LE>,
+
+ // NT additional fields.
+ pub image_base: U32<LE>,
+ pub section_alignment: U32<LE>,
+ pub file_alignment: U32<LE>,
+ pub major_operating_system_version: U16<LE>,
+ pub minor_operating_system_version: U16<LE>,
+ pub major_image_version: U16<LE>,
+ pub minor_image_version: U16<LE>,
+ pub major_subsystem_version: U16<LE>,
+ pub minor_subsystem_version: U16<LE>,
+ pub win32_version_value: U32<LE>,
+ pub size_of_image: U32<LE>,
+ pub size_of_headers: U32<LE>,
+ pub check_sum: U32<LE>,
+ pub subsystem: U16<LE>,
+ pub dll_characteristics: U16<LE>,
+ pub size_of_stack_reserve: U32<LE>,
+ pub size_of_stack_commit: U32<LE>,
+ pub size_of_heap_reserve: U32<LE>,
+ pub size_of_heap_commit: U32<LE>,
+ pub loader_flags: U32<LE>,
+ pub number_of_rva_and_sizes: U32<LE>,
+ //pub data_directory: [ImageDataDirectory; IMAGE_NUMBEROF_DIRECTORY_ENTRIES],
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageRomOptionalHeader {
+ pub magic: U16<LE>,
+ pub major_linker_version: u8,
+ pub minor_linker_version: u8,
+ pub size_of_code: U32<LE>,
+ pub size_of_initialized_data: U32<LE>,
+ pub size_of_uninitialized_data: U32<LE>,
+ pub address_of_entry_point: U32<LE>,
+ pub base_of_code: U32<LE>,
+ pub base_of_data: U32<LE>,
+ pub base_of_bss: U32<LE>,
+ pub gpr_mask: U32<LE>,
+ pub cpr_mask: [U32<LE>; 4],
+ pub gp_value: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageOptionalHeader64 {
+ pub magic: U16<LE>,
+ pub major_linker_version: u8,
+ pub minor_linker_version: u8,
+ pub size_of_code: U32<LE>,
+ pub size_of_initialized_data: U32<LE>,
+ pub size_of_uninitialized_data: U32<LE>,
+ pub address_of_entry_point: U32<LE>,
+ pub base_of_code: U32<LE>,
+ pub image_base: U64<LE>,
+ pub section_alignment: U32<LE>,
+ pub file_alignment: U32<LE>,
+ pub major_operating_system_version: U16<LE>,
+ pub minor_operating_system_version: U16<LE>,
+ pub major_image_version: U16<LE>,
+ pub minor_image_version: U16<LE>,
+ pub major_subsystem_version: U16<LE>,
+ pub minor_subsystem_version: U16<LE>,
+ pub win32_version_value: U32<LE>,
+ pub size_of_image: U32<LE>,
+ pub size_of_headers: U32<LE>,
+ pub check_sum: U32<LE>,
+ pub subsystem: U16<LE>,
+ pub dll_characteristics: U16<LE>,
+ pub size_of_stack_reserve: U64<LE>,
+ pub size_of_stack_commit: U64<LE>,
+ pub size_of_heap_reserve: U64<LE>,
+ pub size_of_heap_commit: U64<LE>,
+ pub loader_flags: U32<LE>,
+ pub number_of_rva_and_sizes: U32<LE>,
+ //pub data_directory: [ImageDataDirectory; IMAGE_NUMBEROF_DIRECTORY_ENTRIES],
+}
+
+pub const IMAGE_NT_OPTIONAL_HDR32_MAGIC: u16 = 0x10b;
+pub const IMAGE_NT_OPTIONAL_HDR64_MAGIC: u16 = 0x20b;
+pub const IMAGE_ROM_OPTIONAL_HDR_MAGIC: u16 = 0x107;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageNtHeaders64 {
+ pub signature: U32<LE>,
+ pub file_header: ImageFileHeader,
+ pub optional_header: ImageOptionalHeader64,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageNtHeaders32 {
+ pub signature: U32<LE>,
+ pub file_header: ImageFileHeader,
+ pub optional_header: ImageOptionalHeader32,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageRomHeaders {
+ pub file_header: ImageFileHeader,
+ pub optional_header: ImageRomOptionalHeader,
+}
+
+// Values for `ImageOptionalHeader*::subsystem`.
+
+/// Unknown subsystem.
+pub const IMAGE_SUBSYSTEM_UNKNOWN: u16 = 0;
+/// Image doesn't require a subsystem.
+pub const IMAGE_SUBSYSTEM_NATIVE: u16 = 1;
+/// Image runs in the Windows GUI subsystem.
+pub const IMAGE_SUBSYSTEM_WINDOWS_GUI: u16 = 2;
+/// Image runs in the Windows character subsystem.
+pub const IMAGE_SUBSYSTEM_WINDOWS_CUI: u16 = 3;
+/// image runs in the OS/2 character subsystem.
+pub const IMAGE_SUBSYSTEM_OS2_CUI: u16 = 5;
+/// image runs in the Posix character subsystem.
+pub const IMAGE_SUBSYSTEM_POSIX_CUI: u16 = 7;
+/// image is a native Win9x driver.
+pub const IMAGE_SUBSYSTEM_NATIVE_WINDOWS: u16 = 8;
+/// Image runs in the Windows CE subsystem.
+pub const IMAGE_SUBSYSTEM_WINDOWS_CE_GUI: u16 = 9;
+pub const IMAGE_SUBSYSTEM_EFI_APPLICATION: u16 = 10;
+pub const IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER: u16 = 11;
+pub const IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER: u16 = 12;
+pub const IMAGE_SUBSYSTEM_EFI_ROM: u16 = 13;
+pub const IMAGE_SUBSYSTEM_XBOX: u16 = 14;
+pub const IMAGE_SUBSYSTEM_WINDOWS_BOOT_APPLICATION: u16 = 16;
+pub const IMAGE_SUBSYSTEM_XBOX_CODE_CATALOG: u16 = 17;
+
+// Values for `ImageOptionalHeader*::dll_characteristics`.
+
+// IMAGE_LIBRARY_PROCESS_INIT 0x0001 // Reserved.
+// IMAGE_LIBRARY_PROCESS_TERM 0x0002 // Reserved.
+// IMAGE_LIBRARY_THREAD_INIT 0x0004 // Reserved.
+// IMAGE_LIBRARY_THREAD_TERM 0x0008 // Reserved.
+/// Image can handle a high entropy 64-bit virtual address space.
+pub const IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA: u16 = 0x0020;
+/// DLL can move.
+pub const IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE: u16 = 0x0040;
+/// Code Integrity Image
+pub const IMAGE_DLLCHARACTERISTICS_FORCE_INTEGRITY: u16 = 0x0080;
+/// Image is NX compatible
+pub const IMAGE_DLLCHARACTERISTICS_NX_COMPAT: u16 = 0x0100;
+/// Image understands isolation and doesn't want it
+pub const IMAGE_DLLCHARACTERISTICS_NO_ISOLATION: u16 = 0x0200;
+/// Image does not use SEH. No SE handler may reside in this image
+pub const IMAGE_DLLCHARACTERISTICS_NO_SEH: u16 = 0x0400;
+/// Do not bind this image.
+pub const IMAGE_DLLCHARACTERISTICS_NO_BIND: u16 = 0x0800;
+/// Image should execute in an AppContainer
+pub const IMAGE_DLLCHARACTERISTICS_APPCONTAINER: u16 = 0x1000;
+/// Driver uses WDM model
+pub const IMAGE_DLLCHARACTERISTICS_WDM_DRIVER: u16 = 0x2000;
+/// Image supports Control Flow Guard.
+pub const IMAGE_DLLCHARACTERISTICS_GUARD_CF: u16 = 0x4000;
+pub const IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE: u16 = 0x8000;
+
+// Indices for `ImageOptionalHeader*::data_directory`.
+
+/// Export Directory
+pub const IMAGE_DIRECTORY_ENTRY_EXPORT: usize = 0;
+/// Import Directory
+pub const IMAGE_DIRECTORY_ENTRY_IMPORT: usize = 1;
+/// Resource Directory
+pub const IMAGE_DIRECTORY_ENTRY_RESOURCE: usize = 2;
+/// Exception Directory
+pub const IMAGE_DIRECTORY_ENTRY_EXCEPTION: usize = 3;
+/// Security Directory
+pub const IMAGE_DIRECTORY_ENTRY_SECURITY: usize = 4;
+/// Base Relocation Table
+pub const IMAGE_DIRECTORY_ENTRY_BASERELOC: usize = 5;
+/// Debug Directory
+pub const IMAGE_DIRECTORY_ENTRY_DEBUG: usize = 6;
+// IMAGE_DIRECTORY_ENTRY_COPYRIGHT 7 // (X86 usage)
+/// Architecture Specific Data
+pub const IMAGE_DIRECTORY_ENTRY_ARCHITECTURE: usize = 7;
+/// RVA of GP
+pub const IMAGE_DIRECTORY_ENTRY_GLOBALPTR: usize = 8;
+/// TLS Directory
+pub const IMAGE_DIRECTORY_ENTRY_TLS: usize = 9;
+/// Load Configuration Directory
+pub const IMAGE_DIRECTORY_ENTRY_LOAD_CONFIG: usize = 10;
+/// Bound Import Directory in headers
+pub const IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT: usize = 11;
+/// Import Address Table
+pub const IMAGE_DIRECTORY_ENTRY_IAT: usize = 12;
+/// Delay Load Import Descriptors
+pub const IMAGE_DIRECTORY_ENTRY_DELAY_IMPORT: usize = 13;
+/// COM Runtime descriptor
+pub const IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR: usize = 14;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Guid {
+ pub data1: U32<LE>,
+ pub data2: U16<LE>,
+ pub data3: U16<LE>,
+ pub data4: [u8; 8],
+}
+
+pub type ClsId = Guid;
+
+/// Non-COFF Object file header
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct AnonObjectHeader {
+ /// Must be IMAGE_FILE_MACHINE_UNKNOWN
+ pub sig1: U16<LE>,
+ /// Must be 0xffff
+ pub sig2: U16<LE>,
+ /// >= 1 (implies the ClsId field is present)
+ pub version: U16<LE>,
+ pub machine: U16<LE>,
+ pub time_date_stamp: U32<LE>,
+ /// Used to invoke CoCreateInstance
+ pub class_id: ClsId,
+ /// Size of data that follows the header
+ pub size_of_data: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct AnonObjectHeaderV2 {
+ /// Must be IMAGE_FILE_MACHINE_UNKNOWN
+ pub sig1: U16<LE>,
+ /// Must be 0xffff
+ pub sig2: U16<LE>,
+ /// >= 2 (implies the Flags field is present - otherwise V1)
+ pub version: U16<LE>,
+ pub machine: U16<LE>,
+ pub time_date_stamp: U32<LE>,
+ /// Used to invoke CoCreateInstance
+ pub class_id: ClsId,
+ /// Size of data that follows the header
+ pub size_of_data: U32<LE>,
+ /// 0x1 -> contains metadata
+ pub flags: U32<LE>,
+ /// Size of CLR metadata
+ pub meta_data_size: U32<LE>,
+ /// Offset of CLR metadata
+ pub meta_data_offset: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct AnonObjectHeaderBigobj {
+ /* same as ANON_OBJECT_HEADER_V2 */
+ /// Must be IMAGE_FILE_MACHINE_UNKNOWN
+ pub sig1: U16<LE>,
+ /// Must be 0xffff
+ pub sig2: U16<LE>,
+ /// >= 2 (implies the Flags field is present)
+ pub version: U16<LE>,
+ /// Actual machine - IMAGE_FILE_MACHINE_xxx
+ pub machine: U16<LE>,
+ pub time_date_stamp: U32<LE>,
+ /// {D1BAA1C7-BAEE-4ba9-AF20-FAF66AA4DCB8}
+ pub class_id: ClsId,
+ /// Size of data that follows the header
+ pub size_of_data: U32<LE>,
+ /// 0x1 -> contains metadata
+ pub flags: U32<LE>,
+ /// Size of CLR metadata
+ pub meta_data_size: U32<LE>,
+ /// Offset of CLR metadata
+ pub meta_data_offset: U32<LE>,
+
+ /* bigobj specifics */
+ /// extended from WORD
+ pub number_of_sections: U32<LE>,
+ pub pointer_to_symbol_table: U32<LE>,
+ pub number_of_symbols: U32<LE>,
+}
+
+pub const IMAGE_SIZEOF_SHORT_NAME: usize = 8;
+
+//
+// Section header format.
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageSectionHeader {
+ pub name: [u8; IMAGE_SIZEOF_SHORT_NAME],
+ pub virtual_size: U32<LE>,
+ pub virtual_address: U32<LE>,
+ pub size_of_raw_data: U32<LE>,
+ pub pointer_to_raw_data: U32<LE>,
+ pub pointer_to_relocations: U32<LE>,
+ pub pointer_to_linenumbers: U32<LE>,
+ pub number_of_relocations: U16<LE>,
+ pub number_of_linenumbers: U16<LE>,
+ pub characteristics: U32<LE>,
+}
+
+pub const IMAGE_SIZEOF_SECTION_HEADER: usize = 40;
+
+// Values for `ImageSectionHeader::characteristics`.
+
+// IMAGE_SCN_TYPE_REG 0x00000000 // Reserved.
+// IMAGE_SCN_TYPE_DSECT 0x00000001 // Reserved.
+// IMAGE_SCN_TYPE_NOLOAD 0x00000002 // Reserved.
+// IMAGE_SCN_TYPE_GROUP 0x00000004 // Reserved.
+/// Reserved.
+pub const IMAGE_SCN_TYPE_NO_PAD: u32 = 0x0000_0008;
+// IMAGE_SCN_TYPE_COPY 0x00000010 // Reserved.
+
+/// Section contains code.
+pub const IMAGE_SCN_CNT_CODE: u32 = 0x0000_0020;
+/// Section contains initialized data.
+pub const IMAGE_SCN_CNT_INITIALIZED_DATA: u32 = 0x0000_0040;
+/// Section contains uninitialized data.
+pub const IMAGE_SCN_CNT_UNINITIALIZED_DATA: u32 = 0x0000_0080;
+
+/// Reserved.
+pub const IMAGE_SCN_LNK_OTHER: u32 = 0x0000_0100;
+/// Section contains comments or some other type of information.
+pub const IMAGE_SCN_LNK_INFO: u32 = 0x0000_0200;
+// IMAGE_SCN_TYPE_OVER 0x00000400 // Reserved.
+/// Section contents will not become part of image.
+pub const IMAGE_SCN_LNK_REMOVE: u32 = 0x0000_0800;
+/// Section contents comdat.
+pub const IMAGE_SCN_LNK_COMDAT: u32 = 0x0000_1000;
+// 0x00002000 // Reserved.
+// IMAGE_SCN_MEM_PROTECTED - Obsolete 0x00004000
+/// Reset speculative exceptions handling bits in the TLB entries for this section.
+pub const IMAGE_SCN_NO_DEFER_SPEC_EXC: u32 = 0x0000_4000;
+/// Section content can be accessed relative to GP
+pub const IMAGE_SCN_GPREL: u32 = 0x0000_8000;
+pub const IMAGE_SCN_MEM_FARDATA: u32 = 0x0000_8000;
+// IMAGE_SCN_MEM_SYSHEAP - Obsolete 0x00010000
+pub const IMAGE_SCN_MEM_PURGEABLE: u32 = 0x0002_0000;
+pub const IMAGE_SCN_MEM_16BIT: u32 = 0x0002_0000;
+pub const IMAGE_SCN_MEM_LOCKED: u32 = 0x0004_0000;
+pub const IMAGE_SCN_MEM_PRELOAD: u32 = 0x0008_0000;
+
+pub const IMAGE_SCN_ALIGN_1BYTES: u32 = 0x0010_0000;
+pub const IMAGE_SCN_ALIGN_2BYTES: u32 = 0x0020_0000;
+pub const IMAGE_SCN_ALIGN_4BYTES: u32 = 0x0030_0000;
+pub const IMAGE_SCN_ALIGN_8BYTES: u32 = 0x0040_0000;
+/// Default alignment if no others are specified.
+pub const IMAGE_SCN_ALIGN_16BYTES: u32 = 0x0050_0000;
+pub const IMAGE_SCN_ALIGN_32BYTES: u32 = 0x0060_0000;
+pub const IMAGE_SCN_ALIGN_64BYTES: u32 = 0x0070_0000;
+pub const IMAGE_SCN_ALIGN_128BYTES: u32 = 0x0080_0000;
+pub const IMAGE_SCN_ALIGN_256BYTES: u32 = 0x0090_0000;
+pub const IMAGE_SCN_ALIGN_512BYTES: u32 = 0x00A0_0000;
+pub const IMAGE_SCN_ALIGN_1024BYTES: u32 = 0x00B0_0000;
+pub const IMAGE_SCN_ALIGN_2048BYTES: u32 = 0x00C0_0000;
+pub const IMAGE_SCN_ALIGN_4096BYTES: u32 = 0x00D0_0000;
+pub const IMAGE_SCN_ALIGN_8192BYTES: u32 = 0x00E0_0000;
+// Unused 0x00F0_0000
+pub const IMAGE_SCN_ALIGN_MASK: u32 = 0x00F0_0000;
+
+/// Section contains extended relocations.
+pub const IMAGE_SCN_LNK_NRELOC_OVFL: u32 = 0x0100_0000;
+/// Section can be discarded.
+pub const IMAGE_SCN_MEM_DISCARDABLE: u32 = 0x0200_0000;
+/// Section is not cachable.
+pub const IMAGE_SCN_MEM_NOT_CACHED: u32 = 0x0400_0000;
+/// Section is not pageable.
+pub const IMAGE_SCN_MEM_NOT_PAGED: u32 = 0x0800_0000;
+/// Section is shareable.
+pub const IMAGE_SCN_MEM_SHARED: u32 = 0x1000_0000;
+/// Section is executable.
+pub const IMAGE_SCN_MEM_EXECUTE: u32 = 0x2000_0000;
+/// Section is readable.
+pub const IMAGE_SCN_MEM_READ: u32 = 0x4000_0000;
+/// Section is writeable.
+pub const IMAGE_SCN_MEM_WRITE: u32 = 0x8000_0000;
+
+//
+// TLS Characteristic Flags
+//
+/// Tls index is scaled
+pub const IMAGE_SCN_SCALE_INDEX: u32 = 0x0000_0001;
+
+//
+// Symbol format.
+//
+
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageSymbol {
+ /// If first 4 bytes are 0, then second 4 bytes are offset into string table.
+ pub name: [u8; 8],
+ pub value: U32Bytes<LE>,
+ pub section_number: U16Bytes<LE>,
+ pub typ: U16Bytes<LE>,
+ pub storage_class: u8,
+ pub number_of_aux_symbols: u8,
+}
+
+pub const IMAGE_SIZEOF_SYMBOL: usize = 18;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageSymbolBytes(pub [u8; IMAGE_SIZEOF_SYMBOL]);
+
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageSymbolEx {
+ /// If first 4 bytes are 0, then second 4 bytes are offset into string table.
+ pub name: [u8; 8],
+ pub value: U32Bytes<LE>,
+ pub section_number: U32Bytes<LE>,
+ pub typ: U16Bytes<LE>,
+ pub storage_class: u8,
+ pub number_of_aux_symbols: u8,
+}
+
+pub const IMAGE_SIZEOF_SYMBOL_EX: usize = 20;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageSymbolExBytes(pub [u8; IMAGE_SIZEOF_SYMBOL_EX]);
+
+// Values for `ImageSymbol::section_number`.
+//
+// Symbols have a section number of the section in which they are
+// defined. Otherwise, section numbers have the following meanings:
+
+/// Symbol is undefined or is common.
+pub const IMAGE_SYM_UNDEFINED: u16 = 0;
+/// Symbol is an absolute value.
+pub const IMAGE_SYM_ABSOLUTE: u16 = 0xffff;
+/// Symbol is a special debug item.
+pub const IMAGE_SYM_DEBUG: u16 = 0xfffe;
+/// Values 0xFF00-0xFFFF are special
+pub const IMAGE_SYM_SECTION_MAX: u16 = 0xFEFF;
+pub const IMAGE_SYM_SECTION_MAX_EX: u32 = 0x7fff_ffff;
+
+// Values for `ImageSymbol::typ` (basic component).
+
+/// no type.
+pub const IMAGE_SYM_TYPE_NULL: u16 = 0x0000;
+pub const IMAGE_SYM_TYPE_VOID: u16 = 0x0001;
+/// type character.
+pub const IMAGE_SYM_TYPE_CHAR: u16 = 0x0002;
+/// type short integer.
+pub const IMAGE_SYM_TYPE_SHORT: u16 = 0x0003;
+pub const IMAGE_SYM_TYPE_INT: u16 = 0x0004;
+pub const IMAGE_SYM_TYPE_LONG: u16 = 0x0005;
+pub const IMAGE_SYM_TYPE_FLOAT: u16 = 0x0006;
+pub const IMAGE_SYM_TYPE_DOUBLE: u16 = 0x0007;
+pub const IMAGE_SYM_TYPE_STRUCT: u16 = 0x0008;
+pub const IMAGE_SYM_TYPE_UNION: u16 = 0x0009;
+/// enumeration.
+pub const IMAGE_SYM_TYPE_ENUM: u16 = 0x000A;
+/// member of enumeration.
+pub const IMAGE_SYM_TYPE_MOE: u16 = 0x000B;
+pub const IMAGE_SYM_TYPE_BYTE: u16 = 0x000C;
+pub const IMAGE_SYM_TYPE_WORD: u16 = 0x000D;
+pub const IMAGE_SYM_TYPE_UINT: u16 = 0x000E;
+pub const IMAGE_SYM_TYPE_DWORD: u16 = 0x000F;
+pub const IMAGE_SYM_TYPE_PCODE: u16 = 0x8000;
+
+// Values for `ImageSymbol::typ` (derived component).
+
+/// no derived type.
+pub const IMAGE_SYM_DTYPE_NULL: u16 = 0;
+/// pointer.
+pub const IMAGE_SYM_DTYPE_POINTER: u16 = 1;
+/// function.
+pub const IMAGE_SYM_DTYPE_FUNCTION: u16 = 2;
+/// array.
+pub const IMAGE_SYM_DTYPE_ARRAY: u16 = 3;
+
+// Values for `ImageSymbol::storage_class`.
+pub const IMAGE_SYM_CLASS_END_OF_FUNCTION: u8 = 0xff;
+pub const IMAGE_SYM_CLASS_NULL: u8 = 0x00;
+pub const IMAGE_SYM_CLASS_AUTOMATIC: u8 = 0x01;
+pub const IMAGE_SYM_CLASS_EXTERNAL: u8 = 0x02;
+pub const IMAGE_SYM_CLASS_STATIC: u8 = 0x03;
+pub const IMAGE_SYM_CLASS_REGISTER: u8 = 0x04;
+pub const IMAGE_SYM_CLASS_EXTERNAL_DEF: u8 = 0x05;
+pub const IMAGE_SYM_CLASS_LABEL: u8 = 0x06;
+pub const IMAGE_SYM_CLASS_UNDEFINED_LABEL: u8 = 0x07;
+pub const IMAGE_SYM_CLASS_MEMBER_OF_STRUCT: u8 = 0x08;
+pub const IMAGE_SYM_CLASS_ARGUMENT: u8 = 0x09;
+pub const IMAGE_SYM_CLASS_STRUCT_TAG: u8 = 0x0A;
+pub const IMAGE_SYM_CLASS_MEMBER_OF_UNION: u8 = 0x0B;
+pub const IMAGE_SYM_CLASS_UNION_TAG: u8 = 0x0C;
+pub const IMAGE_SYM_CLASS_TYPE_DEFINITION: u8 = 0x0D;
+pub const IMAGE_SYM_CLASS_UNDEFINED_STATIC: u8 = 0x0E;
+pub const IMAGE_SYM_CLASS_ENUM_TAG: u8 = 0x0F;
+pub const IMAGE_SYM_CLASS_MEMBER_OF_ENUM: u8 = 0x10;
+pub const IMAGE_SYM_CLASS_REGISTER_PARAM: u8 = 0x11;
+pub const IMAGE_SYM_CLASS_BIT_FIELD: u8 = 0x12;
+
+pub const IMAGE_SYM_CLASS_FAR_EXTERNAL: u8 = 0x44;
+
+pub const IMAGE_SYM_CLASS_BLOCK: u8 = 0x64;
+pub const IMAGE_SYM_CLASS_FUNCTION: u8 = 0x65;
+pub const IMAGE_SYM_CLASS_END_OF_STRUCT: u8 = 0x66;
+pub const IMAGE_SYM_CLASS_FILE: u8 = 0x67;
+// new
+pub const IMAGE_SYM_CLASS_SECTION: u8 = 0x68;
+pub const IMAGE_SYM_CLASS_WEAK_EXTERNAL: u8 = 0x69;
+
+pub const IMAGE_SYM_CLASS_CLR_TOKEN: u8 = 0x6B;
+
+// type packing constants
+
+pub const N_BTMASK: u16 = 0x000F;
+pub const N_TMASK: u16 = 0x0030;
+pub const N_TMASK1: u16 = 0x00C0;
+pub const N_TMASK2: u16 = 0x00F0;
+pub const N_BTSHFT: usize = 4;
+pub const N_TSHIFT: usize = 2;
+
+pub const IMAGE_SYM_DTYPE_SHIFT: usize = N_BTSHFT;
+
+impl ImageSymbol {
+ #[inline]
+ pub fn base_type(&self) -> u16 {
+ self.typ.get(LE) & N_BTMASK
+ }
+
+ #[inline]
+ pub fn derived_type(&self) -> u16 {
+ (self.typ.get(LE) & N_TMASK) >> N_BTSHFT
+ }
+}
+
+impl ImageSymbolEx {
+ #[inline]
+ pub fn base_type(&self) -> u16 {
+ self.typ.get(LE) & N_BTMASK
+ }
+
+ #[inline]
+ pub fn derived_type(&self) -> u16 {
+ (self.typ.get(LE) & N_TMASK) >> N_BTSHFT
+ }
+}
+
+//
+// Auxiliary entry format.
+//
+
+// Used for both ImageSymbol and ImageSymbolEx (with padding).
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageAuxSymbolTokenDef {
+ /// IMAGE_AUX_SYMBOL_TYPE
+ pub aux_type: u8,
+ /// Must be 0
+ pub reserved1: u8,
+ pub symbol_table_index: U32Bytes<LE>,
+ /// Must be 0
+ pub reserved2: [u8; 12],
+}
+
+pub const IMAGE_AUX_SYMBOL_TYPE_TOKEN_DEF: u16 = 1;
+
+/// Auxiliary symbol format 1: function definitions.
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageAuxSymbolFunction {
+ pub tag_index: U32Bytes<LE>,
+ pub total_size: U32Bytes<LE>,
+ pub pointer_to_linenumber: U32Bytes<LE>,
+ pub pointer_to_next_function: U32Bytes<LE>,
+ pub unused: [u8; 2],
+}
+
+/// Auxiliary symbol format 2: .bf and .ef symbols.
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageAuxSymbolFunctionBeginEnd {
+ pub unused1: [u8; 4],
+ /// declaration line number
+ pub linenumber: U16Bytes<LE>,
+ pub unused2: [u8; 6],
+ pub pointer_to_next_function: U32Bytes<LE>,
+ pub unused3: [u8; 2],
+}
+
+/// Auxiliary symbol format 3: weak externals.
+///
+/// Used for both `ImageSymbol` and `ImageSymbolEx` (both with padding).
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageAuxSymbolWeak {
+ /// the weak extern default symbol index
+ pub weak_default_sym_index: U32Bytes<LE>,
+ pub weak_search_type: U32Bytes<LE>,
+}
+
+/// Auxiliary symbol format 5: sections.
+///
+/// Used for both `ImageSymbol` and `ImageSymbolEx` (with padding).
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageAuxSymbolSection {
+ /// section length
+ pub length: U32Bytes<LE>,
+ /// number of relocation entries
+ pub number_of_relocations: U16Bytes<LE>,
+ /// number of line numbers
+ pub number_of_linenumbers: U16Bytes<LE>,
+ /// checksum for communal
+ pub check_sum: U32Bytes<LE>,
+ /// section number to associate with
+ pub number: U16Bytes<LE>,
+ /// communal selection type
+ pub selection: u8,
+ pub reserved: u8,
+ /// high bits of the section number
+ pub high_number: U16Bytes<LE>,
+}
+
+// Used for both ImageSymbol and ImageSymbolEx (both with padding).
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageAuxSymbolCrc {
+ pub crc: U32Bytes<LE>,
+}
+
+//
+// Communal selection types.
+//
+
+pub const IMAGE_COMDAT_SELECT_NODUPLICATES: u8 = 1;
+pub const IMAGE_COMDAT_SELECT_ANY: u8 = 2;
+pub const IMAGE_COMDAT_SELECT_SAME_SIZE: u8 = 3;
+pub const IMAGE_COMDAT_SELECT_EXACT_MATCH: u8 = 4;
+pub const IMAGE_COMDAT_SELECT_ASSOCIATIVE: u8 = 5;
+pub const IMAGE_COMDAT_SELECT_LARGEST: u8 = 6;
+pub const IMAGE_COMDAT_SELECT_NEWEST: u8 = 7;
+
+pub const IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY: u16 = 1;
+pub const IMAGE_WEAK_EXTERN_SEARCH_LIBRARY: u16 = 2;
+pub const IMAGE_WEAK_EXTERN_SEARCH_ALIAS: u16 = 3;
+pub const IMAGE_WEAK_EXTERN_ANTI_DEPENDENCY: u16 = 4;
+
+//
+// Relocation format.
+//
+
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageRelocation {
+ /// Also `RelocCount` when IMAGE_SCN_LNK_NRELOC_OVFL is set
+ pub virtual_address: U32Bytes<LE>,
+ pub symbol_table_index: U32Bytes<LE>,
+ pub typ: U16Bytes<LE>,
+}
+
+//
+// I386 relocation types.
+//
+/// Reference is absolute, no relocation is necessary
+pub const IMAGE_REL_I386_ABSOLUTE: u16 = 0x0000;
+/// Direct 16-bit reference to the symbols virtual address
+pub const IMAGE_REL_I386_DIR16: u16 = 0x0001;
+/// PC-relative 16-bit reference to the symbols virtual address
+pub const IMAGE_REL_I386_REL16: u16 = 0x0002;
+/// Direct 32-bit reference to the symbols virtual address
+pub const IMAGE_REL_I386_DIR32: u16 = 0x0006;
+/// Direct 32-bit reference to the symbols virtual address, base not included
+pub const IMAGE_REL_I386_DIR32NB: u16 = 0x0007;
+/// Direct 16-bit reference to the segment-selector bits of a 32-bit virtual address
+pub const IMAGE_REL_I386_SEG12: u16 = 0x0009;
+pub const IMAGE_REL_I386_SECTION: u16 = 0x000A;
+pub const IMAGE_REL_I386_SECREL: u16 = 0x000B;
+/// clr token
+pub const IMAGE_REL_I386_TOKEN: u16 = 0x000C;
+/// 7 bit offset from base of section containing target
+pub const IMAGE_REL_I386_SECREL7: u16 = 0x000D;
+/// PC-relative 32-bit reference to the symbols virtual address
+pub const IMAGE_REL_I386_REL32: u16 = 0x0014;
+
+//
+// MIPS relocation types.
+//
+/// Reference is absolute, no relocation is necessary
+pub const IMAGE_REL_MIPS_ABSOLUTE: u16 = 0x0000;
+pub const IMAGE_REL_MIPS_REFHALF: u16 = 0x0001;
+pub const IMAGE_REL_MIPS_REFWORD: u16 = 0x0002;
+pub const IMAGE_REL_MIPS_JMPADDR: u16 = 0x0003;
+pub const IMAGE_REL_MIPS_REFHI: u16 = 0x0004;
+pub const IMAGE_REL_MIPS_REFLO: u16 = 0x0005;
+pub const IMAGE_REL_MIPS_GPREL: u16 = 0x0006;
+pub const IMAGE_REL_MIPS_LITERAL: u16 = 0x0007;
+pub const IMAGE_REL_MIPS_SECTION: u16 = 0x000A;
+pub const IMAGE_REL_MIPS_SECREL: u16 = 0x000B;
+/// Low 16-bit section relative referemce (used for >32k TLS)
+pub const IMAGE_REL_MIPS_SECRELLO: u16 = 0x000C;
+/// High 16-bit section relative reference (used for >32k TLS)
+pub const IMAGE_REL_MIPS_SECRELHI: u16 = 0x000D;
+/// clr token
+pub const IMAGE_REL_MIPS_TOKEN: u16 = 0x000E;
+pub const IMAGE_REL_MIPS_JMPADDR16: u16 = 0x0010;
+pub const IMAGE_REL_MIPS_REFWORDNB: u16 = 0x0022;
+pub const IMAGE_REL_MIPS_PAIR: u16 = 0x0025;
+
+//
+// Alpha Relocation types.
+//
+pub const IMAGE_REL_ALPHA_ABSOLUTE: u16 = 0x0000;
+pub const IMAGE_REL_ALPHA_REFLONG: u16 = 0x0001;
+pub const IMAGE_REL_ALPHA_REFQUAD: u16 = 0x0002;
+pub const IMAGE_REL_ALPHA_GPREL32: u16 = 0x0003;
+pub const IMAGE_REL_ALPHA_LITERAL: u16 = 0x0004;
+pub const IMAGE_REL_ALPHA_LITUSE: u16 = 0x0005;
+pub const IMAGE_REL_ALPHA_GPDISP: u16 = 0x0006;
+pub const IMAGE_REL_ALPHA_BRADDR: u16 = 0x0007;
+pub const IMAGE_REL_ALPHA_HINT: u16 = 0x0008;
+pub const IMAGE_REL_ALPHA_INLINE_REFLONG: u16 = 0x0009;
+pub const IMAGE_REL_ALPHA_REFHI: u16 = 0x000A;
+pub const IMAGE_REL_ALPHA_REFLO: u16 = 0x000B;
+pub const IMAGE_REL_ALPHA_PAIR: u16 = 0x000C;
+pub const IMAGE_REL_ALPHA_MATCH: u16 = 0x000D;
+pub const IMAGE_REL_ALPHA_SECTION: u16 = 0x000E;
+pub const IMAGE_REL_ALPHA_SECREL: u16 = 0x000F;
+pub const IMAGE_REL_ALPHA_REFLONGNB: u16 = 0x0010;
+/// Low 16-bit section relative reference
+pub const IMAGE_REL_ALPHA_SECRELLO: u16 = 0x0011;
+/// High 16-bit section relative reference
+pub const IMAGE_REL_ALPHA_SECRELHI: u16 = 0x0012;
+/// High 16 bits of 48 bit reference
+pub const IMAGE_REL_ALPHA_REFQ3: u16 = 0x0013;
+/// Middle 16 bits of 48 bit reference
+pub const IMAGE_REL_ALPHA_REFQ2: u16 = 0x0014;
+/// Low 16 bits of 48 bit reference
+pub const IMAGE_REL_ALPHA_REFQ1: u16 = 0x0015;
+/// Low 16-bit GP relative reference
+pub const IMAGE_REL_ALPHA_GPRELLO: u16 = 0x0016;
+/// High 16-bit GP relative reference
+pub const IMAGE_REL_ALPHA_GPRELHI: u16 = 0x0017;
+
+//
+// IBM PowerPC relocation types.
+//
+/// NOP
+pub const IMAGE_REL_PPC_ABSOLUTE: u16 = 0x0000;
+/// 64-bit address
+pub const IMAGE_REL_PPC_ADDR64: u16 = 0x0001;
+/// 32-bit address
+pub const IMAGE_REL_PPC_ADDR32: u16 = 0x0002;
+/// 26-bit address, shifted left 2 (branch absolute)
+pub const IMAGE_REL_PPC_ADDR24: u16 = 0x0003;
+/// 16-bit address
+pub const IMAGE_REL_PPC_ADDR16: u16 = 0x0004;
+/// 16-bit address, shifted left 2 (load doubleword)
+pub const IMAGE_REL_PPC_ADDR14: u16 = 0x0005;
+/// 26-bit PC-relative offset, shifted left 2 (branch relative)
+pub const IMAGE_REL_PPC_REL24: u16 = 0x0006;
+/// 16-bit PC-relative offset, shifted left 2 (br cond relative)
+pub const IMAGE_REL_PPC_REL14: u16 = 0x0007;
+/// 16-bit offset from TOC base
+pub const IMAGE_REL_PPC_TOCREL16: u16 = 0x0008;
+/// 16-bit offset from TOC base, shifted left 2 (load doubleword)
+pub const IMAGE_REL_PPC_TOCREL14: u16 = 0x0009;
+
+/// 32-bit addr w/o image base
+pub const IMAGE_REL_PPC_ADDR32NB: u16 = 0x000A;
+/// va of containing section (as in an image sectionhdr)
+pub const IMAGE_REL_PPC_SECREL: u16 = 0x000B;
+/// sectionheader number
+pub const IMAGE_REL_PPC_SECTION: u16 = 0x000C;
+/// substitute TOC restore instruction iff symbol is glue code
+pub const IMAGE_REL_PPC_IFGLUE: u16 = 0x000D;
+/// symbol is glue code; virtual address is TOC restore instruction
+pub const IMAGE_REL_PPC_IMGLUE: u16 = 0x000E;
+/// va of containing section (limited to 16 bits)
+pub const IMAGE_REL_PPC_SECREL16: u16 = 0x000F;
+pub const IMAGE_REL_PPC_REFHI: u16 = 0x0010;
+pub const IMAGE_REL_PPC_REFLO: u16 = 0x0011;
+pub const IMAGE_REL_PPC_PAIR: u16 = 0x0012;
+/// Low 16-bit section relative reference (used for >32k TLS)
+pub const IMAGE_REL_PPC_SECRELLO: u16 = 0x0013;
+/// High 16-bit section relative reference (used for >32k TLS)
+pub const IMAGE_REL_PPC_SECRELHI: u16 = 0x0014;
+pub const IMAGE_REL_PPC_GPREL: u16 = 0x0015;
+/// clr token
+pub const IMAGE_REL_PPC_TOKEN: u16 = 0x0016;
+
+/// mask to isolate above values in IMAGE_RELOCATION.Type
+pub const IMAGE_REL_PPC_TYPEMASK: u16 = 0x00FF;
+
+// Flag bits in `ImageRelocation::typ`.
+
+/// subtract reloc value rather than adding it
+pub const IMAGE_REL_PPC_NEG: u16 = 0x0100;
+/// fix branch prediction bit to predict branch taken
+pub const IMAGE_REL_PPC_BRTAKEN: u16 = 0x0200;
+/// fix branch prediction bit to predict branch not taken
+pub const IMAGE_REL_PPC_BRNTAKEN: u16 = 0x0400;
+/// toc slot defined in file (or, data in toc)
+pub const IMAGE_REL_PPC_TOCDEFN: u16 = 0x0800;
+
+//
+// Hitachi SH3 relocation types.
+//
+/// No relocation
+pub const IMAGE_REL_SH3_ABSOLUTE: u16 = 0x0000;
+/// 16 bit direct
+pub const IMAGE_REL_SH3_DIRECT16: u16 = 0x0001;
+/// 32 bit direct
+pub const IMAGE_REL_SH3_DIRECT32: u16 = 0x0002;
+/// 8 bit direct, -128..255
+pub const IMAGE_REL_SH3_DIRECT8: u16 = 0x0003;
+/// 8 bit direct .W (0 ext.)
+pub const IMAGE_REL_SH3_DIRECT8_WORD: u16 = 0x0004;
+/// 8 bit direct .L (0 ext.)
+pub const IMAGE_REL_SH3_DIRECT8_LONG: u16 = 0x0005;
+/// 4 bit direct (0 ext.)
+pub const IMAGE_REL_SH3_DIRECT4: u16 = 0x0006;
+/// 4 bit direct .W (0 ext.)
+pub const IMAGE_REL_SH3_DIRECT4_WORD: u16 = 0x0007;
+/// 4 bit direct .L (0 ext.)
+pub const IMAGE_REL_SH3_DIRECT4_LONG: u16 = 0x0008;
+/// 8 bit PC relative .W
+pub const IMAGE_REL_SH3_PCREL8_WORD: u16 = 0x0009;
+/// 8 bit PC relative .L
+pub const IMAGE_REL_SH3_PCREL8_LONG: u16 = 0x000A;
+/// 12 LSB PC relative .W
+pub const IMAGE_REL_SH3_PCREL12_WORD: u16 = 0x000B;
+/// Start of EXE section
+pub const IMAGE_REL_SH3_STARTOF_SECTION: u16 = 0x000C;
+/// Size of EXE section
+pub const IMAGE_REL_SH3_SIZEOF_SECTION: u16 = 0x000D;
+/// Section table index
+pub const IMAGE_REL_SH3_SECTION: u16 = 0x000E;
+/// Offset within section
+pub const IMAGE_REL_SH3_SECREL: u16 = 0x000F;
+/// 32 bit direct not based
+pub const IMAGE_REL_SH3_DIRECT32_NB: u16 = 0x0010;
+/// GP-relative addressing
+pub const IMAGE_REL_SH3_GPREL4_LONG: u16 = 0x0011;
+/// clr token
+pub const IMAGE_REL_SH3_TOKEN: u16 = 0x0012;
+/// Offset from current instruction in longwords
+/// if not NOMODE, insert the inverse of the low bit at bit 32 to select PTA/PTB
+pub const IMAGE_REL_SHM_PCRELPT: u16 = 0x0013;
+/// Low bits of 32-bit address
+pub const IMAGE_REL_SHM_REFLO: u16 = 0x0014;
+/// High bits of 32-bit address
+pub const IMAGE_REL_SHM_REFHALF: u16 = 0x0015;
+/// Low bits of relative reference
+pub const IMAGE_REL_SHM_RELLO: u16 = 0x0016;
+/// High bits of relative reference
+pub const IMAGE_REL_SHM_RELHALF: u16 = 0x0017;
+/// offset operand for relocation
+pub const IMAGE_REL_SHM_PAIR: u16 = 0x0018;
+
+/// relocation ignores section mode
+pub const IMAGE_REL_SH_NOMODE: u16 = 0x8000;
+
+/// No relocation required
+pub const IMAGE_REL_ARM_ABSOLUTE: u16 = 0x0000;
+/// 32 bit address
+pub const IMAGE_REL_ARM_ADDR32: u16 = 0x0001;
+/// 32 bit address w/o image base
+pub const IMAGE_REL_ARM_ADDR32NB: u16 = 0x0002;
+/// 24 bit offset << 2 & sign ext.
+pub const IMAGE_REL_ARM_BRANCH24: u16 = 0x0003;
+/// Thumb: 2 11 bit offsets
+pub const IMAGE_REL_ARM_BRANCH11: u16 = 0x0004;
+/// clr token
+pub const IMAGE_REL_ARM_TOKEN: u16 = 0x0005;
+/// GP-relative addressing (ARM)
+pub const IMAGE_REL_ARM_GPREL12: u16 = 0x0006;
+/// GP-relative addressing (Thumb)
+pub const IMAGE_REL_ARM_GPREL7: u16 = 0x0007;
+pub const IMAGE_REL_ARM_BLX24: u16 = 0x0008;
+pub const IMAGE_REL_ARM_BLX11: u16 = 0x0009;
+/// Section table index
+pub const IMAGE_REL_ARM_SECTION: u16 = 0x000E;
+/// Offset within section
+pub const IMAGE_REL_ARM_SECREL: u16 = 0x000F;
+/// ARM: MOVW/MOVT
+pub const IMAGE_REL_ARM_MOV32A: u16 = 0x0010;
+/// ARM: MOVW/MOVT (deprecated)
+pub const IMAGE_REL_ARM_MOV32: u16 = 0x0010;
+/// Thumb: MOVW/MOVT
+pub const IMAGE_REL_ARM_MOV32T: u16 = 0x0011;
+/// Thumb: MOVW/MOVT (deprecated)
+pub const IMAGE_REL_THUMB_MOV32: u16 = 0x0011;
+/// Thumb: 32-bit conditional B
+pub const IMAGE_REL_ARM_BRANCH20T: u16 = 0x0012;
+/// Thumb: 32-bit conditional B (deprecated)
+pub const IMAGE_REL_THUMB_BRANCH20: u16 = 0x0012;
+/// Thumb: 32-bit B or BL
+pub const IMAGE_REL_ARM_BRANCH24T: u16 = 0x0014;
+/// Thumb: 32-bit B or BL (deprecated)
+pub const IMAGE_REL_THUMB_BRANCH24: u16 = 0x0014;
+/// Thumb: BLX immediate
+pub const IMAGE_REL_ARM_BLX23T: u16 = 0x0015;
+/// Thumb: BLX immediate (deprecated)
+pub const IMAGE_REL_THUMB_BLX23: u16 = 0x0015;
+
+pub const IMAGE_REL_AM_ABSOLUTE: u16 = 0x0000;
+pub const IMAGE_REL_AM_ADDR32: u16 = 0x0001;
+pub const IMAGE_REL_AM_ADDR32NB: u16 = 0x0002;
+pub const IMAGE_REL_AM_CALL32: u16 = 0x0003;
+pub const IMAGE_REL_AM_FUNCINFO: u16 = 0x0004;
+pub const IMAGE_REL_AM_REL32_1: u16 = 0x0005;
+pub const IMAGE_REL_AM_REL32_2: u16 = 0x0006;
+pub const IMAGE_REL_AM_SECREL: u16 = 0x0007;
+pub const IMAGE_REL_AM_SECTION: u16 = 0x0008;
+pub const IMAGE_REL_AM_TOKEN: u16 = 0x0009;
+
+//
+// ARM64 relocations types.
+//
+
+/// No relocation required
+pub const IMAGE_REL_ARM64_ABSOLUTE: u16 = 0x0000;
+/// 32 bit address. Review! do we need it?
+pub const IMAGE_REL_ARM64_ADDR32: u16 = 0x0001;
+/// 32 bit address w/o image base (RVA: for Data/PData/XData)
+pub const IMAGE_REL_ARM64_ADDR32NB: u16 = 0x0002;
+/// 26 bit offset << 2 & sign ext. for B & BL
+pub const IMAGE_REL_ARM64_BRANCH26: u16 = 0x0003;
+/// ADRP
+pub const IMAGE_REL_ARM64_PAGEBASE_REL21: u16 = 0x0004;
+/// ADR
+pub const IMAGE_REL_ARM64_REL21: u16 = 0x0005;
+/// ADD/ADDS (immediate) with zero shift, for page offset
+pub const IMAGE_REL_ARM64_PAGEOFFSET_12A: u16 = 0x0006;
+/// LDR (indexed, unsigned immediate), for page offset
+pub const IMAGE_REL_ARM64_PAGEOFFSET_12L: u16 = 0x0007;
+/// Offset within section
+pub const IMAGE_REL_ARM64_SECREL: u16 = 0x0008;
+/// ADD/ADDS (immediate) with zero shift, for bit 0:11 of section offset
+pub const IMAGE_REL_ARM64_SECREL_LOW12A: u16 = 0x0009;
+/// ADD/ADDS (immediate) with zero shift, for bit 12:23 of section offset
+pub const IMAGE_REL_ARM64_SECREL_HIGH12A: u16 = 0x000A;
+/// LDR (indexed, unsigned immediate), for bit 0:11 of section offset
+pub const IMAGE_REL_ARM64_SECREL_LOW12L: u16 = 0x000B;
+pub const IMAGE_REL_ARM64_TOKEN: u16 = 0x000C;
+/// Section table index
+pub const IMAGE_REL_ARM64_SECTION: u16 = 0x000D;
+/// 64 bit address
+pub const IMAGE_REL_ARM64_ADDR64: u16 = 0x000E;
+/// 19 bit offset << 2 & sign ext. for conditional B
+pub const IMAGE_REL_ARM64_BRANCH19: u16 = 0x000F;
+
+//
+// x64 relocations
+//
+/// Reference is absolute, no relocation is necessary
+pub const IMAGE_REL_AMD64_ABSOLUTE: u16 = 0x0000;
+/// 64-bit address (VA).
+pub const IMAGE_REL_AMD64_ADDR64: u16 = 0x0001;
+/// 32-bit address (VA).
+pub const IMAGE_REL_AMD64_ADDR32: u16 = 0x0002;
+/// 32-bit address w/o image base (RVA).
+pub const IMAGE_REL_AMD64_ADDR32NB: u16 = 0x0003;
+/// 32-bit relative address from byte following reloc
+pub const IMAGE_REL_AMD64_REL32: u16 = 0x0004;
+/// 32-bit relative address from byte distance 1 from reloc
+pub const IMAGE_REL_AMD64_REL32_1: u16 = 0x0005;
+/// 32-bit relative address from byte distance 2 from reloc
+pub const IMAGE_REL_AMD64_REL32_2: u16 = 0x0006;
+/// 32-bit relative address from byte distance 3 from reloc
+pub const IMAGE_REL_AMD64_REL32_3: u16 = 0x0007;
+/// 32-bit relative address from byte distance 4 from reloc
+pub const IMAGE_REL_AMD64_REL32_4: u16 = 0x0008;
+/// 32-bit relative address from byte distance 5 from reloc
+pub const IMAGE_REL_AMD64_REL32_5: u16 = 0x0009;
+/// Section index
+pub const IMAGE_REL_AMD64_SECTION: u16 = 0x000A;
+/// 32 bit offset from base of section containing target
+pub const IMAGE_REL_AMD64_SECREL: u16 = 0x000B;
+/// 7 bit unsigned offset from base of section containing target
+pub const IMAGE_REL_AMD64_SECREL7: u16 = 0x000C;
+/// 32 bit metadata token
+pub const IMAGE_REL_AMD64_TOKEN: u16 = 0x000D;
+/// 32 bit signed span-dependent value emitted into object
+pub const IMAGE_REL_AMD64_SREL32: u16 = 0x000E;
+pub const IMAGE_REL_AMD64_PAIR: u16 = 0x000F;
+/// 32 bit signed span-dependent value applied at link time
+pub const IMAGE_REL_AMD64_SSPAN32: u16 = 0x0010;
+pub const IMAGE_REL_AMD64_EHANDLER: u16 = 0x0011;
+/// Indirect branch to an import
+pub const IMAGE_REL_AMD64_IMPORT_BR: u16 = 0x0012;
+/// Indirect call to an import
+pub const IMAGE_REL_AMD64_IMPORT_CALL: u16 = 0x0013;
+/// Indirect branch to a CFG check
+pub const IMAGE_REL_AMD64_CFG_BR: u16 = 0x0014;
+/// Indirect branch to a CFG check, with REX.W prefix
+pub const IMAGE_REL_AMD64_CFG_BR_REX: u16 = 0x0015;
+/// Indirect call to a CFG check
+pub const IMAGE_REL_AMD64_CFG_CALL: u16 = 0x0016;
+/// Indirect branch to a target in RAX (no CFG)
+pub const IMAGE_REL_AMD64_INDIR_BR: u16 = 0x0017;
+/// Indirect branch to a target in RAX, with REX.W prefix (no CFG)
+pub const IMAGE_REL_AMD64_INDIR_BR_REX: u16 = 0x0018;
+/// Indirect call to a target in RAX (no CFG)
+pub const IMAGE_REL_AMD64_INDIR_CALL: u16 = 0x0019;
+/// Indirect branch for a switch table using Reg 0 (RAX)
+pub const IMAGE_REL_AMD64_INDIR_BR_SWITCHTABLE_FIRST: u16 = 0x0020;
+/// Indirect branch for a switch table using Reg 15 (R15)
+pub const IMAGE_REL_AMD64_INDIR_BR_SWITCHTABLE_LAST: u16 = 0x002F;
+
+//
+// IA64 relocation types.
+//
+pub const IMAGE_REL_IA64_ABSOLUTE: u16 = 0x0000;
+pub const IMAGE_REL_IA64_IMM14: u16 = 0x0001;
+pub const IMAGE_REL_IA64_IMM22: u16 = 0x0002;
+pub const IMAGE_REL_IA64_IMM64: u16 = 0x0003;
+pub const IMAGE_REL_IA64_DIR32: u16 = 0x0004;
+pub const IMAGE_REL_IA64_DIR64: u16 = 0x0005;
+pub const IMAGE_REL_IA64_PCREL21B: u16 = 0x0006;
+pub const IMAGE_REL_IA64_PCREL21M: u16 = 0x0007;
+pub const IMAGE_REL_IA64_PCREL21F: u16 = 0x0008;
+pub const IMAGE_REL_IA64_GPREL22: u16 = 0x0009;
+pub const IMAGE_REL_IA64_LTOFF22: u16 = 0x000A;
+pub const IMAGE_REL_IA64_SECTION: u16 = 0x000B;
+pub const IMAGE_REL_IA64_SECREL22: u16 = 0x000C;
+pub const IMAGE_REL_IA64_SECREL64I: u16 = 0x000D;
+pub const IMAGE_REL_IA64_SECREL32: u16 = 0x000E;
+//
+pub const IMAGE_REL_IA64_DIR32NB: u16 = 0x0010;
+pub const IMAGE_REL_IA64_SREL14: u16 = 0x0011;
+pub const IMAGE_REL_IA64_SREL22: u16 = 0x0012;
+pub const IMAGE_REL_IA64_SREL32: u16 = 0x0013;
+pub const IMAGE_REL_IA64_UREL32: u16 = 0x0014;
+/// This is always a BRL and never converted
+pub const IMAGE_REL_IA64_PCREL60X: u16 = 0x0015;
+/// If possible, convert to MBB bundle with NOP.B in slot 1
+pub const IMAGE_REL_IA64_PCREL60B: u16 = 0x0016;
+/// If possible, convert to MFB bundle with NOP.F in slot 1
+pub const IMAGE_REL_IA64_PCREL60F: u16 = 0x0017;
+/// If possible, convert to MIB bundle with NOP.I in slot 1
+pub const IMAGE_REL_IA64_PCREL60I: u16 = 0x0018;
+/// If possible, convert to MMB bundle with NOP.M in slot 1
+pub const IMAGE_REL_IA64_PCREL60M: u16 = 0x0019;
+pub const IMAGE_REL_IA64_IMMGPREL64: u16 = 0x001A;
+/// clr token
+pub const IMAGE_REL_IA64_TOKEN: u16 = 0x001B;
+pub const IMAGE_REL_IA64_GPREL32: u16 = 0x001C;
+pub const IMAGE_REL_IA64_ADDEND: u16 = 0x001F;
+
+//
+// CEF relocation types.
+//
+/// Reference is absolute, no relocation is necessary
+pub const IMAGE_REL_CEF_ABSOLUTE: u16 = 0x0000;
+/// 32-bit address (VA).
+pub const IMAGE_REL_CEF_ADDR32: u16 = 0x0001;
+/// 64-bit address (VA).
+pub const IMAGE_REL_CEF_ADDR64: u16 = 0x0002;
+/// 32-bit address w/o image base (RVA).
+pub const IMAGE_REL_CEF_ADDR32NB: u16 = 0x0003;
+/// Section index
+pub const IMAGE_REL_CEF_SECTION: u16 = 0x0004;
+/// 32 bit offset from base of section containing target
+pub const IMAGE_REL_CEF_SECREL: u16 = 0x0005;
+/// 32 bit metadata token
+pub const IMAGE_REL_CEF_TOKEN: u16 = 0x0006;
+
+//
+// clr relocation types.
+//
+/// Reference is absolute, no relocation is necessary
+pub const IMAGE_REL_CEE_ABSOLUTE: u16 = 0x0000;
+/// 32-bit address (VA).
+pub const IMAGE_REL_CEE_ADDR32: u16 = 0x0001;
+/// 64-bit address (VA).
+pub const IMAGE_REL_CEE_ADDR64: u16 = 0x0002;
+/// 32-bit address w/o image base (RVA).
+pub const IMAGE_REL_CEE_ADDR32NB: u16 = 0x0003;
+/// Section index
+pub const IMAGE_REL_CEE_SECTION: u16 = 0x0004;
+/// 32 bit offset from base of section containing target
+pub const IMAGE_REL_CEE_SECREL: u16 = 0x0005;
+/// 32 bit metadata token
+pub const IMAGE_REL_CEE_TOKEN: u16 = 0x0006;
+
+/// No relocation required
+pub const IMAGE_REL_M32R_ABSOLUTE: u16 = 0x0000;
+/// 32 bit address
+pub const IMAGE_REL_M32R_ADDR32: u16 = 0x0001;
+/// 32 bit address w/o image base
+pub const IMAGE_REL_M32R_ADDR32NB: u16 = 0x0002;
+/// 24 bit address
+pub const IMAGE_REL_M32R_ADDR24: u16 = 0x0003;
+/// GP relative addressing
+pub const IMAGE_REL_M32R_GPREL16: u16 = 0x0004;
+/// 24 bit offset << 2 & sign ext.
+pub const IMAGE_REL_M32R_PCREL24: u16 = 0x0005;
+/// 16 bit offset << 2 & sign ext.
+pub const IMAGE_REL_M32R_PCREL16: u16 = 0x0006;
+/// 8 bit offset << 2 & sign ext.
+pub const IMAGE_REL_M32R_PCREL8: u16 = 0x0007;
+/// 16 MSBs
+pub const IMAGE_REL_M32R_REFHALF: u16 = 0x0008;
+/// 16 MSBs; adj for LSB sign ext.
+pub const IMAGE_REL_M32R_REFHI: u16 = 0x0009;
+/// 16 LSBs
+pub const IMAGE_REL_M32R_REFLO: u16 = 0x000A;
+/// Link HI and LO
+pub const IMAGE_REL_M32R_PAIR: u16 = 0x000B;
+/// Section table index
+pub const IMAGE_REL_M32R_SECTION: u16 = 0x000C;
+/// 32 bit section relative reference
+pub const IMAGE_REL_M32R_SECREL32: u16 = 0x000D;
+/// clr token
+pub const IMAGE_REL_M32R_TOKEN: u16 = 0x000E;
+
+/// No relocation required
+pub const IMAGE_REL_EBC_ABSOLUTE: u16 = 0x0000;
+/// 32 bit address w/o image base
+pub const IMAGE_REL_EBC_ADDR32NB: u16 = 0x0001;
+/// 32-bit relative address from byte following reloc
+pub const IMAGE_REL_EBC_REL32: u16 = 0x0002;
+/// Section table index
+pub const IMAGE_REL_EBC_SECTION: u16 = 0x0003;
+/// Offset within section
+pub const IMAGE_REL_EBC_SECREL: u16 = 0x0004;
+
+/*
+// TODO?
+#define EXT_IMM64(Value, Address, Size, InstPos, ValPos) /* Intel-IA64-Filler */ \
+ Value |= (((ULONGLONG)((*(Address) >> InstPos) & (((ULONGLONG)1 << Size) - 1))) << ValPos) // Intel-IA64-Filler
+
+#define INS_IMM64(Value, Address, Size, InstPos, ValPos) /* Intel-IA64-Filler */\
+ *(PDWORD)Address = (*(PDWORD)Address & ~(((1 << Size) - 1) << InstPos)) | /* Intel-IA64-Filler */\
+ ((DWORD)((((ULONGLONG)Value >> ValPos) & (((ULONGLONG)1 << Size) - 1))) << InstPos) // Intel-IA64-Filler
+*/
+
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM7B_INST_WORD_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM7B_SIZE_X: u16 = 7;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM7B_INST_WORD_POS_X: u16 = 4;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM7B_VAL_POS_X: u16 = 0;
+
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM9D_INST_WORD_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM9D_SIZE_X: u16 = 9;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM9D_INST_WORD_POS_X: u16 = 18;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM9D_VAL_POS_X: u16 = 7;
+
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM5C_INST_WORD_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM5C_SIZE_X: u16 = 5;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM5C_INST_WORD_POS_X: u16 = 13;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM5C_VAL_POS_X: u16 = 16;
+
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IC_INST_WORD_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IC_SIZE_X: u16 = 1;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IC_INST_WORD_POS_X: u16 = 12;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IC_VAL_POS_X: u16 = 21;
+
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41A_INST_WORD_X: u16 = 1;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41A_SIZE_X: u16 = 10;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41A_INST_WORD_POS_X: u16 = 14;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41A_VAL_POS_X: u16 = 22;
+
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41B_INST_WORD_X: u16 = 1;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41B_SIZE_X: u16 = 8;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41B_INST_WORD_POS_X: u16 = 24;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41B_VAL_POS_X: u16 = 32;
+
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41C_INST_WORD_X: u16 = 2;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41C_SIZE_X: u16 = 23;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41C_INST_WORD_POS_X: u16 = 0;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_IMM41C_VAL_POS_X: u16 = 40;
+
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_SIGN_INST_WORD_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_SIGN_SIZE_X: u16 = 1;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_SIGN_INST_WORD_POS_X: u16 = 27;
+/// Intel-IA64-Filler
+pub const EMARCH_ENC_I17_SIGN_VAL_POS_X: u16 = 63;
+
+/// Intel-IA64-Filler
+pub const X3_OPCODE_INST_WORD_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const X3_OPCODE_SIZE_X: u16 = 4;
+/// Intel-IA64-Filler
+pub const X3_OPCODE_INST_WORD_POS_X: u16 = 28;
+/// Intel-IA64-Filler
+pub const X3_OPCODE_SIGN_VAL_POS_X: u16 = 0;
+
+/// Intel-IA64-Filler
+pub const X3_I_INST_WORD_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const X3_I_SIZE_X: u16 = 1;
+/// Intel-IA64-Filler
+pub const X3_I_INST_WORD_POS_X: u16 = 27;
+/// Intel-IA64-Filler
+pub const X3_I_SIGN_VAL_POS_X: u16 = 59;
+
+/// Intel-IA64-Filler
+pub const X3_D_WH_INST_WORD_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const X3_D_WH_SIZE_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const X3_D_WH_INST_WORD_POS_X: u16 = 24;
+/// Intel-IA64-Filler
+pub const X3_D_WH_SIGN_VAL_POS_X: u16 = 0;
+
+/// Intel-IA64-Filler
+pub const X3_IMM20_INST_WORD_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const X3_IMM20_SIZE_X: u16 = 20;
+/// Intel-IA64-Filler
+pub const X3_IMM20_INST_WORD_POS_X: u16 = 4;
+/// Intel-IA64-Filler
+pub const X3_IMM20_SIGN_VAL_POS_X: u16 = 0;
+
+/// Intel-IA64-Filler
+pub const X3_IMM39_1_INST_WORD_X: u16 = 2;
+/// Intel-IA64-Filler
+pub const X3_IMM39_1_SIZE_X: u16 = 23;
+/// Intel-IA64-Filler
+pub const X3_IMM39_1_INST_WORD_POS_X: u16 = 0;
+/// Intel-IA64-Filler
+pub const X3_IMM39_1_SIGN_VAL_POS_X: u16 = 36;
+
+/// Intel-IA64-Filler
+pub const X3_IMM39_2_INST_WORD_X: u16 = 1;
+/// Intel-IA64-Filler
+pub const X3_IMM39_2_SIZE_X: u16 = 16;
+/// Intel-IA64-Filler
+pub const X3_IMM39_2_INST_WORD_POS_X: u16 = 16;
+/// Intel-IA64-Filler
+pub const X3_IMM39_2_SIGN_VAL_POS_X: u16 = 20;
+
+/// Intel-IA64-Filler
+pub const X3_P_INST_WORD_X: u16 = 3;
+/// Intel-IA64-Filler
+pub const X3_P_SIZE_X: u16 = 4;
+/// Intel-IA64-Filler
+pub const X3_P_INST_WORD_POS_X: u16 = 0;
+/// Intel-IA64-Filler
+pub const X3_P_SIGN_VAL_POS_X: u16 = 0;
+
+/// Intel-IA64-Filler
+pub const X3_TMPLT_INST_WORD_X: u16 = 0;
+/// Intel-IA64-Filler
+pub const X3_TMPLT_SIZE_X: u16 = 4;
+/// Intel-IA64-Filler
+pub const X3_TMPLT_INST_WORD_POS_X: u16 = 0;
+/// Intel-IA64-Filler
+pub const X3_TMPLT_SIGN_VAL_POS_X: u16 = 0;
+
+/// Intel-IA64-Filler
+pub const X3_BTYPE_QP_INST_WORD_X: u16 = 2;
+/// Intel-IA64-Filler
+pub const X3_BTYPE_QP_SIZE_X: u16 = 9;
+/// Intel-IA64-Filler
+pub const X3_BTYPE_QP_INST_WORD_POS_X: u16 = 23;
+/// Intel-IA64-Filler
+pub const X3_BTYPE_QP_INST_VAL_POS_X: u16 = 0;
+
+/// Intel-IA64-Filler
+pub const X3_EMPTY_INST_WORD_X: u16 = 1;
+/// Intel-IA64-Filler
+pub const X3_EMPTY_SIZE_X: u16 = 2;
+/// Intel-IA64-Filler
+pub const X3_EMPTY_INST_WORD_POS_X: u16 = 14;
+/// Intel-IA64-Filler
+pub const X3_EMPTY_INST_VAL_POS_X: u16 = 0;
+
+//
+// Line number format.
+//
+
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageLinenumber {
+ /// Symbol table index of function name if Linenumber is 0.
+ /// Otherwise virtual address of line number.
+ pub symbol_table_index_or_virtual_address: U32Bytes<LE>,
+ /// Line number.
+ pub linenumber: U16Bytes<LE>,
+}
+
+//
+// Based relocation format.
+//
+
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageBaseRelocation {
+ pub virtual_address: U32Bytes<LE>,
+ pub size_of_block: U32Bytes<LE>,
+ // pub type_offset[1]: U16<LE>,
+}
+
+//
+// Based relocation types.
+//
+
+pub const IMAGE_REL_BASED_ABSOLUTE: u16 = 0;
+pub const IMAGE_REL_BASED_HIGH: u16 = 1;
+pub const IMAGE_REL_BASED_LOW: u16 = 2;
+pub const IMAGE_REL_BASED_HIGHLOW: u16 = 3;
+pub const IMAGE_REL_BASED_HIGHADJ: u16 = 4;
+pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_5: u16 = 5;
+pub const IMAGE_REL_BASED_RESERVED: u16 = 6;
+pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_7: u16 = 7;
+pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_8: u16 = 8;
+pub const IMAGE_REL_BASED_MACHINE_SPECIFIC_9: u16 = 9;
+pub const IMAGE_REL_BASED_DIR64: u16 = 10;
+
+//
+// Platform-specific based relocation types.
+//
+
+pub const IMAGE_REL_BASED_IA64_IMM64: u16 = 9;
+
+pub const IMAGE_REL_BASED_MIPS_JMPADDR: u16 = 5;
+pub const IMAGE_REL_BASED_MIPS_JMPADDR16: u16 = 9;
+
+pub const IMAGE_REL_BASED_ARM_MOV32: u16 = 5;
+pub const IMAGE_REL_BASED_THUMB_MOV32: u16 = 7;
+
+pub const IMAGE_REL_BASED_RISCV_HIGH20: u16 = 5;
+pub const IMAGE_REL_BASED_RISCV_LOW12I: u16 = 7;
+pub const IMAGE_REL_BASED_RISCV_LOW12S: u16 = 8;
+
+//
+// Archive format.
+//
+
+pub const IMAGE_ARCHIVE_START_SIZE: usize = 8;
+pub const IMAGE_ARCHIVE_START: &[u8; 8] = b"!<arch>\n";
+pub const IMAGE_ARCHIVE_END: &[u8] = b"`\n";
+pub const IMAGE_ARCHIVE_PAD: &[u8] = b"\n";
+pub const IMAGE_ARCHIVE_LINKER_MEMBER: &[u8; 16] = b"/ ";
+pub const IMAGE_ARCHIVE_LONGNAMES_MEMBER: &[u8; 16] = b"// ";
+pub const IMAGE_ARCHIVE_HYBRIDMAP_MEMBER: &[u8; 16] = b"/<HYBRIDMAP>/ ";
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageArchiveMemberHeader {
+ /// File member name - `/' terminated.
+ pub name: [u8; 16],
+ /// File member date - decimal.
+ pub date: [u8; 12],
+ /// File member user id - decimal.
+ pub user_id: [u8; 6],
+ /// File member group id - decimal.
+ pub group_id: [u8; 6],
+ /// File member mode - octal.
+ pub mode: [u8; 8],
+ /// File member size - decimal.
+ pub size: [u8; 10],
+ /// String to end header.
+ pub end_header: [u8; 2],
+}
+
+pub const IMAGE_SIZEOF_ARCHIVE_MEMBER_HDR: u16 = 60;
+
+//
+// DLL support.
+//
+
+//
+// Export Format
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageExportDirectory {
+ pub characteristics: U32<LE>,
+ pub time_date_stamp: U32<LE>,
+ pub major_version: U16<LE>,
+ pub minor_version: U16<LE>,
+ pub name: U32<LE>,
+ pub base: U32<LE>,
+ pub number_of_functions: U32<LE>,
+ pub number_of_names: U32<LE>,
+ /// RVA from base of image
+ pub address_of_functions: U32<LE>,
+ /// RVA from base of image
+ pub address_of_names: U32<LE>,
+ /// RVA from base of image
+ pub address_of_name_ordinals: U32<LE>,
+}
+
+//
+// Import Format
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageImportByName {
+ pub hint: U16<LE>,
+ //pub name: [i8; 1],
+}
+
+/*
+// TODO? unions
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageThunkData64 {
+ union {
+/// PBYTE
+ pub forwarder_string: U64<LE>,
+/// PDWORD
+ pub function: U64<LE>,
+ pub ordinal: U64<LE>,
+/// PIMAGE_IMPORT_BY_NAME
+ pub address_of_data: U64<LE>,
+ } u1;
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageThunkData32 {
+ union {
+/// PBYTE
+ pub forwarder_string: U32<LE>,
+/// PDWORD
+ pub function: U32<LE>,
+ pub ordinal: U32<LE>,
+/// PIMAGE_IMPORT_BY_NAME
+ pub address_of_data: U32<LE>,
+ } u1;
+}
+*/
+
+pub const IMAGE_ORDINAL_FLAG64: u64 = 0x8000000000000000;
+pub const IMAGE_ORDINAL_FLAG32: u32 = 0x80000000;
+
+/*
+#define IMAGE_ORDINAL64(Ordinal) (Ordinal & 0xffff)
+#define IMAGE_ORDINAL32(Ordinal) (Ordinal & 0xffff)
+#define IMAGE_SNAP_BY_ORDINAL64(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG64) != 0)
+#define IMAGE_SNAP_BY_ORDINAL32(Ordinal) ((Ordinal & IMAGE_ORDINAL_FLAG32) != 0)
+
+*/
+
+//
+// Thread Local Storage
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageTlsDirectory64 {
+ pub start_address_of_raw_data: U64<LE>,
+ pub end_address_of_raw_data: U64<LE>,
+ /// PDWORD
+ pub address_of_index: U64<LE>,
+ /// PIMAGE_TLS_CALLBACK *;
+ pub address_of_call_backs: U64<LE>,
+ pub size_of_zero_fill: U32<LE>,
+ pub characteristics: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageTlsDirectory32 {
+ pub start_address_of_raw_data: U32<LE>,
+ pub end_address_of_raw_data: U32<LE>,
+ /// PDWORD
+ pub address_of_index: U32<LE>,
+ /// PIMAGE_TLS_CALLBACK *
+ pub address_of_call_backs: U32<LE>,
+ pub size_of_zero_fill: U32<LE>,
+ pub characteristics: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageImportDescriptor {
+ /// RVA to original unbound IAT (`ImageThunkData32`/`ImageThunkData64`)
+ /// 0 for terminating null import descriptor
+ pub original_first_thunk: U32Bytes<LE>,
+ /// 0 if not bound,
+ /// -1 if bound, and real date\time stamp
+ /// in IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT (new BIND)
+ /// O.W. date/time stamp of DLL bound to (Old BIND)
+ pub time_date_stamp: U32Bytes<LE>,
+ /// -1 if no forwarders
+ pub forwarder_chain: U32Bytes<LE>,
+ pub name: U32Bytes<LE>,
+ /// RVA to IAT (if bound this IAT has actual addresses)
+ pub first_thunk: U32Bytes<LE>,
+}
+
+//
+// New format import descriptors pointed to by DataDirectory[ IMAGE_DIRECTORY_ENTRY_BOUND_IMPORT ]
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageBoundImportDescriptor {
+ pub time_date_stamp: U32<LE>,
+ pub offset_module_name: U16<LE>,
+ pub number_of_module_forwarder_refs: U16<LE>,
+ // Array of zero or more IMAGE_BOUND_FORWARDER_REF follows
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageBoundForwarderRef {
+ pub time_date_stamp: U32<LE>,
+ pub offset_module_name: U16<LE>,
+ pub reserved: U16<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageDelayloadDescriptor {
+ pub attributes: U32<LE>,
+
+ /// RVA to the name of the target library (NULL-terminate ASCII string)
+ pub dll_name_rva: U32<LE>,
+ /// RVA to the HMODULE caching location (PHMODULE)
+ pub module_handle_rva: U32<LE>,
+ /// RVA to the start of the IAT (PIMAGE_THUNK_DATA)
+ pub import_address_table_rva: U32<LE>,
+ /// RVA to the start of the name table (PIMAGE_THUNK_DATA::AddressOfData)
+ pub import_name_table_rva: U32<LE>,
+ /// RVA to an optional bound IAT
+ pub bound_import_address_table_rva: U32<LE>,
+ /// RVA to an optional unload info table
+ pub unload_information_table_rva: U32<LE>,
+ /// 0 if not bound, otherwise, date/time of the target DLL
+ pub time_date_stamp: U32<LE>,
+}
+
+/// Delay load version 2 flag for `ImageDelayloadDescriptor::attributes`.
+pub const IMAGE_DELAYLOAD_RVA_BASED: u32 = 0x8000_0000;
+
+//
+// Resource Format.
+//
+
+//
+// Resource directory consists of two counts, following by a variable length
+// array of directory entries. The first count is the number of entries at
+// beginning of the array that have actual names associated with each entry.
+// The entries are in ascending order, case insensitive strings. The second
+// count is the number of entries that immediately follow the named entries.
+// This second count identifies the number of entries that have 16-bit integer
+// Ids as their name. These entries are also sorted in ascending order.
+//
+// This structure allows fast lookup by either name or number, but for any
+// given resource entry only one form of lookup is supported, not both.
+// This is consistant with the syntax of the .RC file and the .RES file.
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageResourceDirectory {
+ pub characteristics: U32<LE>,
+ pub time_date_stamp: U32<LE>,
+ pub major_version: U16<LE>,
+ pub minor_version: U16<LE>,
+ pub number_of_named_entries: U16<LE>,
+ pub number_of_id_entries: U16<LE>,
+ // DirectoryEntries[ImageResourceDirectoryEntry];
+}
+
+pub const IMAGE_RESOURCE_NAME_IS_STRING: u32 = 0x8000_0000;
+pub const IMAGE_RESOURCE_DATA_IS_DIRECTORY: u32 = 0x8000_0000;
+//
+// Each directory contains the 32-bit Name of the entry and an offset,
+// relative to the beginning of the resource directory of the data associated
+// with this directory entry. If the name of the entry is an actual text
+// string instead of an integer Id, then the high order bit of the name field
+// is set to one and the low order 31-bits are an offset, relative to the
+// beginning of the resource directory of the string, which is of type
+// IMAGE_RESOURCE_DIRECTORY_STRING. Otherwise the high bit is clear and the
+// low-order 16-bits are the integer Id that identify this resource directory
+// entry. If the directory entry is yet another resource directory (i.e. a
+// subdirectory), then the high order bit of the offset field will be
+// set to indicate this. Otherwise the high bit is clear and the offset
+// field points to a resource data entry.
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageResourceDirectoryEntry {
+ pub name_or_id: U32<LE>,
+ pub offset_to_data_or_directory: U32<LE>,
+}
+
+//
+// For resource directory entries that have actual string names, the Name
+// field of the directory entry points to an object of the following type.
+// All of these string objects are stored together after the last resource
+// directory entry and before the first resource data object. This minimizes
+// the impact of these variable length objects on the alignment of the fixed
+// size directory entry objects.
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageResourceDirectoryString {
+ pub length: U16<LE>,
+ //pub name_string: [i8; 1],
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageResourceDirStringU {
+ pub length: U16<LE>,
+ //pub name_string: [U16<LE>; 1],
+}
+
+//
+// Each resource data entry describes a leaf node in the resource directory
+// tree. It contains an offset, relative to the beginning of the resource
+// directory of the data for the resource, a size field that gives the number
+// of bytes of data at that offset, a CodePage that should be used when
+// decoding code point values within the resource data. Typically for new
+// applications the code page would be the unicode code page.
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageResourceDataEntry {
+ pub offset_to_data: U32<LE>,
+ pub size: U32<LE>,
+ pub code_page: U32<LE>,
+ pub reserved: U32<LE>,
+}
+
+//
+// Code Integrity in loadconfig (CI)
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageLoadConfigCodeIntegrity {
+ /// Flags to indicate if CI information is available, etc.
+ pub flags: U16<LE>,
+ /// 0xFFFF means not available
+ pub catalog: U16<LE>,
+ pub catalog_offset: U32<LE>,
+ /// Additional bitmask to be defined later
+ pub reserved: U32<LE>,
+}
+
+//
+// Dynamic value relocation table in loadconfig
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageDynamicRelocationTable {
+ pub version: U32<LE>,
+ pub size: U32<LE>,
+ // DynamicRelocations: [ImageDynamicRelocation; 0],
+}
+
+//
+// Dynamic value relocation entries following IMAGE_DYNAMIC_RELOCATION_TABLE
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageDynamicRelocation32 {
+ pub symbol: U32<LE>,
+ pub base_reloc_size: U32<LE>,
+ // BaseRelocations: [ImageBaseRelocation; 0],
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageDynamicRelocation64 {
+ pub symbol: U64<LE>,
+ pub base_reloc_size: U32<LE>,
+ // BaseRelocations: [ImageBaseRelocation; 0],
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageDynamicRelocation32V2 {
+ pub header_size: U32<LE>,
+ pub fixup_info_size: U32<LE>,
+ pub symbol: U32<LE>,
+ pub symbol_group: U32<LE>,
+ pub flags: U32<LE>,
+ // ... variable length header fields
+ // pub fixup_info: [u8; fixup_info_size]
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageDynamicRelocation64V2 {
+ pub header_size: U32<LE>,
+ pub fixup_info_size: U32<LE>,
+ pub symbol: U64<LE>,
+ pub symbol_group: U32<LE>,
+ pub flags: U32<LE>,
+ // ... variable length header fields
+ // pub fixup_info[u8; fixup_info_size]
+}
+
+//
+// Defined symbolic dynamic relocation entries.
+//
+
+pub const IMAGE_DYNAMIC_RELOCATION_GUARD_RF_PROLOGUE: u32 = 0x0000_0001;
+pub const IMAGE_DYNAMIC_RELOCATION_GUARD_RF_EPILOGUE: u32 = 0x0000_0002;
+pub const IMAGE_DYNAMIC_RELOCATION_GUARD_IMPORT_CONTROL_TRANSFER: u32 = 0x0000_0003;
+pub const IMAGE_DYNAMIC_RELOCATION_GUARD_INDIR_CONTROL_TRANSFER: u32 = 0x0000_0004;
+pub const IMAGE_DYNAMIC_RELOCATION_GUARD_SWITCHTABLE_BRANCH: u32 = 0x0000_0005;
+
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImagePrologueDynamicRelocationHeader {
+ pub prologue_byte_count: u8,
+ // pub prologue_bytes: [u8; prologue_byte_count],
+}
+
+// This struct has alignment 1.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageEpilogueDynamicRelocationHeader {
+ pub epilogue_count: U32Bytes<LE>,
+ pub epilogue_byte_count: u8,
+ pub branch_descriptor_element_size: u8,
+ pub branch_descriptor_count: U16Bytes<LE>,
+ // pub branch_descriptors[...],
+ // pub branch_descriptor_bit_map[...],
+}
+
+/*
+// TODO? bitfields
+// TODO: unaligned?
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageImportControlTransferDynamicRelocation {
+ DWORD PageRelativeOffset : 12;
+ DWORD IndirectCall : 1;
+ DWORD IATIndex : 19;
+}
+
+// TODO: unaligned?
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageIndirControlTransferDynamicRelocation {
+ WORD PageRelativeOffset : 12;
+ WORD IndirectCall : 1;
+ WORD RexWPrefix : 1;
+ WORD CfgCheck : 1;
+ WORD Reserved : 1;
+}
+
+// TODO: unaligned?
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageSwitchtableBranchDynamicRelocation {
+ WORD PageRelativeOffset : 12;
+ WORD RegisterNumber : 4;
+}
+*/
+
+//
+// Load Configuration Directory Entry
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageLoadConfigDirectory32 {
+ pub size: U32<LE>,
+ pub time_date_stamp: U32<LE>,
+ pub major_version: U16<LE>,
+ pub minor_version: U16<LE>,
+ pub global_flags_clear: U32<LE>,
+ pub global_flags_set: U32<LE>,
+ pub critical_section_default_timeout: U32<LE>,
+ pub de_commit_free_block_threshold: U32<LE>,
+ pub de_commit_total_free_threshold: U32<LE>,
+ /// VA
+ pub lock_prefix_table: U32<LE>,
+ pub maximum_allocation_size: U32<LE>,
+ pub virtual_memory_threshold: U32<LE>,
+ pub process_heap_flags: U32<LE>,
+ pub process_affinity_mask: U32<LE>,
+ pub csd_version: U16<LE>,
+ pub dependent_load_flags: U16<LE>,
+ /// VA
+ pub edit_list: U32<LE>,
+ /// VA
+ pub security_cookie: U32<LE>,
+ /// VA
+ pub sehandler_table: U32<LE>,
+ pub sehandler_count: U32<LE>,
+ /// VA
+ pub guard_cf_check_function_pointer: U32<LE>,
+ /// VA
+ pub guard_cf_dispatch_function_pointer: U32<LE>,
+ /// VA
+ pub guard_cf_function_table: U32<LE>,
+ pub guard_cf_function_count: U32<LE>,
+ pub guard_flags: U32<LE>,
+ pub code_integrity: ImageLoadConfigCodeIntegrity,
+ /// VA
+ pub guard_address_taken_iat_entry_table: U32<LE>,
+ pub guard_address_taken_iat_entry_count: U32<LE>,
+ /// VA
+ pub guard_long_jump_target_table: U32<LE>,
+ pub guard_long_jump_target_count: U32<LE>,
+ /// VA
+ pub dynamic_value_reloc_table: U32<LE>,
+ pub chpe_metadata_pointer: U32<LE>,
+ /// VA
+ pub guard_rf_failure_routine: U32<LE>,
+ /// VA
+ pub guard_rf_failure_routine_function_pointer: U32<LE>,
+ pub dynamic_value_reloc_table_offset: U32<LE>,
+ pub dynamic_value_reloc_table_section: U16<LE>,
+ pub reserved2: U16<LE>,
+ /// VA
+ pub guard_rf_verify_stack_pointer_function_pointer: U32<LE>,
+ pub hot_patch_table_offset: U32<LE>,
+ pub reserved3: U32<LE>,
+ /// VA
+ pub enclave_configuration_pointer: U32<LE>,
+ /// VA
+ pub volatile_metadata_pointer: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageLoadConfigDirectory64 {
+ pub size: U32<LE>,
+ pub time_date_stamp: U32<LE>,
+ pub major_version: U16<LE>,
+ pub minor_version: U16<LE>,
+ pub global_flags_clear: U32<LE>,
+ pub global_flags_set: U32<LE>,
+ pub critical_section_default_timeout: U32<LE>,
+ pub de_commit_free_block_threshold: U64<LE>,
+ pub de_commit_total_free_threshold: U64<LE>,
+ /// VA
+ pub lock_prefix_table: U64<LE>,
+ pub maximum_allocation_size: U64<LE>,
+ pub virtual_memory_threshold: U64<LE>,
+ pub process_affinity_mask: U64<LE>,
+ pub process_heap_flags: U32<LE>,
+ pub csd_version: U16<LE>,
+ pub dependent_load_flags: U16<LE>,
+ /// VA
+ pub edit_list: U64<LE>,
+ /// VA
+ pub security_cookie: U64<LE>,
+ /// VA
+ pub sehandler_table: U64<LE>,
+ pub sehandler_count: U64<LE>,
+ /// VA
+ pub guard_cf_check_function_pointer: U64<LE>,
+ /// VA
+ pub guard_cf_dispatch_function_pointer: U64<LE>,
+ /// VA
+ pub guard_cf_function_table: U64<LE>,
+ pub guard_cf_function_count: U64<LE>,
+ pub guard_flags: U32<LE>,
+ pub code_integrity: ImageLoadConfigCodeIntegrity,
+ /// VA
+ pub guard_address_taken_iat_entry_table: U64<LE>,
+ pub guard_address_taken_iat_entry_count: U64<LE>,
+ /// VA
+ pub guard_long_jump_target_table: U64<LE>,
+ pub guard_long_jump_target_count: U64<LE>,
+ /// VA
+ pub dynamic_value_reloc_table: U64<LE>,
+ /// VA
+ pub chpe_metadata_pointer: U64<LE>,
+ /// VA
+ pub guard_rf_failure_routine: U64<LE>,
+ /// VA
+ pub guard_rf_failure_routine_function_pointer: U64<LE>,
+ pub dynamic_value_reloc_table_offset: U32<LE>,
+ pub dynamic_value_reloc_table_section: U16<LE>,
+ pub reserved2: U16<LE>,
+ /// VA
+ pub guard_rf_verify_stack_pointer_function_pointer: U64<LE>,
+ pub hot_patch_table_offset: U32<LE>,
+ pub reserved3: U32<LE>,
+ /// VA
+ pub enclave_configuration_pointer: U64<LE>,
+ /// VA
+ pub volatile_metadata_pointer: U64<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageHotPatchInfo {
+ pub version: U32<LE>,
+ pub size: U32<LE>,
+ pub sequence_number: U32<LE>,
+ pub base_image_list: U32<LE>,
+ pub base_image_count: U32<LE>,
+ /// Version 2 and later
+ pub buffer_offset: U32<LE>,
+ /// Version 3 and later
+ pub extra_patch_size: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageHotPatchBase {
+ pub sequence_number: U32<LE>,
+ pub flags: U32<LE>,
+ pub original_time_date_stamp: U32<LE>,
+ pub original_check_sum: U32<LE>,
+ pub code_integrity_info: U32<LE>,
+ pub code_integrity_size: U32<LE>,
+ pub patch_table: U32<LE>,
+ /// Version 2 and later
+ pub buffer_offset: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageHotPatchHashes {
+ pub sha256: [u8; 32],
+ pub sha1: [u8; 20],
+}
+
+pub const IMAGE_HOT_PATCH_BASE_OBLIGATORY: u32 = 0x0000_0001;
+pub const IMAGE_HOT_PATCH_BASE_CAN_ROLL_BACK: u32 = 0x0000_0002;
+
+pub const IMAGE_HOT_PATCH_CHUNK_INVERSE: u32 = 0x8000_0000;
+pub const IMAGE_HOT_PATCH_CHUNK_OBLIGATORY: u32 = 0x4000_0000;
+pub const IMAGE_HOT_PATCH_CHUNK_RESERVED: u32 = 0x3FF0_3000;
+pub const IMAGE_HOT_PATCH_CHUNK_TYPE: u32 = 0x000F_C000;
+pub const IMAGE_HOT_PATCH_CHUNK_SOURCE_RVA: u32 = 0x0000_8000;
+pub const IMAGE_HOT_PATCH_CHUNK_TARGET_RVA: u32 = 0x0000_4000;
+pub const IMAGE_HOT_PATCH_CHUNK_SIZE: u32 = 0x0000_0FFF;
+
+pub const IMAGE_HOT_PATCH_NONE: u32 = 0x0000_0000;
+pub const IMAGE_HOT_PATCH_FUNCTION: u32 = 0x0001_C000;
+pub const IMAGE_HOT_PATCH_ABSOLUTE: u32 = 0x0002_C000;
+pub const IMAGE_HOT_PATCH_REL32: u32 = 0x0003_C000;
+pub const IMAGE_HOT_PATCH_CALL_TARGET: u32 = 0x0004_4000;
+pub const IMAGE_HOT_PATCH_INDIRECT: u32 = 0x0005_C000;
+pub const IMAGE_HOT_PATCH_NO_CALL_TARGET: u32 = 0x0006_4000;
+pub const IMAGE_HOT_PATCH_DYNAMIC_VALUE: u32 = 0x0007_8000;
+
+/// Module performs control flow integrity checks using system-supplied support
+pub const IMAGE_GUARD_CF_INSTRUMENTED: u32 = 0x0000_0100;
+/// Module performs control flow and write integrity checks
+pub const IMAGE_GUARD_CFW_INSTRUMENTED: u32 = 0x0000_0200;
+/// Module contains valid control flow target metadata
+pub const IMAGE_GUARD_CF_FUNCTION_TABLE_PRESENT: u32 = 0x0000_0400;
+/// Module does not make use of the /GS security cookie
+pub const IMAGE_GUARD_SECURITY_COOKIE_UNUSED: u32 = 0x0000_0800;
+/// Module supports read only delay load IAT
+pub const IMAGE_GUARD_PROTECT_DELAYLOAD_IAT: u32 = 0x0000_1000;
+/// Delayload import table in its own .didat section (with nothing else in it) that can be freely reprotected
+pub const IMAGE_GUARD_DELAYLOAD_IAT_IN_ITS_OWN_SECTION: u32 = 0x0000_2000;
+/// Module contains suppressed export information.
+///
+/// This also infers that the address taken taken IAT table is also present in the load config.
+pub const IMAGE_GUARD_CF_EXPORT_SUPPRESSION_INFO_PRESENT: u32 = 0x0000_4000;
+/// Module enables suppression of exports
+pub const IMAGE_GUARD_CF_ENABLE_EXPORT_SUPPRESSION: u32 = 0x0000_8000;
+/// Module contains longjmp target information
+pub const IMAGE_GUARD_CF_LONGJUMP_TABLE_PRESENT: u32 = 0x0001_0000;
+/// Module contains return flow instrumentation and metadata
+pub const IMAGE_GUARD_RF_INSTRUMENTED: u32 = 0x0002_0000;
+/// Module requests that the OS enable return flow protection
+pub const IMAGE_GUARD_RF_ENABLE: u32 = 0x0004_0000;
+/// Module requests that the OS enable return flow protection in strict mode
+pub const IMAGE_GUARD_RF_STRICT: u32 = 0x0008_0000;
+/// Module was built with retpoline support
+pub const IMAGE_GUARD_RETPOLINE_PRESENT: u32 = 0x0010_0000;
+
+/// Stride of Guard CF function table encoded in these bits (additional count of bytes per element)
+pub const IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_MASK: u32 = 0xF000_0000;
+/// Shift to right-justify Guard CF function table stride
+pub const IMAGE_GUARD_CF_FUNCTION_TABLE_SIZE_SHIFT: u32 = 28;
+
+//
+// GFIDS table entry flags.
+//
+
+/// The containing GFID entry is suppressed
+pub const IMAGE_GUARD_FLAG_FID_SUPPRESSED: u16 = 0x01;
+/// The containing GFID entry is export suppressed
+pub const IMAGE_GUARD_FLAG_EXPORT_SUPPRESSED: u16 = 0x02;
+
+//
+// WIN CE Exception table format
+//
+
+//
+// Function table entry format. Function table is pointed to by the
+// IMAGE_DIRECTORY_ENTRY_EXCEPTION directory entry.
+//
+
+/*
+// TODO? bitfields
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageCeRuntimeFunctionEntry {
+ pub func_start: U32<LE>,
+ DWORD PrologLen : 8;
+ DWORD FuncLen : 22;
+ DWORD ThirtyTwoBit : 1;
+ DWORD ExceptionFlag : 1;
+}
+*/
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageArmRuntimeFunctionEntry {
+ pub begin_address: U32<LE>,
+ pub unwind_data: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageArm64RuntimeFunctionEntry {
+ pub begin_address: U32<LE>,
+ pub unwind_data: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageAlpha64RuntimeFunctionEntry {
+ pub begin_address: U64<LE>,
+ pub end_address: U64<LE>,
+ pub exception_handler: U64<LE>,
+ pub handler_data: U64<LE>,
+ pub prolog_end_address: U64<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageAlphaRuntimeFunctionEntry {
+ pub begin_address: U32<LE>,
+ pub end_address: U32<LE>,
+ pub exception_handler: U32<LE>,
+ pub handler_data: U32<LE>,
+ pub prolog_end_address: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageRuntimeFunctionEntry {
+ pub begin_address: U32<LE>,
+ pub end_address: U32<LE>,
+ pub unwind_info_address_or_data: U32<LE>,
+}
+
+//
+// Sofware enclave information
+//
+
+pub const IMAGE_ENCLAVE_LONG_ID_LENGTH: usize = 32;
+pub const IMAGE_ENCLAVE_SHORT_ID_LENGTH: usize = 16;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageEnclaveConfig32 {
+ pub size: U32<LE>,
+ pub minimum_required_config_size: U32<LE>,
+ pub policy_flags: U32<LE>,
+ pub number_of_imports: U32<LE>,
+ pub import_list: U32<LE>,
+ pub import_entry_size: U32<LE>,
+ pub family_id: [u8; IMAGE_ENCLAVE_SHORT_ID_LENGTH],
+ pub image_id: [u8; IMAGE_ENCLAVE_SHORT_ID_LENGTH],
+ pub image_version: U32<LE>,
+ pub security_version: U32<LE>,
+ pub enclave_size: U32<LE>,
+ pub number_of_threads: U32<LE>,
+ pub enclave_flags: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageEnclaveConfig64 {
+ pub size: U32<LE>,
+ pub minimum_required_config_size: U32<LE>,
+ pub policy_flags: U32<LE>,
+ pub number_of_imports: U32<LE>,
+ pub import_list: U32<LE>,
+ pub import_entry_size: U32<LE>,
+ pub family_id: [u8; IMAGE_ENCLAVE_SHORT_ID_LENGTH],
+ pub image_id: [u8; IMAGE_ENCLAVE_SHORT_ID_LENGTH],
+ pub image_version: U32<LE>,
+ pub security_version: U32<LE>,
+ pub enclave_size: U64<LE>,
+ pub number_of_threads: U32<LE>,
+ pub enclave_flags: U32<LE>,
+}
+
+//pub const IMAGE_ENCLAVE_MINIMUM_CONFIG_SIZE: usize = FIELD_OFFSET(IMAGE_ENCLAVE_CONFIG, EnclaveFlags);
+
+pub const IMAGE_ENCLAVE_POLICY_DEBUGGABLE: u32 = 0x0000_0001;
+
+pub const IMAGE_ENCLAVE_FLAG_PRIMARY_IMAGE: u32 = 0x0000_0001;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageEnclaveImport {
+ pub match_type: U32<LE>,
+ pub minimum_security_version: U32<LE>,
+ pub unique_or_author_id: [u8; IMAGE_ENCLAVE_LONG_ID_LENGTH],
+ pub family_id: [u8; IMAGE_ENCLAVE_SHORT_ID_LENGTH],
+ pub image_id: [u8; IMAGE_ENCLAVE_SHORT_ID_LENGTH],
+ pub import_name: U32<LE>,
+ pub reserved: U32<LE>,
+}
+
+pub const IMAGE_ENCLAVE_IMPORT_MATCH_NONE: u32 = 0x0000_0000;
+pub const IMAGE_ENCLAVE_IMPORT_MATCH_UNIQUE_ID: u32 = 0x0000_0001;
+pub const IMAGE_ENCLAVE_IMPORT_MATCH_AUTHOR_ID: u32 = 0x0000_0002;
+pub const IMAGE_ENCLAVE_IMPORT_MATCH_FAMILY_ID: u32 = 0x0000_0003;
+pub const IMAGE_ENCLAVE_IMPORT_MATCH_IMAGE_ID: u32 = 0x0000_0004;
+
+//
+// Debug Format
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageDebugDirectory {
+ pub characteristics: U32<LE>,
+ pub time_date_stamp: U32<LE>,
+ pub major_version: U16<LE>,
+ pub minor_version: U16<LE>,
+ pub typ: U32<LE>,
+ pub size_of_data: U32<LE>,
+ pub address_of_raw_data: U32<LE>,
+ pub pointer_to_raw_data: U32<LE>,
+}
+
+pub const IMAGE_DEBUG_TYPE_UNKNOWN: u32 = 0;
+pub const IMAGE_DEBUG_TYPE_COFF: u32 = 1;
+pub const IMAGE_DEBUG_TYPE_CODEVIEW: u32 = 2;
+pub const IMAGE_DEBUG_TYPE_FPO: u32 = 3;
+pub const IMAGE_DEBUG_TYPE_MISC: u32 = 4;
+pub const IMAGE_DEBUG_TYPE_EXCEPTION: u32 = 5;
+pub const IMAGE_DEBUG_TYPE_FIXUP: u32 = 6;
+pub const IMAGE_DEBUG_TYPE_OMAP_TO_SRC: u32 = 7;
+pub const IMAGE_DEBUG_TYPE_OMAP_FROM_SRC: u32 = 8;
+pub const IMAGE_DEBUG_TYPE_BORLAND: u32 = 9;
+pub const IMAGE_DEBUG_TYPE_RESERVED10: u32 = 10;
+pub const IMAGE_DEBUG_TYPE_CLSID: u32 = 11;
+pub const IMAGE_DEBUG_TYPE_VC_FEATURE: u32 = 12;
+pub const IMAGE_DEBUG_TYPE_POGO: u32 = 13;
+pub const IMAGE_DEBUG_TYPE_ILTCG: u32 = 14;
+pub const IMAGE_DEBUG_TYPE_MPX: u32 = 15;
+pub const IMAGE_DEBUG_TYPE_REPRO: u32 = 16;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageCoffSymbolsHeader {
+ pub number_of_symbols: U32<LE>,
+ pub lva_to_first_symbol: U32<LE>,
+ pub number_of_linenumbers: U32<LE>,
+ pub lva_to_first_linenumber: U32<LE>,
+ pub rva_to_first_byte_of_code: U32<LE>,
+ pub rva_to_last_byte_of_code: U32<LE>,
+ pub rva_to_first_byte_of_data: U32<LE>,
+ pub rva_to_last_byte_of_data: U32<LE>,
+}
+
+pub const FRAME_FPO: u16 = 0;
+pub const FRAME_TRAP: u16 = 1;
+pub const FRAME_TSS: u16 = 2;
+pub const FRAME_NONFPO: u16 = 3;
+
+/*
+// TODO? bitfields
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct FpoData {
+/// offset 1st byte of function code
+ pub ul_off_start: U32<LE>,
+/// # bytes in function
+ pub cb_proc_size: U32<LE>,
+/// # bytes in locals/4
+ pub cdw_locals: U32<LE>,
+/// # bytes in params/4
+ pub cdw_params: U16<LE>,
+/// # bytes in prolog
+ WORD cbProlog : 8;
+/// # regs saved
+ WORD cbRegs : 3;
+/// TRUE if SEH in func
+ WORD fHasSEH : 1;
+/// TRUE if EBP has been allocated
+ WORD fUseBP : 1;
+/// reserved for future use
+ WORD reserved : 1;
+/// frame type
+ WORD cbFrame : 2;
+}
+pub const SIZEOF_RFPO_DATA: usize = 16;
+*/
+
+pub const IMAGE_DEBUG_MISC_EXENAME: u16 = 1;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageDebugMisc {
+ /// type of misc data, see defines
+ pub data_type: U32<LE>,
+ /// total length of record, rounded to four byte multiple.
+ pub length: U32<LE>,
+ /// TRUE if data is unicode string
+ pub unicode: u8,
+ pub reserved: [u8; 3],
+ // Actual data
+ //pub data: [u8; 1],
+}
+
+//
+// Function table extracted from MIPS/ALPHA/IA64 images. Does not contain
+// information needed only for runtime support. Just those fields for
+// each entry needed by a debugger.
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageFunctionEntry {
+ pub starting_address: U32<LE>,
+ pub ending_address: U32<LE>,
+ pub end_of_prologue: U32<LE>,
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageFunctionEntry64 {
+ pub starting_address: U64<LE>,
+ pub ending_address: U64<LE>,
+ pub end_of_prologue_or_unwind_info_address: U64<LE>,
+}
+
+//
+// Debugging information can be stripped from an image file and placed
+// in a separate .DBG file, whose file name part is the same as the
+// image file name part (e.g. symbols for CMD.EXE could be stripped
+// and placed in CMD.DBG). This is indicated by the IMAGE_FILE_DEBUG_STRIPPED
+// flag in the Characteristics field of the file header. The beginning of
+// the .DBG file contains the following structure which captures certain
+// information from the image file. This allows a debug to proceed even if
+// the original image file is not accessable. This header is followed by
+// zero of more IMAGE_SECTION_HEADER structures, followed by zero or more
+// IMAGE_DEBUG_DIRECTORY structures. The latter structures and those in
+// the image file contain file offsets relative to the beginning of the
+// .DBG file.
+//
+// If symbols have been stripped from an image, the IMAGE_DEBUG_MISC structure
+// is left in the image file, but not mapped. This allows a debugger to
+// compute the name of the .DBG file, from the name of the image in the
+// IMAGE_DEBUG_MISC structure.
+//
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageSeparateDebugHeader {
+ pub signature: U16<LE>,
+ pub flags: U16<LE>,
+ pub machine: U16<LE>,
+ pub characteristics: U16<LE>,
+ pub time_date_stamp: U32<LE>,
+ pub check_sum: U32<LE>,
+ pub image_base: U32<LE>,
+ pub size_of_image: U32<LE>,
+ pub number_of_sections: U32<LE>,
+ pub exported_names_size: U32<LE>,
+ pub debug_directory_size: U32<LE>,
+ pub section_alignment: U32<LE>,
+ pub reserved: [U32<LE>; 2],
+}
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct NonPagedDebugInfo {
+ pub signature: U16<LE>,
+ pub flags: U16<LE>,
+ pub size: U32<LE>,
+ pub machine: U16<LE>,
+ pub characteristics: U16<LE>,
+ pub time_date_stamp: U32<LE>,
+ pub check_sum: U32<LE>,
+ pub size_of_image: U32<LE>,
+ pub image_base: U64<LE>,
+ //debug_directory_size
+ //ImageDebugDirectory
+}
+
+pub const IMAGE_SEPARATE_DEBUG_SIGNATURE: u16 = 0x4944;
+pub const NON_PAGED_DEBUG_SIGNATURE: u16 = 0x494E;
+
+pub const IMAGE_SEPARATE_DEBUG_FLAGS_MASK: u16 = 0x8000;
+/// when DBG was updated, the old checksum didn't match.
+pub const IMAGE_SEPARATE_DEBUG_MISMATCH: u16 = 0x8000;
+
+//
+// The .arch section is made up of headers, each describing an amask position/value
+// pointing to an array of IMAGE_ARCHITECTURE_ENTRY's. Each "array" (both the header
+// and entry arrays) are terminiated by a quadword of 0xffffffffL.
+//
+// NOTE: There may be quadwords of 0 sprinkled around and must be skipped.
+//
+
+/*
+// TODO? bitfields
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageArchitectureHeader {
+ /// 1 -> code section depends on mask bit
+ /// 0 -> new instruction depends on mask bit
+ unsigned int AmaskValue: 1;
+ /// MBZ
+ int :7;
+ /// Amask bit in question for this fixup
+ unsigned int AmaskShift: 8;
+ /// MBZ
+ int :16;
+ /// RVA into .arch section to array of ARCHITECTURE_ENTRY's
+ pub first_entry_rva: U32<LE>,
+}
+*/
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageArchitectureEntry {
+ /// RVA of instruction to fixup
+ pub fixup_inst_rva: U32<LE>,
+ /// fixup instruction (see alphaops.h)
+ pub new_inst: U32<LE>,
+}
+
+// The following structure defines the new import object. Note the values of the first two fields,
+// which must be set as stated in order to differentiate old and new import members.
+// Following this structure, the linker emits two null-terminated strings used to recreate the
+// import at the time of use. The first string is the import's name, the second is the dll's name.
+
+pub const IMPORT_OBJECT_HDR_SIG2: u16 = 0xffff;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImportObjectHeader {
+ /// Must be IMAGE_FILE_MACHINE_UNKNOWN
+ pub sig1: U16<LE>,
+ /// Must be IMPORT_OBJECT_HDR_SIG2.
+ pub sig2: U16<LE>,
+ pub version: U16<LE>,
+ pub machine: U16<LE>,
+ /// Time/date stamp
+ pub time_date_stamp: U32<LE>,
+ /// particularly useful for incremental links
+ pub size_of_data: U32<LE>,
+
+ /// if grf & IMPORT_OBJECT_ORDINAL
+ pub ordinal_or_hint: U16<LE>,
+
+ // WORD Type : 2;
+ // WORD NameType : 3;
+ // WORD Reserved : 11;
+ pub name_type: U16<LE>,
+}
+
+pub const IMPORT_OBJECT_CODE: u16 = 0;
+pub const IMPORT_OBJECT_DATA: u16 = 1;
+pub const IMPORT_OBJECT_CONST: u16 = 2;
+
+/// Import by ordinal
+pub const IMPORT_OBJECT_ORDINAL: u16 = 0;
+/// Import name == public symbol name.
+pub const IMPORT_OBJECT_NAME: u16 = 1;
+/// Import name == public symbol name skipping leading ?, @, or optionally _.
+pub const IMPORT_OBJECT_NAME_NO_PREFIX: u16 = 2;
+/// Import name == public symbol name skipping leading ?, @, or optionally _ and truncating at first @.
+pub const IMPORT_OBJECT_NAME_UNDECORATE: u16 = 3;
+/// Import name == a name is explicitly provided after the DLL name.
+pub const IMPORT_OBJECT_NAME_EXPORTAS: u16 = 4;
+
+// COM+ Header entry point flags.
+pub const COMIMAGE_FLAGS_ILONLY: u32 = 0x0000_0001;
+pub const COMIMAGE_FLAGS_32BITREQUIRED: u32 = 0x0000_0002;
+pub const COMIMAGE_FLAGS_IL_LIBRARY: u32 = 0x0000_0004;
+pub const COMIMAGE_FLAGS_STRONGNAMESIGNED: u32 = 0x0000_0008;
+pub const COMIMAGE_FLAGS_NATIVE_ENTRYPOINT: u32 = 0x0000_0010;
+pub const COMIMAGE_FLAGS_TRACKDEBUGDATA: u32 = 0x0001_0000;
+pub const COMIMAGE_FLAGS_32BITPREFERRED: u32 = 0x0002_0000;
+
+// Version flags for image.
+pub const COR_VERSION_MAJOR_V2: u16 = 2;
+pub const COR_VERSION_MAJOR: u16 = COR_VERSION_MAJOR_V2;
+pub const COR_VERSION_MINOR: u16 = 5;
+pub const COR_DELETED_NAME_LENGTH: usize = 8;
+pub const COR_VTABLEGAP_NAME_LENGTH: usize = 8;
+
+// Maximum size of a NativeType descriptor.
+pub const NATIVE_TYPE_MAX_CB: u16 = 1;
+pub const COR_ILMETHOD_SECT_SMALL_MAX_DATASIZE: u16 = 0xFF;
+
+// Consts for the MIH FLAGS
+pub const IMAGE_COR_MIH_METHODRVA: u16 = 0x01;
+pub const IMAGE_COR_MIH_EHRVA: u16 = 0x02;
+pub const IMAGE_COR_MIH_BASICBLOCK: u16 = 0x08;
+
+// V-table constants
+/// V-table slots are 32-bits in size.
+pub const COR_VTABLE_32BIT: u16 = 0x01;
+/// V-table slots are 64-bits in size.
+pub const COR_VTABLE_64BIT: u16 = 0x02;
+/// If set, transition from unmanaged.
+pub const COR_VTABLE_FROM_UNMANAGED: u16 = 0x04;
+/// If set, transition from unmanaged with keeping the current appdomain.
+pub const COR_VTABLE_FROM_UNMANAGED_RETAIN_APPDOMAIN: u16 = 0x08;
+/// Call most derived method described by
+pub const COR_VTABLE_CALL_MOST_DERIVED: u16 = 0x10;
+
+// EATJ constants
+/// Size of a jump thunk reserved range.
+pub const IMAGE_COR_EATJ_THUNK_SIZE: usize = 32;
+
+// Max name lengths
+pub const MAX_CLASS_NAME: usize = 1024;
+pub const MAX_PACKAGE_NAME: usize = 1024;
+
+// CLR 2.0 header structure.
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct ImageCor20Header {
+ // Header versioning
+ pub cb: U32<LE>,
+ pub major_runtime_version: U16<LE>,
+ pub minor_runtime_version: U16<LE>,
+
+ // Symbol table and startup information
+ pub meta_data: ImageDataDirectory,
+ pub flags: U32<LE>,
+
+ // If COMIMAGE_FLAGS_NATIVE_ENTRYPOINT is not set, EntryPointToken represents a managed entrypoint.
+ // If COMIMAGE_FLAGS_NATIVE_ENTRYPOINT is set, EntryPointRVA represents an RVA to a native entrypoint.
+ pub entry_point_token_or_rva: U32<LE>,
+
+ // Binding information
+ pub resources: ImageDataDirectory,
+ pub strong_name_signature: ImageDataDirectory,
+
+ // Regular fixup and binding information
+ pub code_manager_table: ImageDataDirectory,
+ pub vtable_fixups: ImageDataDirectory,
+ pub export_address_table_jumps: ImageDataDirectory,
+
+ // Precompiled image info (internal use only - set to zero)
+ pub managed_native_header: ImageDataDirectory,
+}
+
+unsafe_impl_pod!(
+ ImageDosHeader,
+ ImageOs2Header,
+ ImageVxdHeader,
+ ImageFileHeader,
+ ImageDataDirectory,
+ ImageOptionalHeader32,
+ ImageRomOptionalHeader,
+ ImageOptionalHeader64,
+ ImageNtHeaders64,
+ ImageNtHeaders32,
+ ImageRomHeaders,
+ Guid,
+ AnonObjectHeader,
+ AnonObjectHeaderV2,
+ AnonObjectHeaderBigobj,
+ ImageSectionHeader,
+ ImageSymbol,
+ ImageSymbolBytes,
+ ImageSymbolEx,
+ ImageSymbolExBytes,
+ ImageAuxSymbolTokenDef,
+ ImageAuxSymbolFunction,
+ ImageAuxSymbolFunctionBeginEnd,
+ ImageAuxSymbolWeak,
+ ImageAuxSymbolSection,
+ ImageAuxSymbolCrc,
+ ImageRelocation,
+ ImageLinenumber,
+ ImageBaseRelocation,
+ ImageArchiveMemberHeader,
+ ImageExportDirectory,
+ ImageImportByName,
+ //ImageThunkData64,
+ //ImageThunkData32,
+ ImageTlsDirectory64,
+ ImageTlsDirectory32,
+ ImageImportDescriptor,
+ ImageBoundImportDescriptor,
+ ImageBoundForwarderRef,
+ ImageDelayloadDescriptor,
+ ImageResourceDirectory,
+ ImageResourceDirectoryEntry,
+ ImageResourceDirectoryString,
+ ImageResourceDirStringU,
+ ImageResourceDataEntry,
+ ImageLoadConfigCodeIntegrity,
+ ImageDynamicRelocationTable,
+ ImageDynamicRelocation32,
+ ImageDynamicRelocation64,
+ ImageDynamicRelocation32V2,
+ ImageDynamicRelocation64V2,
+ ImagePrologueDynamicRelocationHeader,
+ ImageEpilogueDynamicRelocationHeader,
+ //ImageImportControlTransferDynamicRelocation,
+ //ImageIndirControlTransferDynamicRelocation,
+ //ImageSwitchtableBranchDynamicRelocation,
+ ImageLoadConfigDirectory32,
+ ImageLoadConfigDirectory64,
+ ImageHotPatchInfo,
+ ImageHotPatchBase,
+ ImageHotPatchHashes,
+ //ImageCeRuntimeFunctionEntry,
+ ImageArmRuntimeFunctionEntry,
+ ImageArm64RuntimeFunctionEntry,
+ ImageAlpha64RuntimeFunctionEntry,
+ ImageAlphaRuntimeFunctionEntry,
+ ImageRuntimeFunctionEntry,
+ ImageEnclaveConfig32,
+ ImageEnclaveConfig64,
+ ImageEnclaveImport,
+ ImageDebugDirectory,
+ ImageCoffSymbolsHeader,
+ //FpoData,
+ ImageDebugMisc,
+ ImageFunctionEntry,
+ ImageFunctionEntry64,
+ ImageSeparateDebugHeader,
+ NonPagedDebugInfo,
+ //ImageArchitectureHeader,
+ ImageArchitectureEntry,
+ ImportObjectHeader,
+ ImageCor20Header,
+);
diff --git a/vendor/object-0.26.2/src/pod.rs b/vendor/object-0.26.2/src/pod.rs
new file mode 100644
index 000000000..805cf8249
--- /dev/null
+++ b/vendor/object-0.26.2/src/pod.rs
@@ -0,0 +1,238 @@
+//! Tools for converting file format structures to and from bytes.
+//!
+//! This module should be replaced once rust provides safe transmutes.
+
+// This module provides functions for both read and write features.
+#![cfg_attr(
+ not(all(feature = "read_core", feature = "write_core")),
+ allow(dead_code)
+)]
+
+use core::{mem, result, slice};
+
+type Result<T> = result::Result<T, ()>;
+
+/// A trait for types that can safely be converted from and to byte slices.
+///
+/// A type that is `Pod` must:
+/// - be `#[repr(C)]` or `#[repr(transparent)]`
+/// - have no invalid byte values
+/// - have no padding
+pub unsafe trait Pod: Copy + 'static {}
+
+/// Cast a byte slice to a `Pod` type.
+///
+/// Returns the type and the tail of the slice.
+#[inline]
+pub fn from_bytes<T: Pod>(data: &[u8]) -> Result<(&T, &[u8])> {
+ let size = mem::size_of::<T>();
+ let tail = data.get(size..).ok_or(())?;
+ let ptr = data.as_ptr();
+ if (ptr as usize) % mem::align_of::<T>() != 0 {
+ return Err(());
+ }
+ // Safety:
+ // The alignment and size are checked by this function.
+ // The Pod trait ensures the type is valid to cast from bytes.
+ let val = unsafe { &*ptr.cast() };
+ Ok((val, tail))
+}
+
+/// Cast a mutable byte slice to a `Pod` type.
+///
+/// Returns the type and the tail of the slice.
+#[inline]
+pub fn from_bytes_mut<T: Pod>(data: &mut [u8]) -> Result<(&mut T, &mut [u8])> {
+ let size = mem::size_of::<T>();
+ if size > data.len() {
+ return Err(());
+ }
+ let (data, tail) = data.split_at_mut(size);
+ let ptr = data.as_mut_ptr();
+ if (ptr as usize) % mem::align_of::<T>() != 0 {
+ return Err(());
+ }
+ // Safety:
+ // The alignment and size are checked by this function.
+ // The Pod trait ensures the type is valid to cast from bytes.
+ let val = unsafe { &mut *ptr.cast() };
+ Ok((val, tail))
+}
+
+/// Cast a byte slice to a slice of a `Pod` type.
+///
+/// Returns the type slice and the tail of the byte slice.
+#[inline]
+pub fn slice_from_bytes<T: Pod>(data: &[u8], count: usize) -> Result<(&[T], &[u8])> {
+ let size = count.checked_mul(mem::size_of::<T>()).ok_or(())?;
+ let tail = data.get(size..).ok_or(())?;
+ let ptr = data.as_ptr();
+ if (ptr as usize) % mem::align_of::<T>() != 0 {
+ return Err(());
+ }
+ // Safety:
+ // The alignment and size are checked by this function.
+ // The Pod trait ensures the type is valid to cast from bytes.
+ let slice = unsafe { slice::from_raw_parts(ptr.cast(), count) };
+ Ok((slice, tail))
+}
+
+/// Cast a mutable byte slice to a slice of a `Pod` type.
+///
+/// Returns the type slice and the tail of the byte slice.
+#[inline]
+pub fn slice_from_bytes_mut<T: Pod>(
+ data: &mut [u8],
+ count: usize,
+) -> Result<(&mut [T], &mut [u8])> {
+ let size = count.checked_mul(mem::size_of::<T>()).ok_or(())?;
+ if size > data.len() {
+ return Err(());
+ }
+ let (data, tail) = data.split_at_mut(size);
+ let ptr = data.as_mut_ptr();
+ if (ptr as usize) % mem::align_of::<T>() != 0 {
+ return Err(());
+ }
+ // Safety:
+ // The alignment and size are checked by this function.
+ // The Pod trait ensures the type is valid to cast from bytes.
+ let slice = unsafe { slice::from_raw_parts_mut(ptr.cast(), count) };
+ Ok((slice, tail))
+}
+
+/// Cast a `Pod` type to a byte slice.
+#[inline]
+pub fn bytes_of<T: Pod>(val: &T) -> &[u8] {
+ let size = mem::size_of::<T>();
+ // Safety:
+ // Any alignment is allowed.
+ // The size is determined in this function.
+ // The Pod trait ensures the type is valid to cast to bytes.
+ unsafe { slice::from_raw_parts(slice::from_ref(val).as_ptr().cast(), size) }
+}
+
+/// Cast a `Pod` type to a mutable byte slice.
+#[inline]
+pub fn bytes_of_mut<T: Pod>(val: &mut T) -> &mut [u8] {
+ let size = mem::size_of::<T>();
+ // Safety:
+ // Any alignment is allowed.
+ // The size is determined in this function.
+ // The Pod trait ensures the type is valid to cast to bytes.
+ unsafe { slice::from_raw_parts_mut(slice::from_mut(val).as_mut_ptr().cast(), size) }
+}
+
+/// Cast a slice of a `Pod` type to a byte slice.
+#[inline]
+pub fn bytes_of_slice<T: Pod>(val: &[T]) -> &[u8] {
+ let size = val.len().wrapping_mul(mem::size_of::<T>());
+ // Safety:
+ // Any alignment is allowed.
+ // The size is determined in this function.
+ // The Pod trait ensures the type is valid to cast to bytes.
+ unsafe { slice::from_raw_parts(val.as_ptr().cast(), size) }
+}
+
+/// Cast a slice of a `Pod` type to a mutable byte slice.
+#[inline]
+pub fn bytes_of_slice_mut<T: Pod>(val: &mut [T]) -> &mut [u8] {
+ let size = val.len().wrapping_mul(mem::size_of::<T>());
+ // Safety:
+ // Any alignment is allowed.
+ // The size is determined in this function.
+ // The Pod trait ensures the type is valid to cast to bytes.
+ unsafe { slice::from_raw_parts_mut(val.as_mut_ptr().cast(), size) }
+}
+
+macro_rules! unsafe_impl_pod {
+ ($($struct_name:ident),+ $(,)?) => {
+ $(
+ unsafe impl Pod for $struct_name { }
+ )+
+ }
+}
+
+unsafe_impl_pod!(u8, u16, u32, u64);
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn single() {
+ let x = u32::to_be(0x0123_4567);
+ let mut x_mut = x;
+ let bytes = bytes_of(&x);
+ let bytes_mut = bytes_of_mut(&mut x_mut);
+ assert_eq!(bytes, [0x01, 0x23, 0x45, 0x67]);
+ assert_eq!(bytes, bytes_mut);
+
+ let x16 = [u16::to_be(0x0123), u16::to_be(0x4567)];
+
+ let (y, tail) = from_bytes::<u32>(bytes).unwrap();
+ let (y_mut, tail_mut) = from_bytes_mut::<u32>(bytes_mut).unwrap();
+ assert_eq!(*y, x);
+ assert_eq!(y, y_mut);
+ assert_eq!(tail, &[]);
+ assert_eq!(tail, tail_mut);
+
+ let (y, tail) = from_bytes::<u16>(bytes).unwrap();
+ let (y_mut, tail_mut) = from_bytes_mut::<u16>(bytes_mut).unwrap();
+ assert_eq!(*y, x16[0]);
+ assert_eq!(y, y_mut);
+ assert_eq!(tail, &bytes[2..]);
+ assert_eq!(tail, tail_mut);
+
+ let (y, tail) = from_bytes::<u16>(&bytes[2..]).unwrap();
+ let (y_mut, tail_mut) = from_bytes_mut::<u16>(&mut bytes_mut[2..]).unwrap();
+ assert_eq!(*y, x16[1]);
+ assert_eq!(y, y_mut);
+ assert_eq!(tail, &[]);
+ assert_eq!(tail, tail_mut);
+
+ assert_eq!(from_bytes::<u16>(&bytes[1..]), Err(()));
+ assert_eq!(from_bytes::<u16>(&bytes[3..]), Err(()));
+ assert_eq!(from_bytes::<u16>(&bytes[4..]), Err(()));
+ assert_eq!(from_bytes_mut::<u16>(&mut bytes_mut[1..]), Err(()));
+ assert_eq!(from_bytes_mut::<u16>(&mut bytes_mut[3..]), Err(()));
+ assert_eq!(from_bytes_mut::<u16>(&mut bytes_mut[4..]), Err(()));
+ }
+
+ #[test]
+ fn slice() {
+ let x = [
+ u16::to_be(0x0123),
+ u16::to_be(0x4567),
+ u16::to_be(0x89ab),
+ u16::to_be(0xcdef),
+ ];
+ let mut x_mut = x;
+
+ let bytes = bytes_of_slice(&x);
+ let bytes_mut = bytes_of_slice_mut(&mut x_mut);
+ assert_eq!(bytes, [0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef]);
+ assert_eq!(bytes, bytes_mut);
+
+ let (y, tail) = slice_from_bytes::<u16>(bytes, 4).unwrap();
+ let (y_mut, tail_mut) = slice_from_bytes_mut::<u16>(bytes_mut, 4).unwrap();
+ assert_eq!(y, x);
+ assert_eq!(y, y_mut);
+ assert_eq!(tail, &[]);
+ assert_eq!(tail, tail_mut);
+
+ let (y, tail) = slice_from_bytes::<u16>(&bytes[2..], 2).unwrap();
+ let (y_mut, tail_mut) = slice_from_bytes::<u16>(&mut bytes_mut[2..], 2).unwrap();
+ assert_eq!(y, &x[1..3]);
+ assert_eq!(y, y_mut);
+ assert_eq!(tail, &bytes[6..]);
+ assert_eq!(tail, tail_mut);
+
+ assert_eq!(slice_from_bytes::<u16>(bytes, 5), Err(()));
+ assert_eq!(slice_from_bytes::<u16>(&bytes[2..], 4), Err(()));
+ assert_eq!(slice_from_bytes::<u16>(&bytes[1..], 2), Err(()));
+ assert_eq!(slice_from_bytes_mut::<u16>(bytes_mut, 5), Err(()));
+ assert_eq!(slice_from_bytes_mut::<u16>(&mut bytes_mut[2..], 4), Err(()));
+ assert_eq!(slice_from_bytes_mut::<u16>(&mut bytes_mut[1..], 2), Err(()));
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/any.rs b/vendor/object-0.26.2/src/read/any.rs
new file mode 100644
index 000000000..80526e994
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/any.rs
@@ -0,0 +1,1225 @@
+use alloc::fmt;
+use alloc::vec::Vec;
+use core::marker::PhantomData;
+
+#[cfg(feature = "coff")]
+use crate::read::coff;
+#[cfg(feature = "elf")]
+use crate::read::elf;
+#[cfg(feature = "macho")]
+use crate::read::macho;
+#[cfg(feature = "pe")]
+use crate::read::pe;
+#[cfg(feature = "wasm")]
+use crate::read::wasm;
+use crate::read::{
+ self, Architecture, BinaryFormat, CodeView, ComdatKind, CompressedData, CompressedFileRange,
+ Error, Export, FileFlags, FileKind, Import, Object, ObjectComdat, ObjectMap, ObjectSection,
+ ObjectSegment, ObjectSymbol, ObjectSymbolTable, ReadRef, Relocation, Result, SectionFlags,
+ SectionIndex, SectionKind, SymbolFlags, SymbolIndex, SymbolKind, SymbolMap, SymbolMapName,
+ SymbolScope, SymbolSection,
+};
+#[allow(unused_imports)]
+use crate::Endianness;
+
+/// Evaluate an expression on the contents of a file format enum.
+///
+/// This is a hack to avoid virtual calls.
+macro_rules! with_inner {
+ ($inner:expr, $enum:ident, | $var:ident | $body:expr) => {
+ match $inner {
+ #[cfg(feature = "coff")]
+ $enum::Coff(ref $var) => $body,
+ #[cfg(feature = "elf")]
+ $enum::Elf32(ref $var) => $body,
+ #[cfg(feature = "elf")]
+ $enum::Elf64(ref $var) => $body,
+ #[cfg(feature = "macho")]
+ $enum::MachO32(ref $var) => $body,
+ #[cfg(feature = "macho")]
+ $enum::MachO64(ref $var) => $body,
+ #[cfg(feature = "pe")]
+ $enum::Pe32(ref $var) => $body,
+ #[cfg(feature = "pe")]
+ $enum::Pe64(ref $var) => $body,
+ #[cfg(feature = "wasm")]
+ $enum::Wasm(ref $var) => $body,
+ }
+ };
+}
+
+macro_rules! with_inner_mut {
+ ($inner:expr, $enum:ident, | $var:ident | $body:expr) => {
+ match $inner {
+ #[cfg(feature = "coff")]
+ $enum::Coff(ref mut $var) => $body,
+ #[cfg(feature = "elf")]
+ $enum::Elf32(ref mut $var) => $body,
+ #[cfg(feature = "elf")]
+ $enum::Elf64(ref mut $var) => $body,
+ #[cfg(feature = "macho")]
+ $enum::MachO32(ref mut $var) => $body,
+ #[cfg(feature = "macho")]
+ $enum::MachO64(ref mut $var) => $body,
+ #[cfg(feature = "pe")]
+ $enum::Pe32(ref mut $var) => $body,
+ #[cfg(feature = "pe")]
+ $enum::Pe64(ref mut $var) => $body,
+ #[cfg(feature = "wasm")]
+ $enum::Wasm(ref mut $var) => $body,
+ }
+ };
+}
+
+/// Like `with_inner!`, but wraps the result in another enum.
+macro_rules! map_inner {
+ ($inner:expr, $from:ident, $to:ident, | $var:ident | $body:expr) => {
+ match $inner {
+ #[cfg(feature = "coff")]
+ $from::Coff(ref $var) => $to::Coff($body),
+ #[cfg(feature = "elf")]
+ $from::Elf32(ref $var) => $to::Elf32($body),
+ #[cfg(feature = "elf")]
+ $from::Elf64(ref $var) => $to::Elf64($body),
+ #[cfg(feature = "macho")]
+ $from::MachO32(ref $var) => $to::MachO32($body),
+ #[cfg(feature = "macho")]
+ $from::MachO64(ref $var) => $to::MachO64($body),
+ #[cfg(feature = "pe")]
+ $from::Pe32(ref $var) => $to::Pe32($body),
+ #[cfg(feature = "pe")]
+ $from::Pe64(ref $var) => $to::Pe64($body),
+ #[cfg(feature = "wasm")]
+ $from::Wasm(ref $var) => $to::Wasm($body),
+ }
+ };
+}
+
+/// Like `map_inner!`, but the result is a Result or Option.
+macro_rules! map_inner_option {
+ ($inner:expr, $from:ident, $to:ident, | $var:ident | $body:expr) => {
+ match $inner {
+ #[cfg(feature = "coff")]
+ $from::Coff(ref $var) => $body.map($to::Coff),
+ #[cfg(feature = "elf")]
+ $from::Elf32(ref $var) => $body.map($to::Elf32),
+ #[cfg(feature = "elf")]
+ $from::Elf64(ref $var) => $body.map($to::Elf64),
+ #[cfg(feature = "macho")]
+ $from::MachO32(ref $var) => $body.map($to::MachO32),
+ #[cfg(feature = "macho")]
+ $from::MachO64(ref $var) => $body.map($to::MachO64),
+ #[cfg(feature = "pe")]
+ $from::Pe32(ref $var) => $body.map($to::Pe32),
+ #[cfg(feature = "pe")]
+ $from::Pe64(ref $var) => $body.map($to::Pe64),
+ #[cfg(feature = "wasm")]
+ $from::Wasm(ref $var) => $body.map($to::Wasm),
+ }
+ };
+}
+
+macro_rules! map_inner_option_mut {
+ ($inner:expr, $from:ident, $to:ident, | $var:ident | $body:expr) => {
+ match $inner {
+ #[cfg(feature = "coff")]
+ $from::Coff(ref mut $var) => $body.map($to::Coff),
+ #[cfg(feature = "elf")]
+ $from::Elf32(ref mut $var) => $body.map($to::Elf32),
+ #[cfg(feature = "elf")]
+ $from::Elf64(ref mut $var) => $body.map($to::Elf64),
+ #[cfg(feature = "macho")]
+ $from::MachO32(ref mut $var) => $body.map($to::MachO32),
+ #[cfg(feature = "macho")]
+ $from::MachO64(ref mut $var) => $body.map($to::MachO64),
+ #[cfg(feature = "pe")]
+ $from::Pe32(ref mut $var) => $body.map($to::Pe32),
+ #[cfg(feature = "pe")]
+ $from::Pe64(ref mut $var) => $body.map($to::Pe64),
+ #[cfg(feature = "wasm")]
+ $from::Wasm(ref mut $var) => $body.map($to::Wasm),
+ }
+ };
+}
+
+/// Call `next` for a file format iterator.
+macro_rules! next_inner {
+ ($inner:expr, $from:ident, $to:ident) => {
+ match $inner {
+ #[cfg(feature = "coff")]
+ $from::Coff(ref mut iter) => iter.next().map($to::Coff),
+ #[cfg(feature = "elf")]
+ $from::Elf32(ref mut iter) => iter.next().map($to::Elf32),
+ #[cfg(feature = "elf")]
+ $from::Elf64(ref mut iter) => iter.next().map($to::Elf64),
+ #[cfg(feature = "macho")]
+ $from::MachO32(ref mut iter) => iter.next().map($to::MachO32),
+ #[cfg(feature = "macho")]
+ $from::MachO64(ref mut iter) => iter.next().map($to::MachO64),
+ #[cfg(feature = "pe")]
+ $from::Pe32(ref mut iter) => iter.next().map($to::Pe32),
+ #[cfg(feature = "pe")]
+ $from::Pe64(ref mut iter) => iter.next().map($to::Pe64),
+ #[cfg(feature = "wasm")]
+ $from::Wasm(ref mut iter) => iter.next().map($to::Wasm),
+ }
+ };
+}
+
+/// An object file.
+///
+/// Most functionality is provided by the `Object` trait implementation.
+#[derive(Debug)]
+pub struct File<'data, R: ReadRef<'data> = &'data [u8]> {
+ inner: FileInternal<'data, R>,
+}
+
+#[derive(Debug)]
+enum FileInternal<'data, R: ReadRef<'data>> {
+ #[cfg(feature = "coff")]
+ Coff(coff::CoffFile<'data, R>),
+ #[cfg(feature = "elf")]
+ Elf32(elf::ElfFile32<'data, Endianness, R>),
+ #[cfg(feature = "elf")]
+ Elf64(elf::ElfFile64<'data, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO32(macho::MachOFile32<'data, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO64(macho::MachOFile64<'data, Endianness, R>),
+ #[cfg(feature = "pe")]
+ Pe32(pe::PeFile32<'data, R>),
+ #[cfg(feature = "pe")]
+ Pe64(pe::PeFile64<'data, R>),
+ #[cfg(feature = "wasm")]
+ Wasm(wasm::WasmFile<'data, R>),
+}
+
+impl<'data, R: ReadRef<'data>> File<'data, R> {
+ /// Parse the raw file data.
+ pub fn parse(data: R) -> Result<Self> {
+ let inner = match FileKind::parse(data)? {
+ #[cfg(feature = "elf")]
+ FileKind::Elf32 => FileInternal::Elf32(elf::ElfFile32::parse(data)?),
+ #[cfg(feature = "elf")]
+ FileKind::Elf64 => FileInternal::Elf64(elf::ElfFile64::parse(data)?),
+ #[cfg(feature = "macho")]
+ FileKind::MachO32 => FileInternal::MachO32(macho::MachOFile32::parse(data)?),
+ #[cfg(feature = "macho")]
+ FileKind::MachO64 => FileInternal::MachO64(macho::MachOFile64::parse(data)?),
+ #[cfg(feature = "wasm")]
+ FileKind::Wasm => FileInternal::Wasm(wasm::WasmFile::parse(data)?),
+ #[cfg(feature = "pe")]
+ FileKind::Pe32 => FileInternal::Pe32(pe::PeFile32::parse(data)?),
+ #[cfg(feature = "pe")]
+ FileKind::Pe64 => FileInternal::Pe64(pe::PeFile64::parse(data)?),
+ #[cfg(feature = "coff")]
+ FileKind::Coff => FileInternal::Coff(coff::CoffFile::parse(data)?),
+ #[allow(unreachable_patterns)]
+ _ => return Err(Error("Unsupported file format")),
+ };
+ Ok(File { inner })
+ }
+
+ /// Parse the raw file data at an arbitrary offset inside the input data.
+ ///
+ /// Currently, this is only supported for Mach-O images.
+ /// This can be used for parsing Mach-O images inside the dyld shared cache,
+ /// where multiple images, located at different offsets, share the same address
+ /// space.
+ pub fn parse_at(data: R, offset: u64) -> Result<Self> {
+ let _inner = match FileKind::parse_at(data, offset)? {
+ #[cfg(feature = "macho")]
+ FileKind::MachO32 => FileInternal::MachO32(macho::MachOFile32::parse_at(data, offset)?),
+ #[cfg(feature = "macho")]
+ FileKind::MachO64 => FileInternal::MachO64(macho::MachOFile64::parse_at(data, offset)?),
+ #[allow(unreachable_patterns)]
+ _ => return Err(Error("Unsupported file format")),
+ };
+ #[allow(unreachable_code)]
+ Ok(File { inner: _inner })
+ }
+
+ /// Return the file format.
+ pub fn format(&self) -> BinaryFormat {
+ match self.inner {
+ #[cfg(feature = "coff")]
+ FileInternal::Coff(_) => BinaryFormat::Coff,
+ #[cfg(feature = "elf")]
+ FileInternal::Elf32(_) | FileInternal::Elf64(_) => BinaryFormat::Elf,
+ #[cfg(feature = "macho")]
+ FileInternal::MachO32(_) | FileInternal::MachO64(_) => BinaryFormat::MachO,
+ #[cfg(feature = "pe")]
+ FileInternal::Pe32(_) | FileInternal::Pe64(_) => BinaryFormat::Pe,
+ #[cfg(feature = "wasm")]
+ FileInternal::Wasm(_) => BinaryFormat::Wasm,
+ }
+ }
+}
+
+impl<'data, R: ReadRef<'data>> read::private::Sealed for File<'data, R> {}
+
+impl<'data, 'file, R> Object<'data, 'file> for File<'data, R>
+where
+ 'data: 'file,
+ R: 'file + ReadRef<'data>,
+{
+ type Segment = Segment<'data, 'file, R>;
+ type SegmentIterator = SegmentIterator<'data, 'file, R>;
+ type Section = Section<'data, 'file, R>;
+ type SectionIterator = SectionIterator<'data, 'file, R>;
+ type Comdat = Comdat<'data, 'file, R>;
+ type ComdatIterator = ComdatIterator<'data, 'file, R>;
+ type Symbol = Symbol<'data, 'file, R>;
+ type SymbolIterator = SymbolIterator<'data, 'file, R>;
+ type SymbolTable = SymbolTable<'data, 'file, R>;
+ type DynamicRelocationIterator = DynamicRelocationIterator<'data, 'file, R>;
+
+ fn architecture(&self) -> Architecture {
+ with_inner!(self.inner, FileInternal, |x| x.architecture())
+ }
+
+ fn is_little_endian(&self) -> bool {
+ with_inner!(self.inner, FileInternal, |x| x.is_little_endian())
+ }
+
+ fn is_64(&self) -> bool {
+ with_inner!(self.inner, FileInternal, |x| x.is_64())
+ }
+
+ fn segments(&'file self) -> SegmentIterator<'data, 'file, R> {
+ SegmentIterator {
+ inner: map_inner!(self.inner, FileInternal, SegmentIteratorInternal, |x| x
+ .segments()),
+ }
+ }
+
+ fn section_by_name(&'file self, section_name: &str) -> Option<Section<'data, 'file, R>> {
+ map_inner_option!(self.inner, FileInternal, SectionInternal, |x| x
+ .section_by_name(section_name))
+ .map(|inner| Section { inner })
+ }
+
+ fn section_by_index(&'file self, index: SectionIndex) -> Result<Section<'data, 'file, R>> {
+ map_inner_option!(self.inner, FileInternal, SectionInternal, |x| x
+ .section_by_index(index))
+ .map(|inner| Section { inner })
+ }
+
+ fn sections(&'file self) -> SectionIterator<'data, 'file, R> {
+ SectionIterator {
+ inner: map_inner!(self.inner, FileInternal, SectionIteratorInternal, |x| x
+ .sections()),
+ }
+ }
+
+ fn comdats(&'file self) -> ComdatIterator<'data, 'file, R> {
+ ComdatIterator {
+ inner: map_inner!(self.inner, FileInternal, ComdatIteratorInternal, |x| x
+ .comdats()),
+ }
+ }
+
+ fn symbol_by_index(&'file self, index: SymbolIndex) -> Result<Symbol<'data, 'file, R>> {
+ map_inner_option!(self.inner, FileInternal, SymbolInternal, |x| x
+ .symbol_by_index(index)
+ .map(|x| (x, PhantomData)))
+ .map(|inner| Symbol { inner })
+ }
+
+ fn symbols(&'file self) -> SymbolIterator<'data, 'file, R> {
+ SymbolIterator {
+ inner: map_inner!(self.inner, FileInternal, SymbolIteratorInternal, |x| (
+ x.symbols(),
+ PhantomData
+ )),
+ }
+ }
+
+ fn symbol_table(&'file self) -> Option<SymbolTable<'data, 'file, R>> {
+ map_inner_option!(self.inner, FileInternal, SymbolTableInternal, |x| x
+ .symbol_table()
+ .map(|x| (x, PhantomData)))
+ .map(|inner| SymbolTable { inner })
+ }
+
+ fn dynamic_symbols(&'file self) -> SymbolIterator<'data, 'file, R> {
+ SymbolIterator {
+ inner: map_inner!(self.inner, FileInternal, SymbolIteratorInternal, |x| (
+ x.dynamic_symbols(),
+ PhantomData
+ )),
+ }
+ }
+
+ fn dynamic_symbol_table(&'file self) -> Option<SymbolTable<'data, 'file, R>> {
+ map_inner_option!(self.inner, FileInternal, SymbolTableInternal, |x| x
+ .dynamic_symbol_table()
+ .map(|x| (x, PhantomData)))
+ .map(|inner| SymbolTable { inner })
+ }
+
+ #[cfg(feature = "elf")]
+ fn dynamic_relocations(&'file self) -> Option<DynamicRelocationIterator<'data, 'file, R>> {
+ let inner = match self.inner {
+ FileInternal::Elf32(ref elf) => {
+ DynamicRelocationIteratorInternal::Elf32(elf.dynamic_relocations()?)
+ }
+ FileInternal::Elf64(ref elf) => {
+ DynamicRelocationIteratorInternal::Elf64(elf.dynamic_relocations()?)
+ }
+ #[allow(unreachable_patterns)]
+ _ => return None,
+ };
+ Some(DynamicRelocationIterator { inner })
+ }
+
+ #[cfg(not(feature = "elf"))]
+ fn dynamic_relocations(&'file self) -> Option<DynamicRelocationIterator<'data, 'file, R>> {
+ None
+ }
+
+ fn symbol_map(&self) -> SymbolMap<SymbolMapName<'data>> {
+ with_inner!(self.inner, FileInternal, |x| x.symbol_map())
+ }
+
+ fn object_map(&self) -> ObjectMap<'data> {
+ with_inner!(self.inner, FileInternal, |x| x.object_map())
+ }
+
+ fn imports(&self) -> Result<Vec<Import<'data>>> {
+ with_inner!(self.inner, FileInternal, |x| x.imports())
+ }
+
+ fn exports(&self) -> Result<Vec<Export<'data>>> {
+ with_inner!(self.inner, FileInternal, |x| x.exports())
+ }
+
+ fn has_debug_symbols(&self) -> bool {
+ with_inner!(self.inner, FileInternal, |x| x.has_debug_symbols())
+ }
+
+ #[inline]
+ fn mach_uuid(&self) -> Result<Option<[u8; 16]>> {
+ with_inner!(self.inner, FileInternal, |x| x.mach_uuid())
+ }
+
+ #[inline]
+ fn build_id(&self) -> Result<Option<&'data [u8]>> {
+ with_inner!(self.inner, FileInternal, |x| x.build_id())
+ }
+
+ #[inline]
+ fn gnu_debuglink(&self) -> Result<Option<(&'data [u8], u32)>> {
+ with_inner!(self.inner, FileInternal, |x| x.gnu_debuglink())
+ }
+
+ #[inline]
+ fn gnu_debugaltlink(&self) -> Result<Option<(&'data [u8], &'data [u8])>> {
+ with_inner!(self.inner, FileInternal, |x| x.gnu_debugaltlink())
+ }
+
+ #[inline]
+ fn pdb_info(&self) -> Result<Option<CodeView>> {
+ with_inner!(self.inner, FileInternal, |x| x.pdb_info())
+ }
+
+ fn relative_address_base(&self) -> u64 {
+ with_inner!(self.inner, FileInternal, |x| x.relative_address_base())
+ }
+
+ fn entry(&self) -> u64 {
+ with_inner!(self.inner, FileInternal, |x| x.entry())
+ }
+
+ fn flags(&self) -> FileFlags {
+ with_inner!(self.inner, FileInternal, |x| x.flags())
+ }
+}
+
+/// An iterator over the segments of a `File`.
+#[derive(Debug)]
+pub struct SegmentIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]>
+where
+ 'data: 'file,
+{
+ inner: SegmentIteratorInternal<'data, 'file, R>,
+}
+
+#[derive(Debug)]
+enum SegmentIteratorInternal<'data, 'file, R: ReadRef<'data>>
+where
+ 'data: 'file,
+{
+ #[cfg(feature = "coff")]
+ Coff(coff::CoffSegmentIterator<'data, 'file, R>),
+ #[cfg(feature = "elf")]
+ Elf32(elf::ElfSegmentIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "elf")]
+ Elf64(elf::ElfSegmentIterator64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO32(macho::MachOSegmentIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO64(macho::MachOSegmentIterator64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "pe")]
+ Pe32(pe::PeSegmentIterator32<'data, 'file, R>),
+ #[cfg(feature = "pe")]
+ Pe64(pe::PeSegmentIterator64<'data, 'file, R>),
+ #[cfg(feature = "wasm")]
+ Wasm(wasm::WasmSegmentIterator<'data, 'file, R>),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for SegmentIterator<'data, 'file, R> {
+ type Item = Segment<'data, 'file, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ next_inner!(self.inner, SegmentIteratorInternal, SegmentInternal)
+ .map(|inner| Segment { inner })
+ }
+}
+
+/// A segment of a `File`.
+pub struct Segment<'data, 'file, R: ReadRef<'data> = &'data [u8]>
+where
+ 'data: 'file,
+{
+ inner: SegmentInternal<'data, 'file, R>,
+}
+
+#[derive(Debug)]
+enum SegmentInternal<'data, 'file, R: ReadRef<'data>>
+where
+ 'data: 'file,
+{
+ #[cfg(feature = "coff")]
+ Coff(coff::CoffSegment<'data, 'file, R>),
+ #[cfg(feature = "elf")]
+ Elf32(elf::ElfSegment32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "elf")]
+ Elf64(elf::ElfSegment64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO32(macho::MachOSegment32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO64(macho::MachOSegment64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "pe")]
+ Pe32(pe::PeSegment32<'data, 'file, R>),
+ #[cfg(feature = "pe")]
+ Pe64(pe::PeSegment64<'data, 'file, R>),
+ #[cfg(feature = "wasm")]
+ Wasm(wasm::WasmSegment<'data, 'file, R>),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> fmt::Debug for Segment<'data, 'file, R> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // It's painful to do much better than this
+ let mut s = f.debug_struct("Segment");
+ match self.name() {
+ Ok(Some(ref name)) => {
+ s.field("name", name);
+ }
+ Ok(None) => {}
+ Err(_) => {
+ s.field("name", &"<invalid>");
+ }
+ }
+ s.field("address", &self.address())
+ .field("size", &self.size())
+ .finish()
+ }
+}
+
+impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for Segment<'data, 'file, R> {}
+
+impl<'data, 'file, R: ReadRef<'data>> ObjectSegment<'data> for Segment<'data, 'file, R> {
+ fn address(&self) -> u64 {
+ with_inner!(self.inner, SegmentInternal, |x| x.address())
+ }
+
+ fn size(&self) -> u64 {
+ with_inner!(self.inner, SegmentInternal, |x| x.size())
+ }
+
+ fn align(&self) -> u64 {
+ with_inner!(self.inner, SegmentInternal, |x| x.align())
+ }
+
+ fn file_range(&self) -> (u64, u64) {
+ with_inner!(self.inner, SegmentInternal, |x| x.file_range())
+ }
+
+ fn data(&self) -> Result<&'data [u8]> {
+ with_inner!(self.inner, SegmentInternal, |x| x.data())
+ }
+
+ fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
+ with_inner!(self.inner, SegmentInternal, |x| x.data_range(address, size))
+ }
+
+ fn name(&self) -> Result<Option<&str>> {
+ with_inner!(self.inner, SegmentInternal, |x| x.name())
+ }
+}
+
+/// An iterator of the sections of a `File`.
+#[derive(Debug)]
+pub struct SectionIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]>
+where
+ 'data: 'file,
+{
+ inner: SectionIteratorInternal<'data, 'file, R>,
+}
+
+// we wrap our enums in a struct so that they are kept private.
+#[derive(Debug)]
+enum SectionIteratorInternal<'data, 'file, R: ReadRef<'data>>
+where
+ 'data: 'file,
+{
+ #[cfg(feature = "coff")]
+ Coff(coff::CoffSectionIterator<'data, 'file, R>),
+ #[cfg(feature = "elf")]
+ Elf32(elf::ElfSectionIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "elf")]
+ Elf64(elf::ElfSectionIterator64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO32(macho::MachOSectionIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO64(macho::MachOSectionIterator64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "pe")]
+ Pe32(pe::PeSectionIterator32<'data, 'file, R>),
+ #[cfg(feature = "pe")]
+ Pe64(pe::PeSectionIterator64<'data, 'file, R>),
+ #[cfg(feature = "wasm")]
+ Wasm(wasm::WasmSectionIterator<'data, 'file, R>),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for SectionIterator<'data, 'file, R> {
+ type Item = Section<'data, 'file, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ next_inner!(self.inner, SectionIteratorInternal, SectionInternal)
+ .map(|inner| Section { inner })
+ }
+}
+
+/// A Section of a File
+pub struct Section<'data, 'file, R: ReadRef<'data> = &'data [u8]>
+where
+ 'data: 'file,
+{
+ inner: SectionInternal<'data, 'file, R>,
+}
+
+enum SectionInternal<'data, 'file, R: ReadRef<'data>>
+where
+ 'data: 'file,
+{
+ #[cfg(feature = "coff")]
+ Coff(coff::CoffSection<'data, 'file, R>),
+ #[cfg(feature = "elf")]
+ Elf32(elf::ElfSection32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "elf")]
+ Elf64(elf::ElfSection64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO32(macho::MachOSection32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO64(macho::MachOSection64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "pe")]
+ Pe32(pe::PeSection32<'data, 'file, R>),
+ #[cfg(feature = "pe")]
+ Pe64(pe::PeSection64<'data, 'file, R>),
+ #[cfg(feature = "wasm")]
+ Wasm(wasm::WasmSection<'data, 'file, R>),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> fmt::Debug for Section<'data, 'file, R> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // It's painful to do much better than this
+ let mut s = f.debug_struct("Section");
+ match self.segment_name() {
+ Ok(Some(ref name)) => {
+ s.field("segment", name);
+ }
+ Ok(None) => {}
+ Err(_) => {
+ s.field("segment", &"<invalid>");
+ }
+ }
+ s.field("name", &self.name().unwrap_or("<invalid>"))
+ .field("address", &self.address())
+ .field("size", &self.size())
+ .field("align", &self.align())
+ .field("kind", &self.kind())
+ .field("flags", &self.flags())
+ .finish()
+ }
+}
+
+impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for Section<'data, 'file, R> {}
+
+impl<'data, 'file, R: ReadRef<'data>> ObjectSection<'data> for Section<'data, 'file, R> {
+ type RelocationIterator = SectionRelocationIterator<'data, 'file, R>;
+
+ fn index(&self) -> SectionIndex {
+ with_inner!(self.inner, SectionInternal, |x| x.index())
+ }
+
+ fn address(&self) -> u64 {
+ with_inner!(self.inner, SectionInternal, |x| x.address())
+ }
+
+ fn size(&self) -> u64 {
+ with_inner!(self.inner, SectionInternal, |x| x.size())
+ }
+
+ fn align(&self) -> u64 {
+ with_inner!(self.inner, SectionInternal, |x| x.align())
+ }
+
+ fn file_range(&self) -> Option<(u64, u64)> {
+ with_inner!(self.inner, SectionInternal, |x| x.file_range())
+ }
+
+ fn data(&self) -> Result<&'data [u8]> {
+ with_inner!(self.inner, SectionInternal, |x| x.data())
+ }
+
+ fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
+ with_inner!(self.inner, SectionInternal, |x| x.data_range(address, size))
+ }
+
+ fn compressed_file_range(&self) -> Result<CompressedFileRange> {
+ with_inner!(self.inner, SectionInternal, |x| x.compressed_file_range())
+ }
+
+ fn compressed_data(&self) -> Result<CompressedData<'data>> {
+ with_inner!(self.inner, SectionInternal, |x| x.compressed_data())
+ }
+
+ fn name(&self) -> Result<&str> {
+ with_inner!(self.inner, SectionInternal, |x| x.name())
+ }
+
+ fn segment_name(&self) -> Result<Option<&str>> {
+ with_inner!(self.inner, SectionInternal, |x| x.segment_name())
+ }
+
+ fn kind(&self) -> SectionKind {
+ with_inner!(self.inner, SectionInternal, |x| x.kind())
+ }
+
+ fn relocations(&self) -> SectionRelocationIterator<'data, 'file, R> {
+ SectionRelocationIterator {
+ inner: map_inner!(
+ self.inner,
+ SectionInternal,
+ SectionRelocationIteratorInternal,
+ |x| x.relocations()
+ ),
+ }
+ }
+
+ fn flags(&self) -> SectionFlags {
+ with_inner!(self.inner, SectionInternal, |x| x.flags())
+ }
+}
+
+/// An iterator of the COMDAT section groups of a `File`.
+#[derive(Debug)]
+pub struct ComdatIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]>
+where
+ 'data: 'file,
+{
+ inner: ComdatIteratorInternal<'data, 'file, R>,
+}
+
+#[derive(Debug)]
+enum ComdatIteratorInternal<'data, 'file, R: ReadRef<'data>>
+where
+ 'data: 'file,
+{
+ #[cfg(feature = "coff")]
+ Coff(coff::CoffComdatIterator<'data, 'file, R>),
+ #[cfg(feature = "elf")]
+ Elf32(elf::ElfComdatIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "elf")]
+ Elf64(elf::ElfComdatIterator64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO32(macho::MachOComdatIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO64(macho::MachOComdatIterator64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "pe")]
+ Pe32(pe::PeComdatIterator32<'data, 'file, R>),
+ #[cfg(feature = "pe")]
+ Pe64(pe::PeComdatIterator64<'data, 'file, R>),
+ #[cfg(feature = "wasm")]
+ Wasm(wasm::WasmComdatIterator<'data, 'file, R>),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for ComdatIterator<'data, 'file, R> {
+ type Item = Comdat<'data, 'file, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ next_inner!(self.inner, ComdatIteratorInternal, ComdatInternal)
+ .map(|inner| Comdat { inner })
+ }
+}
+
+/// A COMDAT section group of a `File`.
+pub struct Comdat<'data, 'file, R: ReadRef<'data> = &'data [u8]>
+where
+ 'data: 'file,
+{
+ inner: ComdatInternal<'data, 'file, R>,
+}
+
+enum ComdatInternal<'data, 'file, R: ReadRef<'data>>
+where
+ 'data: 'file,
+{
+ #[cfg(feature = "coff")]
+ Coff(coff::CoffComdat<'data, 'file, R>),
+ #[cfg(feature = "elf")]
+ Elf32(elf::ElfComdat32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "elf")]
+ Elf64(elf::ElfComdat64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO32(macho::MachOComdat32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO64(macho::MachOComdat64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "pe")]
+ Pe32(pe::PeComdat32<'data, 'file, R>),
+ #[cfg(feature = "pe")]
+ Pe64(pe::PeComdat64<'data, 'file, R>),
+ #[cfg(feature = "wasm")]
+ Wasm(wasm::WasmComdat<'data, 'file, R>),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> fmt::Debug for Comdat<'data, 'file, R> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut s = f.debug_struct("Comdat");
+ s.field("symbol", &self.symbol())
+ .field("name", &self.name().unwrap_or("<invalid>"))
+ .field("kind", &self.kind())
+ .finish()
+ }
+}
+
+impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for Comdat<'data, 'file, R> {}
+
+impl<'data, 'file, R: ReadRef<'data>> ObjectComdat<'data> for Comdat<'data, 'file, R> {
+ type SectionIterator = ComdatSectionIterator<'data, 'file, R>;
+
+ fn kind(&self) -> ComdatKind {
+ with_inner!(self.inner, ComdatInternal, |x| x.kind())
+ }
+
+ fn symbol(&self) -> SymbolIndex {
+ with_inner!(self.inner, ComdatInternal, |x| x.symbol())
+ }
+
+ fn name(&self) -> Result<&str> {
+ with_inner!(self.inner, ComdatInternal, |x| x.name())
+ }
+
+ fn sections(&self) -> ComdatSectionIterator<'data, 'file, R> {
+ ComdatSectionIterator {
+ inner: map_inner!(
+ self.inner,
+ ComdatInternal,
+ ComdatSectionIteratorInternal,
+ |x| x.sections()
+ ),
+ }
+ }
+}
+
+/// An iterator over COMDAT section entries.
+#[derive(Debug)]
+pub struct ComdatSectionIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]>
+where
+ 'data: 'file,
+{
+ inner: ComdatSectionIteratorInternal<'data, 'file, R>,
+}
+
+#[derive(Debug)]
+enum ComdatSectionIteratorInternal<'data, 'file, R: ReadRef<'data>>
+where
+ 'data: 'file,
+{
+ #[cfg(feature = "coff")]
+ Coff(coff::CoffComdatSectionIterator<'data, 'file, R>),
+ #[cfg(feature = "elf")]
+ Elf32(elf::ElfComdatSectionIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "elf")]
+ Elf64(elf::ElfComdatSectionIterator64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO32(macho::MachOComdatSectionIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO64(macho::MachOComdatSectionIterator64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "pe")]
+ Pe32(pe::PeComdatSectionIterator32<'data, 'file, R>),
+ #[cfg(feature = "pe")]
+ Pe64(pe::PeComdatSectionIterator64<'data, 'file, R>),
+ #[cfg(feature = "wasm")]
+ Wasm(wasm::WasmComdatSectionIterator<'data, 'file, R>),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for ComdatSectionIterator<'data, 'file, R> {
+ type Item = SectionIndex;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ with_inner_mut!(self.inner, ComdatSectionIteratorInternal, |x| x.next())
+ }
+}
+
+/// A symbol table.
+#[derive(Debug)]
+pub struct SymbolTable<'data, 'file, R = &'data [u8]>
+where
+ 'data: 'file,
+ R: ReadRef<'data>,
+{
+ inner: SymbolTableInternal<'data, 'file, R>,
+}
+
+#[derive(Debug)]
+enum SymbolTableInternal<'data, 'file, R>
+where
+ 'data: 'file,
+ R: ReadRef<'data>,
+{
+ #[cfg(feature = "coff")]
+ Coff((coff::CoffSymbolTable<'data, 'file, R>, PhantomData<R>)),
+ #[cfg(feature = "elf")]
+ Elf32(
+ (
+ elf::ElfSymbolTable32<'data, 'file, Endianness, R>,
+ PhantomData<R>,
+ ),
+ ),
+ #[cfg(feature = "elf")]
+ Elf64(
+ (
+ elf::ElfSymbolTable64<'data, 'file, Endianness, R>,
+ PhantomData<R>,
+ ),
+ ),
+ #[cfg(feature = "macho")]
+ MachO32(
+ (
+ macho::MachOSymbolTable32<'data, 'file, Endianness, R>,
+ PhantomData<()>,
+ ),
+ ),
+ #[cfg(feature = "macho")]
+ MachO64(
+ (
+ macho::MachOSymbolTable64<'data, 'file, Endianness, R>,
+ PhantomData<()>,
+ ),
+ ),
+ #[cfg(feature = "pe")]
+ Pe32((coff::CoffSymbolTable<'data, 'file, R>, PhantomData<R>)),
+ #[cfg(feature = "pe")]
+ Pe64((coff::CoffSymbolTable<'data, 'file, R>, PhantomData<R>)),
+ #[cfg(feature = "wasm")]
+ Wasm((wasm::WasmSymbolTable<'data, 'file>, PhantomData<R>)),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for SymbolTable<'data, 'file, R> {}
+
+impl<'data, 'file, R: ReadRef<'data>> ObjectSymbolTable<'data> for SymbolTable<'data, 'file, R> {
+ type Symbol = Symbol<'data, 'file, R>;
+ type SymbolIterator = SymbolIterator<'data, 'file, R>;
+
+ fn symbols(&self) -> Self::SymbolIterator {
+ SymbolIterator {
+ inner: map_inner!(
+ self.inner,
+ SymbolTableInternal,
+ SymbolIteratorInternal,
+ |x| (x.0.symbols(), PhantomData)
+ ),
+ }
+ }
+
+ fn symbol_by_index(&self, index: SymbolIndex) -> Result<Self::Symbol> {
+ map_inner_option!(self.inner, SymbolTableInternal, SymbolInternal, |x| x
+ .0
+ .symbol_by_index(index)
+ .map(|x| (x, PhantomData)))
+ .map(|inner| Symbol { inner })
+ }
+}
+
+/// An iterator over symbol table entries.
+#[derive(Debug)]
+pub struct SymbolIterator<'data, 'file, R = &'data [u8]>
+where
+ 'data: 'file,
+ R: ReadRef<'data>,
+{
+ inner: SymbolIteratorInternal<'data, 'file, R>,
+}
+
+#[derive(Debug)]
+enum SymbolIteratorInternal<'data, 'file, R>
+where
+ 'data: 'file,
+ R: ReadRef<'data>,
+{
+ #[cfg(feature = "coff")]
+ Coff((coff::CoffSymbolIterator<'data, 'file, R>, PhantomData<R>)),
+ #[cfg(feature = "elf")]
+ Elf32(
+ (
+ elf::ElfSymbolIterator32<'data, 'file, Endianness, R>,
+ PhantomData<R>,
+ ),
+ ),
+ #[cfg(feature = "elf")]
+ Elf64(
+ (
+ elf::ElfSymbolIterator64<'data, 'file, Endianness, R>,
+ PhantomData<R>,
+ ),
+ ),
+ #[cfg(feature = "macho")]
+ MachO32(
+ (
+ macho::MachOSymbolIterator32<'data, 'file, Endianness, R>,
+ PhantomData<()>,
+ ),
+ ),
+ #[cfg(feature = "macho")]
+ MachO64(
+ (
+ macho::MachOSymbolIterator64<'data, 'file, Endianness, R>,
+ PhantomData<()>,
+ ),
+ ),
+ #[cfg(feature = "pe")]
+ Pe32((coff::CoffSymbolIterator<'data, 'file, R>, PhantomData<R>)),
+ #[cfg(feature = "pe")]
+ Pe64((coff::CoffSymbolIterator<'data, 'file, R>, PhantomData<R>)),
+ #[cfg(feature = "wasm")]
+ Wasm((wasm::WasmSymbolIterator<'data, 'file>, PhantomData<R>)),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for SymbolIterator<'data, 'file, R> {
+ type Item = Symbol<'data, 'file, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ map_inner_option_mut!(self.inner, SymbolIteratorInternal, SymbolInternal, |iter| {
+ iter.0.next().map(|x| (x, PhantomData))
+ })
+ .map(|inner| Symbol { inner })
+ }
+}
+
+/// A symbol table entry.
+pub struct Symbol<'data, 'file, R = &'data [u8]>
+where
+ 'data: 'file,
+ R: ReadRef<'data>,
+{
+ inner: SymbolInternal<'data, 'file, R>,
+}
+
+enum SymbolInternal<'data, 'file, R>
+where
+ 'data: 'file,
+ R: ReadRef<'data>,
+{
+ #[cfg(feature = "coff")]
+ Coff((coff::CoffSymbol<'data, 'file, R>, PhantomData<R>)),
+ #[cfg(feature = "elf")]
+ Elf32(
+ (
+ elf::ElfSymbol32<'data, 'file, Endianness, R>,
+ PhantomData<R>,
+ ),
+ ),
+ #[cfg(feature = "elf")]
+ Elf64(
+ (
+ elf::ElfSymbol64<'data, 'file, Endianness, R>,
+ PhantomData<R>,
+ ),
+ ),
+ #[cfg(feature = "macho")]
+ MachO32(
+ (
+ macho::MachOSymbol32<'data, 'file, Endianness, R>,
+ PhantomData<()>,
+ ),
+ ),
+ #[cfg(feature = "macho")]
+ MachO64(
+ (
+ macho::MachOSymbol64<'data, 'file, Endianness, R>,
+ PhantomData<()>,
+ ),
+ ),
+ #[cfg(feature = "pe")]
+ Pe32((coff::CoffSymbol<'data, 'file, R>, PhantomData<R>)),
+ #[cfg(feature = "pe")]
+ Pe64((coff::CoffSymbol<'data, 'file, R>, PhantomData<R>)),
+ #[cfg(feature = "wasm")]
+ Wasm((wasm::WasmSymbol<'data, 'file>, PhantomData<R>)),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> fmt::Debug for Symbol<'data, 'file, R> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("Symbol")
+ .field("name", &self.name().unwrap_or("<invalid>"))
+ .field("address", &self.address())
+ .field("size", &self.size())
+ .field("kind", &self.kind())
+ .field("section", &self.section())
+ .field("scope", &self.scope())
+ .field("weak", &self.is_weak())
+ .field("flags", &self.flags())
+ .finish()
+ }
+}
+
+impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for Symbol<'data, 'file, R> {}
+
+impl<'data, 'file, R: ReadRef<'data>> ObjectSymbol<'data> for Symbol<'data, 'file, R> {
+ fn index(&self) -> SymbolIndex {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.index())
+ }
+
+ fn name(&self) -> Result<&'data str> {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.name())
+ }
+
+ fn address(&self) -> u64 {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.address())
+ }
+
+ fn size(&self) -> u64 {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.size())
+ }
+
+ fn kind(&self) -> SymbolKind {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.kind())
+ }
+
+ fn section(&self) -> SymbolSection {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.section())
+ }
+
+ fn is_undefined(&self) -> bool {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.is_undefined())
+ }
+
+ fn is_definition(&self) -> bool {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.is_definition())
+ }
+
+ fn is_common(&self) -> bool {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.is_common())
+ }
+
+ fn is_weak(&self) -> bool {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.is_weak())
+ }
+
+ fn scope(&self) -> SymbolScope {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.scope())
+ }
+
+ fn is_global(&self) -> bool {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.is_global())
+ }
+
+ fn is_local(&self) -> bool {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.is_local())
+ }
+
+ fn flags(&self) -> SymbolFlags<SectionIndex> {
+ with_inner!(self.inner, SymbolInternal, |x| x.0.flags())
+ }
+}
+
+/// An iterator over dynamic relocation entries.
+#[derive(Debug)]
+pub struct DynamicRelocationIterator<'data, 'file, R = &'data [u8]>
+where
+ 'data: 'file,
+ R: ReadRef<'data>,
+{
+ inner: DynamicRelocationIteratorInternal<'data, 'file, R>,
+}
+
+#[derive(Debug)]
+enum DynamicRelocationIteratorInternal<'data, 'file, R>
+where
+ 'data: 'file,
+ R: ReadRef<'data>,
+{
+ #[cfg(feature = "elf")]
+ Elf32(elf::ElfDynamicRelocationIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "elf")]
+ Elf64(elf::ElfDynamicRelocationIterator64<'data, 'file, Endianness, R>),
+ // We need to always use the lifetime parameters.
+ #[allow(unused)]
+ None(PhantomData<(&'data (), &'file (), R)>),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for DynamicRelocationIterator<'data, 'file, R> {
+ type Item = (u64, Relocation);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ match self.inner {
+ #[cfg(feature = "elf")]
+ DynamicRelocationIteratorInternal::Elf32(ref mut elf) => elf.next(),
+ #[cfg(feature = "elf")]
+ DynamicRelocationIteratorInternal::Elf64(ref mut elf) => elf.next(),
+ DynamicRelocationIteratorInternal::None(_) => None,
+ }
+ }
+}
+
+/// An iterator over section relocation entries.
+#[derive(Debug)]
+pub struct SectionRelocationIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]>
+where
+ 'data: 'file,
+{
+ inner: SectionRelocationIteratorInternal<'data, 'file, R>,
+}
+
+#[derive(Debug)]
+enum SectionRelocationIteratorInternal<'data, 'file, R: ReadRef<'data>>
+where
+ 'data: 'file,
+{
+ #[cfg(feature = "coff")]
+ Coff(coff::CoffRelocationIterator<'data, 'file, R>),
+ #[cfg(feature = "elf")]
+ Elf32(elf::ElfSectionRelocationIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "elf")]
+ Elf64(elf::ElfSectionRelocationIterator64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO32(macho::MachORelocationIterator32<'data, 'file, Endianness, R>),
+ #[cfg(feature = "macho")]
+ MachO64(macho::MachORelocationIterator64<'data, 'file, Endianness, R>),
+ #[cfg(feature = "pe")]
+ Pe32(pe::PeRelocationIterator<'data, 'file, R>),
+ #[cfg(feature = "pe")]
+ Pe64(pe::PeRelocationIterator<'data, 'file, R>),
+ #[cfg(feature = "wasm")]
+ Wasm(wasm::WasmRelocationIterator<'data, 'file, R>),
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for SectionRelocationIterator<'data, 'file, R> {
+ type Item = (u64, Relocation);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ with_inner_mut!(self.inner, SectionRelocationIteratorInternal, |x| x.next())
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/archive.rs b/vendor/object-0.26.2/src/read/archive.rs
new file mode 100644
index 000000000..0208878e4
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/archive.rs
@@ -0,0 +1,502 @@
+//! Support for archive files.
+
+use core::convert::TryInto;
+
+use crate::archive;
+use crate::read::{self, Error, ReadError, ReadRef};
+
+/// The kind of archive format.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum ArchiveKind {
+ /// There are no special files that indicate the archive format.
+ Unknown,
+ /// The GNU (or System V) archive format.
+ Gnu,
+ /// The GNU (or System V) archive format with 64-bit symbol table.
+ Gnu64,
+ /// The BSD archive format.
+ Bsd,
+ /// The BSD archive format with 64-bit symbol table.
+ ///
+ /// This is used for Darwin.
+ Bsd64,
+ /// The Windows COFF archive format.
+ Coff,
+}
+
+/// A partially parsed archive file.
+#[derive(Debug)]
+pub struct ArchiveFile<'data, R: ReadRef<'data> = &'data [u8]> {
+ data: R,
+ len: u64,
+ offset: u64,
+ kind: ArchiveKind,
+ symbols: (u64, u64),
+ names: &'data [u8],
+}
+
+impl<'data, R: ReadRef<'data>> ArchiveFile<'data, R> {
+ /// Parse the archive header and special members.
+ pub fn parse(data: R) -> read::Result<Self> {
+ let len = data.len().read_error("Unknown archive length")?;
+ let mut tail = 0;
+ let magic = data
+ .read_bytes(&mut tail, archive::MAGIC.len() as u64)
+ .read_error("Invalid archive size")?;
+ if magic != &archive::MAGIC[..] {
+ return Err(Error("Unsupported archive identifier"));
+ }
+
+ let mut file = ArchiveFile {
+ data,
+ offset: tail,
+ len,
+ kind: ArchiveKind::Unknown,
+ symbols: (0, 0),
+ names: &[],
+ };
+
+ // The first few members may be special, so parse them.
+ // GNU has:
+ // - "/" or "/SYM64/": symbol table (optional)
+ // - "//": names table (optional)
+ // COFF has:
+ // - "/": first linker member
+ // - "/": second linker member
+ // - "//": names table
+ // BSD has:
+ // - "__.SYMDEF" or "__.SYMDEF SORTED": symbol table (optional)
+ // BSD 64-bit has:
+ // - "__.SYMDEF_64" or "__.SYMDEF_64 SORTED": symbol table (optional)
+ // BSD may use the extended name for the symbol table. This is handled
+ // by `ArchiveMember::parse`.
+ if tail < len {
+ let member = ArchiveMember::parse(data, &mut tail, &[])?;
+ if member.name == b"/" {
+ // GNU symbol table (unless we later determine this is COFF).
+ file.kind = ArchiveKind::Gnu;
+ file.symbols = member.file_range();
+ file.offset = tail;
+
+ if tail < len {
+ let member = ArchiveMember::parse(data, &mut tail, &[])?;
+ if member.name == b"/" {
+ // COFF linker member.
+ file.kind = ArchiveKind::Coff;
+ file.symbols = member.file_range();
+ file.offset = tail;
+
+ if tail < len {
+ let member = ArchiveMember::parse(data, &mut tail, &[])?;
+ if member.name == b"//" {
+ // COFF names table.
+ file.names = member.data(data)?;
+ file.offset = tail;
+ }
+ }
+ } else if member.name == b"//" {
+ // GNU names table.
+ file.names = member.data(data)?;
+ file.offset = tail;
+ }
+ }
+ } else if member.name == b"/SYM64/" {
+ // GNU 64-bit symbol table.
+ file.kind = ArchiveKind::Gnu64;
+ file.symbols = member.file_range();
+ file.offset = tail;
+
+ if tail < len {
+ let member = ArchiveMember::parse(data, &mut tail, &[])?;
+ if member.name == b"//" {
+ // GNU names table.
+ file.names = member.data(data)?;
+ file.offset = tail;
+ }
+ }
+ } else if member.name == b"//" {
+ // GNU names table.
+ file.kind = ArchiveKind::Gnu;
+ file.names = member.data(data)?;
+ file.offset = tail;
+ } else if member.name == b"__.SYMDEF" || member.name == b"__.SYMDEF SORTED" {
+ // BSD symbol table.
+ file.kind = ArchiveKind::Bsd;
+ file.symbols = member.file_range();
+ file.offset = tail;
+ } else if member.name == b"__.SYMDEF_64" || member.name == b"__.SYMDEF_64 SORTED" {
+ // BSD 64-bit symbol table.
+ file.kind = ArchiveKind::Bsd64;
+ file.symbols = member.file_range();
+ file.offset = tail;
+ } else {
+ // TODO: This could still be a BSD file. We leave this as unknown for now.
+ }
+ }
+ Ok(file)
+ }
+
+ /// Return the archive format.
+ #[inline]
+ pub fn kind(&self) -> ArchiveKind {
+ self.kind
+ }
+
+ /// Iterate over the members of the archive.
+ ///
+ /// This does not return special members.
+ #[inline]
+ pub fn members(&self) -> ArchiveMemberIterator<'data, R> {
+ ArchiveMemberIterator {
+ data: self.data,
+ offset: self.offset,
+ len: self.len,
+ names: self.names,
+ }
+ }
+}
+
+/// An iterator over the members of an archive.
+#[derive(Debug)]
+pub struct ArchiveMemberIterator<'data, R: ReadRef<'data> = &'data [u8]> {
+ data: R,
+ offset: u64,
+ len: u64,
+ names: &'data [u8],
+}
+
+impl<'data, R: ReadRef<'data>> Iterator for ArchiveMemberIterator<'data, R> {
+ type Item = read::Result<ArchiveMember<'data>>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ if self.offset >= self.len {
+ return None;
+ }
+ let member = ArchiveMember::parse(self.data, &mut self.offset, self.names);
+ if member.is_err() {
+ self.offset = self.len;
+ }
+ Some(member)
+ }
+}
+
+/// A partially parsed archive member.
+#[derive(Debug)]
+pub struct ArchiveMember<'data> {
+ header: &'data archive::Header,
+ name: &'data [u8],
+ offset: u64,
+ size: u64,
+}
+
+impl<'data> ArchiveMember<'data> {
+ /// Parse the archive member header, name, and file data.
+ ///
+ /// This reads the extended name (if any) and adjusts the file size.
+ fn parse<R: ReadRef<'data>>(
+ data: R,
+ offset: &mut u64,
+ names: &'data [u8],
+ ) -> read::Result<Self> {
+ let header = data
+ .read::<archive::Header>(offset)
+ .read_error("Invalid archive member header")?;
+ if header.terminator != archive::TERMINATOR {
+ return Err(Error("Invalid archive terminator"));
+ }
+
+ let mut file_offset = *offset;
+ let mut file_size =
+ parse_u64_digits(&header.size, 10).read_error("Invalid archive member size")?;
+ *offset = offset
+ .checked_add(file_size)
+ .read_error("Archive member size is too large")?;
+ // Entries are padded to an even number of bytes.
+ if (file_size & 1) != 0 {
+ *offset = offset.saturating_add(1);
+ }
+
+ let name = if header.name[0] == b'/' && (header.name[1] as char).is_digit(10) {
+ // Read file name from the names table.
+ parse_sysv_extended_name(&header.name[1..], names)
+ .read_error("Invalid archive extended name offset")?
+ } else if &header.name[..3] == b"#1/" && (header.name[3] as char).is_digit(10) {
+ // Read file name from the start of the file data.
+ parse_bsd_extended_name(&header.name[3..], data, &mut file_offset, &mut file_size)
+ .read_error("Invalid archive extended name length")?
+ } else if header.name[0] == b'/' {
+ let name_len = memchr::memchr(b' ', &header.name).unwrap_or(header.name.len());
+ &header.name[..name_len]
+ } else {
+ let name_len = memchr::memchr(b'/', &header.name)
+ .or_else(|| memchr::memchr(b' ', &header.name))
+ .unwrap_or(header.name.len());
+ &header.name[..name_len]
+ };
+
+ Ok(ArchiveMember {
+ header,
+ name,
+ offset: file_offset,
+ size: file_size,
+ })
+ }
+
+ /// Return the raw header.
+ #[inline]
+ pub fn header(&self) -> &'data archive::Header {
+ self.header
+ }
+
+ /// Return the parsed file name.
+ ///
+ /// This may be an extended file name.
+ #[inline]
+ pub fn name(&self) -> &'data [u8] {
+ self.name
+ }
+
+ /// Parse the file modification timestamp from the header.
+ #[inline]
+ pub fn date(&self) -> Option<u64> {
+ parse_u64_digits(&self.header.date, 10)
+ }
+
+ /// Parse the user ID from the header.
+ #[inline]
+ pub fn uid(&self) -> Option<u64> {
+ parse_u64_digits(&self.header.uid, 10)
+ }
+
+ /// Parse the group ID from the header.
+ #[inline]
+ pub fn gid(&self) -> Option<u64> {
+ parse_u64_digits(&self.header.gid, 10)
+ }
+
+ /// Parse the file mode from the header.
+ #[inline]
+ pub fn mode(&self) -> Option<u64> {
+ parse_u64_digits(&self.header.mode, 8)
+ }
+
+ /// Return the offset and size of the file data.
+ pub fn file_range(&self) -> (u64, u64) {
+ (self.offset, self.size)
+ }
+
+ /// Return the file data.
+ #[inline]
+ pub fn data<R: ReadRef<'data>>(&self, data: R) -> read::Result<&'data [u8]> {
+ data.read_bytes_at(self.offset, self.size)
+ .read_error("Archive member size is too large")
+ }
+}
+
+// Ignores bytes starting from the first space.
+fn parse_u64_digits(digits: &[u8], radix: u32) -> Option<u64> {
+ if let [b' ', ..] = digits {
+ return None;
+ }
+ let mut result: u64 = 0;
+ for &c in digits {
+ if c == b' ' {
+ return Some(result);
+ } else {
+ let x = (c as char).to_digit(radix)?;
+ result = result
+ .checked_mul(u64::from(radix))?
+ .checked_add(u64::from(x))?;
+ }
+ }
+ Some(result)
+}
+
+fn parse_sysv_extended_name<'data>(digits: &[u8], names: &'data [u8]) -> Result<&'data [u8], ()> {
+ let offset = parse_u64_digits(digits, 10).ok_or(())?;
+ let offset = offset.try_into().map_err(|_| ())?;
+ let name_data = names.get(offset..).ok_or(())?;
+ let name = match memchr::memchr2(b'/', b'\0', name_data) {
+ Some(len) => &name_data[..len],
+ None => name_data,
+ };
+ Ok(name)
+}
+
+/// Modifies `data` to start after the extended name.
+fn parse_bsd_extended_name<'data, R: ReadRef<'data>>(
+ digits: &[u8],
+ data: R,
+ offset: &mut u64,
+ size: &mut u64,
+) -> Result<&'data [u8], ()> {
+ let len = parse_u64_digits(digits, 10).ok_or(())?;
+ *size = size.checked_sub(len).ok_or(())?;
+ let name_data = data.read_bytes(offset, len)?;
+ let name = match memchr::memchr(b'\0', name_data) {
+ Some(len) => &name_data[..len],
+ None => name_data,
+ };
+ Ok(name)
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn kind() {
+ let data = b"!<arch>\n";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Unknown);
+
+ let data = b"\
+ !<arch>\n\
+ / 4 `\n\
+ 0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Gnu);
+
+ let data = b"\
+ !<arch>\n\
+ // 4 `\n\
+ 0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Gnu);
+
+ let data = b"\
+ !<arch>\n\
+ / 4 `\n\
+ 0000\
+ // 4 `\n\
+ 0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Gnu);
+
+ let data = b"\
+ !<arch>\n\
+ /SYM64/ 4 `\n\
+ 0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Gnu64);
+
+ let data = b"\
+ !<arch>\n\
+ /SYM64/ 4 `\n\
+ 0000\
+ // 4 `\n\
+ 0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Gnu64);
+
+ let data = b"\
+ !<arch>\n\
+ __.SYMDEF 4 `\n\
+ 0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Bsd);
+
+ let data = b"\
+ !<arch>\n\
+ #1/9 13 `\n\
+ __.SYMDEF0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Bsd);
+
+ let data = b"\
+ !<arch>\n\
+ #1/16 20 `\n\
+ __.SYMDEF SORTED0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Bsd);
+
+ let data = b"\
+ !<arch>\n\
+ __.SYMDEF_64 4 `\n\
+ 0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Bsd64);
+
+ let data = b"\
+ !<arch>\n\
+ #1/12 16 `\n\
+ __.SYMDEF_640000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Bsd64);
+
+ let data = b"\
+ !<arch>\n\
+ #1/19 23 `\n\
+ __.SYMDEF_64 SORTED0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Bsd64);
+
+ let data = b"\
+ !<arch>\n\
+ / 4 `\n\
+ 0000\
+ / 4 `\n\
+ 0000\
+ // 4 `\n\
+ 0000";
+ let archive = ArchiveFile::parse(&data[..]).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Coff);
+ }
+
+ #[test]
+ fn gnu_names() {
+ let data = b"\
+ !<arch>\n\
+ // 18 `\n\
+ 0123456789abcdef/\n\
+ s p a c e/ 0 0 0 644 4 `\n\
+ 0000\
+ 0123456789abcde/0 0 0 644 3 `\n\
+ odd\n\
+ /0 0 0 0 644 4 `\n\
+ even";
+ let data = &data[..];
+ let archive = ArchiveFile::parse(data).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Gnu);
+ let mut members = archive.members();
+
+ let member = members.next().unwrap().unwrap();
+ assert_eq!(member.name(), b"s p a c e");
+ assert_eq!(member.data(data).unwrap(), &b"0000"[..]);
+
+ let member = members.next().unwrap().unwrap();
+ assert_eq!(member.name(), b"0123456789abcde");
+ assert_eq!(member.data(data).unwrap(), &b"odd"[..]);
+
+ let member = members.next().unwrap().unwrap();
+ assert_eq!(member.name(), b"0123456789abcdef");
+ assert_eq!(member.data(data).unwrap(), &b"even"[..]);
+
+ assert!(members.next().is_none());
+ }
+
+ #[test]
+ fn bsd_names() {
+ let data = b"\
+ !<arch>\n\
+ 0123456789abcde 0 0 0 644 3 `\n\
+ odd\n\
+ #1/16 0 0 0 644 20 `\n\
+ 0123456789abcdefeven";
+ let data = &data[..];
+ let archive = ArchiveFile::parse(data).unwrap();
+ assert_eq!(archive.kind(), ArchiveKind::Unknown);
+ let mut members = archive.members();
+
+ let member = members.next().unwrap().unwrap();
+ assert_eq!(member.name(), b"0123456789abcde");
+ assert_eq!(member.data(data).unwrap(), &b"odd"[..]);
+
+ let member = members.next().unwrap().unwrap();
+ assert_eq!(member.name(), b"0123456789abcdef");
+ assert_eq!(member.data(data).unwrap(), &b"even"[..]);
+
+ assert!(members.next().is_none());
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/coff/comdat.rs b/vendor/object-0.26.2/src/read/coff/comdat.rs
new file mode 100644
index 000000000..2d87a6d99
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/coff/comdat.rs
@@ -0,0 +1,162 @@
+use core::str;
+
+use crate::endian::LittleEndian as LE;
+use crate::pe;
+use crate::read::{
+ self, ComdatKind, ObjectComdat, ReadError, ReadRef, Result, SectionIndex, SymbolIndex,
+};
+
+use super::CoffFile;
+
+/// An iterator over the COMDAT section groups of a `CoffFile`.
+#[derive(Debug)]
+pub struct CoffComdatIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
+ pub(super) file: &'file CoffFile<'data, R>,
+ pub(super) index: usize,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for CoffComdatIterator<'data, 'file, R> {
+ type Item = CoffComdat<'data, 'file, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ loop {
+ let index = self.index;
+ let symbol = self.file.common.symbols.symbol(index).ok()?;
+ self.index += 1 + symbol.number_of_aux_symbols as usize;
+ if let Some(comdat) = CoffComdat::parse(self.file, symbol, index) {
+ return Some(comdat);
+ }
+ }
+ }
+}
+
+/// A COMDAT section group of a `CoffFile`.
+#[derive(Debug)]
+pub struct CoffComdat<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
+ file: &'file CoffFile<'data, R>,
+ symbol_index: SymbolIndex,
+ symbol: &'data pe::ImageSymbol,
+ selection: u8,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> CoffComdat<'data, 'file, R> {
+ fn parse(
+ file: &'file CoffFile<'data, R>,
+ section_symbol: &'data pe::ImageSymbol,
+ index: usize,
+ ) -> Option<CoffComdat<'data, 'file, R>> {
+ // Must be a section symbol.
+ if !section_symbol.has_aux_section() {
+ return None;
+ }
+
+ // Auxiliary record must have a non-associative selection.
+ let aux = file.common.symbols.aux_section(index).ok()?;
+ let selection = aux.selection;
+ if selection == 0 || selection == pe::IMAGE_COMDAT_SELECT_ASSOCIATIVE {
+ return None;
+ }
+
+ // Find the COMDAT symbol.
+ let mut symbol_index = index;
+ let mut symbol = section_symbol;
+ let section_number = section_symbol.section_number.get(LE);
+ loop {
+ symbol_index += 1 + symbol.number_of_aux_symbols as usize;
+ symbol = file.common.symbols.symbol(symbol_index).ok()?;
+ if section_number == symbol.section_number.get(LE) {
+ break;
+ }
+ }
+
+ Some(CoffComdat {
+ file,
+ symbol_index: SymbolIndex(symbol_index),
+ symbol,
+ selection,
+ })
+ }
+}
+
+impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for CoffComdat<'data, 'file, R> {}
+
+impl<'data, 'file, R: ReadRef<'data>> ObjectComdat<'data> for CoffComdat<'data, 'file, R> {
+ type SectionIterator = CoffComdatSectionIterator<'data, 'file, R>;
+
+ #[inline]
+ fn kind(&self) -> ComdatKind {
+ match self.selection {
+ pe::IMAGE_COMDAT_SELECT_NODUPLICATES => ComdatKind::NoDuplicates,
+ pe::IMAGE_COMDAT_SELECT_ANY => ComdatKind::Any,
+ pe::IMAGE_COMDAT_SELECT_SAME_SIZE => ComdatKind::SameSize,
+ pe::IMAGE_COMDAT_SELECT_EXACT_MATCH => ComdatKind::ExactMatch,
+ pe::IMAGE_COMDAT_SELECT_LARGEST => ComdatKind::Largest,
+ pe::IMAGE_COMDAT_SELECT_NEWEST => ComdatKind::Newest,
+ _ => ComdatKind::Unknown,
+ }
+ }
+
+ #[inline]
+ fn symbol(&self) -> SymbolIndex {
+ self.symbol_index
+ }
+
+ #[inline]
+ fn name(&self) -> Result<&str> {
+ // Find the name of first symbol referring to the section.
+ let name = self.symbol.name(self.file.common.symbols.strings())?;
+ str::from_utf8(name)
+ .ok()
+ .read_error("Non UTF-8 COFF COMDAT name")
+ }
+
+ #[inline]
+ fn sections(&self) -> Self::SectionIterator {
+ CoffComdatSectionIterator {
+ file: self.file,
+ section_number: self.symbol.section_number.get(LE),
+ index: 0,
+ }
+ }
+}
+
+/// An iterator over the sections in a COMDAT section group of a `CoffFile`.
+#[derive(Debug)]
+pub struct CoffComdatSectionIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
+ file: &'file CoffFile<'data, R>,
+ section_number: u16,
+ index: usize,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for CoffComdatSectionIterator<'data, 'file, R> {
+ type Item = SectionIndex;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ // Find associated COMDAT symbols.
+ // TODO: it seems gcc doesn't use associated symbols for this
+ loop {
+ let index = self.index;
+ let symbol = self.file.common.symbols.symbol(index).ok()?;
+ self.index += 1 + symbol.number_of_aux_symbols as usize;
+
+ // Must be a section symbol.
+ if !symbol.has_aux_section() {
+ continue;
+ }
+
+ let section_number = symbol.section_number.get(LE);
+
+ let aux = self.file.common.symbols.aux_section(index).ok()?;
+ if aux.selection == pe::IMAGE_COMDAT_SELECT_ASSOCIATIVE {
+ // TODO: use high_number for bigobj
+ if aux.number.get(LE) == self.section_number {
+ return Some(SectionIndex(section_number as usize));
+ }
+ } else if aux.selection != 0 {
+ if section_number == self.section_number {
+ return Some(SectionIndex(section_number as usize));
+ }
+ }
+ }
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/coff/file.rs b/vendor/object-0.26.2/src/read/coff/file.rs
new file mode 100644
index 000000000..fad2efd9a
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/coff/file.rs
@@ -0,0 +1,241 @@
+use alloc::vec::Vec;
+use core::str;
+
+use crate::read::{
+ self, Architecture, Export, FileFlags, Import, NoDynamicRelocationIterator, Object,
+ ObjectSection, ReadError, ReadRef, Result, SectionIndex, SymbolIndex,
+};
+use crate::{pe, LittleEndian as LE};
+
+use super::{
+ CoffComdat, CoffComdatIterator, CoffSection, CoffSectionIterator, CoffSegment,
+ CoffSegmentIterator, CoffSymbol, CoffSymbolIterator, CoffSymbolTable, SectionTable,
+ SymbolTable,
+};
+
+/// The common parts of `PeFile` and `CoffFile`.
+#[derive(Debug)]
+pub(crate) struct CoffCommon<'data, R: ReadRef<'data>> {
+ pub(crate) sections: SectionTable<'data>,
+ // TODO: ImageSymbolExBytes
+ pub(crate) symbols: SymbolTable<'data, R>,
+ pub(crate) image_base: u64,
+}
+
+/// A COFF object file.
+#[derive(Debug)]
+pub struct CoffFile<'data, R: ReadRef<'data> = &'data [u8]> {
+ pub(super) header: &'data pe::ImageFileHeader,
+ pub(super) common: CoffCommon<'data, R>,
+ pub(super) data: R,
+}
+
+impl<'data, R: ReadRef<'data>> CoffFile<'data, R> {
+ /// Parse the raw COFF file data.
+ pub fn parse(data: R) -> Result<Self> {
+ let mut offset = 0;
+ let header = pe::ImageFileHeader::parse(data, &mut offset)?;
+ let sections = header.sections(data, offset)?;
+ let symbols = header.symbols(data)?;
+
+ Ok(CoffFile {
+ header,
+ common: CoffCommon {
+ sections,
+ symbols,
+ image_base: 0,
+ },
+ data,
+ })
+ }
+}
+
+impl<'data, R: ReadRef<'data>> read::private::Sealed for CoffFile<'data, R> {}
+
+impl<'data, 'file, R> Object<'data, 'file> for CoffFile<'data, R>
+where
+ 'data: 'file,
+ R: 'file + ReadRef<'data>,
+{
+ type Segment = CoffSegment<'data, 'file, R>;
+ type SegmentIterator = CoffSegmentIterator<'data, 'file, R>;
+ type Section = CoffSection<'data, 'file, R>;
+ type SectionIterator = CoffSectionIterator<'data, 'file, R>;
+ type Comdat = CoffComdat<'data, 'file, R>;
+ type ComdatIterator = CoffComdatIterator<'data, 'file, R>;
+ type Symbol = CoffSymbol<'data, 'file, R>;
+ type SymbolIterator = CoffSymbolIterator<'data, 'file, R>;
+ type SymbolTable = CoffSymbolTable<'data, 'file, R>;
+ type DynamicRelocationIterator = NoDynamicRelocationIterator;
+
+ fn architecture(&self) -> Architecture {
+ match self.header.machine.get(LE) {
+ pe::IMAGE_FILE_MACHINE_ARMNT => Architecture::Arm,
+ pe::IMAGE_FILE_MACHINE_ARM64 => Architecture::Aarch64,
+ pe::IMAGE_FILE_MACHINE_I386 => Architecture::I386,
+ pe::IMAGE_FILE_MACHINE_AMD64 => Architecture::X86_64,
+ _ => Architecture::Unknown,
+ }
+ }
+
+ #[inline]
+ fn is_little_endian(&self) -> bool {
+ true
+ }
+
+ #[inline]
+ fn is_64(&self) -> bool {
+ // Windows COFF is always 32-bit, even for 64-bit architectures. This could be confusing.
+ false
+ }
+
+ fn segments(&'file self) -> CoffSegmentIterator<'data, 'file, R> {
+ CoffSegmentIterator {
+ file: self,
+ iter: self.common.sections.iter(),
+ }
+ }
+
+ fn section_by_name(&'file self, section_name: &str) -> Option<CoffSection<'data, 'file, R>> {
+ self.sections()
+ .find(|section| section.name() == Ok(section_name))
+ }
+
+ fn section_by_index(&'file self, index: SectionIndex) -> Result<CoffSection<'data, 'file, R>> {
+ let section = self.common.sections.section(index.0)?;
+ Ok(CoffSection {
+ file: self,
+ index,
+ section,
+ })
+ }
+
+ fn sections(&'file self) -> CoffSectionIterator<'data, 'file, R> {
+ CoffSectionIterator {
+ file: self,
+ iter: self.common.sections.iter().enumerate(),
+ }
+ }
+
+ fn comdats(&'file self) -> CoffComdatIterator<'data, 'file, R> {
+ CoffComdatIterator {
+ file: self,
+ index: 0,
+ }
+ }
+
+ fn symbol_by_index(&'file self, index: SymbolIndex) -> Result<CoffSymbol<'data, 'file, R>> {
+ let symbol = self.common.symbols.symbol(index.0)?;
+ Ok(CoffSymbol {
+ file: &self.common,
+ index,
+ symbol,
+ })
+ }
+
+ fn symbols(&'file self) -> CoffSymbolIterator<'data, 'file, R> {
+ CoffSymbolIterator {
+ file: &self.common,
+ index: 0,
+ }
+ }
+
+ #[inline]
+ fn symbol_table(&'file self) -> Option<CoffSymbolTable<'data, 'file, R>> {
+ Some(CoffSymbolTable { file: &self.common })
+ }
+
+ fn dynamic_symbols(&'file self) -> CoffSymbolIterator<'data, 'file, R> {
+ CoffSymbolIterator {
+ file: &self.common,
+ // Hack: don't return any.
+ index: self.common.symbols.len(),
+ }
+ }
+
+ #[inline]
+ fn dynamic_symbol_table(&'file self) -> Option<CoffSymbolTable<'data, 'file, R>> {
+ None
+ }
+
+ #[inline]
+ fn dynamic_relocations(&'file self) -> Option<NoDynamicRelocationIterator> {
+ None
+ }
+
+ #[inline]
+ fn imports(&self) -> Result<Vec<Import<'data>>> {
+ // TODO: this could return undefined symbols, but not needed yet.
+ Ok(Vec::new())
+ }
+
+ #[inline]
+ fn exports(&self) -> Result<Vec<Export<'data>>> {
+ // TODO: this could return global symbols, but not needed yet.
+ Ok(Vec::new())
+ }
+
+ fn has_debug_symbols(&self) -> bool {
+ self.section_by_name(".debug_info").is_some()
+ }
+
+ fn relative_address_base(&self) -> u64 {
+ 0
+ }
+
+ #[inline]
+ fn entry(&self) -> u64 {
+ 0
+ }
+
+ fn flags(&self) -> FileFlags {
+ FileFlags::Coff {
+ characteristics: self.header.characteristics.get(LE),
+ }
+ }
+}
+
+impl pe::ImageFileHeader {
+ /// Read the file header.
+ ///
+ /// `data` must be the entire file data.
+ /// `offset` must be the file header offset. It is updated to point after the optional header,
+ /// which is where the section headers are located.
+ pub fn parse<'data, R: ReadRef<'data>>(data: R, offset: &mut u64) -> read::Result<&'data Self> {
+ let header = data
+ .read::<pe::ImageFileHeader>(offset)
+ .read_error("Invalid COFF file header size or alignment")?;
+
+ // Skip over the optional header.
+ *offset = offset
+ .checked_add(header.size_of_optional_header.get(LE).into())
+ .read_error("Invalid COFF optional header size")?;
+
+ // TODO: maybe validate that the machine is known?
+ Ok(header)
+ }
+
+ /// Read the section table.
+ ///
+ /// `data` must be the entire file data.
+ /// `offset` must be after the optional file header.
+ #[inline]
+ pub fn sections<'data, R: ReadRef<'data>>(
+ &self,
+ data: R,
+ offset: u64,
+ ) -> read::Result<SectionTable<'data>> {
+ SectionTable::parse(self, data, offset)
+ }
+
+ /// Read the symbol table and string table.
+ ///
+ /// `data` must be the entire file data.
+ #[inline]
+ pub fn symbols<'data, R: ReadRef<'data>>(
+ &self,
+ data: R,
+ ) -> read::Result<SymbolTable<'data, R>> {
+ SymbolTable::parse(self, data)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/coff/mod.rs b/vendor/object-0.26.2/src/read/coff/mod.rs
new file mode 100644
index 000000000..d5b3caf32
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/coff/mod.rs
@@ -0,0 +1,18 @@
+//! Support for reading Windows COFF files.
+//!
+//! Provides `CoffFile` and related types which implement the `Object` trait.
+
+mod file;
+pub use file::*;
+
+mod section;
+pub use section::*;
+
+mod symbol;
+pub use symbol::*;
+
+mod relocation;
+pub use relocation::*;
+
+mod comdat;
+pub use comdat::*;
diff --git a/vendor/object-0.26.2/src/read/coff/relocation.rs b/vendor/object-0.26.2/src/read/coff/relocation.rs
new file mode 100644
index 000000000..e921ed580
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/coff/relocation.rs
@@ -0,0 +1,85 @@
+use alloc::fmt;
+use core::slice;
+
+use crate::endian::LittleEndian as LE;
+use crate::pe;
+use crate::read::{
+ ReadRef, Relocation, RelocationEncoding, RelocationKind, RelocationTarget, SymbolIndex,
+};
+
+use super::CoffFile;
+
+/// An iterator over the relocations in a `CoffSection`.
+pub struct CoffRelocationIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
+ pub(super) file: &'file CoffFile<'data, R>,
+ pub(super) iter: slice::Iter<'data, pe::ImageRelocation>,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for CoffRelocationIterator<'data, 'file, R> {
+ type Item = (u64, Relocation);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.iter.next().map(|relocation| {
+ let (kind, size, addend) = match self.file.header.machine.get(LE) {
+ pe::IMAGE_FILE_MACHINE_ARMNT => match relocation.typ.get(LE) {
+ pe::IMAGE_REL_ARM_ADDR32 => (RelocationKind::Absolute, 32, 0),
+ pe::IMAGE_REL_ARM_SECREL => (RelocationKind::SectionOffset, 32, 0),
+ typ => (RelocationKind::Coff(typ), 0, 0),
+ },
+ pe::IMAGE_FILE_MACHINE_ARM64 => match relocation.typ.get(LE) {
+ pe::IMAGE_REL_ARM64_ADDR32 => (RelocationKind::Absolute, 32, 0),
+ pe::IMAGE_REL_ARM64_SECREL => (RelocationKind::SectionOffset, 32, 0),
+ pe::IMAGE_REL_ARM64_ADDR64 => (RelocationKind::Absolute, 64, 0),
+ typ => (RelocationKind::Coff(typ), 0, 0),
+ },
+ pe::IMAGE_FILE_MACHINE_I386 => match relocation.typ.get(LE) {
+ pe::IMAGE_REL_I386_DIR16 => (RelocationKind::Absolute, 16, 0),
+ pe::IMAGE_REL_I386_REL16 => (RelocationKind::Relative, 16, 0),
+ pe::IMAGE_REL_I386_DIR32 => (RelocationKind::Absolute, 32, 0),
+ pe::IMAGE_REL_I386_DIR32NB => (RelocationKind::ImageOffset, 32, 0),
+ pe::IMAGE_REL_I386_SECTION => (RelocationKind::SectionIndex, 16, 0),
+ pe::IMAGE_REL_I386_SECREL => (RelocationKind::SectionOffset, 32, 0),
+ pe::IMAGE_REL_I386_SECREL7 => (RelocationKind::SectionOffset, 7, 0),
+ pe::IMAGE_REL_I386_REL32 => (RelocationKind::Relative, 32, -4),
+ typ => (RelocationKind::Coff(typ), 0, 0),
+ },
+ pe::IMAGE_FILE_MACHINE_AMD64 => match relocation.typ.get(LE) {
+ pe::IMAGE_REL_AMD64_ADDR64 => (RelocationKind::Absolute, 64, 0),
+ pe::IMAGE_REL_AMD64_ADDR32 => (RelocationKind::Absolute, 32, 0),
+ pe::IMAGE_REL_AMD64_ADDR32NB => (RelocationKind::ImageOffset, 32, 0),
+ pe::IMAGE_REL_AMD64_REL32 => (RelocationKind::Relative, 32, -4),
+ pe::IMAGE_REL_AMD64_REL32_1 => (RelocationKind::Relative, 32, -5),
+ pe::IMAGE_REL_AMD64_REL32_2 => (RelocationKind::Relative, 32, -6),
+ pe::IMAGE_REL_AMD64_REL32_3 => (RelocationKind::Relative, 32, -7),
+ pe::IMAGE_REL_AMD64_REL32_4 => (RelocationKind::Relative, 32, -8),
+ pe::IMAGE_REL_AMD64_REL32_5 => (RelocationKind::Relative, 32, -9),
+ pe::IMAGE_REL_AMD64_SECTION => (RelocationKind::SectionIndex, 16, 0),
+ pe::IMAGE_REL_AMD64_SECREL => (RelocationKind::SectionOffset, 32, 0),
+ pe::IMAGE_REL_AMD64_SECREL7 => (RelocationKind::SectionOffset, 7, 0),
+ typ => (RelocationKind::Coff(typ), 0, 0),
+ },
+ _ => (RelocationKind::Coff(relocation.typ.get(LE)), 0, 0),
+ };
+ let target = RelocationTarget::Symbol(SymbolIndex(
+ relocation.symbol_table_index.get(LE) as usize,
+ ));
+ (
+ u64::from(relocation.virtual_address.get(LE)),
+ Relocation {
+ kind,
+ encoding: RelocationEncoding::Generic,
+ size,
+ target,
+ addend,
+ implicit_addend: true,
+ },
+ )
+ })
+ }
+}
+
+impl<'data, 'file, R: ReadRef<'data>> fmt::Debug for CoffRelocationIterator<'data, 'file, R> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("CoffRelocationIterator").finish()
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/coff/section.rs b/vendor/object-0.26.2/src/read/coff/section.rs
new file mode 100644
index 000000000..8762e2490
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/coff/section.rs
@@ -0,0 +1,420 @@
+use core::{iter, result, slice, str};
+
+use crate::endian::LittleEndian as LE;
+use crate::pe;
+use crate::read::util::StringTable;
+use crate::read::{
+ self, CompressedData, CompressedFileRange, Error, ObjectSection, ObjectSegment, ReadError,
+ ReadRef, Result, SectionFlags, SectionIndex, SectionKind,
+};
+
+use super::{CoffFile, CoffRelocationIterator};
+
+/// The table of section headers in a COFF or PE file.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct SectionTable<'data> {
+ sections: &'data [pe::ImageSectionHeader],
+}
+
+impl<'data> SectionTable<'data> {
+ /// Parse the section table.
+ ///
+ /// `data` must be the entire file data.
+ /// `offset` must be after the optional file header.
+ pub fn parse<R: ReadRef<'data>>(
+ header: &pe::ImageFileHeader,
+ data: R,
+ offset: u64,
+ ) -> Result<Self> {
+ let sections = data
+ .read_slice_at(offset, header.number_of_sections.get(LE).into())
+ .read_error("Invalid COFF/PE section headers")?;
+ Ok(SectionTable { sections })
+ }
+
+ /// Iterate over the section headers.
+ ///
+ /// Warning: sections indices start at 1.
+ #[inline]
+ pub fn iter(&self) -> slice::Iter<'data, pe::ImageSectionHeader> {
+ self.sections.iter()
+ }
+
+ /// Return true if the section table is empty.
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.sections.is_empty()
+ }
+
+ /// The number of section headers.
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.sections.len()
+ }
+
+ /// Return the section header at the given index.
+ ///
+ /// The index is 1-based.
+ pub fn section(&self, index: usize) -> read::Result<&'data pe::ImageSectionHeader> {
+ self.sections
+ .get(index.wrapping_sub(1))
+ .read_error("Invalid COFF/PE section index")
+ }
+
+ /// Return the section header with the given name.
+ ///
+ /// The returned index is 1-based.
+ ///
+ /// Ignores sections with invalid names.
+ pub fn section_by_name<R: ReadRef<'data>>(
+ &self,
+ strings: StringTable<'data, R>,
+ name: &[u8],
+ ) -> Option<(usize, &'data pe::ImageSectionHeader)> {
+ self.sections
+ .iter()
+ .enumerate()
+ .find(|(_, section)| section.name(strings) == Ok(name))
+ .map(|(index, section)| (index + 1, section))
+ }
+}
+
+/// An iterator over the loadable sections of a `CoffFile`.
+#[derive(Debug)]
+pub struct CoffSegmentIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
+ pub(super) file: &'file CoffFile<'data, R>,
+ pub(super) iter: slice::Iter<'data, pe::ImageSectionHeader>,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for CoffSegmentIterator<'data, 'file, R> {
+ type Item = CoffSegment<'data, 'file, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.iter.next().map(|section| CoffSegment {
+ file: self.file,
+ section,
+ })
+ }
+}
+
+/// A loadable section of a `CoffFile`.
+#[derive(Debug)]
+pub struct CoffSegment<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
+ pub(super) file: &'file CoffFile<'data, R>,
+ pub(super) section: &'data pe::ImageSectionHeader,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> CoffSegment<'data, 'file, R> {
+ fn bytes(&self) -> Result<&'data [u8]> {
+ self.section
+ .coff_data(self.file.data)
+ .read_error("Invalid COFF section offset or size")
+ }
+}
+
+impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for CoffSegment<'data, 'file, R> {}
+
+impl<'data, 'file, R: ReadRef<'data>> ObjectSegment<'data> for CoffSegment<'data, 'file, R> {
+ #[inline]
+ fn address(&self) -> u64 {
+ u64::from(self.section.virtual_address.get(LE))
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ u64::from(self.section.virtual_size.get(LE))
+ }
+
+ #[inline]
+ fn align(&self) -> u64 {
+ self.section.coff_alignment()
+ }
+
+ #[inline]
+ fn file_range(&self) -> (u64, u64) {
+ let (offset, size) = self.section.coff_file_range().unwrap_or((0, 0));
+ (u64::from(offset), u64::from(size))
+ }
+
+ fn data(&self) -> Result<&'data [u8]> {
+ self.bytes()
+ }
+
+ fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
+ Ok(read::util::data_range(
+ self.bytes()?,
+ self.address(),
+ address,
+ size,
+ ))
+ }
+
+ #[inline]
+ fn name(&self) -> Result<Option<&str>> {
+ let name = self.section.name(self.file.common.symbols.strings())?;
+ Ok(Some(
+ str::from_utf8(name)
+ .ok()
+ .read_error("Non UTF-8 COFF section name")?,
+ ))
+ }
+}
+
+/// An iterator over the sections of a `CoffFile`.
+#[derive(Debug)]
+pub struct CoffSectionIterator<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
+ pub(super) file: &'file CoffFile<'data, R>,
+ pub(super) iter: iter::Enumerate<slice::Iter<'data, pe::ImageSectionHeader>>,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for CoffSectionIterator<'data, 'file, R> {
+ type Item = CoffSection<'data, 'file, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.iter.next().map(|(index, section)| CoffSection {
+ file: self.file,
+ index: SectionIndex(index + 1),
+ section,
+ })
+ }
+}
+
+/// A section of a `CoffFile`.
+#[derive(Debug)]
+pub struct CoffSection<'data, 'file, R: ReadRef<'data> = &'data [u8]> {
+ pub(super) file: &'file CoffFile<'data, R>,
+ pub(super) index: SectionIndex,
+ pub(super) section: &'data pe::ImageSectionHeader,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> CoffSection<'data, 'file, R> {
+ fn bytes(&self) -> Result<&'data [u8]> {
+ self.section
+ .coff_data(self.file.data)
+ .read_error("Invalid COFF section offset or size")
+ }
+}
+
+impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for CoffSection<'data, 'file, R> {}
+
+impl<'data, 'file, R: ReadRef<'data>> ObjectSection<'data> for CoffSection<'data, 'file, R> {
+ type RelocationIterator = CoffRelocationIterator<'data, 'file, R>;
+
+ #[inline]
+ fn index(&self) -> SectionIndex {
+ self.index
+ }
+
+ #[inline]
+ fn address(&self) -> u64 {
+ u64::from(self.section.virtual_address.get(LE))
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ // TODO: This may need to be the length from the auxiliary symbol for this section.
+ u64::from(self.section.size_of_raw_data.get(LE))
+ }
+
+ #[inline]
+ fn align(&self) -> u64 {
+ self.section.coff_alignment()
+ }
+
+ #[inline]
+ fn file_range(&self) -> Option<(u64, u64)> {
+ let (offset, size) = self.section.coff_file_range()?;
+ Some((u64::from(offset), u64::from(size)))
+ }
+
+ fn data(&self) -> Result<&'data [u8]> {
+ self.bytes()
+ }
+
+ fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
+ Ok(read::util::data_range(
+ self.bytes()?,
+ self.address(),
+ address,
+ size,
+ ))
+ }
+
+ #[inline]
+ fn compressed_file_range(&self) -> Result<CompressedFileRange> {
+ Ok(CompressedFileRange::none(self.file_range()))
+ }
+
+ #[inline]
+ fn compressed_data(&self) -> Result<CompressedData<'data>> {
+ self.data().map(CompressedData::none)
+ }
+
+ #[inline]
+ fn name(&self) -> Result<&str> {
+ let name = self.section.name(self.file.common.symbols.strings())?;
+ str::from_utf8(name)
+ .ok()
+ .read_error("Non UTF-8 COFF section name")
+ }
+
+ #[inline]
+ fn segment_name(&self) -> Result<Option<&str>> {
+ Ok(None)
+ }
+
+ #[inline]
+ fn kind(&self) -> SectionKind {
+ self.section.kind()
+ }
+
+ fn relocations(&self) -> CoffRelocationIterator<'data, 'file, R> {
+ let relocations = self.section.coff_relocations(self.file.data).unwrap_or(&[]);
+ CoffRelocationIterator {
+ file: self.file,
+ iter: relocations.iter(),
+ }
+ }
+
+ fn flags(&self) -> SectionFlags {
+ SectionFlags::Coff {
+ characteristics: self.section.characteristics.get(LE),
+ }
+ }
+}
+
+impl pe::ImageSectionHeader {
+ pub(crate) fn kind(&self) -> SectionKind {
+ let characteristics = self.characteristics.get(LE);
+ if characteristics & (pe::IMAGE_SCN_CNT_CODE | pe::IMAGE_SCN_MEM_EXECUTE) != 0 {
+ SectionKind::Text
+ } else if characteristics & pe::IMAGE_SCN_CNT_INITIALIZED_DATA != 0 {
+ if characteristics & pe::IMAGE_SCN_MEM_DISCARDABLE != 0 {
+ SectionKind::Other
+ } else if characteristics & pe::IMAGE_SCN_MEM_WRITE != 0 {
+ SectionKind::Data
+ } else {
+ SectionKind::ReadOnlyData
+ }
+ } else if characteristics & pe::IMAGE_SCN_CNT_UNINITIALIZED_DATA != 0 {
+ SectionKind::UninitializedData
+ } else if characteristics & pe::IMAGE_SCN_LNK_INFO != 0 {
+ SectionKind::Linker
+ } else {
+ SectionKind::Unknown
+ }
+ }
+}
+
+impl pe::ImageSectionHeader {
+ /// Return the section name.
+ ///
+ /// This handles decoding names that are offsets into the symbol string table.
+ pub fn name<'data, R: ReadRef<'data>>(
+ &'data self,
+ strings: StringTable<'data, R>,
+ ) -> Result<&'data [u8]> {
+ let bytes = &self.name;
+ Ok(if bytes[0] == b'/' {
+ let mut offset = 0;
+ if bytes[1] == b'/' {
+ for byte in bytes[2..].iter() {
+ let digit = match byte {
+ b'A'..=b'Z' => byte - b'A',
+ b'a'..=b'z' => byte - b'a' + 26,
+ b'0'..=b'9' => byte - b'0' + 52,
+ b'+' => 62,
+ b'/' => 63,
+ _ => return Err(Error("Invalid COFF section name base-64 offset")),
+ };
+ offset = offset * 64 + digit as u32;
+ }
+ } else {
+ for byte in bytes[1..].iter() {
+ let digit = match byte {
+ b'0'..=b'9' => byte - b'0',
+ 0 => break,
+ _ => return Err(Error("Invalid COFF section name base-10 offset")),
+ };
+ offset = offset * 10 + digit as u32;
+ }
+ };
+ strings
+ .get(offset)
+ .read_error("Invalid COFF section name offset")?
+ } else {
+ self.raw_name()
+ })
+ }
+
+ /// Return the raw section name.
+ pub fn raw_name(&self) -> &[u8] {
+ let bytes = &self.name;
+ match memchr::memchr(b'\0', bytes) {
+ Some(end) => &bytes[..end],
+ None => &bytes[..],
+ }
+ }
+
+ /// Return the offset and size of the section in a COFF file.
+ ///
+ /// Returns `None` for sections that have no data in the file.
+ pub fn coff_file_range(&self) -> Option<(u32, u32)> {
+ if self.characteristics.get(LE) & pe::IMAGE_SCN_CNT_UNINITIALIZED_DATA != 0 {
+ None
+ } else {
+ let offset = self.pointer_to_raw_data.get(LE);
+ // Note: virtual size is not used for COFF.
+ let size = self.size_of_raw_data.get(LE);
+ Some((offset, size))
+ }
+ }
+
+ /// Return the section data in a COFF file.
+ ///
+ /// Returns `Ok(&[])` if the section has no data.
+ /// Returns `Err` for invalid values.
+ pub fn coff_data<'data, R: ReadRef<'data>>(&self, data: R) -> result::Result<&'data [u8], ()> {
+ if let Some((offset, size)) = self.coff_file_range() {
+ data.read_bytes_at(offset.into(), size.into())
+ } else {
+ Ok(&[])
+ }
+ }
+
+ /// Return the section alignment in bytes.
+ ///
+ /// This is only valid for sections in a COFF file.
+ pub fn coff_alignment(&self) -> u64 {
+ match self.characteristics.get(LE) & pe::IMAGE_SCN_ALIGN_MASK {
+ pe::IMAGE_SCN_ALIGN_1BYTES => 1,
+ pe::IMAGE_SCN_ALIGN_2BYTES => 2,
+ pe::IMAGE_SCN_ALIGN_4BYTES => 4,
+ pe::IMAGE_SCN_ALIGN_8BYTES => 8,
+ pe::IMAGE_SCN_ALIGN_16BYTES => 16,
+ pe::IMAGE_SCN_ALIGN_32BYTES => 32,
+ pe::IMAGE_SCN_ALIGN_64BYTES => 64,
+ pe::IMAGE_SCN_ALIGN_128BYTES => 128,
+ pe::IMAGE_SCN_ALIGN_256BYTES => 256,
+ pe::IMAGE_SCN_ALIGN_512BYTES => 512,
+ pe::IMAGE_SCN_ALIGN_1024BYTES => 1024,
+ pe::IMAGE_SCN_ALIGN_2048BYTES => 2048,
+ pe::IMAGE_SCN_ALIGN_4096BYTES => 4096,
+ pe::IMAGE_SCN_ALIGN_8192BYTES => 8192,
+ _ => 16,
+ }
+ }
+
+ /// Read the relocations in a COFF file.
+ ///
+ /// `data` must be the entire file data.
+ pub fn coff_relocations<'data, R: ReadRef<'data>>(
+ &self,
+ data: R,
+ ) -> read::Result<&'data [pe::ImageRelocation]> {
+ let pointer = self.pointer_to_relocations.get(LE).into();
+ let number = self.number_of_relocations.get(LE).into();
+ data.read_slice_at(pointer, number)
+ .read_error("Invalid COFF relocation offset or number")
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/coff/symbol.rs b/vendor/object-0.26.2/src/read/coff/symbol.rs
new file mode 100644
index 000000000..5af801f17
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/coff/symbol.rs
@@ -0,0 +1,505 @@
+use alloc::fmt;
+use alloc::vec::Vec;
+use core::convert::TryInto;
+use core::str;
+
+use super::{CoffCommon, SectionTable};
+use crate::endian::{LittleEndian as LE, U32Bytes};
+use crate::pe;
+use crate::pod::{bytes_of_slice, Pod};
+use crate::read::util::StringTable;
+use crate::read::{
+ self, Bytes, ObjectSymbol, ObjectSymbolTable, ReadError, ReadRef, Result, SectionIndex,
+ SymbolFlags, SymbolIndex, SymbolKind, SymbolMap, SymbolMapEntry, SymbolScope, SymbolSection,
+};
+
+/// A table of symbol entries in a COFF or PE file.
+///
+/// Also includes the string table used for the symbol names.
+#[derive(Debug)]
+pub struct SymbolTable<'data, R = &'data [u8]>
+where
+ R: ReadRef<'data>,
+{
+ symbols: &'data [pe::ImageSymbolBytes],
+ strings: StringTable<'data, R>,
+}
+
+impl<'data, R: ReadRef<'data>> SymbolTable<'data, R> {
+ /// Read the symbol table.
+ pub fn parse(header: &pe::ImageFileHeader, data: R) -> Result<Self> {
+ // The symbol table may not be present.
+ let mut offset = header.pointer_to_symbol_table.get(LE).into();
+ let (symbols, strings) = if offset != 0 {
+ let symbols = data
+ .read_slice(&mut offset, header.number_of_symbols.get(LE) as usize)
+ .read_error("Invalid COFF symbol table offset or size")?;
+
+ // Note: don't update data when reading length; the length includes itself.
+ let length = data
+ .read_at::<U32Bytes<_>>(offset)
+ .read_error("Missing COFF string table")?
+ .get(LE);
+ let str_end = offset
+ .checked_add(length as u64)
+ .read_error("Invalid COFF string table length")?;
+ let strings = StringTable::new(data, offset, str_end);
+
+ (symbols, strings)
+ } else {
+ (&[][..], StringTable::default())
+ };
+
+ Ok(SymbolTable { symbols, strings })
+ }
+
+ /// Return the string table used for the symbol names.
+ #[inline]
+ pub fn strings(&self) -> StringTable<'data, R> {
+ self.strings
+ }
+
+ /// Return true if the symbol table is empty.
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.symbols.is_empty()
+ }
+
+ /// The number of symbol table entries.
+ ///
+ /// This includes auxiliary symbol table entries.
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.symbols.len()
+ }
+
+ /// Iterate over the symbols.
+ #[inline]
+ pub fn iter<'table>(&'table self) -> SymbolIterator<'data, 'table, R> {
+ SymbolIterator {
+ symbols: self,
+ index: 0,
+ }
+ }
+
+ /// Return the symbol table entry at the given index.
+ #[inline]
+ pub fn symbol(&self, index: usize) -> Result<&'data pe::ImageSymbol> {
+ self.get::<pe::ImageSymbol>(index, 0)
+ }
+
+ /// Return the auxiliary function symbol for the symbol table entry at the given index.
+ ///
+ /// Note that the index is of the symbol, not the first auxiliary record.
+ #[inline]
+ pub fn aux_function(&self, index: usize) -> Result<&'data pe::ImageAuxSymbolFunction> {
+ self.get::<pe::ImageAuxSymbolFunction>(index, 1)
+ }
+
+ /// Return the auxiliary section symbol for the symbol table entry at the given index.
+ ///
+ /// Note that the index is of the symbol, not the first auxiliary record.
+ #[inline]
+ pub fn aux_section(&self, index: usize) -> Result<&'data pe::ImageAuxSymbolSection> {
+ self.get::<pe::ImageAuxSymbolSection>(index, 1)
+ }
+
+ /// Return the auxiliary file name for the symbol table entry at the given index.
+ ///
+ /// Note that the index is of the symbol, not the first auxiliary record.
+ pub fn aux_file_name(&self, index: usize, aux_count: u8) -> Result<&'data [u8]> {
+ let entries = index
+ .checked_add(1)
+ .and_then(|x| Some(x..x.checked_add(aux_count.into())?))
+ .and_then(|x| self.symbols.get(x))
+ .read_error("Invalid COFF symbol index")?;
+ let bytes = bytes_of_slice(entries);
+ // The name is padded with nulls.
+ Ok(match memchr::memchr(b'\0', bytes) {
+ Some(end) => &bytes[..end],
+ None => bytes,
+ })
+ }
+
+ /// Return the symbol table entry or auxiliary record at the given index and offset.
+ pub fn get<T: Pod>(&self, index: usize, offset: usize) -> Result<&'data T> {
+ let bytes = index
+ .checked_add(offset)
+ .and_then(|x| self.symbols.get(x))
+ .read_error("Invalid COFF symbol index")?;
+ Bytes(&bytes.0[..])
+ .read()
+ .read_error("Invalid COFF symbol data")
+ }
+
+ /// Construct a map from addresses to a user-defined map entry.
+ pub fn map<Entry: SymbolMapEntry, F: Fn(&'data pe::ImageSymbol) -> Option<Entry>>(
+ &self,
+ f: F,
+ ) -> SymbolMap<Entry> {
+ let mut symbols = Vec::with_capacity(self.symbols.len());
+ for (_, symbol) in self.iter() {
+ if !symbol.is_definition() {
+ continue;
+ }
+ if let Some(entry) = f(symbol) {
+ symbols.push(entry);
+ }
+ }
+ SymbolMap::new(symbols)
+ }
+}
+
+/// An iterator for symbol entries in a COFF or PE file.
+///
+/// Yields the index and symbol structure for each symbol.
+#[derive(Debug)]
+pub struct SymbolIterator<'data, 'table, R = &'data [u8]>
+where
+ R: ReadRef<'data>,
+{
+ symbols: &'table SymbolTable<'data, R>,
+ index: usize,
+}
+
+impl<'data, 'table, R: ReadRef<'data>> Iterator for SymbolIterator<'data, 'table, R> {
+ type Item = (usize, &'data pe::ImageSymbol);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let index = self.index;
+ let symbol = self.symbols.symbol(index).ok()?;
+ self.index += 1 + symbol.number_of_aux_symbols as usize;
+ Some((index, symbol))
+ }
+}
+
+impl pe::ImageSymbol {
+ /// Parse a COFF symbol name.
+ ///
+ /// `strings` must be the string table used for symbol names.
+ pub fn name<'data, R: ReadRef<'data>>(
+ &'data self,
+ strings: StringTable<'data, R>,
+ ) -> Result<&'data [u8]> {
+ if self.name[0] == 0 {
+ // If the name starts with 0 then the last 4 bytes are a string table offset.
+ let offset = u32::from_le_bytes(self.name[4..8].try_into().unwrap());
+ strings
+ .get(offset)
+ .read_error("Invalid COFF symbol name offset")
+ } else {
+ // The name is inline and padded with nulls.
+ Ok(match memchr::memchr(b'\0', &self.name) {
+ Some(end) => &self.name[..end],
+ None => &self.name[..],
+ })
+ }
+ }
+
+ /// Return the symbol address.
+ ///
+ /// This takes into account the image base and the section address.
+ pub fn address(&self, image_base: u64, sections: &SectionTable) -> Result<u64> {
+ let section_number = self.section_number.get(LE) as usize;
+ let section = sections.section(section_number)?;
+ let virtual_address = u64::from(section.virtual_address.get(LE));
+ let value = u64::from(self.value.get(LE));
+ Ok(image_base + virtual_address + value)
+ }
+
+ /// Return true if the symbol is a definition of a function or data object.
+ pub fn is_definition(&self) -> bool {
+ let section_number = self.section_number.get(LE);
+ if section_number == pe::IMAGE_SYM_UNDEFINED {
+ return false;
+ }
+ match self.storage_class {
+ pe::IMAGE_SYM_CLASS_STATIC => {
+ // Exclude section symbols.
+ !(self.value.get(LE) == 0 && self.number_of_aux_symbols > 0)
+ }
+ pe::IMAGE_SYM_CLASS_EXTERNAL | pe::IMAGE_SYM_CLASS_WEAK_EXTERNAL => true,
+ _ => false,
+ }
+ }
+
+ /// Return true if the symbol has an auxiliary file name.
+ pub fn has_aux_file_name(&self) -> bool {
+ self.number_of_aux_symbols > 0 && self.storage_class == pe::IMAGE_SYM_CLASS_FILE
+ }
+
+ /// Return true if the symbol has an auxiliary function symbol.
+ pub fn has_aux_function(&self) -> bool {
+ self.number_of_aux_symbols > 0 && self.derived_type() == pe::IMAGE_SYM_DTYPE_FUNCTION
+ }
+
+ /// Return true if the symbol has an auxiliary section symbol.
+ pub fn has_aux_section(&self) -> bool {
+ self.number_of_aux_symbols > 0
+ && self.storage_class == pe::IMAGE_SYM_CLASS_STATIC
+ && self.value.get(LE) == 0
+ }
+}
+
+/// A symbol table of a `CoffFile`.
+#[derive(Debug, Clone, Copy)]
+pub struct CoffSymbolTable<'data, 'file, R = &'data [u8]>
+where
+ R: ReadRef<'data>,
+{
+ pub(crate) file: &'file CoffCommon<'data, R>,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for CoffSymbolTable<'data, 'file, R> {}
+
+impl<'data, 'file, R: ReadRef<'data>> ObjectSymbolTable<'data>
+ for CoffSymbolTable<'data, 'file, R>
+{
+ type Symbol = CoffSymbol<'data, 'file, R>;
+ type SymbolIterator = CoffSymbolIterator<'data, 'file, R>;
+
+ fn symbols(&self) -> Self::SymbolIterator {
+ CoffSymbolIterator {
+ file: self.file,
+ index: 0,
+ }
+ }
+
+ fn symbol_by_index(&self, index: SymbolIndex) -> Result<Self::Symbol> {
+ let symbol = self.file.symbols.symbol(index.0)?;
+ Ok(CoffSymbol {
+ file: self.file,
+ index,
+ symbol,
+ })
+ }
+}
+
+/// An iterator over the symbols of a `CoffFile`.
+pub struct CoffSymbolIterator<'data, 'file, R = &'data [u8]>
+where
+ R: ReadRef<'data>,
+{
+ pub(crate) file: &'file CoffCommon<'data, R>,
+ pub(crate) index: usize,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> fmt::Debug for CoffSymbolIterator<'data, 'file, R> {
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("CoffSymbolIterator").finish()
+ }
+}
+
+impl<'data, 'file, R: ReadRef<'data>> Iterator for CoffSymbolIterator<'data, 'file, R> {
+ type Item = CoffSymbol<'data, 'file, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let index = self.index;
+ let symbol = self.file.symbols.symbol(index).ok()?;
+ self.index += 1 + symbol.number_of_aux_symbols as usize;
+ Some(CoffSymbol {
+ file: self.file,
+ index: SymbolIndex(index),
+ symbol,
+ })
+ }
+}
+
+/// A symbol of a `CoffFile`.
+#[derive(Debug, Clone, Copy)]
+pub struct CoffSymbol<'data, 'file, R = &'data [u8]>
+where
+ R: ReadRef<'data>,
+{
+ pub(crate) file: &'file CoffCommon<'data, R>,
+ pub(crate) index: SymbolIndex,
+ pub(crate) symbol: &'data pe::ImageSymbol,
+}
+
+impl<'data, 'file, R: ReadRef<'data>> read::private::Sealed for CoffSymbol<'data, 'file, R> {}
+
+impl<'data, 'file, R: ReadRef<'data>> ObjectSymbol<'data> for CoffSymbol<'data, 'file, R> {
+ #[inline]
+ fn index(&self) -> SymbolIndex {
+ self.index
+ }
+
+ fn name(&self) -> read::Result<&'data str> {
+ let name = if self.symbol.has_aux_file_name() {
+ self.file
+ .symbols
+ .aux_file_name(self.index.0, self.symbol.number_of_aux_symbols)?
+ } else {
+ self.symbol.name(self.file.symbols.strings())?
+ };
+ str::from_utf8(name)
+ .ok()
+ .read_error("Non UTF-8 COFF symbol name")
+ }
+
+ fn address(&self) -> u64 {
+ // Only return an address for storage classes that we know use an address.
+ match self.symbol.storage_class {
+ pe::IMAGE_SYM_CLASS_STATIC
+ | pe::IMAGE_SYM_CLASS_WEAK_EXTERNAL
+ | pe::IMAGE_SYM_CLASS_LABEL => {}
+ pe::IMAGE_SYM_CLASS_EXTERNAL => {
+ if self.symbol.section_number.get(LE) == pe::IMAGE_SYM_UNDEFINED {
+ // Undefined or common data, neither of which have an address.
+ return 0;
+ }
+ }
+ _ => return 0,
+ }
+ self.symbol
+ .address(self.file.image_base, &self.file.sections)
+ .unwrap_or(0)
+ }
+
+ fn size(&self) -> u64 {
+ match self.symbol.storage_class {
+ pe::IMAGE_SYM_CLASS_STATIC => {
+ // Section symbols may duplicate the size from the section table.
+ if self.symbol.has_aux_section() {
+ if let Ok(aux) = self.file.symbols.aux_section(self.index.0) {
+ u64::from(aux.length.get(LE))
+ } else {
+ 0
+ }
+ } else {
+ 0
+ }
+ }
+ pe::IMAGE_SYM_CLASS_EXTERNAL => {
+ if self.symbol.section_number.get(LE) == pe::IMAGE_SYM_UNDEFINED {
+ // For undefined symbols, symbol.value is 0 and the size is 0.
+ // For common data, symbol.value is the size.
+ u64::from(self.symbol.value.get(LE))
+ } else if self.symbol.has_aux_function() {
+ // Function symbols may have a size.
+ if let Ok(aux) = self.file.symbols.aux_function(self.index.0) {
+ u64::from(aux.total_size.get(LE))
+ } else {
+ 0
+ }
+ } else {
+ 0
+ }
+ }
+ // Most symbols don't have sizes.
+ _ => 0,
+ }
+ }
+
+ fn kind(&self) -> SymbolKind {
+ let derived_kind = if self.symbol.derived_type() == pe::IMAGE_SYM_DTYPE_FUNCTION {
+ SymbolKind::Text
+ } else {
+ SymbolKind::Data
+ };
+ match self.symbol.storage_class {
+ pe::IMAGE_SYM_CLASS_STATIC => {
+ if self.symbol.value.get(LE) == 0 && self.symbol.number_of_aux_symbols > 0 {
+ SymbolKind::Section
+ } else {
+ derived_kind
+ }
+ }
+ pe::IMAGE_SYM_CLASS_EXTERNAL | pe::IMAGE_SYM_CLASS_WEAK_EXTERNAL => derived_kind,
+ pe::IMAGE_SYM_CLASS_SECTION => SymbolKind::Section,
+ pe::IMAGE_SYM_CLASS_FILE => SymbolKind::File,
+ pe::IMAGE_SYM_CLASS_LABEL => SymbolKind::Label,
+ _ => SymbolKind::Unknown,
+ }
+ }
+
+ fn section(&self) -> SymbolSection {
+ match self.symbol.section_number.get(LE) {
+ pe::IMAGE_SYM_UNDEFINED => {
+ if self.symbol.storage_class == pe::IMAGE_SYM_CLASS_EXTERNAL
+ && self.symbol.value.get(LE) == 0
+ {
+ SymbolSection::Undefined
+ } else {
+ SymbolSection::Common
+ }
+ }
+ pe::IMAGE_SYM_ABSOLUTE => SymbolSection::Absolute,
+ pe::IMAGE_SYM_DEBUG => {
+ if self.symbol.storage_class == pe::IMAGE_SYM_CLASS_FILE {
+ SymbolSection::None
+ } else {
+ SymbolSection::Unknown
+ }
+ }
+ index if index > 0 => SymbolSection::Section(SectionIndex(index.into())),
+ _ => SymbolSection::Unknown,
+ }
+ }
+
+ #[inline]
+ fn is_undefined(&self) -> bool {
+ self.symbol.storage_class == pe::IMAGE_SYM_CLASS_EXTERNAL
+ && self.symbol.section_number.get(LE) == pe::IMAGE_SYM_UNDEFINED
+ && self.symbol.value.get(LE) == 0
+ }
+
+ #[inline]
+ fn is_definition(&self) -> bool {
+ self.symbol.is_definition()
+ }
+
+ #[inline]
+ fn is_common(&self) -> bool {
+ self.symbol.storage_class == pe::IMAGE_SYM_CLASS_EXTERNAL
+ && self.symbol.section_number.get(LE) == pe::IMAGE_SYM_UNDEFINED
+ && self.symbol.value.get(LE) != 0
+ }
+
+ #[inline]
+ fn is_weak(&self) -> bool {
+ self.symbol.storage_class == pe::IMAGE_SYM_CLASS_WEAK_EXTERNAL
+ }
+
+ #[inline]
+ fn scope(&self) -> SymbolScope {
+ match self.symbol.storage_class {
+ pe::IMAGE_SYM_CLASS_EXTERNAL | pe::IMAGE_SYM_CLASS_WEAK_EXTERNAL => {
+ // TODO: determine if symbol is exported
+ SymbolScope::Linkage
+ }
+ _ => SymbolScope::Compilation,
+ }
+ }
+
+ #[inline]
+ fn is_global(&self) -> bool {
+ match self.symbol.storage_class {
+ pe::IMAGE_SYM_CLASS_EXTERNAL | pe::IMAGE_SYM_CLASS_WEAK_EXTERNAL => true,
+ _ => false,
+ }
+ }
+
+ #[inline]
+ fn is_local(&self) -> bool {
+ !self.is_global()
+ }
+
+ fn flags(&self) -> SymbolFlags<SectionIndex> {
+ if self.symbol.has_aux_section() {
+ if let Ok(aux) = self.file.symbols.aux_section(self.index.0) {
+ // TODO: use high_number for bigobj
+ let number = aux.number.get(LE) as usize;
+ return SymbolFlags::CoffSection {
+ selection: aux.selection,
+ associative_section: if number == 0 {
+ None
+ } else {
+ Some(SectionIndex(number))
+ },
+ };
+ }
+ }
+ SymbolFlags::None
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/comdat.rs b/vendor/object-0.26.2/src/read/elf/comdat.rs
new file mode 100644
index 000000000..5feb55b12
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/comdat.rs
@@ -0,0 +1,161 @@
+use core::fmt::Debug;
+use core::{iter, slice, str};
+
+use crate::elf;
+use crate::endian::{Endianness, U32Bytes};
+use crate::read::{self, ComdatKind, ObjectComdat, ReadError, ReadRef, SectionIndex, SymbolIndex};
+
+use super::{ElfFile, FileHeader, SectionHeader, Sym};
+
+/// An iterator over the COMDAT section groups of an `ElfFile32`.
+pub type ElfComdatIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfComdatIterator<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// An iterator over the COMDAT section groups of an `ElfFile64`.
+pub type ElfComdatIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfComdatIterator<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// An iterator over the COMDAT section groups of an `ElfFile`.
+#[derive(Debug)]
+pub struct ElfComdatIterator<'data, 'file, Elf, R = &'data [u8]>
+where
+ 'data: 'file,
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file ElfFile<'data, Elf, R>,
+ pub(super) iter: iter::Enumerate<slice::Iter<'data, Elf::SectionHeader>>,
+}
+
+impl<'data, 'file, Elf, R> Iterator for ElfComdatIterator<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ type Item = ElfComdat<'data, 'file, Elf, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ while let Some((index, section)) = self.iter.next() {
+ if let Some(comdat) = ElfComdat::parse(self.file, index, section) {
+ return Some(comdat);
+ }
+ }
+ None
+ }
+}
+
+/// A COMDAT section group of an `ElfFile32`.
+pub type ElfComdat32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfComdat<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// A COMDAT section group of an `ElfFile64`.
+pub type ElfComdat64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfComdat<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// A COMDAT section group of an `ElfFile`.
+#[derive(Debug)]
+pub struct ElfComdat<'data, 'file, Elf, R = &'data [u8]>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ file: &'file ElfFile<'data, Elf, R>,
+ index: SectionIndex,
+ section: &'data Elf::SectionHeader,
+ sections: &'data [U32Bytes<Elf::Endian>],
+}
+
+impl<'data, 'file, Elf, R> ElfComdat<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ fn parse(
+ file: &'file ElfFile<'data, Elf, R>,
+ index: usize,
+ section: &'data Elf::SectionHeader,
+ ) -> Option<ElfComdat<'data, 'file, Elf, R>> {
+ let (flag, sections) = section.group(file.endian, file.data).ok()??;
+ if flag != elf::GRP_COMDAT {
+ return None;
+ }
+ Some(ElfComdat {
+ file,
+ index: SectionIndex(index),
+ section,
+ sections,
+ })
+ }
+}
+
+impl<'data, 'file, Elf, R> read::private::Sealed for ElfComdat<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Elf, R> ObjectComdat<'data> for ElfComdat<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ type SectionIterator = ElfComdatSectionIterator<'data, 'file, Elf, R>;
+
+ #[inline]
+ fn kind(&self) -> ComdatKind {
+ ComdatKind::Any
+ }
+
+ #[inline]
+ fn symbol(&self) -> SymbolIndex {
+ SymbolIndex(self.section.sh_info(self.file.endian) as usize)
+ }
+
+ fn name(&self) -> read::Result<&str> {
+ // FIXME: check sh_link
+ let index = self.section.sh_info(self.file.endian) as usize;
+ let symbol = self.file.symbols.symbol(index)?;
+ let name = symbol.name(self.file.endian, self.file.symbols.strings())?;
+ str::from_utf8(name)
+ .ok()
+ .read_error("Non UTF-8 ELF COMDAT name")
+ }
+
+ fn sections(&self) -> Self::SectionIterator {
+ ElfComdatSectionIterator {
+ file: self.file,
+ sections: self.sections.iter(),
+ }
+ }
+}
+
+/// An iterator over the sections in a COMDAT section group of an `ElfFile32`.
+pub type ElfComdatSectionIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfComdatSectionIterator<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// An iterator over the sections in a COMDAT section group of an `ElfFile64`.
+pub type ElfComdatSectionIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfComdatSectionIterator<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// An iterator over the sections in a COMDAT section group of an `ElfFile`.
+#[derive(Debug)]
+pub struct ElfComdatSectionIterator<'data, 'file, Elf, R = &'data [u8]>
+where
+ 'data: 'file,
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ file: &'file ElfFile<'data, Elf, R>,
+ sections: slice::Iter<'data, U32Bytes<Elf::Endian>>,
+}
+
+impl<'data, 'file, Elf, R> Iterator for ElfComdatSectionIterator<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ type Item = SectionIndex;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let index = self.sections.next()?;
+ Some(SectionIndex(index.get(self.file.endian) as usize))
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/compression.rs b/vendor/object-0.26.2/src/read/elf/compression.rs
new file mode 100644
index 000000000..7242dd39c
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/compression.rs
@@ -0,0 +1,56 @@
+use core::fmt::Debug;
+
+use crate::elf;
+use crate::endian;
+use crate::pod::Pod;
+
+/// A trait for generic access to `CompressionHeader32` and `CompressionHeader64`.
+#[allow(missing_docs)]
+pub trait CompressionHeader: Debug + Pod {
+ type Word: Into<u64>;
+ type Endian: endian::Endian;
+
+ fn ch_type(&self, endian: Self::Endian) -> u32;
+ fn ch_size(&self, endian: Self::Endian) -> Self::Word;
+ fn ch_addralign(&self, endian: Self::Endian) -> Self::Word;
+}
+
+impl<Endian: endian::Endian> CompressionHeader for elf::CompressionHeader32<Endian> {
+ type Word = u32;
+ type Endian = Endian;
+
+ #[inline]
+ fn ch_type(&self, endian: Self::Endian) -> u32 {
+ self.ch_type.get(endian)
+ }
+
+ #[inline]
+ fn ch_size(&self, endian: Self::Endian) -> Self::Word {
+ self.ch_size.get(endian)
+ }
+
+ #[inline]
+ fn ch_addralign(&self, endian: Self::Endian) -> Self::Word {
+ self.ch_addralign.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> CompressionHeader for elf::CompressionHeader64<Endian> {
+ type Word = u64;
+ type Endian = Endian;
+
+ #[inline]
+ fn ch_type(&self, endian: Self::Endian) -> u32 {
+ self.ch_type.get(endian)
+ }
+
+ #[inline]
+ fn ch_size(&self, endian: Self::Endian) -> Self::Word {
+ self.ch_size.get(endian)
+ }
+
+ #[inline]
+ fn ch_addralign(&self, endian: Self::Endian) -> Self::Word {
+ self.ch_addralign.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/dynamic.rs b/vendor/object-0.26.2/src/read/elf/dynamic.rs
new file mode 100644
index 000000000..dd7c25570
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/dynamic.rs
@@ -0,0 +1,45 @@
+use core::fmt::Debug;
+
+use crate::elf;
+use crate::endian;
+use crate::pod::Pod;
+
+/// A trait for generic access to `Dyn32` and `Dyn64`.
+#[allow(missing_docs)]
+pub trait Dyn: Debug + Pod {
+ type Word: Into<u64>;
+ type Endian: endian::Endian;
+
+ fn d_tag(&self, endian: Self::Endian) -> Self::Word;
+ fn d_val(&self, endian: Self::Endian) -> Self::Word;
+}
+
+impl<Endian: endian::Endian> Dyn for elf::Dyn32<Endian> {
+ type Word = u32;
+ type Endian = Endian;
+
+ #[inline]
+ fn d_tag(&self, endian: Self::Endian) -> Self::Word {
+ self.d_tag.get(endian)
+ }
+
+ #[inline]
+ fn d_val(&self, endian: Self::Endian) -> Self::Word {
+ self.d_val.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> Dyn for elf::Dyn64<Endian> {
+ type Word = u64;
+ type Endian = Endian;
+
+ #[inline]
+ fn d_tag(&self, endian: Self::Endian) -> Self::Word {
+ self.d_tag.get(endian)
+ }
+
+ #[inline]
+ fn d_val(&self, endian: Self::Endian) -> Self::Word {
+ self.d_val.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/file.rs b/vendor/object-0.26.2/src/read/elf/file.rs
new file mode 100644
index 000000000..91273ca41
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/file.rs
@@ -0,0 +1,859 @@
+use alloc::vec::Vec;
+use core::convert::TryInto;
+use core::fmt::Debug;
+use core::{mem, str};
+
+use crate::read::{
+ self, util, Architecture, ByteString, Bytes, Error, Export, FileFlags, Import, Object,
+ ReadError, ReadRef, SectionIndex, StringTable, SymbolIndex,
+};
+use crate::{elf, endian, Endian, Endianness, Pod, U32};
+
+use super::{
+ CompressionHeader, Dyn, ElfComdat, ElfComdatIterator, ElfDynamicRelocationIterator, ElfSection,
+ ElfSectionIterator, ElfSegment, ElfSegmentIterator, ElfSymbol, ElfSymbolIterator,
+ ElfSymbolTable, NoteHeader, ProgramHeader, Rel, Rela, RelocationSections, SectionHeader,
+ SectionTable, Sym, SymbolTable,
+};
+
+/// A 32-bit ELF object file.
+pub type ElfFile32<'data, Endian = Endianness, R = &'data [u8]> =
+ ElfFile<'data, elf::FileHeader32<Endian>, R>;
+/// A 64-bit ELF object file.
+pub type ElfFile64<'data, Endian = Endianness, R = &'data [u8]> =
+ ElfFile<'data, elf::FileHeader64<Endian>, R>;
+
+/// A partially parsed ELF file.
+///
+/// Most of the functionality of this type is provided by the `Object` trait implementation.
+#[derive(Debug)]
+pub struct ElfFile<'data, Elf, R = &'data [u8]>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) endian: Elf::Endian,
+ pub(super) data: R,
+ pub(super) header: &'data Elf,
+ pub(super) segments: &'data [Elf::ProgramHeader],
+ pub(super) sections: SectionTable<'data, Elf, R>,
+ pub(super) relocations: RelocationSections,
+ pub(super) symbols: SymbolTable<'data, Elf, R>,
+ pub(super) dynamic_symbols: SymbolTable<'data, Elf, R>,
+}
+
+impl<'data, Elf, R> ElfFile<'data, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ /// Parse the raw ELF file data.
+ pub fn parse(data: R) -> read::Result<Self> {
+ let header = Elf::parse(data)?;
+ let endian = header.endian()?;
+ let segments = header.program_headers(endian, data)?;
+ let sections = header.sections(endian, data)?;
+ let symbols = sections.symbols(endian, data, elf::SHT_SYMTAB)?;
+ // TODO: get dynamic symbols from DT_SYMTAB if there are no sections
+ let dynamic_symbols = sections.symbols(endian, data, elf::SHT_DYNSYM)?;
+ // The API we provide requires a mapping from section to relocations, so build it now.
+ let relocations = sections.relocation_sections(endian, symbols.section())?;
+
+ Ok(ElfFile {
+ endian,
+ data,
+ header,
+ segments,
+ sections,
+ relocations,
+ symbols,
+ dynamic_symbols,
+ })
+ }
+
+ /// Returns the endianness.
+ pub fn endian(&self) -> Elf::Endian {
+ self.endian
+ }
+
+ /// Returns the raw data.
+ pub fn data(&self) -> R {
+ self.data
+ }
+
+ /// Returns the raw ELF file header.
+ pub fn raw_header(&self) -> &'data Elf {
+ self.header
+ }
+
+ /// Returns the raw ELF segments.
+ pub fn raw_segments(&self) -> &'data [Elf::ProgramHeader] {
+ self.segments
+ }
+
+ fn raw_section_by_name<'file>(
+ &'file self,
+ section_name: &str,
+ ) -> Option<ElfSection<'data, 'file, Elf, R>> {
+ self.sections
+ .section_by_name(self.endian, section_name.as_bytes())
+ .map(|(index, section)| ElfSection {
+ file: self,
+ index: SectionIndex(index),
+ section,
+ })
+ }
+
+ #[cfg(feature = "compression")]
+ fn zdebug_section_by_name<'file>(
+ &'file self,
+ section_name: &str,
+ ) -> Option<ElfSection<'data, 'file, Elf, R>> {
+ if !section_name.starts_with(".debug_") {
+ return None;
+ }
+ self.raw_section_by_name(&format!(".zdebug_{}", &section_name[7..]))
+ }
+
+ #[cfg(not(feature = "compression"))]
+ fn zdebug_section_by_name<'file>(
+ &'file self,
+ _section_name: &str,
+ ) -> Option<ElfSection<'data, 'file, Elf, R>> {
+ None
+ }
+}
+
+impl<'data, Elf, R> read::private::Sealed for ElfFile<'data, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Elf, R> Object<'data, 'file> for ElfFile<'data, Elf, R>
+where
+ 'data: 'file,
+ Elf: FileHeader,
+ R: 'file + ReadRef<'data>,
+{
+ type Segment = ElfSegment<'data, 'file, Elf, R>;
+ type SegmentIterator = ElfSegmentIterator<'data, 'file, Elf, R>;
+ type Section = ElfSection<'data, 'file, Elf, R>;
+ type SectionIterator = ElfSectionIterator<'data, 'file, Elf, R>;
+ type Comdat = ElfComdat<'data, 'file, Elf, R>;
+ type ComdatIterator = ElfComdatIterator<'data, 'file, Elf, R>;
+ type Symbol = ElfSymbol<'data, 'file, Elf, R>;
+ type SymbolIterator = ElfSymbolIterator<'data, 'file, Elf, R>;
+ type SymbolTable = ElfSymbolTable<'data, 'file, Elf, R>;
+ type DynamicRelocationIterator = ElfDynamicRelocationIterator<'data, 'file, Elf, R>;
+
+ fn architecture(&self) -> Architecture {
+ match (
+ self.header.e_machine(self.endian),
+ self.header.is_class_64(),
+ ) {
+ (elf::EM_AARCH64, _) => Architecture::Aarch64,
+ (elf::EM_ARM, _) => Architecture::Arm,
+ (elf::EM_AVR, _) => Architecture::Avr,
+ (elf::EM_BPF, _) => Architecture::Bpf,
+ (elf::EM_386, _) => Architecture::I386,
+ (elf::EM_X86_64, false) => Architecture::X86_64_X32,
+ (elf::EM_X86_64, true) => Architecture::X86_64,
+ (elf::EM_HEXAGON, _) => Architecture::Hexagon,
+ (elf::EM_MIPS, false) => Architecture::Mips,
+ (elf::EM_MIPS, true) => Architecture::Mips64,
+ (elf::EM_MSP430, _) => Architecture::Msp430,
+ (elf::EM_PPC, _) => Architecture::PowerPc,
+ (elf::EM_PPC64, _) => Architecture::PowerPc64,
+ (elf::EM_RISCV, false) => Architecture::Riscv32,
+ (elf::EM_RISCV, true) => Architecture::Riscv64,
+ // This is either s390 or s390x, depending on the ELF class.
+ // We only support the 64-bit variant s390x here.
+ (elf::EM_S390, true) => Architecture::S390x,
+ (elf::EM_SPARCV9, true) => Architecture::Sparc64,
+ _ => Architecture::Unknown,
+ }
+ }
+
+ #[inline]
+ fn is_little_endian(&self) -> bool {
+ self.header.is_little_endian()
+ }
+
+ #[inline]
+ fn is_64(&self) -> bool {
+ self.header.is_class_64()
+ }
+
+ fn segments(&'file self) -> ElfSegmentIterator<'data, 'file, Elf, R> {
+ ElfSegmentIterator {
+ file: self,
+ iter: self.segments.iter(),
+ }
+ }
+
+ fn section_by_name(
+ &'file self,
+ section_name: &str,
+ ) -> Option<ElfSection<'data, 'file, Elf, R>> {
+ self.raw_section_by_name(section_name)
+ .or_else(|| self.zdebug_section_by_name(section_name))
+ }
+
+ fn section_by_index(
+ &'file self,
+ index: SectionIndex,
+ ) -> read::Result<ElfSection<'data, 'file, Elf, R>> {
+ let section = self.sections.section(index.0)?;
+ Ok(ElfSection {
+ file: self,
+ index,
+ section,
+ })
+ }
+
+ fn sections(&'file self) -> ElfSectionIterator<'data, 'file, Elf, R> {
+ ElfSectionIterator {
+ file: self,
+ iter: self.sections.iter().enumerate(),
+ }
+ }
+
+ fn comdats(&'file self) -> ElfComdatIterator<'data, 'file, Elf, R> {
+ ElfComdatIterator {
+ file: self,
+ iter: self.sections.iter().enumerate(),
+ }
+ }
+
+ fn symbol_by_index(
+ &'file self,
+ index: SymbolIndex,
+ ) -> read::Result<ElfSymbol<'data, 'file, Elf, R>> {
+ let symbol = self.symbols.symbol(index.0)?;
+ Ok(ElfSymbol {
+ endian: self.endian,
+ symbols: &self.symbols,
+ index,
+ symbol,
+ })
+ }
+
+ fn symbols(&'file self) -> ElfSymbolIterator<'data, 'file, Elf, R> {
+ ElfSymbolIterator {
+ endian: self.endian,
+ symbols: &self.symbols,
+ index: 0,
+ }
+ }
+
+ fn symbol_table(&'file self) -> Option<ElfSymbolTable<'data, 'file, Elf, R>> {
+ Some(ElfSymbolTable {
+ endian: self.endian,
+ symbols: &self.symbols,
+ })
+ }
+
+ fn dynamic_symbols(&'file self) -> ElfSymbolIterator<'data, 'file, Elf, R> {
+ ElfSymbolIterator {
+ endian: self.endian,
+ symbols: &self.dynamic_symbols,
+ index: 0,
+ }
+ }
+
+ fn dynamic_symbol_table(&'file self) -> Option<ElfSymbolTable<'data, 'file, Elf, R>> {
+ Some(ElfSymbolTable {
+ endian: self.endian,
+ symbols: &self.dynamic_symbols,
+ })
+ }
+
+ fn dynamic_relocations(
+ &'file self,
+ ) -> Option<ElfDynamicRelocationIterator<'data, 'file, Elf, R>> {
+ Some(ElfDynamicRelocationIterator {
+ section_index: 1,
+ file: self,
+ relocations: None,
+ })
+ }
+
+ /// Get the imported symbols.
+ fn imports(&self) -> read::Result<Vec<Import<'data>>> {
+ let mut imports = Vec::new();
+ for symbol in self.dynamic_symbols.iter() {
+ if symbol.is_undefined(self.endian) {
+ let name = symbol.name(self.endian, self.dynamic_symbols.strings())?;
+ if !name.is_empty() {
+ // TODO: use symbol versioning to determine library
+ imports.push(Import {
+ name: ByteString(name),
+ library: ByteString(&[]),
+ });
+ }
+ }
+ }
+ Ok(imports)
+ }
+
+ /// Get the exported symbols.
+ fn exports(&self) -> read::Result<Vec<Export<'data>>> {
+ let mut exports = Vec::new();
+ for symbol in self.dynamic_symbols.iter() {
+ if symbol.is_definition(self.endian) {
+ let name = symbol.name(self.endian, self.dynamic_symbols.strings())?;
+ let address = symbol.st_value(self.endian).into();
+ exports.push(Export {
+ name: ByteString(name),
+ address,
+ });
+ }
+ }
+ Ok(exports)
+ }
+
+ fn has_debug_symbols(&self) -> bool {
+ for section in self.sections.iter() {
+ if let Ok(name) = self.sections.section_name(self.endian, section) {
+ if name == b".debug_info" || name == b".zdebug_info" {
+ return true;
+ }
+ }
+ }
+ false
+ }
+
+ fn build_id(&self) -> read::Result<Option<&'data [u8]>> {
+ let endian = self.endian;
+ // Use section headers if present, otherwise use program headers.
+ if !self.sections.is_empty() {
+ for section in self.sections.iter() {
+ if let Some(mut notes) = section.notes(endian, self.data)? {
+ while let Some(note) = notes.next()? {
+ if note.name() == elf::ELF_NOTE_GNU
+ && note.n_type(endian) == elf::NT_GNU_BUILD_ID
+ {
+ return Ok(Some(note.desc()));
+ }
+ }
+ }
+ }
+ } else {
+ for segment in self.segments {
+ if let Some(mut notes) = segment.notes(endian, self.data)? {
+ while let Some(note) = notes.next()? {
+ if note.name() == elf::ELF_NOTE_GNU
+ && note.n_type(endian) == elf::NT_GNU_BUILD_ID
+ {
+ return Ok(Some(note.desc()));
+ }
+ }
+ }
+ }
+ }
+ Ok(None)
+ }
+
+ fn gnu_debuglink(&self) -> read::Result<Option<(&'data [u8], u32)>> {
+ let section = match self.raw_section_by_name(".gnu_debuglink") {
+ Some(section) => section,
+ None => return Ok(None),
+ };
+ let data = section
+ .section
+ .data(self.endian, self.data)
+ .read_error("Invalid ELF .gnu_debuglink section offset or size")
+ .map(Bytes)?;
+ let filename = data
+ .read_string_at(0)
+ .read_error("Missing ELF .gnu_debuglink filename")?;
+ let crc_offset = util::align(filename.len() + 1, 4);
+ let crc = data
+ .read_at::<U32<_>>(crc_offset)
+ .read_error("Missing ELF .gnu_debuglink crc")?
+ .get(self.endian);
+ Ok(Some((filename, crc)))
+ }
+
+ fn gnu_debugaltlink(&self) -> read::Result<Option<(&'data [u8], &'data [u8])>> {
+ let section = match self.raw_section_by_name(".gnu_debugaltlink") {
+ Some(section) => section,
+ None => return Ok(None),
+ };
+ let mut data = section
+ .section
+ .data(self.endian, self.data)
+ .read_error("Invalid ELF .gnu_debugaltlink section offset or size")
+ .map(Bytes)?;
+ let filename = data
+ .read_string()
+ .read_error("Missing ELF .gnu_debugaltlink filename")?;
+ let build_id = data.0;
+ Ok(Some((filename, build_id)))
+ }
+
+ fn relative_address_base(&self) -> u64 {
+ 0
+ }
+
+ fn entry(&self) -> u64 {
+ self.header.e_entry(self.endian).into()
+ }
+
+ fn flags(&self) -> FileFlags {
+ FileFlags::Elf {
+ e_flags: self.header.e_flags(self.endian),
+ }
+ }
+}
+
+/// A trait for generic access to `FileHeader32` and `FileHeader64`.
+#[allow(missing_docs)]
+pub trait FileHeader: Debug + Pod {
+ // Ideally this would be a `u64: From<Word>`, but can't express that.
+ type Word: Into<u64>;
+ type Sword: Into<i64>;
+ type Endian: endian::Endian;
+ type ProgramHeader: ProgramHeader<Elf = Self, Endian = Self::Endian, Word = Self::Word>;
+ type SectionHeader: SectionHeader<Elf = Self, Endian = Self::Endian, Word = Self::Word>;
+ type CompressionHeader: CompressionHeader<Endian = Self::Endian, Word = Self::Word>;
+ type NoteHeader: NoteHeader<Endian = Self::Endian>;
+ type Dyn: Dyn<Endian = Self::Endian, Word = Self::Word>;
+ type Sym: Sym<Endian = Self::Endian, Word = Self::Word>;
+ type Rel: Rel<Endian = Self::Endian, Word = Self::Word>;
+ type Rela: Rela<Endian = Self::Endian, Word = Self::Word> + From<Self::Rel>;
+
+ /// Return true if this type is a 64-bit header.
+ ///
+ /// This is a property of the type, not a value in the header data.
+ fn is_type_64(&self) -> bool;
+
+ fn e_ident(&self) -> &elf::Ident;
+ fn e_type(&self, endian: Self::Endian) -> u16;
+ fn e_machine(&self, endian: Self::Endian) -> u16;
+ fn e_version(&self, endian: Self::Endian) -> u32;
+ fn e_entry(&self, endian: Self::Endian) -> Self::Word;
+ fn e_phoff(&self, endian: Self::Endian) -> Self::Word;
+ fn e_shoff(&self, endian: Self::Endian) -> Self::Word;
+ fn e_flags(&self, endian: Self::Endian) -> u32;
+ fn e_ehsize(&self, endian: Self::Endian) -> u16;
+ fn e_phentsize(&self, endian: Self::Endian) -> u16;
+ fn e_phnum(&self, endian: Self::Endian) -> u16;
+ fn e_shentsize(&self, endian: Self::Endian) -> u16;
+ fn e_shnum(&self, endian: Self::Endian) -> u16;
+ fn e_shstrndx(&self, endian: Self::Endian) -> u16;
+
+ // Provided methods.
+
+ /// Read the file header.
+ ///
+ /// Also checks that the ident field in the file header is a supported format.
+ fn parse<'data, R: ReadRef<'data>>(data: R) -> read::Result<&'data Self> {
+ let header = data
+ .read_at::<Self>(0)
+ .read_error("Invalid ELF header size or alignment")?;
+ if !header.is_supported() {
+ return Err(Error("Unsupported ELF header"));
+ }
+ // TODO: Check self.e_ehsize?
+ Ok(header)
+ }
+
+ /// Check that the ident field in the file header is a supported format.
+ ///
+ /// This checks the magic number, version, class, and endianness.
+ fn is_supported(&self) -> bool {
+ let ident = self.e_ident();
+ // TODO: Check self.e_version too? Requires endian though.
+ ident.magic == elf::ELFMAG
+ && (self.is_type_64() || self.is_class_32())
+ && (!self.is_type_64() || self.is_class_64())
+ && (self.is_little_endian() || self.is_big_endian())
+ && ident.version == elf::EV_CURRENT
+ }
+
+ fn is_class_32(&self) -> bool {
+ self.e_ident().class == elf::ELFCLASS32
+ }
+
+ fn is_class_64(&self) -> bool {
+ self.e_ident().class == elf::ELFCLASS64
+ }
+
+ fn is_little_endian(&self) -> bool {
+ self.e_ident().data == elf::ELFDATA2LSB
+ }
+
+ fn is_big_endian(&self) -> bool {
+ self.e_ident().data == elf::ELFDATA2MSB
+ }
+
+ fn endian(&self) -> read::Result<Self::Endian> {
+ Self::Endian::from_big_endian(self.is_big_endian()).read_error("Unsupported ELF endian")
+ }
+
+ /// Return the first section header, if present.
+ ///
+ /// Section 0 is a special case because getting the section headers normally
+ /// requires `shnum`, but `shnum` may be in the first section header.
+ fn section_0<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<&'data Self::SectionHeader>> {
+ let shoff: u64 = self.e_shoff(endian).into();
+ if shoff == 0 {
+ // No section headers is ok.
+ return Ok(None);
+ }
+ let shentsize = usize::from(self.e_shentsize(endian));
+ if shentsize != mem::size_of::<Self::SectionHeader>() {
+ // Section header size must match.
+ return Err(Error("Invalid ELF section header entry size"));
+ }
+ data.read_at(shoff)
+ .map(Some)
+ .read_error("Invalid ELF section header offset or size")
+ }
+
+ /// Return the `e_phnum` field of the header. Handles extended values.
+ ///
+ /// Returns `Err` for invalid values.
+ fn phnum<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<usize> {
+ let e_phnum = self.e_phnum(endian);
+ if e_phnum < elf::PN_XNUM {
+ Ok(e_phnum as usize)
+ } else if let Some(section_0) = self.section_0(endian, data)? {
+ Ok(section_0.sh_info(endian) as usize)
+ } else {
+ // Section 0 must exist if e_phnum overflows.
+ Err(Error("Missing ELF section headers for e_phnum overflow"))
+ }
+ }
+
+ /// Return the `e_shnum` field of the header. Handles extended values.
+ ///
+ /// Returns `Err` for invalid values.
+ fn shnum<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<usize> {
+ let e_shnum = self.e_shnum(endian);
+ if e_shnum > 0 {
+ Ok(e_shnum as usize)
+ } else if let Some(section_0) = self.section_0(endian, data)? {
+ section_0
+ .sh_size(endian)
+ .into()
+ .try_into()
+ .ok()
+ .read_error("Invalid ELF extended e_shnum")
+ } else {
+ // No section headers is ok.
+ Ok(0)
+ }
+ }
+
+ /// Return the `e_shstrndx` field of the header. Handles extended values.
+ ///
+ /// Returns `Err` for invalid values (including if the index is 0).
+ fn shstrndx<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<u32> {
+ let e_shstrndx = self.e_shstrndx(endian);
+ let index = if e_shstrndx != elf::SHN_XINDEX {
+ e_shstrndx.into()
+ } else if let Some(section_0) = self.section_0(endian, data)? {
+ section_0.sh_link(endian)
+ } else {
+ // Section 0 must exist if we're trying to read e_shstrndx.
+ return Err(Error("Missing ELF section headers for e_shstrndx overflow"));
+ };
+ if index == 0 {
+ return Err(Error("Missing ELF e_shstrndx"));
+ }
+ Ok(index)
+ }
+
+ /// Return the slice of program headers.
+ ///
+ /// Returns `Ok(&[])` if there are no program headers.
+ /// Returns `Err` for invalid values.
+ fn program_headers<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<&'data [Self::ProgramHeader]> {
+ let phoff: u64 = self.e_phoff(endian).into();
+ if phoff == 0 {
+ // No program headers is ok.
+ return Ok(&[]);
+ }
+ let phnum = self.phnum(endian, data)?;
+ if phnum == 0 {
+ // No program headers is ok.
+ return Ok(&[]);
+ }
+ let phentsize = self.e_phentsize(endian) as usize;
+ if phentsize != mem::size_of::<Self::ProgramHeader>() {
+ // Program header size must match.
+ return Err(Error("Invalid ELF program header entry size"));
+ }
+ data.read_slice_at(phoff, phnum)
+ .read_error("Invalid ELF program header size or alignment")
+ }
+
+ /// Return the slice of section headers.
+ ///
+ /// Returns `Ok(&[])` if there are no section headers.
+ /// Returns `Err` for invalid values.
+ fn section_headers<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<&'data [Self::SectionHeader]> {
+ let shoff: u64 = self.e_shoff(endian).into();
+ if shoff == 0 {
+ // No section headers is ok.
+ return Ok(&[]);
+ }
+ let shnum = self.shnum(endian, data)?;
+ if shnum == 0 {
+ // No section headers is ok.
+ return Ok(&[]);
+ }
+ let shentsize = usize::from(self.e_shentsize(endian));
+ if shentsize != mem::size_of::<Self::SectionHeader>() {
+ // Section header size must match.
+ return Err(Error("Invalid ELF section header entry size"));
+ }
+ data.read_slice_at(shoff, shnum)
+ .read_error("Invalid ELF section header offset/size/alignment")
+ }
+
+ /// Return the string table for the section headers.
+ fn section_strings<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ sections: &[Self::SectionHeader],
+ ) -> read::Result<StringTable<'data, R>> {
+ if sections.is_empty() {
+ return Ok(StringTable::default());
+ }
+ let index = self.shstrndx(endian, data)? as usize;
+ let shstrtab = sections.get(index).read_error("Invalid ELF e_shstrndx")?;
+ let strings = if let Some((shstrtab_offset, shstrtab_size)) = shstrtab.file_range(endian) {
+ let shstrtab_end = shstrtab_offset
+ .checked_add(shstrtab_size)
+ .read_error("Invalid ELF shstrtab size")?;
+ StringTable::new(data, shstrtab_offset, shstrtab_end)
+ } else {
+ StringTable::default()
+ };
+ Ok(strings)
+ }
+
+ /// Return the section table.
+ fn sections<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<SectionTable<'data, Self, R>> {
+ let sections = self.section_headers(endian, data)?;
+ let strings = self.section_strings(endian, data, sections)?;
+ Ok(SectionTable::new(sections, strings))
+ }
+
+ /// Returns whether this is a mips64el elf file.
+ fn is_mips64el(&self, endian: Self::Endian) -> bool {
+ self.is_class_64() && self.is_little_endian() && self.e_machine(endian) == elf::EM_MIPS
+ }
+}
+
+impl<Endian: endian::Endian> FileHeader for elf::FileHeader32<Endian> {
+ type Word = u32;
+ type Sword = i32;
+ type Endian = Endian;
+ type ProgramHeader = elf::ProgramHeader32<Endian>;
+ type SectionHeader = elf::SectionHeader32<Endian>;
+ type CompressionHeader = elf::CompressionHeader32<Endian>;
+ type NoteHeader = elf::NoteHeader32<Endian>;
+ type Dyn = elf::Dyn32<Endian>;
+ type Sym = elf::Sym32<Endian>;
+ type Rel = elf::Rel32<Endian>;
+ type Rela = elf::Rela32<Endian>;
+
+ #[inline]
+ fn is_type_64(&self) -> bool {
+ false
+ }
+
+ #[inline]
+ fn e_ident(&self) -> &elf::Ident {
+ &self.e_ident
+ }
+
+ #[inline]
+ fn e_type(&self, endian: Self::Endian) -> u16 {
+ self.e_type.get(endian)
+ }
+
+ #[inline]
+ fn e_machine(&self, endian: Self::Endian) -> u16 {
+ self.e_machine.get(endian)
+ }
+
+ #[inline]
+ fn e_version(&self, endian: Self::Endian) -> u32 {
+ self.e_version.get(endian)
+ }
+
+ #[inline]
+ fn e_entry(&self, endian: Self::Endian) -> Self::Word {
+ self.e_entry.get(endian)
+ }
+
+ #[inline]
+ fn e_phoff(&self, endian: Self::Endian) -> Self::Word {
+ self.e_phoff.get(endian)
+ }
+
+ #[inline]
+ fn e_shoff(&self, endian: Self::Endian) -> Self::Word {
+ self.e_shoff.get(endian)
+ }
+
+ #[inline]
+ fn e_flags(&self, endian: Self::Endian) -> u32 {
+ self.e_flags.get(endian)
+ }
+
+ #[inline]
+ fn e_ehsize(&self, endian: Self::Endian) -> u16 {
+ self.e_ehsize.get(endian)
+ }
+
+ #[inline]
+ fn e_phentsize(&self, endian: Self::Endian) -> u16 {
+ self.e_phentsize.get(endian)
+ }
+
+ #[inline]
+ fn e_phnum(&self, endian: Self::Endian) -> u16 {
+ self.e_phnum.get(endian)
+ }
+
+ #[inline]
+ fn e_shentsize(&self, endian: Self::Endian) -> u16 {
+ self.e_shentsize.get(endian)
+ }
+
+ #[inline]
+ fn e_shnum(&self, endian: Self::Endian) -> u16 {
+ self.e_shnum.get(endian)
+ }
+
+ #[inline]
+ fn e_shstrndx(&self, endian: Self::Endian) -> u16 {
+ self.e_shstrndx.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> FileHeader for elf::FileHeader64<Endian> {
+ type Word = u64;
+ type Sword = i64;
+ type Endian = Endian;
+ type ProgramHeader = elf::ProgramHeader64<Endian>;
+ type SectionHeader = elf::SectionHeader64<Endian>;
+ type CompressionHeader = elf::CompressionHeader64<Endian>;
+ type NoteHeader = elf::NoteHeader32<Endian>;
+ type Dyn = elf::Dyn64<Endian>;
+ type Sym = elf::Sym64<Endian>;
+ type Rel = elf::Rel64<Endian>;
+ type Rela = elf::Rela64<Endian>;
+
+ #[inline]
+ fn is_type_64(&self) -> bool {
+ true
+ }
+
+ #[inline]
+ fn e_ident(&self) -> &elf::Ident {
+ &self.e_ident
+ }
+
+ #[inline]
+ fn e_type(&self, endian: Self::Endian) -> u16 {
+ self.e_type.get(endian)
+ }
+
+ #[inline]
+ fn e_machine(&self, endian: Self::Endian) -> u16 {
+ self.e_machine.get(endian)
+ }
+
+ #[inline]
+ fn e_version(&self, endian: Self::Endian) -> u32 {
+ self.e_version.get(endian)
+ }
+
+ #[inline]
+ fn e_entry(&self, endian: Self::Endian) -> Self::Word {
+ self.e_entry.get(endian)
+ }
+
+ #[inline]
+ fn e_phoff(&self, endian: Self::Endian) -> Self::Word {
+ self.e_phoff.get(endian)
+ }
+
+ #[inline]
+ fn e_shoff(&self, endian: Self::Endian) -> Self::Word {
+ self.e_shoff.get(endian)
+ }
+
+ #[inline]
+ fn e_flags(&self, endian: Self::Endian) -> u32 {
+ self.e_flags.get(endian)
+ }
+
+ #[inline]
+ fn e_ehsize(&self, endian: Self::Endian) -> u16 {
+ self.e_ehsize.get(endian)
+ }
+
+ #[inline]
+ fn e_phentsize(&self, endian: Self::Endian) -> u16 {
+ self.e_phentsize.get(endian)
+ }
+
+ #[inline]
+ fn e_phnum(&self, endian: Self::Endian) -> u16 {
+ self.e_phnum.get(endian)
+ }
+
+ #[inline]
+ fn e_shentsize(&self, endian: Self::Endian) -> u16 {
+ self.e_shentsize.get(endian)
+ }
+
+ #[inline]
+ fn e_shnum(&self, endian: Self::Endian) -> u16 {
+ self.e_shnum.get(endian)
+ }
+
+ #[inline]
+ fn e_shstrndx(&self, endian: Self::Endian) -> u16 {
+ self.e_shstrndx.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/hash.rs b/vendor/object-0.26.2/src/read/elf/hash.rs
new file mode 100644
index 000000000..fab484e44
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/hash.rs
@@ -0,0 +1,211 @@
+use core::mem;
+
+use crate::elf;
+use crate::read::{ReadError, ReadRef, Result};
+use crate::{U32, U64};
+
+use super::{FileHeader, Sym, SymbolTable};
+
+/// A SysV symbol hash table in an ELF file.
+#[derive(Debug)]
+pub struct HashTable<'data, Elf: FileHeader> {
+ buckets: &'data [U32<Elf::Endian>],
+ chains: &'data [U32<Elf::Endian>],
+}
+
+impl<'data, Elf: FileHeader> HashTable<'data, Elf> {
+ /// Parse a SysV hash table.
+ ///
+ /// `data` should be from a `SHT_HASH` section, or from a
+ /// segment pointed to via the `DT_HASH` entry.
+ ///
+ /// The header is read at offset 0 in the given `data`.
+ pub fn parse(endian: Elf::Endian, data: &'data [u8]) -> Result<Self> {
+ let mut offset = 0;
+ let header = data
+ .read::<elf::HashHeader<Elf::Endian>>(&mut offset)
+ .read_error("Invalid hash header")?;
+ let buckets = data
+ .read_slice(&mut offset, header.bucket_count.get(endian) as usize)
+ .read_error("Invalid hash buckets")?;
+ let chains = data
+ .read_slice(&mut offset, header.chain_count.get(endian) as usize)
+ .read_error("Invalid hash chains")?;
+ Ok(HashTable { buckets, chains })
+ }
+
+ /// Return the symbol table length.
+ pub fn symbol_table_length(&self) -> u32 {
+ self.chains.len() as u32
+ }
+
+ /// Use the hash table to find the symbol table entry with the given name and hash.
+ pub fn find<R: ReadRef<'data>>(
+ &self,
+ endian: Elf::Endian,
+ name: &[u8],
+ hash: u32,
+ symbols: &SymbolTable<'data, Elf, R>,
+ ) -> Option<&'data Elf::Sym> {
+ // Get the chain start from the bucket for this hash.
+ let mut index = self.buckets[(hash as usize) % self.buckets.len()].get(endian) as usize;
+ // Avoid infinite loop.
+ let mut i = 0;
+ let strings = symbols.strings();
+ while index != 0 && i < self.chains.len() {
+ if let Ok(symbol) = symbols.symbol(index) {
+ if symbol.name(endian, strings) == Ok(name) {
+ return Some(symbol);
+ }
+ }
+ index = self.chains.get(index)?.get(endian) as usize;
+ i += 1;
+ }
+ None
+ }
+}
+
+/// A GNU symbol hash table in an ELF file.
+#[derive(Debug)]
+pub struct GnuHashTable<'data, Elf: FileHeader> {
+ symbol_base: u32,
+ bloom_shift: u32,
+ bloom_filters: &'data [u8],
+ buckets: &'data [U32<Elf::Endian>],
+ values: &'data [U32<Elf::Endian>],
+}
+
+impl<'data, Elf: FileHeader> GnuHashTable<'data, Elf> {
+ /// Parse a GNU hash table.
+ ///
+ /// `data` should be from a `SHT_GNU_HASH` section, or from a
+ /// segment pointed to via the `DT_GNU_HASH` entry.
+ ///
+ /// The header is read at offset 0 in the given `data`.
+ ///
+ /// The header does not contain a length field, and so all of `data`
+ /// will be used as the hash table values. It does not matter if this
+ /// is longer than needed, and this will often the case when accessing
+ /// the hash table via the `DT_GNU_HASH` entry.
+ pub fn parse(endian: Elf::Endian, data: &'data [u8]) -> Result<Self> {
+ let mut offset = 0;
+ let header = data
+ .read::<elf::GnuHashHeader<Elf::Endian>>(&mut offset)
+ .read_error("Invalid GNU hash header")?;
+ let bloom_len =
+ u64::from(header.bloom_count.get(endian)) * mem::size_of::<Elf::Word>() as u64;
+ let bloom_filters = data
+ .read_bytes(&mut offset, bloom_len)
+ .read_error("Invalid GNU hash bloom filters")?;
+ let buckets = data
+ .read_slice(&mut offset, header.bucket_count.get(endian) as usize)
+ .read_error("Invalid GNU hash buckets")?;
+ let chain_count = (data.len() - offset as usize) / 4;
+ let values = data
+ .read_slice(&mut offset, chain_count)
+ .read_error("Invalid GNU hash values")?;
+ Ok(GnuHashTable {
+ symbol_base: header.symbol_base.get(endian),
+ bloom_shift: header.bloom_shift.get(endian),
+ bloom_filters,
+ buckets,
+ values,
+ })
+ }
+
+ /// Return the symbol table index of the first symbol in the hash table.
+ pub fn symbol_base(&self) -> u32 {
+ self.symbol_base
+ }
+
+ /// Determine the symbol table length by finding the last entry in the hash table.
+ ///
+ /// Returns `None` if the hash table is empty or invalid.
+ pub fn symbol_table_length(&self, endian: Elf::Endian) -> Option<u32> {
+ // Ensure we find a non-empty bucket.
+ if self.symbol_base == 0 {
+ return None;
+ }
+
+ // Find the highest chain index in a bucket.
+ let mut max_symbol = 0;
+ for bucket in self.buckets {
+ let bucket = bucket.get(endian);
+ if max_symbol < bucket {
+ max_symbol = bucket;
+ }
+ }
+
+ // Find the end of the chain.
+ for value in self
+ .values
+ .get(max_symbol.checked_sub(self.symbol_base)? as usize..)?
+ {
+ max_symbol += 1;
+ if value.get(endian) & 1 != 0 {
+ return Some(max_symbol);
+ }
+ }
+
+ None
+ }
+
+ /// Use the hash table to find the symbol table entry with the given name and hash.
+ pub fn find<R: ReadRef<'data>>(
+ &self,
+ endian: Elf::Endian,
+ name: &[u8],
+ hash: u32,
+ symbols: &SymbolTable<'data, Elf, R>,
+ ) -> Option<&'data Elf::Sym> {
+ let word_bits = mem::size_of::<Elf::Word>() as u32 * 8;
+
+ // Test against bloom filter.
+ let bloom_count = self.bloom_filters.len() / mem::size_of::<Elf::Word>();
+ let offset =
+ ((hash / word_bits) & (bloom_count as u32 - 1)) * mem::size_of::<Elf::Word>() as u32;
+ let filter = if word_bits == 64 {
+ self.bloom_filters
+ .read_at::<U64<Elf::Endian>>(offset.into())
+ .ok()?
+ .get(endian)
+ } else {
+ self.bloom_filters
+ .read_at::<U32<Elf::Endian>>(offset.into())
+ .ok()?
+ .get(endian)
+ .into()
+ };
+ if filter & (1 << (hash % word_bits)) == 0 {
+ return None;
+ }
+ if filter & (1 << ((hash >> self.bloom_shift) % word_bits)) == 0 {
+ return None;
+ }
+
+ // Get the chain start from the bucket for this hash.
+ let index = self.buckets[(hash as usize) % self.buckets.len()].get(endian) as usize;
+ if index == 0 {
+ return None;
+ }
+
+ // Test symbols in the chain.
+ let strings = symbols.strings();
+ let symbols = symbols.symbols().get(index..)?;
+ let values = self
+ .values
+ .get(index.checked_sub(self.symbol_base as usize)?..)?;
+ for (symbol, value) in symbols.iter().zip(values.iter()) {
+ let value = value.get(endian);
+ if value | 1 == hash | 1 {
+ if symbol.name(endian, strings) == Ok(name) {
+ return Some(symbol);
+ }
+ }
+ if value & 1 != 0 {
+ break;
+ }
+ }
+ None
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/mod.rs b/vendor/object-0.26.2/src/read/elf/mod.rs
new file mode 100644
index 000000000..5b7d7f9f7
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/mod.rs
@@ -0,0 +1,39 @@
+//! Support for reading ELF files.
+//!
+//! Defines traits to abstract over the difference between ELF32/ELF64,
+//! and implements read functionality in terms of these traits.
+//!
+//! Also provides `ElfFile` and related types which implement the `Object` trait.
+
+mod file;
+pub use file::*;
+
+mod segment;
+pub use segment::*;
+
+mod section;
+pub use section::*;
+
+mod symbol;
+pub use symbol::*;
+
+mod relocation;
+pub use relocation::*;
+
+mod comdat;
+pub use comdat::*;
+
+mod dynamic;
+pub use dynamic::*;
+
+mod compression;
+pub use compression::*;
+
+mod note;
+pub use note::*;
+
+mod hash;
+pub use hash::*;
+
+mod version;
+pub use version::*;
diff --git a/vendor/object-0.26.2/src/read/elf/note.rs b/vendor/object-0.26.2/src/read/elf/note.rs
new file mode 100644
index 000000000..34024dbb8
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/note.rs
@@ -0,0 +1,185 @@
+use core::fmt::Debug;
+use core::mem;
+
+use crate::elf;
+use crate::endian;
+use crate::pod::Pod;
+use crate::read::util;
+use crate::read::{self, Bytes, Error, ReadError};
+
+use super::FileHeader;
+
+/// An iterator over the notes in an ELF section or segment.
+#[derive(Debug)]
+pub struct NoteIterator<'data, Elf>
+where
+ Elf: FileHeader,
+{
+ endian: Elf::Endian,
+ align: usize,
+ data: Bytes<'data>,
+}
+
+impl<'data, Elf> NoteIterator<'data, Elf>
+where
+ Elf: FileHeader,
+{
+ /// Returns `Err` if `align` is invalid.
+ pub(super) fn new(
+ endian: Elf::Endian,
+ align: Elf::Word,
+ data: &'data [u8],
+ ) -> read::Result<Self> {
+ let align = match align.into() {
+ 0u64..=4 => 4,
+ 8 => 8,
+ _ => return Err(Error("Invalid ELF note alignment")),
+ };
+ // TODO: check data alignment?
+ Ok(NoteIterator {
+ endian,
+ align,
+ data: Bytes(data),
+ })
+ }
+
+ /// Returns the next note.
+ pub fn next(&mut self) -> read::Result<Option<Note<'data, Elf>>> {
+ let mut data = self.data;
+ if data.is_empty() {
+ return Ok(None);
+ }
+
+ let header = data
+ .read_at::<Elf::NoteHeader>(0)
+ .read_error("ELF note is too short")?;
+
+ // The name has no alignment requirement.
+ let offset = mem::size_of::<Elf::NoteHeader>();
+ let namesz = header.n_namesz(self.endian) as usize;
+ let name = data
+ .read_bytes_at(offset, namesz)
+ .read_error("Invalid ELF note namesz")?
+ .0;
+
+ // The descriptor must be aligned.
+ let offset = util::align(offset + namesz, self.align);
+ let descsz = header.n_descsz(self.endian) as usize;
+ let desc = data
+ .read_bytes_at(offset, descsz)
+ .read_error("Invalid ELF note descsz")?
+ .0;
+
+ // The next note (if any) must be aligned.
+ let offset = util::align(offset + descsz, self.align);
+ if data.skip(offset).is_err() {
+ data = Bytes(&[]);
+ }
+ self.data = data;
+
+ Ok(Some(Note { header, name, desc }))
+ }
+}
+
+/// A parsed `NoteHeader`.
+#[derive(Debug)]
+pub struct Note<'data, Elf>
+where
+ Elf: FileHeader,
+{
+ header: &'data Elf::NoteHeader,
+ name: &'data [u8],
+ desc: &'data [u8],
+}
+
+impl<'data, Elf: FileHeader> Note<'data, Elf> {
+ /// Return the `n_type` field of the `NoteHeader`.
+ ///
+ /// The meaning of this field is determined by `name`.
+ pub fn n_type(&self, endian: Elf::Endian) -> u32 {
+ self.header.n_type(endian)
+ }
+
+ /// Return the `n_namesz` field of the `NoteHeader`.
+ pub fn n_namesz(&self, endian: Elf::Endian) -> u32 {
+ self.header.n_namesz(endian)
+ }
+
+ /// Return the `n_descsz` field of the `NoteHeader`.
+ pub fn n_descsz(&self, endian: Elf::Endian) -> u32 {
+ self.header.n_descsz(endian)
+ }
+
+ /// Return the bytes for the name field following the `NoteHeader`,
+ /// excluding any null terminator.
+ ///
+ /// This field is usually a string including a null terminator
+ /// (but it is not required to be).
+ ///
+ /// The length of this field (including any null terminator) is given by
+ /// `n_namesz`.
+ pub fn name(&self) -> &'data [u8] {
+ if let Some((last, name)) = self.name.split_last() {
+ if *last == 0 {
+ return name;
+ }
+ }
+ self.name
+ }
+
+ /// Return the bytes for the desc field following the `NoteHeader`.
+ ///
+ /// The length of this field is given by `n_descsz`. The meaning
+ /// of this field is determined by `name` and `n_type`.
+ pub fn desc(&self) -> &'data [u8] {
+ self.desc
+ }
+}
+
+/// A trait for generic access to `NoteHeader32` and `NoteHeader64`.
+#[allow(missing_docs)]
+pub trait NoteHeader: Debug + Pod {
+ type Endian: endian::Endian;
+
+ fn n_namesz(&self, endian: Self::Endian) -> u32;
+ fn n_descsz(&self, endian: Self::Endian) -> u32;
+ fn n_type(&self, endian: Self::Endian) -> u32;
+}
+
+impl<Endian: endian::Endian> NoteHeader for elf::NoteHeader32<Endian> {
+ type Endian = Endian;
+
+ #[inline]
+ fn n_namesz(&self, endian: Self::Endian) -> u32 {
+ self.n_namesz.get(endian)
+ }
+
+ #[inline]
+ fn n_descsz(&self, endian: Self::Endian) -> u32 {
+ self.n_descsz.get(endian)
+ }
+
+ #[inline]
+ fn n_type(&self, endian: Self::Endian) -> u32 {
+ self.n_type.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> NoteHeader for elf::NoteHeader64<Endian> {
+ type Endian = Endian;
+
+ #[inline]
+ fn n_namesz(&self, endian: Self::Endian) -> u32 {
+ self.n_namesz.get(endian)
+ }
+
+ #[inline]
+ fn n_descsz(&self, endian: Self::Endian) -> u32 {
+ self.n_descsz.get(endian)
+ }
+
+ #[inline]
+ fn n_type(&self, endian: Self::Endian) -> u32 {
+ self.n_type.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/relocation.rs b/vendor/object-0.26.2/src/read/elf/relocation.rs
new file mode 100644
index 000000000..d3e24b2e8
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/relocation.rs
@@ -0,0 +1,534 @@
+use alloc::fmt;
+use alloc::vec::Vec;
+use core::fmt::Debug;
+use core::slice;
+
+use crate::elf;
+use crate::endian::{self, Endianness};
+use crate::pod::Pod;
+use crate::read::{
+ self, Error, ReadRef, Relocation, RelocationEncoding, RelocationKind, RelocationTarget,
+ SymbolIndex,
+};
+
+use super::{ElfFile, FileHeader, SectionHeader, SectionTable};
+
+/// A mapping from section index to associated relocation sections.
+#[derive(Debug)]
+pub struct RelocationSections {
+ relocations: Vec<usize>,
+}
+
+impl RelocationSections {
+ /// Create a new mapping using the section table.
+ ///
+ /// Skips relocation sections that do not use the given symbol table section.
+ pub fn parse<'data, Elf: FileHeader, R: ReadRef<'data>>(
+ endian: Elf::Endian,
+ sections: &SectionTable<'data, Elf, R>,
+ symbol_section: usize,
+ ) -> read::Result<Self> {
+ let mut relocations = vec![0; sections.len()];
+ for (index, section) in sections.iter().enumerate().rev() {
+ let sh_type = section.sh_type(endian);
+ if sh_type == elf::SHT_REL || sh_type == elf::SHT_RELA {
+ // The symbol indices used in relocations must be for the symbol table
+ // we are expecting to use.
+ let sh_link = section.sh_link(endian) as usize;
+ if sh_link != symbol_section {
+ continue;
+ }
+
+ let sh_info = section.sh_info(endian) as usize;
+ if sh_info == 0 {
+ // Skip dynamic relocations.
+ continue;
+ }
+ if sh_info >= relocations.len() {
+ return Err(Error("Invalid ELF sh_info for relocation section"));
+ }
+
+ // Handle multiple relocation sections by chaining them.
+ let next = relocations[sh_info];
+ relocations[sh_info] = index;
+ relocations[index] = next;
+ }
+ }
+ Ok(Self { relocations })
+ }
+
+ /// Given a section index, return the section index of the associated relocation section.
+ ///
+ /// This may also be called with a relocation section index, and it will return the
+ /// next associated relocation section.
+ pub fn get(&self, index: usize) -> Option<usize> {
+ self.relocations.get(index).cloned().filter(|x| *x != 0)
+ }
+}
+
+pub(super) enum ElfRelaIterator<'data, Elf: FileHeader> {
+ Rel(slice::Iter<'data, Elf::Rel>),
+ Rela(slice::Iter<'data, Elf::Rela>),
+}
+
+impl<'data, Elf: FileHeader> ElfRelaIterator<'data, Elf> {
+ fn is_rel(&self) -> bool {
+ match self {
+ ElfRelaIterator::Rel(_) => true,
+ ElfRelaIterator::Rela(_) => false,
+ }
+ }
+}
+
+impl<'data, Elf: FileHeader> Iterator for ElfRelaIterator<'data, Elf> {
+ type Item = Elf::Rela;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ match self {
+ ElfRelaIterator::Rel(ref mut i) => i.next().cloned().map(Self::Item::from),
+ ElfRelaIterator::Rela(ref mut i) => i.next().cloned(),
+ }
+ }
+}
+
+/// An iterator over the dynamic relocations for an `ElfFile32`.
+pub type ElfDynamicRelocationIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfDynamicRelocationIterator<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// An iterator over the dynamic relocations for an `ElfFile64`.
+pub type ElfDynamicRelocationIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfDynamicRelocationIterator<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// An iterator over the dynamic relocations for an `ElfFile`.
+pub struct ElfDynamicRelocationIterator<'data, 'file, Elf, R = &'data [u8]>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ /// The current relocation section index.
+ pub(super) section_index: usize,
+ pub(super) file: &'file ElfFile<'data, Elf, R>,
+ pub(super) relocations: Option<ElfRelaIterator<'data, Elf>>,
+}
+
+impl<'data, 'file, Elf, R> Iterator for ElfDynamicRelocationIterator<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ type Item = (u64, Relocation);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let endian = self.file.endian;
+ loop {
+ if let Some(ref mut relocations) = self.relocations {
+ if let Some(reloc) = relocations.next() {
+ let relocation =
+ parse_relocation(self.file.header, endian, reloc, relocations.is_rel());
+ return Some((reloc.r_offset(endian).into(), relocation));
+ }
+ self.relocations = None;
+ }
+
+ let section = self.file.sections.section(self.section_index).ok()?;
+ self.section_index += 1;
+
+ let sh_link = section.sh_link(endian) as usize;
+ if sh_link != self.file.dynamic_symbols.section() {
+ continue;
+ }
+
+ match section.sh_type(endian) {
+ elf::SHT_REL => {
+ if let Ok(relocations) = section.data_as_array(endian, self.file.data) {
+ self.relocations = Some(ElfRelaIterator::Rel(relocations.iter()));
+ }
+ }
+ elf::SHT_RELA => {
+ if let Ok(relocations) = section.data_as_array(endian, self.file.data) {
+ self.relocations = Some(ElfRelaIterator::Rela(relocations.iter()));
+ }
+ }
+ _ => {}
+ }
+ }
+ }
+}
+
+impl<'data, 'file, Elf, R> fmt::Debug for ElfDynamicRelocationIterator<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("ElfDynamicRelocationIterator").finish()
+ }
+}
+
+/// An iterator over the relocations for an `ElfSection32`.
+pub type ElfSectionRelocationIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSectionRelocationIterator<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// An iterator over the relocations for an `ElfSection64`.
+pub type ElfSectionRelocationIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSectionRelocationIterator<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// An iterator over the relocations for an `ElfSection`.
+pub struct ElfSectionRelocationIterator<'data, 'file, Elf, R = &'data [u8]>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ /// The current pointer in the chain of relocation sections.
+ pub(super) section_index: usize,
+ pub(super) file: &'file ElfFile<'data, Elf, R>,
+ pub(super) relocations: Option<ElfRelaIterator<'data, Elf>>,
+}
+
+impl<'data, 'file, Elf, R> Iterator for ElfSectionRelocationIterator<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ type Item = (u64, Relocation);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let endian = self.file.endian;
+ loop {
+ if let Some(ref mut relocations) = self.relocations {
+ if let Some(reloc) = relocations.next() {
+ let relocation =
+ parse_relocation(self.file.header, endian, reloc, relocations.is_rel());
+ return Some((reloc.r_offset(endian).into(), relocation));
+ }
+ self.relocations = None;
+ }
+ self.section_index = self.file.relocations.get(self.section_index)?;
+ // The construction of RelocationSections ensures section_index is valid.
+ let section = self.file.sections.section(self.section_index).unwrap();
+ match section.sh_type(endian) {
+ elf::SHT_REL => {
+ if let Ok(relocations) = section.data_as_array(endian, self.file.data) {
+ self.relocations = Some(ElfRelaIterator::Rel(relocations.iter()));
+ }
+ }
+ elf::SHT_RELA => {
+ if let Ok(relocations) = section.data_as_array(endian, self.file.data) {
+ self.relocations = Some(ElfRelaIterator::Rela(relocations.iter()));
+ }
+ }
+ _ => {}
+ }
+ }
+ }
+}
+
+impl<'data, 'file, Elf, R> fmt::Debug for ElfSectionRelocationIterator<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("ElfSectionRelocationIterator").finish()
+ }
+}
+
+fn parse_relocation<Elf: FileHeader>(
+ header: &Elf,
+ endian: Elf::Endian,
+ reloc: Elf::Rela,
+ implicit_addend: bool,
+) -> Relocation {
+ let mut encoding = RelocationEncoding::Generic;
+ let is_mips64el = header.is_mips64el(endian);
+ let (kind, size) = match header.e_machine(endian) {
+ elf::EM_AARCH64 => match reloc.r_type(endian, false) {
+ elf::R_AARCH64_ABS64 => (RelocationKind::Absolute, 64),
+ elf::R_AARCH64_ABS32 => (RelocationKind::Absolute, 32),
+ elf::R_AARCH64_ABS16 => (RelocationKind::Absolute, 16),
+ elf::R_AARCH64_PREL64 => (RelocationKind::Relative, 64),
+ elf::R_AARCH64_PREL32 => (RelocationKind::Relative, 32),
+ elf::R_AARCH64_PREL16 => (RelocationKind::Relative, 16),
+ elf::R_AARCH64_CALL26 => {
+ encoding = RelocationEncoding::AArch64Call;
+ (RelocationKind::PltRelative, 26)
+ }
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_ARM => match reloc.r_type(endian, false) {
+ elf::R_ARM_ABS32 => (RelocationKind::Absolute, 32),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_AVR => match reloc.r_type(endian, false) {
+ elf::R_AVR_32 => (RelocationKind::Absolute, 32),
+ elf::R_AVR_16 => (RelocationKind::Absolute, 16),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_BPF => match reloc.r_type(endian, false) {
+ elf::R_BPF_64_64 => (RelocationKind::Absolute, 64),
+ elf::R_BPF_64_32 => (RelocationKind::Absolute, 32),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_386 => match reloc.r_type(endian, false) {
+ elf::R_386_32 => (RelocationKind::Absolute, 32),
+ elf::R_386_PC32 => (RelocationKind::Relative, 32),
+ elf::R_386_GOT32 => (RelocationKind::Got, 32),
+ elf::R_386_PLT32 => (RelocationKind::PltRelative, 32),
+ elf::R_386_GOTOFF => (RelocationKind::GotBaseOffset, 32),
+ elf::R_386_GOTPC => (RelocationKind::GotBaseRelative, 32),
+ elf::R_386_16 => (RelocationKind::Absolute, 16),
+ elf::R_386_PC16 => (RelocationKind::Relative, 16),
+ elf::R_386_8 => (RelocationKind::Absolute, 8),
+ elf::R_386_PC8 => (RelocationKind::Relative, 8),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_X86_64 => match reloc.r_type(endian, false) {
+ elf::R_X86_64_64 => (RelocationKind::Absolute, 64),
+ elf::R_X86_64_PC32 => (RelocationKind::Relative, 32),
+ elf::R_X86_64_GOT32 => (RelocationKind::Got, 32),
+ elf::R_X86_64_PLT32 => (RelocationKind::PltRelative, 32),
+ elf::R_X86_64_GOTPCREL => (RelocationKind::GotRelative, 32),
+ elf::R_X86_64_32 => (RelocationKind::Absolute, 32),
+ elf::R_X86_64_32S => {
+ encoding = RelocationEncoding::X86Signed;
+ (RelocationKind::Absolute, 32)
+ }
+ elf::R_X86_64_16 => (RelocationKind::Absolute, 16),
+ elf::R_X86_64_PC16 => (RelocationKind::Relative, 16),
+ elf::R_X86_64_8 => (RelocationKind::Absolute, 8),
+ elf::R_X86_64_PC8 => (RelocationKind::Relative, 8),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_HEXAGON => match reloc.r_type(endian, false) {
+ elf::R_HEX_32 => (RelocationKind::Absolute, 32),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_MIPS => match reloc.r_type(endian, is_mips64el) {
+ elf::R_MIPS_16 => (RelocationKind::Absolute, 16),
+ elf::R_MIPS_32 => (RelocationKind::Absolute, 32),
+ elf::R_MIPS_64 => (RelocationKind::Absolute, 64),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_MSP430 => match reloc.r_type(endian, false) {
+ elf::R_MSP430_32 => (RelocationKind::Absolute, 32),
+ elf::R_MSP430_16_BYTE => (RelocationKind::Absolute, 16),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_PPC => match reloc.r_type(endian, false) {
+ elf::R_PPC_ADDR32 => (RelocationKind::Absolute, 32),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_PPC64 => match reloc.r_type(endian, false) {
+ elf::R_PPC64_ADDR32 => (RelocationKind::Absolute, 32),
+ elf::R_PPC64_ADDR64 => (RelocationKind::Absolute, 64),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_RISCV => match reloc.r_type(endian, false) {
+ elf::R_RISCV_32 => (RelocationKind::Absolute, 32),
+ elf::R_RISCV_64 => (RelocationKind::Absolute, 64),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_S390 => match reloc.r_type(endian, false) {
+ elf::R_390_8 => (RelocationKind::Absolute, 8),
+ elf::R_390_16 => (RelocationKind::Absolute, 16),
+ elf::R_390_32 => (RelocationKind::Absolute, 32),
+ elf::R_390_64 => (RelocationKind::Absolute, 64),
+ elf::R_390_PC16 => (RelocationKind::Relative, 16),
+ elf::R_390_PC32 => (RelocationKind::Relative, 32),
+ elf::R_390_PC64 => (RelocationKind::Relative, 64),
+ elf::R_390_PC16DBL => {
+ encoding = RelocationEncoding::S390xDbl;
+ (RelocationKind::Relative, 16)
+ }
+ elf::R_390_PC32DBL => {
+ encoding = RelocationEncoding::S390xDbl;
+ (RelocationKind::Relative, 32)
+ }
+ elf::R_390_PLT16DBL => {
+ encoding = RelocationEncoding::S390xDbl;
+ (RelocationKind::PltRelative, 16)
+ }
+ elf::R_390_PLT32DBL => {
+ encoding = RelocationEncoding::S390xDbl;
+ (RelocationKind::PltRelative, 32)
+ }
+ elf::R_390_GOT16 => (RelocationKind::Got, 16),
+ elf::R_390_GOT32 => (RelocationKind::Got, 32),
+ elf::R_390_GOT64 => (RelocationKind::Got, 64),
+ elf::R_390_GOTENT => {
+ encoding = RelocationEncoding::S390xDbl;
+ (RelocationKind::GotRelative, 32)
+ }
+ elf::R_390_GOTOFF16 => (RelocationKind::GotBaseOffset, 16),
+ elf::R_390_GOTOFF32 => (RelocationKind::GotBaseOffset, 32),
+ elf::R_390_GOTOFF64 => (RelocationKind::GotBaseOffset, 64),
+ elf::R_390_GOTPC => (RelocationKind::GotBaseRelative, 64),
+ elf::R_390_GOTPCDBL => {
+ encoding = RelocationEncoding::S390xDbl;
+ (RelocationKind::GotBaseRelative, 32)
+ }
+ r_type => (RelocationKind::Elf(r_type), 0),
+ },
+ elf::EM_SPARC | elf::EM_SPARC32PLUS | elf::EM_SPARCV9 => {
+ match reloc.r_type(endian, false) {
+ elf::R_SPARC_32 | elf::R_SPARC_UA32 => (RelocationKind::Absolute, 32),
+ elf::R_SPARC_64 | elf::R_SPARC_UA64 => (RelocationKind::Absolute, 64),
+ r_type => (RelocationKind::Elf(r_type), 0),
+ }
+ }
+ _ => (RelocationKind::Elf(reloc.r_type(endian, false)), 0),
+ };
+ let sym = reloc.r_sym(endian, is_mips64el) as usize;
+ let target = if sym == 0 {
+ RelocationTarget::Absolute
+ } else {
+ RelocationTarget::Symbol(SymbolIndex(sym))
+ };
+ Relocation {
+ kind,
+ encoding,
+ size,
+ target,
+ addend: reloc.r_addend(endian).into(),
+ implicit_addend,
+ }
+}
+
+/// A trait for generic access to `Rel32` and `Rel64`.
+#[allow(missing_docs)]
+pub trait Rel: Debug + Pod + Clone {
+ type Word: Into<u64>;
+ type Sword: Into<i64>;
+ type Endian: endian::Endian;
+
+ fn r_offset(&self, endian: Self::Endian) -> Self::Word;
+ fn r_info(&self, endian: Self::Endian) -> Self::Word;
+ fn r_sym(&self, endian: Self::Endian) -> u32;
+ fn r_type(&self, endian: Self::Endian) -> u32;
+}
+
+impl<Endian: endian::Endian> Rel for elf::Rel32<Endian> {
+ type Word = u32;
+ type Sword = i32;
+ type Endian = Endian;
+
+ #[inline]
+ fn r_offset(&self, endian: Self::Endian) -> Self::Word {
+ self.r_offset.get(endian)
+ }
+
+ #[inline]
+ fn r_info(&self, endian: Self::Endian) -> Self::Word {
+ self.r_info.get(endian)
+ }
+
+ #[inline]
+ fn r_sym(&self, endian: Self::Endian) -> u32 {
+ self.r_sym(endian)
+ }
+
+ #[inline]
+ fn r_type(&self, endian: Self::Endian) -> u32 {
+ self.r_type(endian)
+ }
+}
+
+impl<Endian: endian::Endian> Rel for elf::Rel64<Endian> {
+ type Word = u64;
+ type Sword = i64;
+ type Endian = Endian;
+
+ #[inline]
+ fn r_offset(&self, endian: Self::Endian) -> Self::Word {
+ self.r_offset.get(endian)
+ }
+
+ #[inline]
+ fn r_info(&self, endian: Self::Endian) -> Self::Word {
+ self.r_info.get(endian)
+ }
+
+ #[inline]
+ fn r_sym(&self, endian: Self::Endian) -> u32 {
+ self.r_sym(endian)
+ }
+
+ #[inline]
+ fn r_type(&self, endian: Self::Endian) -> u32 {
+ self.r_type(endian)
+ }
+}
+
+/// A trait for generic access to `Rela32` and `Rela64`.
+#[allow(missing_docs)]
+pub trait Rela: Debug + Pod + Clone {
+ type Word: Into<u64>;
+ type Sword: Into<i64>;
+ type Endian: endian::Endian;
+
+ fn r_offset(&self, endian: Self::Endian) -> Self::Word;
+ fn r_info(&self, endian: Self::Endian, is_mips64el: bool) -> Self::Word;
+ fn r_addend(&self, endian: Self::Endian) -> Self::Sword;
+ fn r_sym(&self, endian: Self::Endian, is_mips64el: bool) -> u32;
+ fn r_type(&self, endian: Self::Endian, is_mips64el: bool) -> u32;
+}
+
+impl<Endian: endian::Endian> Rela for elf::Rela32<Endian> {
+ type Word = u32;
+ type Sword = i32;
+ type Endian = Endian;
+
+ #[inline]
+ fn r_offset(&self, endian: Self::Endian) -> Self::Word {
+ self.r_offset.get(endian)
+ }
+
+ #[inline]
+ fn r_info(&self, endian: Self::Endian, _is_mips64el: bool) -> Self::Word {
+ self.r_info.get(endian)
+ }
+
+ #[inline]
+ fn r_addend(&self, endian: Self::Endian) -> Self::Sword {
+ self.r_addend.get(endian)
+ }
+
+ #[inline]
+ fn r_sym(&self, endian: Self::Endian, _is_mips64el: bool) -> u32 {
+ self.r_sym(endian)
+ }
+
+ #[inline]
+ fn r_type(&self, endian: Self::Endian, _is_mips64el: bool) -> u32 {
+ self.r_type(endian)
+ }
+}
+
+impl<Endian: endian::Endian> Rela for elf::Rela64<Endian> {
+ type Word = u64;
+ type Sword = i64;
+ type Endian = Endian;
+
+ #[inline]
+ fn r_offset(&self, endian: Self::Endian) -> Self::Word {
+ self.r_offset.get(endian)
+ }
+
+ #[inline]
+ fn r_info(&self, endian: Self::Endian, is_mips64el: bool) -> Self::Word {
+ self.get_r_info(endian, is_mips64el)
+ }
+
+ #[inline]
+ fn r_addend(&self, endian: Self::Endian) -> Self::Sword {
+ self.r_addend.get(endian)
+ }
+
+ #[inline]
+ fn r_sym(&self, endian: Self::Endian, is_mips64el: bool) -> u32 {
+ self.r_sym(endian, is_mips64el)
+ }
+
+ #[inline]
+ fn r_type(&self, endian: Self::Endian, is_mips64el: bool) -> u32 {
+ self.r_type(endian, is_mips64el)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/section.rs b/vendor/object-0.26.2/src/read/elf/section.rs
new file mode 100644
index 000000000..5d8999229
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/section.rs
@@ -0,0 +1,970 @@
+use core::fmt::Debug;
+use core::{iter, mem, slice, str};
+
+use crate::elf;
+use crate::endian::{self, Endianness, U32Bytes};
+use crate::pod::Pod;
+use crate::read::{
+ self, Bytes, CompressedData, CompressedFileRange, CompressionFormat, Error, ObjectSection,
+ ReadError, ReadRef, SectionFlags, SectionIndex, SectionKind, StringTable,
+};
+
+use super::{
+ CompressionHeader, ElfFile, ElfSectionRelocationIterator, FileHeader, GnuHashTable, HashTable,
+ NoteIterator, RelocationSections, SymbolTable, VerdefIterator, VerneedIterator,
+};
+
+/// The table of section headers in an ELF file.
+///
+/// Also includes the string table used for the section names.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct SectionTable<'data, Elf: FileHeader, R = &'data [u8]>
+where
+ R: ReadRef<'data>,
+{
+ sections: &'data [Elf::SectionHeader],
+ strings: StringTable<'data, R>,
+}
+
+impl<'data, Elf: FileHeader, R: ReadRef<'data>> SectionTable<'data, Elf, R> {
+ /// Create a new section table.
+ #[inline]
+ pub fn new(sections: &'data [Elf::SectionHeader], strings: StringTable<'data, R>) -> Self {
+ SectionTable { sections, strings }
+ }
+
+ /// Iterate over the section headers.
+ #[inline]
+ pub fn iter(&self) -> slice::Iter<'data, Elf::SectionHeader> {
+ self.sections.iter()
+ }
+
+ /// Return true if the section table is empty.
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.sections.is_empty()
+ }
+
+ /// The number of section headers.
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.sections.len()
+ }
+
+ /// Return the section header at the given index.
+ pub fn section(&self, index: usize) -> read::Result<&'data Elf::SectionHeader> {
+ self.sections
+ .get(index)
+ .read_error("Invalid ELF section index")
+ }
+
+ /// Return the section header with the given name.
+ ///
+ /// Ignores sections with invalid names.
+ pub fn section_by_name(
+ &self,
+ endian: Elf::Endian,
+ name: &[u8],
+ ) -> Option<(usize, &'data Elf::SectionHeader)> {
+ self.sections
+ .iter()
+ .enumerate()
+ .find(|(_, section)| self.section_name(endian, section) == Ok(name))
+ }
+
+ /// Return the section name for the given section header.
+ pub fn section_name(
+ &self,
+ endian: Elf::Endian,
+ section: &'data Elf::SectionHeader,
+ ) -> read::Result<&'data [u8]> {
+ section.name(endian, self.strings)
+ }
+
+ /// Return the symbol table of the given section type.
+ ///
+ /// Returns an empty symbol table if the symbol table does not exist.
+ #[inline]
+ pub fn symbols(
+ &self,
+ endian: Elf::Endian,
+ data: R,
+ sh_type: u32,
+ ) -> read::Result<SymbolTable<'data, Elf, R>> {
+ debug_assert!(sh_type == elf::SHT_DYNSYM || sh_type == elf::SHT_SYMTAB);
+
+ let (index, section) = match self
+ .iter()
+ .enumerate()
+ .find(|s| s.1.sh_type(endian) == sh_type)
+ {
+ Some(s) => s,
+ None => return Ok(SymbolTable::default()),
+ };
+
+ SymbolTable::parse(endian, data, self, index, section)
+ }
+
+ /// Return the symbol table at the given section index.
+ ///
+ /// Returns an error if the section is not a symbol table.
+ #[inline]
+ pub fn symbol_table_by_index(
+ &self,
+ endian: Elf::Endian,
+ data: R,
+ index: usize,
+ ) -> read::Result<SymbolTable<'data, Elf, R>> {
+ let section = self.section(index)?;
+ match section.sh_type(endian) {
+ elf::SHT_DYNSYM | elf::SHT_SYMTAB => {}
+ _ => return Err(Error("Invalid ELF symbol table section type.")),
+ }
+ SymbolTable::parse(endian, data, self, index, section)
+ }
+
+ /// Create a mapping from section index to associated relocation sections.
+ #[inline]
+ pub fn relocation_sections(
+ &self,
+ endian: Elf::Endian,
+ symbol_section: usize,
+ ) -> read::Result<RelocationSections> {
+ RelocationSections::parse(endian, self, symbol_section)
+ }
+
+ /// Return the header of a SysV hash section.
+ ///
+ /// Returns `Ok(None)` if there is no SysV GNU hash section.
+ /// Returns `Err` for invalid values.
+ pub fn hash_header(
+ &self,
+ endian: Elf::Endian,
+ data: R,
+ ) -> read::Result<Option<&'data elf::HashHeader<Elf::Endian>>> {
+ for section in self.sections {
+ if let Some(hash) = section.hash_header(endian, data)? {
+ return Ok(Some(hash));
+ }
+ }
+ Ok(None)
+ }
+
+ /// Return the contents of a SysV hash section.
+ ///
+ /// Returns `Ok(None)` if there is no SysV hash section.
+ /// Returns `Err` for invalid values.
+ pub fn hash(
+ &self,
+ endian: Elf::Endian,
+ data: R,
+ ) -> read::Result<Option<HashTable<'data, Elf>>> {
+ for section in self.sections {
+ if let Some(hash) = section.hash(endian, data)? {
+ return Ok(Some(hash));
+ }
+ }
+ Ok(None)
+ }
+
+ /// Return the header of a GNU hash section.
+ ///
+ /// Returns `Ok(None)` if there is no GNU hash section.
+ /// Returns `Err` for invalid values.
+ pub fn gnu_hash_header(
+ &self,
+ endian: Elf::Endian,
+ data: R,
+ ) -> read::Result<Option<&'data elf::GnuHashHeader<Elf::Endian>>> {
+ for section in self.sections {
+ if let Some(hash) = section.gnu_hash_header(endian, data)? {
+ return Ok(Some(hash));
+ }
+ }
+ Ok(None)
+ }
+
+ /// Return the contents of a GNU hash section.
+ ///
+ /// Returns `Ok(None)` if there is no GNU hash section.
+ /// Returns `Err` for invalid values.
+ pub fn gnu_hash(
+ &self,
+ endian: Elf::Endian,
+ data: R,
+ ) -> read::Result<Option<GnuHashTable<'data, Elf>>> {
+ for section in self.sections {
+ if let Some(hash) = section.gnu_hash(endian, data)? {
+ return Ok(Some(hash));
+ }
+ }
+ Ok(None)
+ }
+
+ /// Return the contents of a `SHT_GNU_VERSYM` section.
+ ///
+ /// Returns `Ok(None)` if there is no `SHT_GNU_VERSYM` section.
+ /// Returns `Err` for invalid values.
+ pub fn gnu_versym(
+ &self,
+ endian: Elf::Endian,
+ data: R,
+ ) -> read::Result<Option<&'data [elf::Versym<Elf::Endian>]>> {
+ for section in self.sections {
+ if let Some(syms) = section.gnu_versym(endian, data)? {
+ return Ok(Some(syms));
+ }
+ }
+ Ok(None)
+ }
+
+ /// Return the contents of a `SHT_GNU_VERDEF` section.
+ ///
+ /// Returns `Ok(None)` if there is no `SHT_GNU_VERDEF` section.
+ /// Returns `Err` for invalid values.
+ pub fn gnu_verdef(
+ &self,
+ endian: Elf::Endian,
+ data: R,
+ ) -> read::Result<Option<VerdefIterator<'data, Elf>>> {
+ for section in self.sections {
+ if let Some(defs) = section.gnu_verdef(endian, data)? {
+ return Ok(Some(defs));
+ }
+ }
+ Ok(None)
+ }
+
+ /// Return the contents of a `SHT_GNU_VERNEED` section.
+ ///
+ /// Returns `Ok(None)` if there is no `SHT_GNU_VERNEED` section.
+ /// Returns `Err` for invalid values.
+ pub fn gnu_verneed(
+ &self,
+ endian: Elf::Endian,
+ data: R,
+ ) -> read::Result<Option<VerneedIterator<'data, Elf>>> {
+ for section in self.sections {
+ if let Some(needs) = section.gnu_verneed(endian, data)? {
+ return Ok(Some(needs));
+ }
+ }
+ Ok(None)
+ }
+}
+
+/// An iterator over the sections of an `ElfFile32`.
+pub type ElfSectionIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSectionIterator<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// An iterator over the sections of an `ElfFile64`.
+pub type ElfSectionIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSectionIterator<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// An iterator over the sections of an `ElfFile`.
+#[derive(Debug)]
+pub struct ElfSectionIterator<'data, 'file, Elf, R = &'data [u8]>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file ElfFile<'data, Elf, R>,
+ pub(super) iter: iter::Enumerate<slice::Iter<'data, Elf::SectionHeader>>,
+}
+
+impl<'data, 'file, Elf, R> Iterator for ElfSectionIterator<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ type Item = ElfSection<'data, 'file, Elf, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.iter.next().map(|(index, section)| ElfSection {
+ index: SectionIndex(index),
+ file: self.file,
+ section,
+ })
+ }
+}
+
+/// A section of an `ElfFile32`.
+pub type ElfSection32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSection<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// A section of an `ElfFile64`.
+pub type ElfSection64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSection<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// A section of an `ElfFile`.
+#[derive(Debug)]
+pub struct ElfSection<'data, 'file, Elf, R = &'data [u8]>
+where
+ 'data: 'file,
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file ElfFile<'data, Elf, R>,
+ pub(super) index: SectionIndex,
+ pub(super) section: &'data Elf::SectionHeader,
+}
+
+impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> ElfSection<'data, 'file, Elf, R> {
+ fn bytes(&self) -> read::Result<&'data [u8]> {
+ self.section
+ .data(self.file.endian, self.file.data)
+ .read_error("Invalid ELF section size or offset")
+ }
+
+ fn maybe_compressed(&self) -> read::Result<Option<CompressedFileRange>> {
+ let endian = self.file.endian;
+ if (self.section.sh_flags(endian).into() & u64::from(elf::SHF_COMPRESSED)) == 0 {
+ return Ok(None);
+ }
+ let (section_offset, section_size) = self
+ .section
+ .file_range(endian)
+ .read_error("Invalid ELF compressed section type")?;
+ let mut offset = section_offset;
+ let header = self
+ .file
+ .data
+ .read::<Elf::CompressionHeader>(&mut offset)
+ .read_error("Invalid ELF compressed section offset")?;
+ if header.ch_type(endian) != elf::ELFCOMPRESS_ZLIB {
+ return Err(Error("Unsupported ELF compression type"));
+ }
+ let uncompressed_size = header.ch_size(endian).into();
+ let compressed_size = section_size
+ .checked_sub(offset - section_offset)
+ .read_error("Invalid ELF compressed section size")?;
+ Ok(Some(CompressedFileRange {
+ format: CompressionFormat::Zlib,
+ offset,
+ compressed_size,
+ uncompressed_size,
+ }))
+ }
+
+ /// Try GNU-style "ZLIB" header decompression.
+ fn maybe_compressed_gnu(&self) -> read::Result<Option<CompressedFileRange>> {
+ let name = match self.name() {
+ Ok(name) => name,
+ // I think it's ok to ignore this error?
+ Err(_) => return Ok(None),
+ };
+ if !name.starts_with(".zdebug_") {
+ return Ok(None);
+ }
+ let (section_offset, section_size) = self
+ .section
+ .file_range(self.file.endian)
+ .read_error("Invalid ELF GNU compressed section type")?;
+ let mut offset = section_offset;
+ let data = self.file.data;
+ // Assume ZLIB-style uncompressed data is no more than 4GB to avoid accidentally
+ // huge allocations. This also reduces the chance of accidentally matching on a
+ // .debug_str that happens to start with "ZLIB".
+ if data
+ .read_bytes(&mut offset, 8)
+ .read_error("ELF GNU compressed section is too short")?
+ != b"ZLIB\0\0\0\0"
+ {
+ return Err(Error("Invalid ELF GNU compressed section header"));
+ }
+ let uncompressed_size = data
+ .read::<U32Bytes<_>>(&mut offset)
+ .read_error("ELF GNU compressed section is too short")?
+ .get(endian::BigEndian)
+ .into();
+ let compressed_size = section_size
+ .checked_sub(offset - section_offset)
+ .read_error("ELF GNU compressed section is too short")?;
+ Ok(Some(CompressedFileRange {
+ format: CompressionFormat::Zlib,
+ offset,
+ compressed_size,
+ uncompressed_size,
+ }))
+ }
+}
+
+impl<'data, 'file, Elf, R> read::private::Sealed for ElfSection<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Elf, R> ObjectSection<'data> for ElfSection<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ type RelocationIterator = ElfSectionRelocationIterator<'data, 'file, Elf, R>;
+
+ #[inline]
+ fn index(&self) -> SectionIndex {
+ self.index
+ }
+
+ #[inline]
+ fn address(&self) -> u64 {
+ self.section.sh_addr(self.file.endian).into()
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ self.section.sh_size(self.file.endian).into()
+ }
+
+ #[inline]
+ fn align(&self) -> u64 {
+ self.section.sh_addralign(self.file.endian).into()
+ }
+
+ #[inline]
+ fn file_range(&self) -> Option<(u64, u64)> {
+ self.section.file_range(self.file.endian)
+ }
+
+ #[inline]
+ fn data(&self) -> read::Result<&'data [u8]> {
+ self.bytes()
+ }
+
+ fn data_range(&self, address: u64, size: u64) -> read::Result<Option<&'data [u8]>> {
+ Ok(read::util::data_range(
+ self.bytes()?,
+ self.address(),
+ address,
+ size,
+ ))
+ }
+
+ fn compressed_file_range(&self) -> read::Result<CompressedFileRange> {
+ Ok(if let Some(data) = self.maybe_compressed()? {
+ data
+ } else if let Some(data) = self.maybe_compressed_gnu()? {
+ data
+ } else {
+ CompressedFileRange::none(self.file_range())
+ })
+ }
+
+ fn compressed_data(&self) -> read::Result<CompressedData<'data>> {
+ self.compressed_file_range()?.data(self.file.data)
+ }
+
+ fn name(&self) -> read::Result<&str> {
+ let name = self
+ .file
+ .sections
+ .section_name(self.file.endian, self.section)?;
+ str::from_utf8(name)
+ .ok()
+ .read_error("Non UTF-8 ELF section name")
+ }
+
+ #[inline]
+ fn segment_name(&self) -> read::Result<Option<&str>> {
+ Ok(None)
+ }
+
+ fn kind(&self) -> SectionKind {
+ let flags = self.section.sh_flags(self.file.endian).into();
+ let sh_type = self.section.sh_type(self.file.endian);
+ match sh_type {
+ elf::SHT_PROGBITS => {
+ if flags & u64::from(elf::SHF_ALLOC) != 0 {
+ if flags & u64::from(elf::SHF_EXECINSTR) != 0 {
+ SectionKind::Text
+ } else if flags & u64::from(elf::SHF_TLS) != 0 {
+ SectionKind::Tls
+ } else if flags & u64::from(elf::SHF_WRITE) != 0 {
+ SectionKind::Data
+ } else if flags & u64::from(elf::SHF_STRINGS) != 0 {
+ SectionKind::ReadOnlyString
+ } else {
+ SectionKind::ReadOnlyData
+ }
+ } else if flags & u64::from(elf::SHF_STRINGS) != 0 {
+ SectionKind::OtherString
+ } else {
+ SectionKind::Other
+ }
+ }
+ elf::SHT_NOBITS => {
+ if flags & u64::from(elf::SHF_TLS) != 0 {
+ SectionKind::UninitializedTls
+ } else {
+ SectionKind::UninitializedData
+ }
+ }
+ elf::SHT_NOTE => SectionKind::Note,
+ elf::SHT_NULL
+ | elf::SHT_SYMTAB
+ | elf::SHT_STRTAB
+ | elf::SHT_RELA
+ | elf::SHT_HASH
+ | elf::SHT_DYNAMIC
+ | elf::SHT_REL
+ | elf::SHT_DYNSYM
+ | elf::SHT_GROUP => SectionKind::Metadata,
+ _ => SectionKind::Elf(sh_type),
+ }
+ }
+
+ fn relocations(&self) -> ElfSectionRelocationIterator<'data, 'file, Elf, R> {
+ ElfSectionRelocationIterator {
+ section_index: self.index.0,
+ file: self.file,
+ relocations: None,
+ }
+ }
+
+ fn flags(&self) -> SectionFlags {
+ SectionFlags::Elf {
+ sh_flags: self.section.sh_flags(self.file.endian).into(),
+ }
+ }
+}
+
+/// A trait for generic access to `SectionHeader32` and `SectionHeader64`.
+#[allow(missing_docs)]
+pub trait SectionHeader: Debug + Pod {
+ type Elf: FileHeader<SectionHeader = Self, Endian = Self::Endian, Word = Self::Word>;
+ type Word: Into<u64>;
+ type Endian: endian::Endian;
+
+ fn sh_name(&self, endian: Self::Endian) -> u32;
+ fn sh_type(&self, endian: Self::Endian) -> u32;
+ fn sh_flags(&self, endian: Self::Endian) -> Self::Word;
+ fn sh_addr(&self, endian: Self::Endian) -> Self::Word;
+ fn sh_offset(&self, endian: Self::Endian) -> Self::Word;
+ fn sh_size(&self, endian: Self::Endian) -> Self::Word;
+ fn sh_link(&self, endian: Self::Endian) -> u32;
+ fn sh_info(&self, endian: Self::Endian) -> u32;
+ fn sh_addralign(&self, endian: Self::Endian) -> Self::Word;
+ fn sh_entsize(&self, endian: Self::Endian) -> Self::Word;
+
+ /// Parse the section name from the string table.
+ fn name<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ strings: StringTable<'data, R>,
+ ) -> read::Result<&'data [u8]> {
+ strings
+ .get(self.sh_name(endian))
+ .read_error("Invalid ELF section name offset")
+ }
+
+ /// Return the offset and size of the section in the file.
+ ///
+ /// Returns `None` for sections that have no data in the file.
+ fn file_range(&self, endian: Self::Endian) -> Option<(u64, u64)> {
+ if self.sh_type(endian) == elf::SHT_NOBITS {
+ None
+ } else {
+ Some((self.sh_offset(endian).into(), self.sh_size(endian).into()))
+ }
+ }
+
+ /// Return the section data.
+ ///
+ /// Returns `Ok(&[])` if the section has no data.
+ /// Returns `Err` for invalid values.
+ fn data<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<&'data [u8]> {
+ if let Some((offset, size)) = self.file_range(endian) {
+ data.read_bytes_at(offset, size)
+ .read_error("Invalid ELF section size or offset")
+ } else {
+ Ok(&[])
+ }
+ }
+
+ /// Return the section data as a slice of the given type.
+ ///
+ /// Allows padding at the end of the data.
+ /// Returns `Ok(&[])` if the section has no data.
+ /// Returns `Err` for invalid values, including bad alignment.
+ fn data_as_array<'data, T: Pod, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<&'data [T]> {
+ let mut data = self.data(endian, data).map(Bytes)?;
+ data.read_slice(data.len() / mem::size_of::<T>())
+ .read_error("Invalid ELF section size or offset")
+ }
+
+ /// Return the symbols in the section.
+ ///
+ /// Also finds the corresponding string table in `sections`.
+ ///
+ /// `section_index` must be the 0-based index of this section, and is used
+ /// to find the corresponding extended section index table in `sections`.
+ ///
+ /// Returns `Ok(None)` if the section does not contain symbols.
+ /// Returns `Err` for invalid values.
+ fn symbols<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ sections: &SectionTable<'data, Self::Elf, R>,
+ section_index: usize,
+ ) -> read::Result<Option<SymbolTable<'data, Self::Elf, R>>> {
+ let sh_type = self.sh_type(endian);
+ if sh_type != elf::SHT_SYMTAB && sh_type != elf::SHT_DYNSYM {
+ return Ok(None);
+ }
+ SymbolTable::parse(endian, data, sections, section_index, self).map(Some)
+ }
+
+ /// Return the `Elf::Rel` entries in the section.
+ ///
+ /// Returns `Ok(None)` if the section does not contain relocations.
+ /// Returns `Err` for invalid values.
+ fn rel<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<&'data [<Self::Elf as FileHeader>::Rel]>> {
+ if self.sh_type(endian) != elf::SHT_REL {
+ return Ok(None);
+ }
+ self.data_as_array(endian, data)
+ .map(Some)
+ .read_error("Invalid ELF relocation section offset or size")
+ }
+
+ /// Return the `Elf::Rela` entries in the section.
+ ///
+ /// Returns `Ok(None)` if the section does not contain relocations.
+ /// Returns `Err` for invalid values.
+ fn rela<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<&'data [<Self::Elf as FileHeader>::Rela]>> {
+ if self.sh_type(endian) != elf::SHT_RELA {
+ return Ok(None);
+ }
+ self.data_as_array(endian, data)
+ .map(Some)
+ .read_error("Invalid ELF relocation section offset or size")
+ }
+
+ /// Return the symbol table for a relocation section.
+ ///
+ /// Returns `Err` for invalid values, including if the section does not contain
+ /// relocations.
+ fn relocation_symbols<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ sections: &SectionTable<'data, Self::Elf, R>,
+ ) -> read::Result<SymbolTable<'data, Self::Elf, R>> {
+ let sh_type = self.sh_type(endian);
+ if sh_type != elf::SHT_REL && sh_type != elf::SHT_RELA {
+ return Err(Error("Invalid ELF relocation section type"));
+ }
+ sections.symbol_table_by_index(endian, data, self.sh_link(endian) as usize)
+ }
+
+ /// Return a note iterator for the section data.
+ ///
+ /// Returns `Ok(None)` if the section does not contain notes.
+ /// Returns `Err` for invalid values.
+ fn notes<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<NoteIterator<'data, Self::Elf>>> {
+ if self.sh_type(endian) != elf::SHT_NOTE {
+ return Ok(None);
+ }
+ let data = self
+ .data(endian, data)
+ .read_error("Invalid ELF note section offset or size")?;
+ let notes = NoteIterator::new(endian, self.sh_addralign(endian), data)?;
+ Ok(Some(notes))
+ }
+
+ /// Return the contents of a group section.
+ ///
+ /// The first value is a `GRP_*` value, and the remaining values
+ /// are section indices.
+ ///
+ /// Returns `Ok(None)` if the section does not define a group.
+ /// Returns `Err` for invalid values.
+ fn group<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<(u32, &'data [U32Bytes<Self::Endian>])>> {
+ if self.sh_type(endian) != elf::SHT_GROUP {
+ return Ok(None);
+ }
+ let mut data = self
+ .data(endian, data)
+ .read_error("Invalid ELF group section offset or size")
+ .map(Bytes)?;
+ let flag = data
+ .read::<U32Bytes<_>>()
+ .read_error("Invalid ELF group section offset or size")?
+ .get(endian);
+ let count = data.len() / mem::size_of::<U32Bytes<Self::Endian>>();
+ let sections = data
+ .read_slice(count)
+ .read_error("Invalid ELF group section offset or size")?;
+ Ok(Some((flag, sections)))
+ }
+
+ /// Return the header of a SysV hash section.
+ ///
+ /// Returns `Ok(None)` if the section does not contain a SysV hash.
+ /// Returns `Err` for invalid values.
+ fn hash_header<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<&'data elf::HashHeader<Self::Endian>>> {
+ if self.sh_type(endian) != elf::SHT_HASH {
+ return Ok(None);
+ }
+ let data = self
+ .data(endian, data)
+ .read_error("Invalid ELF hash section offset or size")?;
+ let header = data
+ .read_at::<elf::HashHeader<Self::Endian>>(0)
+ .read_error("Invalid hash header")?;
+ Ok(Some(header))
+ }
+
+ /// Return the contents of a SysV hash section.
+ ///
+ /// Returns `Ok(None)` if the section does not contain a SysV hash.
+ /// Returns `Err` for invalid values.
+ fn hash<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<HashTable<'data, Self::Elf>>> {
+ if self.sh_type(endian) != elf::SHT_HASH {
+ return Ok(None);
+ }
+ let data = self
+ .data(endian, data)
+ .read_error("Invalid ELF hash section offset or size")?;
+ let hash = HashTable::parse(endian, data)?;
+ Ok(Some(hash))
+ }
+
+ /// Return the header of a GNU hash section.
+ ///
+ /// Returns `Ok(None)` if the section does not contain a GNU hash.
+ /// Returns `Err` for invalid values.
+ fn gnu_hash_header<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<&'data elf::GnuHashHeader<Self::Endian>>> {
+ if self.sh_type(endian) != elf::SHT_GNU_HASH {
+ return Ok(None);
+ }
+ let data = self
+ .data(endian, data)
+ .read_error("Invalid ELF GNU hash section offset or size")?;
+ let header = data
+ .read_at::<elf::GnuHashHeader<Self::Endian>>(0)
+ .read_error("Invalid GNU hash header")?;
+ Ok(Some(header))
+ }
+
+ /// Return the contents of a GNU hash section.
+ ///
+ /// Returns `Ok(None)` if the section does not contain a GNU hash.
+ /// Returns `Err` for invalid values.
+ fn gnu_hash<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<GnuHashTable<'data, Self::Elf>>> {
+ if self.sh_type(endian) != elf::SHT_GNU_HASH {
+ return Ok(None);
+ }
+ let data = self
+ .data(endian, data)
+ .read_error("Invalid ELF GNU hash section offset or size")?;
+ let hash = GnuHashTable::parse(endian, data)?;
+ Ok(Some(hash))
+ }
+
+ /// Return the contents of a `SHT_GNU_VERSYM` section.
+ ///
+ /// Returns `Ok(None)` if the section type is not `SHT_GNU_VERSYM`.
+ /// Returns `Err` for invalid values.
+ fn gnu_versym<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<&'data [elf::Versym<Self::Endian>]>> {
+ if self.sh_type(endian) != elf::SHT_GNU_VERSYM {
+ return Ok(None);
+ }
+ self.data_as_array(endian, data)
+ .read_error("Invalid ELF GNU versym section offset or size")
+ .map(Some)
+ }
+
+ /// Return an iterator for the entries of a `SHT_GNU_VERDEF` section.
+ ///
+ /// Returns `Ok(None)` if the section type is not `SHT_GNU_VERDEF`.
+ /// Returns `Err` for invalid values.
+ fn gnu_verdef<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<VerdefIterator<'data, Self::Elf>>> {
+ if self.sh_type(endian) != elf::SHT_GNU_VERDEF {
+ return Ok(None);
+ }
+ let data = self
+ .data_as_array(endian, data)
+ .read_error("Invalid ELF GNU verdef section offset or size")?;
+ Ok(Some(VerdefIterator::new(endian, data)))
+ }
+
+ /// Return an iterator for the entries of a `SHT_GNU_VERNEED` section.
+ ///
+ /// Returns `Ok(None)` if the section type is not `SHT_GNU_VERNEED`.
+ /// Returns `Err` for invalid values.
+ fn gnu_verneed<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<VerneedIterator<'data, Self::Elf>>> {
+ if self.sh_type(endian) != elf::SHT_GNU_VERNEED {
+ return Ok(None);
+ }
+ let data = self
+ .data_as_array(endian, data)
+ .read_error("Invalid ELF GNU verneed section offset or size")?;
+ Ok(Some(VerneedIterator::new(endian, data)))
+ }
+}
+
+impl<Endian: endian::Endian> SectionHeader for elf::SectionHeader32<Endian> {
+ type Elf = elf::FileHeader32<Endian>;
+ type Word = u32;
+ type Endian = Endian;
+
+ #[inline]
+ fn sh_name(&self, endian: Self::Endian) -> u32 {
+ self.sh_name.get(endian)
+ }
+
+ #[inline]
+ fn sh_type(&self, endian: Self::Endian) -> u32 {
+ self.sh_type.get(endian)
+ }
+
+ #[inline]
+ fn sh_flags(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_flags.get(endian)
+ }
+
+ #[inline]
+ fn sh_addr(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_addr.get(endian)
+ }
+
+ #[inline]
+ fn sh_offset(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_offset.get(endian)
+ }
+
+ #[inline]
+ fn sh_size(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_size.get(endian)
+ }
+
+ #[inline]
+ fn sh_link(&self, endian: Self::Endian) -> u32 {
+ self.sh_link.get(endian)
+ }
+
+ #[inline]
+ fn sh_info(&self, endian: Self::Endian) -> u32 {
+ self.sh_info.get(endian)
+ }
+
+ #[inline]
+ fn sh_addralign(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_addralign.get(endian)
+ }
+
+ #[inline]
+ fn sh_entsize(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_entsize.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> SectionHeader for elf::SectionHeader64<Endian> {
+ type Word = u64;
+ type Endian = Endian;
+ type Elf = elf::FileHeader64<Endian>;
+
+ #[inline]
+ fn sh_name(&self, endian: Self::Endian) -> u32 {
+ self.sh_name.get(endian)
+ }
+
+ #[inline]
+ fn sh_type(&self, endian: Self::Endian) -> u32 {
+ self.sh_type.get(endian)
+ }
+
+ #[inline]
+ fn sh_flags(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_flags.get(endian)
+ }
+
+ #[inline]
+ fn sh_addr(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_addr.get(endian)
+ }
+
+ #[inline]
+ fn sh_offset(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_offset.get(endian)
+ }
+
+ #[inline]
+ fn sh_size(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_size.get(endian)
+ }
+
+ #[inline]
+ fn sh_link(&self, endian: Self::Endian) -> u32 {
+ self.sh_link.get(endian)
+ }
+
+ #[inline]
+ fn sh_info(&self, endian: Self::Endian) -> u32 {
+ self.sh_info.get(endian)
+ }
+
+ #[inline]
+ fn sh_addralign(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_addralign.get(endian)
+ }
+
+ #[inline]
+ fn sh_entsize(&self, endian: Self::Endian) -> Self::Word {
+ self.sh_entsize.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/segment.rs b/vendor/object-0.26.2/src/read/elf/segment.rs
new file mode 100644
index 000000000..70528b59a
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/segment.rs
@@ -0,0 +1,322 @@
+use core::fmt::Debug;
+use core::{mem, slice, str};
+
+use crate::elf;
+use crate::endian::{self, Endianness};
+use crate::pod::Pod;
+use crate::read::{self, Bytes, ObjectSegment, ReadError, ReadRef};
+
+use super::{ElfFile, FileHeader, NoteIterator};
+
+/// An iterator over the segments of an `ElfFile32`.
+pub type ElfSegmentIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSegmentIterator<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// An iterator over the segments of an `ElfFile64`.
+pub type ElfSegmentIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSegmentIterator<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// An iterator over the segments of an `ElfFile`.
+#[derive(Debug)]
+pub struct ElfSegmentIterator<'data, 'file, Elf, R = &'data [u8]>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file ElfFile<'data, Elf, R>,
+ pub(super) iter: slice::Iter<'data, Elf::ProgramHeader>,
+}
+
+impl<'data, 'file, Elf, R> Iterator for ElfSegmentIterator<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ type Item = ElfSegment<'data, 'file, Elf, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ while let Some(segment) = self.iter.next() {
+ if segment.p_type(self.file.endian) == elf::PT_LOAD {
+ return Some(ElfSegment {
+ file: self.file,
+ segment,
+ });
+ }
+ }
+ None
+ }
+}
+
+/// A segment of an `ElfFile32`.
+pub type ElfSegment32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSegment<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// A segment of an `ElfFile64`.
+pub type ElfSegment64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSegment<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// A segment of an `ElfFile`.
+#[derive(Debug)]
+pub struct ElfSegment<'data, 'file, Elf, R = &'data [u8]>
+where
+ 'data: 'file,
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file ElfFile<'data, Elf, R>,
+ pub(super) segment: &'data Elf::ProgramHeader,
+}
+
+impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> ElfSegment<'data, 'file, Elf, R> {
+ fn bytes(&self) -> read::Result<&'data [u8]> {
+ self.segment
+ .data(self.file.endian, self.file.data)
+ .read_error("Invalid ELF segment size or offset")
+ }
+}
+
+impl<'data, 'file, Elf, R> read::private::Sealed for ElfSegment<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Elf, R> ObjectSegment<'data> for ElfSegment<'data, 'file, Elf, R>
+where
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ #[inline]
+ fn address(&self) -> u64 {
+ self.segment.p_vaddr(self.file.endian).into()
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ self.segment.p_memsz(self.file.endian).into()
+ }
+
+ #[inline]
+ fn align(&self) -> u64 {
+ self.segment.p_align(self.file.endian).into()
+ }
+
+ #[inline]
+ fn file_range(&self) -> (u64, u64) {
+ self.segment.file_range(self.file.endian)
+ }
+
+ #[inline]
+ fn data(&self) -> read::Result<&'data [u8]> {
+ self.bytes()
+ }
+
+ fn data_range(&self, address: u64, size: u64) -> read::Result<Option<&'data [u8]>> {
+ Ok(read::util::data_range(
+ self.bytes()?,
+ self.address(),
+ address,
+ size,
+ ))
+ }
+
+ #[inline]
+ fn name(&self) -> read::Result<Option<&str>> {
+ Ok(None)
+ }
+}
+
+/// A trait for generic access to `ProgramHeader32` and `ProgramHeader64`.
+#[allow(missing_docs)]
+pub trait ProgramHeader: Debug + Pod {
+ type Elf: FileHeader<ProgramHeader = Self, Endian = Self::Endian, Word = Self::Word>;
+ type Word: Into<u64>;
+ type Endian: endian::Endian;
+
+ fn p_type(&self, endian: Self::Endian) -> u32;
+ fn p_flags(&self, endian: Self::Endian) -> u32;
+ fn p_offset(&self, endian: Self::Endian) -> Self::Word;
+ fn p_vaddr(&self, endian: Self::Endian) -> Self::Word;
+ fn p_paddr(&self, endian: Self::Endian) -> Self::Word;
+ fn p_filesz(&self, endian: Self::Endian) -> Self::Word;
+ fn p_memsz(&self, endian: Self::Endian) -> Self::Word;
+ fn p_align(&self, endian: Self::Endian) -> Self::Word;
+
+ /// Return the offset and size of the segment in the file.
+ fn file_range(&self, endian: Self::Endian) -> (u64, u64) {
+ (self.p_offset(endian).into(), self.p_filesz(endian).into())
+ }
+
+ /// Return the segment data.
+ ///
+ /// Returns `Err` for invalid values.
+ fn data<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> Result<&'data [u8], ()> {
+ let (offset, size) = self.file_range(endian);
+ data.read_bytes_at(offset, size)
+ }
+
+ /// Return the segment data as a slice of the given type.
+ ///
+ /// Allows padding at the end of the data.
+ /// Returns `Ok(&[])` if the segment has no data.
+ /// Returns `Err` for invalid values, including bad alignment.
+ fn data_as_array<'data, T: Pod, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> Result<&'data [T], ()> {
+ let mut data = self.data(endian, data).map(Bytes)?;
+ data.read_slice(data.len() / mem::size_of::<T>())
+ }
+
+ /// Return the segment data in the given virtual address range
+ ///
+ /// Returns `Ok(None)` if the segment does not contain the address.
+ /// Returns `Err` for invalid values.
+ fn data_range<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ address: u64,
+ size: u64,
+ ) -> Result<Option<&'data [u8]>, ()> {
+ Ok(read::util::data_range(
+ self.data(endian, data)?,
+ self.p_vaddr(endian).into(),
+ address,
+ size,
+ ))
+ }
+
+ /// Return entries in a dynamic segment.
+ ///
+ /// Returns `Ok(None)` if the segment is not `PT_DYNAMIC`.
+ /// Returns `Err` for invalid values.
+ fn dynamic<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<&'data [<Self::Elf as FileHeader>::Dyn]>> {
+ if self.p_type(endian) != elf::PT_DYNAMIC {
+ return Ok(None);
+ }
+ let dynamic = self
+ .data_as_array(endian, data)
+ .read_error("Invalid ELF dynamic segment offset or size")?;
+ Ok(Some(dynamic))
+ }
+
+ /// Return a note iterator for the segment data.
+ ///
+ /// Returns `Ok(None)` if the segment does not contain notes.
+ /// Returns `Err` for invalid values.
+ fn notes<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> read::Result<Option<NoteIterator<'data, Self::Elf>>> {
+ if self.p_type(endian) != elf::PT_NOTE {
+ return Ok(None);
+ }
+ let data = self
+ .data(endian, data)
+ .read_error("Invalid ELF note segment offset or size")?;
+ let notes = NoteIterator::new(endian, self.p_align(endian), data)?;
+ Ok(Some(notes))
+ }
+}
+
+impl<Endian: endian::Endian> ProgramHeader for elf::ProgramHeader32<Endian> {
+ type Word = u32;
+ type Endian = Endian;
+ type Elf = elf::FileHeader32<Endian>;
+
+ #[inline]
+ fn p_type(&self, endian: Self::Endian) -> u32 {
+ self.p_type.get(endian)
+ }
+
+ #[inline]
+ fn p_flags(&self, endian: Self::Endian) -> u32 {
+ self.p_flags.get(endian)
+ }
+
+ #[inline]
+ fn p_offset(&self, endian: Self::Endian) -> Self::Word {
+ self.p_offset.get(endian)
+ }
+
+ #[inline]
+ fn p_vaddr(&self, endian: Self::Endian) -> Self::Word {
+ self.p_vaddr.get(endian)
+ }
+
+ #[inline]
+ fn p_paddr(&self, endian: Self::Endian) -> Self::Word {
+ self.p_paddr.get(endian)
+ }
+
+ #[inline]
+ fn p_filesz(&self, endian: Self::Endian) -> Self::Word {
+ self.p_filesz.get(endian)
+ }
+
+ #[inline]
+ fn p_memsz(&self, endian: Self::Endian) -> Self::Word {
+ self.p_memsz.get(endian)
+ }
+
+ #[inline]
+ fn p_align(&self, endian: Self::Endian) -> Self::Word {
+ self.p_align.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> ProgramHeader for elf::ProgramHeader64<Endian> {
+ type Word = u64;
+ type Endian = Endian;
+ type Elf = elf::FileHeader64<Endian>;
+
+ #[inline]
+ fn p_type(&self, endian: Self::Endian) -> u32 {
+ self.p_type.get(endian)
+ }
+
+ #[inline]
+ fn p_flags(&self, endian: Self::Endian) -> u32 {
+ self.p_flags.get(endian)
+ }
+
+ #[inline]
+ fn p_offset(&self, endian: Self::Endian) -> Self::Word {
+ self.p_offset.get(endian)
+ }
+
+ #[inline]
+ fn p_vaddr(&self, endian: Self::Endian) -> Self::Word {
+ self.p_vaddr.get(endian)
+ }
+
+ #[inline]
+ fn p_paddr(&self, endian: Self::Endian) -> Self::Word {
+ self.p_paddr.get(endian)
+ }
+
+ #[inline]
+ fn p_filesz(&self, endian: Self::Endian) -> Self::Word {
+ self.p_filesz.get(endian)
+ }
+
+ #[inline]
+ fn p_memsz(&self, endian: Self::Endian) -> Self::Word {
+ self.p_memsz.get(endian)
+ }
+
+ #[inline]
+ fn p_align(&self, endian: Self::Endian) -> Self::Word {
+ self.p_align.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/symbol.rs b/vendor/object-0.26.2/src/read/elf/symbol.rs
new file mode 100644
index 000000000..ff2ed199a
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/symbol.rs
@@ -0,0 +1,545 @@
+use alloc::fmt;
+use alloc::vec::Vec;
+use core::fmt::Debug;
+use core::slice;
+use core::str;
+
+use crate::elf;
+use crate::endian::{self, Endianness};
+use crate::pod::Pod;
+use crate::read::util::StringTable;
+use crate::read::{
+ self, ObjectSymbol, ObjectSymbolTable, ReadError, ReadRef, SectionIndex, SymbolFlags,
+ SymbolIndex, SymbolKind, SymbolMap, SymbolMapEntry, SymbolScope, SymbolSection,
+};
+
+use super::{FileHeader, SectionHeader, SectionTable};
+
+/// A table of symbol entries in an ELF file.
+///
+/// Also includes the string table used for the symbol names.
+#[derive(Debug, Clone, Copy)]
+pub struct SymbolTable<'data, Elf: FileHeader, R = &'data [u8]>
+where
+ R: ReadRef<'data>,
+{
+ section: usize,
+ symbols: &'data [Elf::Sym],
+ strings: StringTable<'data, R>,
+ shndx: &'data [u32],
+}
+
+impl<'data, Elf: FileHeader, R: ReadRef<'data>> Default for SymbolTable<'data, Elf, R> {
+ fn default() -> Self {
+ SymbolTable {
+ section: 0,
+ symbols: &[],
+ strings: Default::default(),
+ shndx: &[],
+ }
+ }
+}
+
+impl<'data, Elf: FileHeader, R: ReadRef<'data>> SymbolTable<'data, Elf, R> {
+ /// Parse the given symbol table section.
+ pub fn parse(
+ endian: Elf::Endian,
+ data: R,
+ sections: &SectionTable<'data, Elf, R>,
+ section_index: usize,
+ section: &Elf::SectionHeader,
+ ) -> read::Result<SymbolTable<'data, Elf, R>> {
+ debug_assert!(
+ section.sh_type(endian) == elf::SHT_DYNSYM
+ || section.sh_type(endian) == elf::SHT_SYMTAB
+ );
+
+ let symbols = section
+ .data_as_array(endian, data)
+ .read_error("Invalid ELF symbol table data")?;
+
+ let strtab = sections.section(section.sh_link(endian) as usize)?;
+ let strings = if let Some((str_offset, str_size)) = strtab.file_range(endian) {
+ let str_end = str_offset
+ .checked_add(str_size)
+ .read_error("Invalid str_size")?;
+ StringTable::new(data, str_offset, str_end)
+ } else {
+ StringTable::default()
+ };
+
+ let shndx = sections
+ .iter()
+ .find(|s| {
+ s.sh_type(endian) == elf::SHT_SYMTAB_SHNDX
+ && s.sh_link(endian) as usize == section_index
+ })
+ .map(|section| {
+ section
+ .data_as_array(endian, data)
+ .read_error("Invalid ELF symtab_shndx data")
+ })
+ .transpose()?
+ .unwrap_or(&[]);
+
+ Ok(SymbolTable {
+ section: section_index,
+ symbols,
+ strings,
+ shndx,
+ })
+ }
+
+ /// Return the section index of this symbol table.
+ #[inline]
+ pub fn section(&self) -> usize {
+ self.section
+ }
+
+ /// Return the string table used for the symbol names.
+ #[inline]
+ pub fn strings(&self) -> StringTable<'data, R> {
+ self.strings
+ }
+
+ /// Return the symbol table.
+ #[inline]
+ pub fn symbols(&self) -> &'data [Elf::Sym] {
+ self.symbols
+ }
+
+ /// Iterate over the symbols.
+ #[inline]
+ pub fn iter(&self) -> slice::Iter<'data, Elf::Sym> {
+ self.symbols.iter()
+ }
+
+ /// Return true if the symbol table is empty.
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.symbols.is_empty()
+ }
+
+ /// The number of symbols.
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.symbols.len()
+ }
+
+ /// Return the symbol at the given index.
+ pub fn symbol(&self, index: usize) -> read::Result<&'data Elf::Sym> {
+ self.symbols
+ .get(index)
+ .read_error("Invalid ELF symbol index")
+ }
+
+ /// Return the extended section index for the given symbol if present.
+ #[inline]
+ pub fn shndx(&self, index: usize) -> Option<u32> {
+ self.shndx.get(index).cloned()
+ }
+
+ /// Return the symbol name for the given symbol.
+ pub fn symbol_name(
+ &self,
+ endian: Elf::Endian,
+ symbol: &'data Elf::Sym,
+ ) -> read::Result<&'data [u8]> {
+ symbol.name(endian, self.strings)
+ }
+
+ /// Construct a map from addresses to a user-defined map entry.
+ pub fn map<Entry: SymbolMapEntry, F: Fn(&'data Elf::Sym) -> Option<Entry>>(
+ &self,
+ endian: Elf::Endian,
+ f: F,
+ ) -> SymbolMap<Entry> {
+ let mut symbols = Vec::with_capacity(self.symbols.len());
+ for symbol in self.symbols {
+ if !symbol.is_definition(endian) {
+ continue;
+ }
+ if let Some(entry) = f(symbol) {
+ symbols.push(entry);
+ }
+ }
+ SymbolMap::new(symbols)
+ }
+}
+
+/// A symbol table of an `ElfFile32`.
+pub type ElfSymbolTable32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSymbolTable<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// A symbol table of an `ElfFile32`.
+pub type ElfSymbolTable64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSymbolTable<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// A symbol table of an `ElfFile`.
+#[derive(Debug, Clone, Copy)]
+pub struct ElfSymbolTable<'data, 'file, Elf, R = &'data [u8]>
+where
+ 'data: 'file,
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) endian: Elf::Endian,
+ pub(super) symbols: &'file SymbolTable<'data, Elf, R>,
+}
+
+impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> read::private::Sealed
+ for ElfSymbolTable<'data, 'file, Elf, R>
+{
+}
+
+impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> ObjectSymbolTable<'data>
+ for ElfSymbolTable<'data, 'file, Elf, R>
+{
+ type Symbol = ElfSymbol<'data, 'file, Elf, R>;
+ type SymbolIterator = ElfSymbolIterator<'data, 'file, Elf, R>;
+
+ fn symbols(&self) -> Self::SymbolIterator {
+ ElfSymbolIterator {
+ endian: self.endian,
+ symbols: self.symbols,
+ index: 0,
+ }
+ }
+
+ fn symbol_by_index(&self, index: SymbolIndex) -> read::Result<Self::Symbol> {
+ let symbol = self.symbols.symbol(index.0)?;
+ Ok(ElfSymbol {
+ endian: self.endian,
+ symbols: self.symbols,
+ index,
+ symbol,
+ })
+ }
+}
+
+/// An iterator over the symbols of an `ElfFile32`.
+pub type ElfSymbolIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSymbolIterator<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// An iterator over the symbols of an `ElfFile64`.
+pub type ElfSymbolIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSymbolIterator<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// An iterator over the symbols of an `ElfFile`.
+pub struct ElfSymbolIterator<'data, 'file, Elf, R = &'data [u8]>
+where
+ 'data: 'file,
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) endian: Elf::Endian,
+ pub(super) symbols: &'file SymbolTable<'data, Elf, R>,
+ pub(super) index: usize,
+}
+
+impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> fmt::Debug
+ for ElfSymbolIterator<'data, 'file, Elf, R>
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("ElfSymbolIterator").finish()
+ }
+}
+
+impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> Iterator
+ for ElfSymbolIterator<'data, 'file, Elf, R>
+{
+ type Item = ElfSymbol<'data, 'file, Elf, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let index = self.index;
+ let symbol = self.symbols.symbols.get(index)?;
+ self.index += 1;
+ Some(ElfSymbol {
+ endian: self.endian,
+ symbols: self.symbols,
+ index: SymbolIndex(index),
+ symbol,
+ })
+ }
+}
+
+/// A symbol of an `ElfFile32`.
+pub type ElfSymbol32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSymbol<'data, 'file, elf::FileHeader32<Endian>, R>;
+/// A symbol of an `ElfFile64`.
+pub type ElfSymbol64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ ElfSymbol<'data, 'file, elf::FileHeader64<Endian>, R>;
+
+/// A symbol of an `ElfFile`.
+#[derive(Debug, Clone, Copy)]
+pub struct ElfSymbol<'data, 'file, Elf, R = &'data [u8]>
+where
+ 'data: 'file,
+ Elf: FileHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) endian: Elf::Endian,
+ pub(super) symbols: &'file SymbolTable<'data, Elf, R>,
+ pub(super) index: SymbolIndex,
+ pub(super) symbol: &'data Elf::Sym,
+}
+
+impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> read::private::Sealed
+ for ElfSymbol<'data, 'file, Elf, R>
+{
+}
+
+impl<'data, 'file, Elf: FileHeader, R: ReadRef<'data>> ObjectSymbol<'data>
+ for ElfSymbol<'data, 'file, Elf, R>
+{
+ #[inline]
+ fn index(&self) -> SymbolIndex {
+ self.index
+ }
+
+ fn name(&self) -> read::Result<&'data str> {
+ let name = self.symbol.name(self.endian, self.symbols.strings())?;
+ str::from_utf8(name)
+ .ok()
+ .read_error("Non UTF-8 ELF symbol name")
+ }
+
+ #[inline]
+ fn address(&self) -> u64 {
+ self.symbol.st_value(self.endian).into()
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ self.symbol.st_size(self.endian).into()
+ }
+
+ fn kind(&self) -> SymbolKind {
+ match self.symbol.st_type() {
+ elf::STT_NOTYPE if self.index.0 == 0 => SymbolKind::Null,
+ elf::STT_OBJECT | elf::STT_COMMON => SymbolKind::Data,
+ elf::STT_FUNC => SymbolKind::Text,
+ elf::STT_SECTION => SymbolKind::Section,
+ elf::STT_FILE => SymbolKind::File,
+ elf::STT_TLS => SymbolKind::Tls,
+ _ => SymbolKind::Unknown,
+ }
+ }
+
+ fn section(&self) -> SymbolSection {
+ match self.symbol.st_shndx(self.endian) {
+ elf::SHN_UNDEF => SymbolSection::Undefined,
+ elf::SHN_ABS => {
+ if self.symbol.st_type() == elf::STT_FILE {
+ SymbolSection::None
+ } else {
+ SymbolSection::Absolute
+ }
+ }
+ elf::SHN_COMMON => SymbolSection::Common,
+ elf::SHN_XINDEX => match self.symbols.shndx(self.index.0) {
+ Some(index) => SymbolSection::Section(SectionIndex(index as usize)),
+ None => SymbolSection::Unknown,
+ },
+ index if index < elf::SHN_LORESERVE => {
+ SymbolSection::Section(SectionIndex(index as usize))
+ }
+ _ => SymbolSection::Unknown,
+ }
+ }
+
+ #[inline]
+ fn is_undefined(&self) -> bool {
+ self.symbol.st_shndx(self.endian) == elf::SHN_UNDEF
+ }
+
+ #[inline]
+ fn is_definition(&self) -> bool {
+ self.symbol.is_definition(self.endian)
+ }
+
+ #[inline]
+ fn is_common(&self) -> bool {
+ self.symbol.st_shndx(self.endian) == elf::SHN_COMMON
+ }
+
+ #[inline]
+ fn is_weak(&self) -> bool {
+ self.symbol.st_bind() == elf::STB_WEAK
+ }
+
+ fn scope(&self) -> SymbolScope {
+ if self.symbol.st_shndx(self.endian) == elf::SHN_UNDEF {
+ SymbolScope::Unknown
+ } else {
+ match self.symbol.st_bind() {
+ elf::STB_LOCAL => SymbolScope::Compilation,
+ elf::STB_GLOBAL | elf::STB_WEAK => {
+ if self.symbol.st_visibility() == elf::STV_HIDDEN {
+ SymbolScope::Linkage
+ } else {
+ SymbolScope::Dynamic
+ }
+ }
+ _ => SymbolScope::Unknown,
+ }
+ }
+ }
+
+ #[inline]
+ fn is_global(&self) -> bool {
+ self.symbol.st_bind() != elf::STB_LOCAL
+ }
+
+ #[inline]
+ fn is_local(&self) -> bool {
+ self.symbol.st_bind() == elf::STB_LOCAL
+ }
+
+ #[inline]
+ fn flags(&self) -> SymbolFlags<SectionIndex> {
+ SymbolFlags::Elf {
+ st_info: self.symbol.st_info(),
+ st_other: self.symbol.st_other(),
+ }
+ }
+}
+
+/// A trait for generic access to `Sym32` and `Sym64`.
+#[allow(missing_docs)]
+pub trait Sym: Debug + Pod {
+ type Word: Into<u64>;
+ type Endian: endian::Endian;
+
+ fn st_name(&self, endian: Self::Endian) -> u32;
+ fn st_info(&self) -> u8;
+ fn st_bind(&self) -> u8;
+ fn st_type(&self) -> u8;
+ fn st_other(&self) -> u8;
+ fn st_visibility(&self) -> u8;
+ fn st_shndx(&self, endian: Self::Endian) -> u16;
+ fn st_value(&self, endian: Self::Endian) -> Self::Word;
+ fn st_size(&self, endian: Self::Endian) -> Self::Word;
+
+ /// Parse the symbol name from the string table.
+ fn name<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ strings: StringTable<'data, R>,
+ ) -> read::Result<&'data [u8]> {
+ strings
+ .get(self.st_name(endian))
+ .read_error("Invalid ELF symbol name offset")
+ }
+
+ /// Return true if the symbol is undefined.
+ #[inline]
+ fn is_undefined(&self, endian: Self::Endian) -> bool {
+ self.st_shndx(endian) == elf::SHN_UNDEF
+ }
+
+ /// Return true if the symbol is a definition of a function or data object.
+ fn is_definition(&self, endian: Self::Endian) -> bool {
+ let st_type = self.st_type();
+ (st_type == elf::STT_NOTYPE || st_type == elf::STT_FUNC || st_type == elf::STT_OBJECT)
+ && self.st_shndx(endian) != elf::SHN_UNDEF
+ }
+}
+
+impl<Endian: endian::Endian> Sym for elf::Sym32<Endian> {
+ type Word = u32;
+ type Endian = Endian;
+
+ #[inline]
+ fn st_name(&self, endian: Self::Endian) -> u32 {
+ self.st_name.get(endian)
+ }
+
+ #[inline]
+ fn st_info(&self) -> u8 {
+ self.st_info
+ }
+
+ #[inline]
+ fn st_bind(&self) -> u8 {
+ self.st_bind()
+ }
+
+ #[inline]
+ fn st_type(&self) -> u8 {
+ self.st_type()
+ }
+
+ #[inline]
+ fn st_other(&self) -> u8 {
+ self.st_other
+ }
+
+ #[inline]
+ fn st_visibility(&self) -> u8 {
+ self.st_visibility()
+ }
+
+ #[inline]
+ fn st_shndx(&self, endian: Self::Endian) -> u16 {
+ self.st_shndx.get(endian)
+ }
+
+ #[inline]
+ fn st_value(&self, endian: Self::Endian) -> Self::Word {
+ self.st_value.get(endian)
+ }
+
+ #[inline]
+ fn st_size(&self, endian: Self::Endian) -> Self::Word {
+ self.st_size.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> Sym for elf::Sym64<Endian> {
+ type Word = u64;
+ type Endian = Endian;
+
+ #[inline]
+ fn st_name(&self, endian: Self::Endian) -> u32 {
+ self.st_name.get(endian)
+ }
+
+ #[inline]
+ fn st_info(&self) -> u8 {
+ self.st_info
+ }
+
+ #[inline]
+ fn st_bind(&self) -> u8 {
+ self.st_bind()
+ }
+
+ #[inline]
+ fn st_type(&self) -> u8 {
+ self.st_type()
+ }
+
+ #[inline]
+ fn st_other(&self) -> u8 {
+ self.st_other
+ }
+
+ #[inline]
+ fn st_visibility(&self) -> u8 {
+ self.st_visibility()
+ }
+
+ #[inline]
+ fn st_shndx(&self, endian: Self::Endian) -> u16 {
+ self.st_shndx.get(endian)
+ }
+
+ #[inline]
+ fn st_value(&self, endian: Self::Endian) -> Self::Word {
+ self.st_value.get(endian)
+ }
+
+ #[inline]
+ fn st_size(&self, endian: Self::Endian) -> Self::Word {
+ self.st_size.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/elf/version.rs b/vendor/object-0.26.2/src/read/elf/version.rs
new file mode 100644
index 000000000..099e27af3
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/elf/version.rs
@@ -0,0 +1,175 @@
+use crate::elf;
+use crate::read::{Bytes, ReadError, Result};
+
+use super::FileHeader;
+
+/// An iterator over the entries in an ELF `SHT_GNU_verdef` section.
+#[derive(Debug, Clone)]
+pub struct VerdefIterator<'data, Elf: FileHeader> {
+ endian: Elf::Endian,
+ data: Bytes<'data>,
+}
+
+impl<'data, Elf: FileHeader> VerdefIterator<'data, Elf> {
+ pub(super) fn new(endian: Elf::Endian, data: &'data [u8]) -> Self {
+ VerdefIterator {
+ endian,
+ data: Bytes(data),
+ }
+ }
+
+ /// Return the next `Verdef` entry.
+ pub fn next(
+ &mut self,
+ ) -> Result<Option<(&'data elf::Verdef<Elf::Endian>, VerdauxIterator<'data, Elf>)>> {
+ if self.data.is_empty() {
+ return Ok(None);
+ }
+
+ let verdef = self
+ .data
+ .read_at::<elf::Verdef<_>>(0)
+ .read_error("ELF verdef is too short")?;
+
+ let mut verdaux_data = self.data;
+ verdaux_data
+ .skip(verdef.vd_aux.get(self.endian) as usize)
+ .read_error("Invalid ELF vd_aux")?;
+ let verdaux =
+ VerdauxIterator::new(self.endian, verdaux_data.0, verdef.vd_cnt.get(self.endian));
+
+ let next = verdef.vd_next.get(self.endian);
+ if next != 0 {
+ self.data
+ .skip(next as usize)
+ .read_error("Invalid ELF vd_next")?;
+ } else {
+ self.data = Bytes(&[]);
+ }
+ Ok(Some((verdef, verdaux)))
+ }
+}
+
+/// An iterator over the auxiliary records for an entry in an ELF `SHT_GNU_verdef` section.
+#[derive(Debug, Clone)]
+pub struct VerdauxIterator<'data, Elf: FileHeader> {
+ endian: Elf::Endian,
+ data: Bytes<'data>,
+ count: u16,
+}
+
+impl<'data, Elf: FileHeader> VerdauxIterator<'data, Elf> {
+ pub(super) fn new(endian: Elf::Endian, data: &'data [u8], count: u16) -> Self {
+ VerdauxIterator {
+ endian,
+ data: Bytes(data),
+ count,
+ }
+ }
+
+ /// Return the next `Verdaux` entry.
+ pub fn next(&mut self) -> Result<Option<&'data elf::Verdaux<Elf::Endian>>> {
+ if self.count == 0 {
+ return Ok(None);
+ }
+
+ let verdaux = self
+ .data
+ .read_at::<elf::Verdaux<_>>(0)
+ .read_error("ELF verdaux is too short")?;
+
+ self.data
+ .skip(verdaux.vda_next.get(self.endian) as usize)
+ .read_error("Invalid ELF vda_next")?;
+ self.count -= 1;
+ Ok(Some(verdaux))
+ }
+}
+
+/// An iterator over the entries in an ELF `SHT_GNU_verneed` section.
+#[derive(Debug, Clone)]
+pub struct VerneedIterator<'data, Elf: FileHeader> {
+ endian: Elf::Endian,
+ data: Bytes<'data>,
+}
+
+impl<'data, Elf: FileHeader> VerneedIterator<'data, Elf> {
+ pub(super) fn new(endian: Elf::Endian, data: &'data [u8]) -> Self {
+ VerneedIterator {
+ endian,
+ data: Bytes(data),
+ }
+ }
+
+ /// Return the next `Verneed` entry.
+ pub fn next(
+ &mut self,
+ ) -> Result<
+ Option<(
+ &'data elf::Verneed<Elf::Endian>,
+ VernauxIterator<'data, Elf>,
+ )>,
+ > {
+ if self.data.is_empty() {
+ return Ok(None);
+ }
+
+ let verneed = self
+ .data
+ .read_at::<elf::Verneed<_>>(0)
+ .read_error("ELF verneed is too short")?;
+
+ let mut vernaux_data = self.data;
+ vernaux_data
+ .skip(verneed.vn_aux.get(self.endian) as usize)
+ .read_error("Invalid ELF vn_aux")?;
+ let vernaux =
+ VernauxIterator::new(self.endian, vernaux_data.0, verneed.vn_cnt.get(self.endian));
+
+ let next = verneed.vn_next.get(self.endian);
+ if next != 0 {
+ self.data
+ .skip(next as usize)
+ .read_error("Invalid ELF vn_next")?;
+ } else {
+ self.data = Bytes(&[]);
+ }
+ Ok(Some((verneed, vernaux)))
+ }
+}
+
+/// An iterator over the auxiliary records for an entry in an ELF `SHT_GNU_verneed` section.
+#[derive(Debug, Clone)]
+pub struct VernauxIterator<'data, Elf: FileHeader> {
+ endian: Elf::Endian,
+ data: Bytes<'data>,
+ count: u16,
+}
+
+impl<'data, Elf: FileHeader> VernauxIterator<'data, Elf> {
+ pub(super) fn new(endian: Elf::Endian, data: &'data [u8], count: u16) -> Self {
+ VernauxIterator {
+ endian,
+ data: Bytes(data),
+ count,
+ }
+ }
+
+ /// Return the next `Vernaux` entry.
+ pub fn next(&mut self) -> Result<Option<&'data elf::Vernaux<Elf::Endian>>> {
+ if self.count == 0 {
+ return Ok(None);
+ }
+
+ let vernaux = self
+ .data
+ .read_at::<elf::Vernaux<_>>(0)
+ .read_error("ELF vernaux is too short")?;
+
+ self.data
+ .skip(vernaux.vna_next.get(self.endian) as usize)
+ .read_error("Invalid ELF vna_next")?;
+ self.count -= 1;
+ Ok(Some(vernaux))
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/macho/dyld_cache.rs b/vendor/object-0.26.2/src/read/macho/dyld_cache.rs
new file mode 100644
index 000000000..ee758ce0c
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/macho/dyld_cache.rs
@@ -0,0 +1,218 @@
+use core::slice;
+
+use crate::read::{Error, File, ReadError, ReadRef, Result};
+use crate::{macho, Architecture, Endian, Endianness};
+
+/// A parsed representation of the dyld shared cache.
+#[derive(Debug)]
+pub struct DyldCache<'data, E = Endianness, R = &'data [u8]>
+where
+ E: Endian,
+ R: ReadRef<'data>,
+{
+ endian: E,
+ data: R,
+ header: &'data macho::DyldCacheHeader<E>,
+ mappings: &'data [macho::DyldCacheMappingInfo<E>],
+ images: &'data [macho::DyldCacheImageInfo<E>],
+ arch: Architecture,
+}
+
+impl<'data, E, R> DyldCache<'data, E, R>
+where
+ E: Endian,
+ R: ReadRef<'data>,
+{
+ /// Parse the raw dyld shared cache data.
+ pub fn parse(data: R) -> Result<Self> {
+ let header = macho::DyldCacheHeader::parse(data)?;
+ let (arch, endian) = header.parse_magic()?;
+ let mappings = header.mappings(endian, data)?;
+ let images = header.images(endian, data)?;
+ Ok(DyldCache {
+ endian,
+ data,
+ header,
+ mappings,
+ images,
+ arch,
+ })
+ }
+
+ /// Get the architecture type of the file.
+ pub fn architecture(&self) -> Architecture {
+ self.arch
+ }
+
+ /// Get the endianness of the file.
+ #[inline]
+ pub fn endianness(&self) -> Endianness {
+ if self.is_little_endian() {
+ Endianness::Little
+ } else {
+ Endianness::Big
+ }
+ }
+
+ /// Return true if the file is little endian, false if it is big endian.
+ pub fn is_little_endian(&self) -> bool {
+ self.endian.is_little_endian()
+ }
+
+ /// Iterate over the images in this cache.
+ pub fn images<'cache>(&'cache self) -> DyldCacheImageIterator<'data, 'cache, E, R> {
+ DyldCacheImageIterator {
+ cache: self,
+ iter: self.images.iter(),
+ }
+ }
+}
+
+/// An iterator over all the images (dylibs) in the dyld shared cache.
+#[derive(Debug)]
+pub struct DyldCacheImageIterator<'data, 'cache, E = Endianness, R = &'data [u8]>
+where
+ E: Endian,
+ R: ReadRef<'data>,
+{
+ cache: &'cache DyldCache<'data, E, R>,
+ iter: slice::Iter<'data, macho::DyldCacheImageInfo<E>>,
+}
+
+impl<'data, 'cache, E, R> Iterator for DyldCacheImageIterator<'data, 'cache, E, R>
+where
+ E: Endian,
+ R: ReadRef<'data>,
+{
+ type Item = DyldCacheImage<'data, E, R>;
+
+ fn next(&mut self) -> Option<DyldCacheImage<'data, E, R>> {
+ let image_info = self.iter.next()?;
+ Some(DyldCacheImage {
+ endian: self.cache.endian,
+ data: self.cache.data,
+ mappings: self.cache.mappings,
+ image_info,
+ })
+ }
+}
+
+/// One image (dylib) from inside the dyld shared cache.
+#[derive(Debug)]
+pub struct DyldCacheImage<'data, E = Endianness, R = &'data [u8]>
+where
+ E: Endian,
+ R: ReadRef<'data>,
+{
+ endian: E,
+ data: R,
+ mappings: &'data [macho::DyldCacheMappingInfo<E>],
+ image_info: &'data macho::DyldCacheImageInfo<E>,
+}
+
+impl<'data, E, R> DyldCacheImage<'data, E, R>
+where
+ E: Endian,
+ R: ReadRef<'data>,
+{
+ /// The file system path of this image.
+ pub fn path(&self) -> Result<&'data str> {
+ let path = self.image_info.path(self.endian, self.data)?;
+ // The path should always be ascii, so from_utf8 should alway succeed.
+ let path = core::str::from_utf8(path).map_err(|_| Error("Path string not valid utf-8"))?;
+ Ok(path)
+ }
+
+ /// The offset in the dyld cache file where this image starts.
+ pub fn file_offset(&self) -> Result<u64> {
+ self.image_info.file_offset(self.endian, self.mappings)
+ }
+
+ /// Parse this image into an Object.
+ pub fn parse_object(&self) -> Result<File<'data, R>> {
+ File::parse_at(self.data, self.file_offset()?)
+ }
+}
+
+impl<E: Endian> macho::DyldCacheHeader<E> {
+ /// Read the dyld cache header.
+ pub fn parse<'data, R: ReadRef<'data>>(data: R) -> Result<&'data Self> {
+ data.read_at::<macho::DyldCacheHeader<E>>(0)
+ .read_error("Invalid dyld cache header size or alignment")
+ }
+
+ /// Returns (arch, endian) based on the magic string.
+ pub fn parse_magic(&self) -> Result<(Architecture, E)> {
+ let (arch, is_big_endian) = match &self.magic {
+ b"dyld_v1 i386\0" => (Architecture::I386, false),
+ b"dyld_v1 x86_64\0" => (Architecture::X86_64, false),
+ b"dyld_v1 x86_64h\0" => (Architecture::X86_64, false),
+ b"dyld_v1 ppc\0" => (Architecture::PowerPc, true),
+ b"dyld_v1 armv6\0" => (Architecture::Arm, false),
+ b"dyld_v1 armv7\0" => (Architecture::Arm, false),
+ b"dyld_v1 armv7f\0" => (Architecture::Arm, false),
+ b"dyld_v1 armv7s\0" => (Architecture::Arm, false),
+ b"dyld_v1 armv7k\0" => (Architecture::Arm, false),
+ b"dyld_v1 arm64\0" => (Architecture::Aarch64, false),
+ b"dyld_v1 arm64e\0" => (Architecture::Aarch64, false),
+ _ => return Err(Error("Unrecognized dyld cache magic")),
+ };
+ let endian =
+ E::from_big_endian(is_big_endian).read_error("Unsupported dyld cache endian")?;
+ Ok((arch, endian))
+ }
+
+ /// Return the mapping information table.
+ pub fn mappings<'data, R: ReadRef<'data>>(
+ &self,
+ endian: E,
+ data: R,
+ ) -> Result<&'data [macho::DyldCacheMappingInfo<E>]> {
+ data.read_slice_at::<macho::DyldCacheMappingInfo<E>>(
+ self.mapping_offset.get(endian).into(),
+ self.mapping_count.get(endian) as usize,
+ )
+ .read_error("Invalid dyld cache mapping size or alignment")
+ }
+
+ /// Return the image information table.
+ pub fn images<'data, R: ReadRef<'data>>(
+ &self,
+ endian: E,
+ data: R,
+ ) -> Result<&'data [macho::DyldCacheImageInfo<E>]> {
+ data.read_slice_at::<macho::DyldCacheImageInfo<E>>(
+ self.images_offset.get(endian).into(),
+ self.images_count.get(endian) as usize,
+ )
+ .read_error("Invalid dyld cache image size or alignment")
+ }
+}
+
+impl<E: Endian> macho::DyldCacheImageInfo<E> {
+ /// The file system path of this image.
+ pub fn path<'data, R: ReadRef<'data>>(&self, endian: E, data: R) -> Result<&'data [u8]> {
+ let r_start = self.path_file_offset.get(endian).into();
+ let r_end = data.len().read_error("Couldn't get data len()")?;
+ data.read_bytes_at_until(r_start..r_end, 0)
+ .read_error("Couldn't read dyld cache image path")
+ }
+
+ /// Find the file offset of the image by looking up its address in the mappings.
+ pub fn file_offset(
+ &self,
+ endian: E,
+ mappings: &[macho::DyldCacheMappingInfo<E>],
+ ) -> Result<u64> {
+ let address = self.address.get(endian);
+ for mapping in mappings {
+ let mapping_address = mapping.address.get(endian);
+ if address >= mapping_address
+ && address < mapping_address.wrapping_add(mapping.size.get(endian))
+ {
+ return Ok(address - mapping_address + mapping.file_offset.get(endian));
+ }
+ }
+ Err(Error("Invalid dyld cache image address"))
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/macho/fat.rs b/vendor/object-0.26.2/src/read/macho/fat.rs
new file mode 100644
index 000000000..6fc649f31
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/macho/fat.rs
@@ -0,0 +1,120 @@
+use crate::read::{Architecture, Error, ReadError, ReadRef, Result};
+use crate::{macho, BigEndian, Pod};
+
+pub use macho::{FatArch32, FatArch64, FatHeader};
+
+impl FatHeader {
+ /// Attempt to parse a fat header.
+ ///
+ /// Does not validate the magic value.
+ pub fn parse<'data, R: ReadRef<'data>>(file: R) -> Result<&'data FatHeader> {
+ file.read_at::<FatHeader>(0)
+ .read_error("Invalid fat header size or alignment")
+ }
+
+ /// Attempt to parse a fat header and 32-bit fat arches.
+ pub fn parse_arch32<'data, R: ReadRef<'data>>(file: R) -> Result<&'data [FatArch32]> {
+ let mut offset = 0;
+ let header = file
+ .read::<FatHeader>(&mut offset)
+ .read_error("Invalid fat header size or alignment")?;
+ if header.magic.get(BigEndian) != macho::FAT_MAGIC {
+ return Err(Error("Invalid 32-bit fat magic"));
+ }
+ file.read_slice::<FatArch32>(&mut offset, header.nfat_arch.get(BigEndian) as usize)
+ .read_error("Invalid nfat_arch")
+ }
+
+ /// Attempt to parse a fat header and 64-bit fat arches.
+ pub fn parse_arch64<'data, R: ReadRef<'data>>(file: R) -> Result<&'data [FatArch64]> {
+ let mut offset = 0;
+ let header = file
+ .read::<FatHeader>(&mut offset)
+ .read_error("Invalid fat header size or alignment")?;
+ if header.magic.get(BigEndian) != macho::FAT_MAGIC_64 {
+ return Err(Error("Invalid 64-bit fat magic"));
+ }
+ file.read_slice::<FatArch64>(&mut offset, header.nfat_arch.get(BigEndian) as usize)
+ .read_error("Invalid nfat_arch")
+ }
+}
+
+/// A trait for generic access to `FatArch32` and `FatArch64`.
+#[allow(missing_docs)]
+pub trait FatArch: Pod {
+ type Word: Into<u64>;
+
+ fn cputype(&self) -> u32;
+ fn cpusubtype(&self) -> u32;
+ fn offset(&self) -> Self::Word;
+ fn size(&self) -> Self::Word;
+ fn align(&self) -> u32;
+
+ fn architecture(&self) -> Architecture {
+ match self.cputype() {
+ macho::CPU_TYPE_ARM => Architecture::Arm,
+ macho::CPU_TYPE_ARM64 => Architecture::Aarch64,
+ macho::CPU_TYPE_X86 => Architecture::I386,
+ macho::CPU_TYPE_X86_64 => Architecture::X86_64,
+ macho::CPU_TYPE_MIPS => Architecture::Mips,
+ _ => Architecture::Unknown,
+ }
+ }
+
+ fn file_range(&self) -> (u64, u64) {
+ (self.offset().into(), self.size().into())
+ }
+
+ fn data<'data, R: ReadRef<'data>>(&self, file: R) -> Result<&'data [u8]> {
+ file.read_bytes_at(self.offset().into(), self.size().into())
+ .read_error("Invalid fat arch offset or size")
+ }
+}
+
+impl FatArch for FatArch32 {
+ type Word = u32;
+
+ fn cputype(&self) -> u32 {
+ self.cputype.get(BigEndian)
+ }
+
+ fn cpusubtype(&self) -> u32 {
+ self.cpusubtype.get(BigEndian)
+ }
+
+ fn offset(&self) -> Self::Word {
+ self.offset.get(BigEndian)
+ }
+
+ fn size(&self) -> Self::Word {
+ self.size.get(BigEndian)
+ }
+
+ fn align(&self) -> u32 {
+ self.align.get(BigEndian)
+ }
+}
+
+impl FatArch for FatArch64 {
+ type Word = u64;
+
+ fn cputype(&self) -> u32 {
+ self.cputype.get(BigEndian)
+ }
+
+ fn cpusubtype(&self) -> u32 {
+ self.cpusubtype.get(BigEndian)
+ }
+
+ fn offset(&self) -> Self::Word {
+ self.offset.get(BigEndian)
+ }
+
+ fn size(&self) -> Self::Word {
+ self.size.get(BigEndian)
+ }
+
+ fn align(&self) -> u32 {
+ self.align.get(BigEndian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/macho/file.rs b/vendor/object-0.26.2/src/read/macho/file.rs
new file mode 100644
index 000000000..54ae2d83e
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/macho/file.rs
@@ -0,0 +1,648 @@
+use alloc::vec::Vec;
+use core::fmt::Debug;
+use core::{mem, str};
+
+use crate::read::{
+ self, Architecture, ComdatKind, Error, Export, FileFlags, Import, NoDynamicRelocationIterator,
+ Object, ObjectComdat, ObjectMap, ObjectSection, ReadError, ReadRef, Result, SectionIndex,
+ SymbolIndex,
+};
+use crate::{endian, macho, BigEndian, ByteString, Endian, Endianness, Pod};
+
+use super::{
+ LoadCommandIterator, MachOSection, MachOSectionInternal, MachOSectionIterator, MachOSegment,
+ MachOSegmentIterator, MachOSymbol, MachOSymbolIterator, MachOSymbolTable, Nlist, Section,
+ Segment, SymbolTable,
+};
+
+/// A 32-bit Mach-O object file.
+pub type MachOFile32<'data, Endian = Endianness, R = &'data [u8]> =
+ MachOFile<'data, macho::MachHeader32<Endian>, R>;
+/// A 64-bit Mach-O object file.
+pub type MachOFile64<'data, Endian = Endianness, R = &'data [u8]> =
+ MachOFile<'data, macho::MachHeader64<Endian>, R>;
+
+/// A partially parsed Mach-O file.
+///
+/// Most of the functionality of this type is provided by the `Object` trait implementation.
+#[derive(Debug)]
+pub struct MachOFile<'data, Mach, R = &'data [u8]>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) endian: Mach::Endian,
+ pub(super) data: R,
+ pub(super) header_offset: u64,
+ pub(super) header: &'data Mach,
+ pub(super) sections: Vec<MachOSectionInternal<'data, Mach>>,
+ pub(super) symbols: SymbolTable<'data, Mach, R>,
+}
+
+impl<'data, Mach, R> MachOFile<'data, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ /// Parse the raw Mach-O file data.
+ pub fn parse(data: R) -> Result<Self> {
+ Self::parse_at(data, 0)
+ }
+
+ /// Parse the raw Mach-O file data at an arbitrary offset inside the input data.
+ /// This can be used for parsing Mach-O images inside the dyld shared cache,
+ /// where multiple images, located at different offsets, share the same address
+ /// space.
+ pub fn parse_at(data: R, header_offset: u64) -> Result<Self> {
+ let header = Mach::parse(data, header_offset)?;
+ let endian = header.endian()?;
+
+ let mut symbols = SymbolTable::default();
+ // Build a list of sections to make some operations more efficient.
+ let mut sections = Vec::new();
+ if let Ok(mut commands) = header.load_commands(endian, data, header_offset) {
+ while let Ok(Some(command)) = commands.next() {
+ if let Some((segment, section_data)) = Mach::Segment::from_command(command)? {
+ for section in segment.sections(endian, section_data)? {
+ let index = SectionIndex(sections.len() + 1);
+ sections.push(MachOSectionInternal::parse(index, section));
+ }
+ } else if let Some(symtab) = command.symtab()? {
+ symbols = symtab.symbols(endian, data)?;
+ }
+ }
+ }
+
+ Ok(MachOFile {
+ endian,
+ data,
+ header_offset,
+ header,
+ sections,
+ symbols,
+ })
+ }
+
+ /// Return the section at the given index.
+ #[inline]
+ pub(super) fn section_internal(
+ &self,
+ index: SectionIndex,
+ ) -> Result<&MachOSectionInternal<'data, Mach>> {
+ index
+ .0
+ .checked_sub(1)
+ .and_then(|index| self.sections.get(index))
+ .read_error("Invalid Mach-O section index")
+ }
+}
+
+impl<'data, Mach, R> read::private::Sealed for MachOFile<'data, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Mach, R> Object<'data, 'file> for MachOFile<'data, Mach, R>
+where
+ 'data: 'file,
+ Mach: MachHeader,
+ R: 'file + ReadRef<'data>,
+{
+ type Segment = MachOSegment<'data, 'file, Mach, R>;
+ type SegmentIterator = MachOSegmentIterator<'data, 'file, Mach, R>;
+ type Section = MachOSection<'data, 'file, Mach, R>;
+ type SectionIterator = MachOSectionIterator<'data, 'file, Mach, R>;
+ type Comdat = MachOComdat<'data, 'file, Mach, R>;
+ type ComdatIterator = MachOComdatIterator<'data, 'file, Mach, R>;
+ type Symbol = MachOSymbol<'data, 'file, Mach, R>;
+ type SymbolIterator = MachOSymbolIterator<'data, 'file, Mach, R>;
+ type SymbolTable = MachOSymbolTable<'data, 'file, Mach, R>;
+ type DynamicRelocationIterator = NoDynamicRelocationIterator;
+
+ fn architecture(&self) -> Architecture {
+ match self.header.cputype(self.endian) {
+ macho::CPU_TYPE_ARM => Architecture::Arm,
+ macho::CPU_TYPE_ARM64 => Architecture::Aarch64,
+ macho::CPU_TYPE_X86 => Architecture::I386,
+ macho::CPU_TYPE_X86_64 => Architecture::X86_64,
+ macho::CPU_TYPE_MIPS => Architecture::Mips,
+ _ => Architecture::Unknown,
+ }
+ }
+
+ #[inline]
+ fn is_little_endian(&self) -> bool {
+ self.header.is_little_endian()
+ }
+
+ #[inline]
+ fn is_64(&self) -> bool {
+ self.header.is_type_64()
+ }
+
+ fn segments(&'file self) -> MachOSegmentIterator<'data, 'file, Mach, R> {
+ MachOSegmentIterator {
+ file: self,
+ commands: self
+ .header
+ .load_commands(self.endian, self.data, self.header_offset)
+ .ok()
+ .unwrap_or_else(Default::default),
+ }
+ }
+
+ fn section_by_name(
+ &'file self,
+ section_name: &str,
+ ) -> Option<MachOSection<'data, 'file, Mach, R>> {
+ // Translate the "." prefix to the "__" prefix used by OSX/Mach-O, eg
+ // ".debug_info" to "__debug_info", and limit to 16 bytes total.
+ let system_name = if section_name.starts_with('.') {
+ if section_name.len() > 15 {
+ Some(&section_name[1..15])
+ } else {
+ Some(&section_name[1..])
+ }
+ } else {
+ None
+ };
+ let cmp_section_name = |section: &MachOSection<'data, 'file, Mach, R>| {
+ section
+ .name()
+ .map(|name| {
+ section_name == name
+ || system_name
+ .filter(|system_name| {
+ name.starts_with("__") && name[2..] == **system_name
+ })
+ .is_some()
+ })
+ .unwrap_or(false)
+ };
+
+ self.sections().find(cmp_section_name)
+ }
+
+ fn section_by_index(
+ &'file self,
+ index: SectionIndex,
+ ) -> Result<MachOSection<'data, 'file, Mach, R>> {
+ let internal = *self.section_internal(index)?;
+ Ok(MachOSection {
+ file: self,
+ internal,
+ })
+ }
+
+ fn sections(&'file self) -> MachOSectionIterator<'data, 'file, Mach, R> {
+ MachOSectionIterator {
+ file: self,
+ iter: self.sections.iter(),
+ }
+ }
+
+ fn comdats(&'file self) -> MachOComdatIterator<'data, 'file, Mach, R> {
+ MachOComdatIterator { file: self }
+ }
+
+ fn symbol_by_index(
+ &'file self,
+ index: SymbolIndex,
+ ) -> Result<MachOSymbol<'data, 'file, Mach, R>> {
+ let nlist = self.symbols.symbol(index.0)?;
+ MachOSymbol::new(self, index, nlist).read_error("Unsupported Mach-O symbol index")
+ }
+
+ fn symbols(&'file self) -> MachOSymbolIterator<'data, 'file, Mach, R> {
+ MachOSymbolIterator {
+ file: self,
+ index: 0,
+ }
+ }
+
+ #[inline]
+ fn symbol_table(&'file self) -> Option<MachOSymbolTable<'data, 'file, Mach, R>> {
+ Some(MachOSymbolTable { file: self })
+ }
+
+ fn dynamic_symbols(&'file self) -> MachOSymbolIterator<'data, 'file, Mach, R> {
+ MachOSymbolIterator {
+ file: self,
+ index: self.symbols.len(),
+ }
+ }
+
+ #[inline]
+ fn dynamic_symbol_table(&'file self) -> Option<MachOSymbolTable<'data, 'file, Mach, R>> {
+ None
+ }
+
+ fn object_map(&'file self) -> ObjectMap<'data> {
+ self.symbols.object_map(self.endian)
+ }
+
+ fn imports(&self) -> Result<Vec<Import<'data>>> {
+ let mut dysymtab = None;
+ let mut libraries = Vec::new();
+ let twolevel = self.header.flags(self.endian) & macho::MH_TWOLEVEL != 0;
+ if twolevel {
+ libraries.push(&[][..]);
+ }
+ let mut commands = self
+ .header
+ .load_commands(self.endian, self.data, self.header_offset)?;
+ while let Some(command) = commands.next()? {
+ if let Some(command) = command.dysymtab()? {
+ dysymtab = Some(command);
+ }
+ if twolevel {
+ if let Some(dylib) = command.dylib()? {
+ libraries.push(command.string(self.endian, dylib.dylib.name)?);
+ }
+ }
+ }
+
+ let mut imports = Vec::new();
+ if let Some(dysymtab) = dysymtab {
+ let index = dysymtab.iundefsym.get(self.endian) as usize;
+ let number = dysymtab.nundefsym.get(self.endian) as usize;
+ for i in index..(index.wrapping_add(number)) {
+ let symbol = self.symbols.symbol(i)?;
+ let name = symbol.name(self.endian, self.symbols.strings())?;
+ let library = if twolevel {
+ libraries
+ .get(symbol.library_ordinal(self.endian) as usize)
+ .copied()
+ .read_error("Invalid Mach-O symbol library ordinal")?
+ } else {
+ &[]
+ };
+ imports.push(Import {
+ name: ByteString(name),
+ library: ByteString(library),
+ });
+ }
+ }
+ Ok(imports)
+ }
+
+ fn exports(&self) -> Result<Vec<Export<'data>>> {
+ let mut dysymtab = None;
+ let mut commands = self
+ .header
+ .load_commands(self.endian, self.data, self.header_offset)?;
+ while let Some(command) = commands.next()? {
+ if let Some(command) = command.dysymtab()? {
+ dysymtab = Some(command);
+ break;
+ }
+ }
+
+ let mut exports = Vec::new();
+ if let Some(dysymtab) = dysymtab {
+ let index = dysymtab.iextdefsym.get(self.endian) as usize;
+ let number = dysymtab.nextdefsym.get(self.endian) as usize;
+ for i in index..(index.wrapping_add(number)) {
+ let symbol = self.symbols.symbol(i)?;
+ let name = symbol.name(self.endian, self.symbols.strings())?;
+ let address = symbol.n_value(self.endian).into();
+ exports.push(Export {
+ name: ByteString(name),
+ address,
+ });
+ }
+ }
+ Ok(exports)
+ }
+
+ #[inline]
+ fn dynamic_relocations(&'file self) -> Option<NoDynamicRelocationIterator> {
+ None
+ }
+
+ fn has_debug_symbols(&self) -> bool {
+ self.section_by_name(".debug_info").is_some()
+ }
+
+ fn mach_uuid(&self) -> Result<Option<[u8; 16]>> {
+ self.header.uuid(self.endian, self.data, self.header_offset)
+ }
+
+ fn relative_address_base(&self) -> u64 {
+ 0
+ }
+
+ fn entry(&self) -> u64 {
+ if let Ok(mut commands) =
+ self.header
+ .load_commands(self.endian, self.data, self.header_offset)
+ {
+ while let Ok(Some(command)) = commands.next() {
+ if let Ok(Some(command)) = command.entry_point() {
+ return command.entryoff.get(self.endian);
+ }
+ }
+ }
+ 0
+ }
+
+ fn flags(&self) -> FileFlags {
+ FileFlags::MachO {
+ flags: self.header.flags(self.endian),
+ }
+ }
+}
+
+/// An iterator over the COMDAT section groups of a `MachOFile64`.
+pub type MachOComdatIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOComdatIterator<'data, 'file, macho::MachHeader32<Endian>, R>;
+/// An iterator over the COMDAT section groups of a `MachOFile64`.
+pub type MachOComdatIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOComdatIterator<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// An iterator over the COMDAT section groups of a `MachOFile`.
+#[derive(Debug)]
+pub struct MachOComdatIterator<'data, 'file, Mach, R = &'data [u8]>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ file: &'file MachOFile<'data, Mach, R>,
+}
+
+impl<'data, 'file, Mach, R> Iterator for MachOComdatIterator<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ type Item = MachOComdat<'data, 'file, Mach, R>;
+
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
+
+/// A COMDAT section group of a `MachOFile32`.
+pub type MachOComdat32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOComdat<'data, 'file, macho::MachHeader32<Endian>, R>;
+
+/// A COMDAT section group of a `MachOFile64`.
+pub type MachOComdat64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOComdat<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// A COMDAT section group of a `MachOFile`.
+#[derive(Debug)]
+pub struct MachOComdat<'data, 'file, Mach, R = &'data [u8]>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ file: &'file MachOFile<'data, Mach, R>,
+}
+
+impl<'data, 'file, Mach, R> read::private::Sealed for MachOComdat<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Mach, R> ObjectComdat<'data> for MachOComdat<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ type SectionIterator = MachOComdatSectionIterator<'data, 'file, Mach, R>;
+
+ #[inline]
+ fn kind(&self) -> ComdatKind {
+ unreachable!();
+ }
+
+ #[inline]
+ fn symbol(&self) -> SymbolIndex {
+ unreachable!();
+ }
+
+ #[inline]
+ fn name(&self) -> Result<&str> {
+ unreachable!();
+ }
+
+ #[inline]
+ fn sections(&self) -> Self::SectionIterator {
+ unreachable!();
+ }
+}
+
+/// An iterator over the sections in a COMDAT section group of a `MachOFile32`.
+pub type MachOComdatSectionIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOComdatSectionIterator<'data, 'file, macho::MachHeader32<Endian>, R>;
+/// An iterator over the sections in a COMDAT section group of a `MachOFile64`.
+pub type MachOComdatSectionIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOComdatSectionIterator<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// An iterator over the sections in a COMDAT section group of a `MachOFile`.
+#[derive(Debug)]
+pub struct MachOComdatSectionIterator<'data, 'file, Mach, R = &'data [u8]>
+where
+ 'data: 'file,
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ file: &'file MachOFile<'data, Mach, R>,
+}
+
+impl<'data, 'file, Mach, R> Iterator for MachOComdatSectionIterator<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ type Item = SectionIndex;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
+
+/// A trait for generic access to `MachHeader32` and `MachHeader64`.
+#[allow(missing_docs)]
+pub trait MachHeader: Debug + Pod {
+ type Word: Into<u64>;
+ type Endian: endian::Endian;
+ type Segment: Segment<Endian = Self::Endian, Section = Self::Section>;
+ type Section: Section<Endian = Self::Endian>;
+ type Nlist: Nlist<Endian = Self::Endian>;
+
+ /// Return true if this type is a 64-bit header.
+ ///
+ /// This is a property of the type, not a value in the header data.
+ fn is_type_64(&self) -> bool;
+
+ /// Return true if the `magic` field signifies big-endian.
+ fn is_big_endian(&self) -> bool;
+
+ /// Return true if the `magic` field signifies little-endian.
+ fn is_little_endian(&self) -> bool;
+
+ fn magic(&self) -> u32;
+ fn cputype(&self, endian: Self::Endian) -> u32;
+ fn cpusubtype(&self, endian: Self::Endian) -> u32;
+ fn filetype(&self, endian: Self::Endian) -> u32;
+ fn ncmds(&self, endian: Self::Endian) -> u32;
+ fn sizeofcmds(&self, endian: Self::Endian) -> u32;
+ fn flags(&self, endian: Self::Endian) -> u32;
+
+ // Provided methods.
+
+ /// Read the file header.
+ ///
+ /// Also checks that the magic field in the file header is a supported format.
+ fn parse<'data, R: ReadRef<'data>>(data: R, offset: u64) -> read::Result<&'data Self> {
+ let header = data
+ .read_at::<Self>(offset)
+ .read_error("Invalid Mach-O header size or alignment")?;
+ if !header.is_supported() {
+ return Err(Error("Unsupported Mach-O header"));
+ }
+ Ok(header)
+ }
+
+ fn is_supported(&self) -> bool {
+ self.is_little_endian() || self.is_big_endian()
+ }
+
+ fn endian(&self) -> Result<Self::Endian> {
+ Self::Endian::from_big_endian(self.is_big_endian()).read_error("Unsupported Mach-O endian")
+ }
+
+ fn load_commands<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ header_offset: u64,
+ ) -> Result<LoadCommandIterator<'data, Self::Endian>> {
+ let data = data
+ .read_bytes_at(
+ header_offset + mem::size_of::<Self>() as u64,
+ self.sizeofcmds(endian).into(),
+ )
+ .read_error("Invalid Mach-O load command table size")?;
+ Ok(LoadCommandIterator::new(endian, data, self.ncmds(endian)))
+ }
+
+ /// Return the UUID from the `LC_UUID` load command, if one is present.
+ fn uuid<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ header_offset: u64,
+ ) -> Result<Option<[u8; 16]>> {
+ let mut commands = self.load_commands(endian, data, header_offset)?;
+ while let Some(command) = commands.next()? {
+ if let Ok(Some(uuid)) = command.uuid() {
+ return Ok(Some(uuid.uuid));
+ }
+ }
+ Ok(None)
+ }
+}
+
+impl<Endian: endian::Endian> MachHeader for macho::MachHeader32<Endian> {
+ type Word = u32;
+ type Endian = Endian;
+ type Segment = macho::SegmentCommand32<Endian>;
+ type Section = macho::Section32<Endian>;
+ type Nlist = macho::Nlist32<Endian>;
+
+ fn is_type_64(&self) -> bool {
+ false
+ }
+
+ fn is_big_endian(&self) -> bool {
+ self.magic() == macho::MH_MAGIC
+ }
+
+ fn is_little_endian(&self) -> bool {
+ self.magic() == macho::MH_CIGAM
+ }
+
+ fn magic(&self) -> u32 {
+ self.magic.get(BigEndian)
+ }
+
+ fn cputype(&self, endian: Self::Endian) -> u32 {
+ self.cputype.get(endian)
+ }
+
+ fn cpusubtype(&self, endian: Self::Endian) -> u32 {
+ self.cpusubtype.get(endian)
+ }
+
+ fn filetype(&self, endian: Self::Endian) -> u32 {
+ self.filetype.get(endian)
+ }
+
+ fn ncmds(&self, endian: Self::Endian) -> u32 {
+ self.ncmds.get(endian)
+ }
+
+ fn sizeofcmds(&self, endian: Self::Endian) -> u32 {
+ self.sizeofcmds.get(endian)
+ }
+
+ fn flags(&self, endian: Self::Endian) -> u32 {
+ self.flags.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> MachHeader for macho::MachHeader64<Endian> {
+ type Word = u64;
+ type Endian = Endian;
+ type Segment = macho::SegmentCommand64<Endian>;
+ type Section = macho::Section64<Endian>;
+ type Nlist = macho::Nlist64<Endian>;
+
+ fn is_type_64(&self) -> bool {
+ true
+ }
+
+ fn is_big_endian(&self) -> bool {
+ self.magic() == macho::MH_MAGIC_64
+ }
+
+ fn is_little_endian(&self) -> bool {
+ self.magic() == macho::MH_CIGAM_64
+ }
+
+ fn magic(&self) -> u32 {
+ self.magic.get(BigEndian)
+ }
+
+ fn cputype(&self, endian: Self::Endian) -> u32 {
+ self.cputype.get(endian)
+ }
+
+ fn cpusubtype(&self, endian: Self::Endian) -> u32 {
+ self.cpusubtype.get(endian)
+ }
+
+ fn filetype(&self, endian: Self::Endian) -> u32 {
+ self.filetype.get(endian)
+ }
+
+ fn ncmds(&self, endian: Self::Endian) -> u32 {
+ self.ncmds.get(endian)
+ }
+
+ fn sizeofcmds(&self, endian: Self::Endian) -> u32 {
+ self.sizeofcmds.get(endian)
+ }
+
+ fn flags(&self, endian: Self::Endian) -> u32 {
+ self.flags.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/macho/load_command.rs b/vendor/object-0.26.2/src/read/macho/load_command.rs
new file mode 100644
index 000000000..29fab6e0e
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/macho/load_command.rs
@@ -0,0 +1,348 @@
+use core::marker::PhantomData;
+
+use crate::endian::Endian;
+use crate::macho;
+use crate::pod::Pod;
+use crate::read::macho::{MachHeader, SymbolTable};
+use crate::read::{Bytes, ReadError, ReadRef, Result, StringTable};
+
+/// An iterator over the load commands of a `MachHeader`.
+#[derive(Debug, Default, Clone, Copy)]
+pub struct LoadCommandIterator<'data, E: Endian> {
+ endian: E,
+ data: Bytes<'data>,
+ ncmds: u32,
+}
+
+impl<'data, E: Endian> LoadCommandIterator<'data, E> {
+ pub(super) fn new(endian: E, data: &'data [u8], ncmds: u32) -> Self {
+ LoadCommandIterator {
+ endian,
+ data: Bytes(data),
+ ncmds,
+ }
+ }
+
+ /// Return the next load command.
+ pub fn next(&mut self) -> Result<Option<LoadCommandData<'data, E>>> {
+ if self.ncmds == 0 {
+ return Ok(None);
+ }
+ let header = self
+ .data
+ .read_at::<macho::LoadCommand<E>>(0)
+ .read_error("Invalid Mach-O load command header")?;
+ let cmd = header.cmd.get(self.endian);
+ let cmdsize = header.cmdsize.get(self.endian) as usize;
+ let data = self
+ .data
+ .read_bytes(cmdsize)
+ .read_error("Invalid Mach-O load command size")?;
+ self.ncmds -= 1;
+ Ok(Some(LoadCommandData {
+ cmd,
+ data,
+ marker: Default::default(),
+ }))
+ }
+}
+
+/// The data for a `LoadCommand`.
+#[derive(Debug, Clone, Copy)]
+pub struct LoadCommandData<'data, E: Endian> {
+ cmd: u32,
+ // Includes the header.
+ data: Bytes<'data>,
+ marker: PhantomData<E>,
+}
+
+impl<'data, E: Endian> LoadCommandData<'data, E> {
+ /// Return the `cmd` field of the `LoadCommand`.
+ ///
+ /// This is one of the `LC_` constants.
+ pub fn cmd(&self) -> u32 {
+ self.cmd
+ }
+
+ /// Return the `cmdsize` field of the `LoadCommand`.
+ pub fn cmdsize(&self) -> u32 {
+ self.data.len() as u32
+ }
+
+ /// Parse the data as the given type.
+ #[inline]
+ pub fn data<T: Pod>(&self) -> Result<&'data T> {
+ self.data
+ .read_at(0)
+ .read_error("Invalid Mach-O command size")
+ }
+
+ /// Parse a load command string value.
+ ///
+ /// Strings used by load commands are specified by offsets that are
+ /// relative to the load command header.
+ pub fn string(&self, endian: E, s: macho::LcStr<E>) -> Result<&'data [u8]> {
+ self.data
+ .read_string_at(s.offset.get(endian) as usize)
+ .read_error("Invalid load command string offset")
+ }
+
+ /// Parse the command data according to the `cmd` field.
+ pub fn variant(&self) -> Result<LoadCommandVariant<'data, E>> {
+ Ok(match self.cmd {
+ macho::LC_SEGMENT => {
+ let mut data = self.data;
+ let segment = data.read().read_error("Invalid Mach-O command size")?;
+ LoadCommandVariant::Segment32(segment, data.0)
+ }
+ macho::LC_SYMTAB => LoadCommandVariant::Symtab(self.data()?),
+ macho::LC_THREAD | macho::LC_UNIXTHREAD => {
+ let mut data = self.data;
+ let thread = data.read().read_error("Invalid Mach-O command size")?;
+ LoadCommandVariant::Thread(thread, data.0)
+ }
+ macho::LC_DYSYMTAB => LoadCommandVariant::Dysymtab(self.data()?),
+ macho::LC_LOAD_DYLIB
+ | macho::LC_LOAD_WEAK_DYLIB
+ | macho::LC_REEXPORT_DYLIB
+ | macho::LC_LAZY_LOAD_DYLIB
+ | macho::LC_LOAD_UPWARD_DYLIB => LoadCommandVariant::Dylib(self.data()?),
+ macho::LC_ID_DYLIB => LoadCommandVariant::IdDylib(self.data()?),
+ macho::LC_LOAD_DYLINKER => LoadCommandVariant::LoadDylinker(self.data()?),
+ macho::LC_ID_DYLINKER => LoadCommandVariant::IdDylinker(self.data()?),
+ macho::LC_PREBOUND_DYLIB => LoadCommandVariant::PreboundDylib(self.data()?),
+ macho::LC_ROUTINES => LoadCommandVariant::Routines32(self.data()?),
+ macho::LC_SUB_FRAMEWORK => LoadCommandVariant::SubFramework(self.data()?),
+ macho::LC_SUB_UMBRELLA => LoadCommandVariant::SubUmbrella(self.data()?),
+ macho::LC_SUB_CLIENT => LoadCommandVariant::SubClient(self.data()?),
+ macho::LC_SUB_LIBRARY => LoadCommandVariant::SubLibrary(self.data()?),
+ macho::LC_TWOLEVEL_HINTS => LoadCommandVariant::TwolevelHints(self.data()?),
+ macho::LC_PREBIND_CKSUM => LoadCommandVariant::PrebindCksum(self.data()?),
+ macho::LC_SEGMENT_64 => {
+ let mut data = self.data;
+ let segment = data.read().read_error("Invalid Mach-O command size")?;
+ LoadCommandVariant::Segment64(segment, data.0)
+ }
+ macho::LC_ROUTINES_64 => LoadCommandVariant::Routines64(self.data()?),
+ macho::LC_UUID => LoadCommandVariant::Uuid(self.data()?),
+ macho::LC_RPATH => LoadCommandVariant::Rpath(self.data()?),
+ macho::LC_CODE_SIGNATURE
+ | macho::LC_SEGMENT_SPLIT_INFO
+ | macho::LC_FUNCTION_STARTS
+ | macho::LC_DATA_IN_CODE
+ | macho::LC_DYLIB_CODE_SIGN_DRS
+ | macho::LC_LINKER_OPTIMIZATION_HINT
+ | macho::LC_DYLD_EXPORTS_TRIE
+ | macho::LC_DYLD_CHAINED_FIXUPS => LoadCommandVariant::LinkeditData(self.data()?),
+ macho::LC_ENCRYPTION_INFO => LoadCommandVariant::EncryptionInfo32(self.data()?),
+ macho::LC_DYLD_INFO | macho::LC_DYLD_INFO_ONLY => {
+ LoadCommandVariant::DyldInfo(self.data()?)
+ }
+ macho::LC_VERSION_MIN_MACOSX
+ | macho::LC_VERSION_MIN_IPHONEOS
+ | macho::LC_VERSION_MIN_TVOS
+ | macho::LC_VERSION_MIN_WATCHOS => LoadCommandVariant::VersionMin(self.data()?),
+ macho::LC_DYLD_ENVIRONMENT => LoadCommandVariant::DyldEnvironment(self.data()?),
+ macho::LC_MAIN => LoadCommandVariant::EntryPoint(self.data()?),
+ macho::LC_SOURCE_VERSION => LoadCommandVariant::SourceVersion(self.data()?),
+ macho::LC_ENCRYPTION_INFO_64 => LoadCommandVariant::EncryptionInfo64(self.data()?),
+ macho::LC_LINKER_OPTION => LoadCommandVariant::LinkerOption(self.data()?),
+ macho::LC_NOTE => LoadCommandVariant::Note(self.data()?),
+ macho::LC_BUILD_VERSION => LoadCommandVariant::BuildVersion(self.data()?),
+ macho::LC_FILESET_ENTRY => LoadCommandVariant::FilesetEntry(self.data()?),
+ _ => LoadCommandVariant::Other,
+ })
+ }
+
+ /// Try to parse this command as a `SegmentCommand32`.
+ ///
+ /// Returns the segment command and the data containing the sections.
+ pub fn segment_32(self) -> Result<Option<(&'data macho::SegmentCommand32<E>, &'data [u8])>> {
+ if self.cmd == macho::LC_SEGMENT {
+ let mut data = self.data;
+ let segment = data.read().read_error("Invalid Mach-O command size")?;
+ Ok(Some((segment, data.0)))
+ } else {
+ Ok(None)
+ }
+ }
+
+ /// Try to parse this command as a `SymtabCommand`.
+ ///
+ /// Returns the segment command and the data containing the sections.
+ pub fn symtab(self) -> Result<Option<&'data macho::SymtabCommand<E>>> {
+ if self.cmd == macho::LC_SYMTAB {
+ Some(self.data()).transpose()
+ } else {
+ Ok(None)
+ }
+ }
+
+ /// Try to parse this command as a `DysymtabCommand`.
+ pub fn dysymtab(self) -> Result<Option<&'data macho::DysymtabCommand<E>>> {
+ if self.cmd == macho::LC_DYSYMTAB {
+ Some(self.data()).transpose()
+ } else {
+ Ok(None)
+ }
+ }
+
+ /// Try to parse this command as a `DylibCommand`.
+ pub fn dylib(self) -> Result<Option<&'data macho::DylibCommand<E>>> {
+ if self.cmd == macho::LC_LOAD_DYLIB
+ || self.cmd == macho::LC_LOAD_WEAK_DYLIB
+ || self.cmd == macho::LC_REEXPORT_DYLIB
+ || self.cmd == macho::LC_LAZY_LOAD_DYLIB
+ || self.cmd == macho::LC_LOAD_UPWARD_DYLIB
+ {
+ Some(self.data()).transpose()
+ } else {
+ Ok(None)
+ }
+ }
+
+ /// Try to parse this command as a `UuidCommand`.
+ pub fn uuid(self) -> Result<Option<&'data macho::UuidCommand<E>>> {
+ if self.cmd == macho::LC_UUID {
+ Some(self.data()).transpose()
+ } else {
+ Ok(None)
+ }
+ }
+
+ /// Try to parse this command as a `SegmentCommand64`.
+ pub fn segment_64(self) -> Result<Option<(&'data macho::SegmentCommand64<E>, &'data [u8])>> {
+ if self.cmd == macho::LC_SEGMENT_64 {
+ let mut data = self.data;
+ let command = data.read().read_error("Invalid Mach-O command size")?;
+ Ok(Some((command, data.0)))
+ } else {
+ Ok(None)
+ }
+ }
+
+ /// Try to parse this command as a `DyldInfoCommand`.
+ pub fn dyld_info(self) -> Result<Option<&'data macho::DyldInfoCommand<E>>> {
+ if self.cmd == macho::LC_DYLD_INFO || self.cmd == macho::LC_DYLD_INFO_ONLY {
+ Some(self.data()).transpose()
+ } else {
+ Ok(None)
+ }
+ }
+
+ /// Try to parse this command as an `EntryPointCommand`.
+ pub fn entry_point(self) -> Result<Option<&'data macho::EntryPointCommand<E>>> {
+ if self.cmd == macho::LC_MAIN {
+ Some(self.data()).transpose()
+ } else {
+ Ok(None)
+ }
+ }
+}
+
+/// A `LoadCommand` that has been interpreted according to its `cmd` field.
+#[derive(Debug, Clone, Copy)]
+#[non_exhaustive]
+pub enum LoadCommandVariant<'data, E: Endian> {
+ /// `LC_SEGMENT`
+ Segment32(&'data macho::SegmentCommand32<E>, &'data [u8]),
+ /// `LC_SYMTAB`
+ Symtab(&'data macho::SymtabCommand<E>),
+ // obsolete: `LC_SYMSEG`
+ //Symseg(&'data macho::SymsegCommand<E>),
+ /// `LC_THREAD` or `LC_UNIXTHREAD`
+ Thread(&'data macho::ThreadCommand<E>, &'data [u8]),
+ // obsolete: `LC_IDFVMLIB` or `LC_LOADFVMLIB`
+ //Fvmlib(&'data macho::FvmlibCommand<E>),
+ // obsolete: `LC_IDENT`
+ //Ident(&'data macho::IdentCommand<E>),
+ // internal: `LC_FVMFILE`
+ //Fvmfile(&'data macho::FvmfileCommand<E>),
+ // internal: `LC_PREPAGE`
+ /// `LC_DYSYMTAB`
+ Dysymtab(&'data macho::DysymtabCommand<E>),
+ /// `LC_LOAD_DYLIB`, `LC_LOAD_WEAK_DYLIB`, `LC_REEXPORT_DYLIB`,
+ /// `LC_LAZY_LOAD_DYLIB`, or `LC_LOAD_UPWARD_DYLIB`
+ Dylib(&'data macho::DylibCommand<E>),
+ /// `LC_ID_DYLIB`
+ IdDylib(&'data macho::DylibCommand<E>),
+ /// `LC_LOAD_DYLINKER`
+ LoadDylinker(&'data macho::DylinkerCommand<E>),
+ /// `LC_ID_DYLINKER`
+ IdDylinker(&'data macho::DylinkerCommand<E>),
+ /// `LC_PREBOUND_DYLIB`
+ PreboundDylib(&'data macho::PreboundDylibCommand<E>),
+ /// `LC_ROUTINES`
+ Routines32(&'data macho::RoutinesCommand32<E>),
+ /// `LC_SUB_FRAMEWORK`
+ SubFramework(&'data macho::SubFrameworkCommand<E>),
+ /// `LC_SUB_UMBRELLA`
+ SubUmbrella(&'data macho::SubUmbrellaCommand<E>),
+ /// `LC_SUB_CLIENT`
+ SubClient(&'data macho::SubClientCommand<E>),
+ /// `LC_SUB_LIBRARY`
+ SubLibrary(&'data macho::SubLibraryCommand<E>),
+ /// `LC_TWOLEVEL_HINTS`
+ TwolevelHints(&'data macho::TwolevelHintsCommand<E>),
+ /// `LC_PREBIND_CKSUM`
+ PrebindCksum(&'data macho::PrebindCksumCommand<E>),
+ /// `LC_SEGMENT_64`
+ Segment64(&'data macho::SegmentCommand64<E>, &'data [u8]),
+ /// `LC_ROUTINES_64`
+ Routines64(&'data macho::RoutinesCommand64<E>),
+ /// `LC_UUID`
+ Uuid(&'data macho::UuidCommand<E>),
+ /// `LC_RPATH`
+ Rpath(&'data macho::RpathCommand<E>),
+ /// `LC_CODE_SIGNATURE`, `LC_SEGMENT_SPLIT_INFO`, `LC_FUNCTION_STARTS`,
+ /// `LC_DATA_IN_CODE`, `LC_DYLIB_CODE_SIGN_DRS`, `LC_LINKER_OPTIMIZATION_HINT`,
+ /// `LC_DYLD_EXPORTS_TRIE`, or `LC_DYLD_CHAINED_FIXUPS`.
+ LinkeditData(&'data macho::LinkeditDataCommand<E>),
+ /// `LC_ENCRYPTION_INFO`
+ EncryptionInfo32(&'data macho::EncryptionInfoCommand32<E>),
+ /// `LC_DYLD_INFO` or `LC_DYLD_INFO_ONLY`
+ DyldInfo(&'data macho::DyldInfoCommand<E>),
+ /// `LC_VERSION_MIN_MACOSX`, `LC_VERSION_MIN_IPHONEOS`, `LC_VERSION_MIN_WATCHOS`,
+ /// or `LC_VERSION_MIN_TVOS`
+ VersionMin(&'data macho::VersionMinCommand<E>),
+ /// `LC_DYLD_ENVIRONMENT`
+ DyldEnvironment(&'data macho::DylinkerCommand<E>),
+ /// `LC_MAIN`
+ EntryPoint(&'data macho::EntryPointCommand<E>),
+ /// `LC_SOURCE_VERSION`
+ SourceVersion(&'data macho::SourceVersionCommand<E>),
+ /// `LC_ENCRYPTION_INFO_64`
+ EncryptionInfo64(&'data macho::EncryptionInfoCommand64<E>),
+ /// `LC_LINKER_OPTION`
+ LinkerOption(&'data macho::LinkerOptionCommand<E>),
+ /// `LC_NOTE`
+ Note(&'data macho::NoteCommand<E>),
+ /// `LC_BUILD_VERSION`
+ BuildVersion(&'data macho::BuildVersionCommand<E>),
+ /// `LC_FILESET_ENTRY`
+ FilesetEntry(&'data macho::FilesetEntryCommand<E>),
+ /// An unrecognized or obsolete load command.
+ Other,
+}
+
+impl<E: Endian> macho::SymtabCommand<E> {
+ /// Return the symbol table that this command references.
+ pub fn symbols<'data, Mach: MachHeader<Endian = E>, R: ReadRef<'data>>(
+ &self,
+ endian: E,
+ data: R,
+ ) -> Result<SymbolTable<'data, Mach, R>> {
+ let symbols = data
+ .read_slice_at(
+ self.symoff.get(endian).into(),
+ self.nsyms.get(endian) as usize,
+ )
+ .read_error("Invalid Mach-O symbol table offset or size")?;
+ let str_start: u64 = self.stroff.get(endian).into();
+ let str_end = str_start
+ .checked_add(self.strsize.get(endian).into())
+ .read_error("Invalid Mach-O string table length")?;
+ let strings = StringTable::new(data, str_start, str_end);
+ Ok(SymbolTable::new(symbols, strings))
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/macho/mod.rs b/vendor/object-0.26.2/src/read/macho/mod.rs
new file mode 100644
index 000000000..f07ed581b
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/macho/mod.rs
@@ -0,0 +1,30 @@
+//! Support for reading Mach-O files.
+//!
+//! Defines traits to abstract over the difference between 32-bit and 64-bit
+//! Mach-O files, and implements read functionality in terms of these traits.
+//!
+//! Also provides `MachOFile` and related types which implement the `Object` trait.
+
+mod dyld_cache;
+pub use dyld_cache::*;
+
+mod fat;
+pub use fat::*;
+
+mod file;
+pub use file::*;
+
+mod load_command;
+pub use load_command::*;
+
+mod segment;
+pub use segment::*;
+
+mod section;
+pub use section::*;
+
+mod symbol;
+pub use symbol::*;
+
+mod relocation;
+pub use relocation::*;
diff --git a/vendor/object-0.26.2/src/read/macho/relocation.rs b/vendor/object-0.26.2/src/read/macho/relocation.rs
new file mode 100644
index 000000000..5dd7df896
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/macho/relocation.rs
@@ -0,0 +1,126 @@
+use core::{fmt, slice};
+
+use crate::endian::Endianness;
+use crate::macho;
+use crate::read::{
+ ReadRef, Relocation, RelocationEncoding, RelocationKind, RelocationTarget, SectionIndex,
+ SymbolIndex,
+};
+
+use super::{MachHeader, MachOFile};
+
+/// An iterator over the relocations in a `MachOSection32`.
+pub type MachORelocationIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachORelocationIterator<'data, 'file, macho::MachHeader32<Endian>, R>;
+/// An iterator over the relocations in a `MachOSection64`.
+pub type MachORelocationIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachORelocationIterator<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// An iterator over the relocations in a `MachOSection`.
+pub struct MachORelocationIterator<'data, 'file, Mach, R = &'data [u8]>
+where
+ 'data: 'file,
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file MachOFile<'data, Mach, R>,
+ pub(super) relocations: slice::Iter<'data, macho::Relocation<Mach::Endian>>,
+}
+
+impl<'data, 'file, Mach, R> Iterator for MachORelocationIterator<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ type Item = (u64, Relocation);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ loop {
+ let reloc = self.relocations.next()?;
+ let endian = self.file.endian;
+ let cputype = self.file.header.cputype(endian);
+ if reloc.r_scattered(endian, cputype) {
+ // FIXME: handle scattered relocations
+ // We need to add `RelocationTarget::Address` for this.
+ continue;
+ }
+ let reloc = reloc.info(self.file.endian);
+ let mut encoding = RelocationEncoding::Generic;
+ let kind = match cputype {
+ macho::CPU_TYPE_ARM => match (reloc.r_type, reloc.r_pcrel) {
+ (macho::ARM_RELOC_VANILLA, false) => RelocationKind::Absolute,
+ _ => RelocationKind::MachO {
+ value: reloc.r_type,
+ relative: reloc.r_pcrel,
+ },
+ },
+ macho::CPU_TYPE_ARM64 => match (reloc.r_type, reloc.r_pcrel) {
+ (macho::ARM64_RELOC_UNSIGNED, false) => RelocationKind::Absolute,
+ _ => RelocationKind::MachO {
+ value: reloc.r_type,
+ relative: reloc.r_pcrel,
+ },
+ },
+ macho::CPU_TYPE_X86 => match (reloc.r_type, reloc.r_pcrel) {
+ (macho::GENERIC_RELOC_VANILLA, false) => RelocationKind::Absolute,
+ _ => RelocationKind::MachO {
+ value: reloc.r_type,
+ relative: reloc.r_pcrel,
+ },
+ },
+ macho::CPU_TYPE_X86_64 => match (reloc.r_type, reloc.r_pcrel) {
+ (macho::X86_64_RELOC_UNSIGNED, false) => RelocationKind::Absolute,
+ (macho::X86_64_RELOC_SIGNED, true) => {
+ encoding = RelocationEncoding::X86RipRelative;
+ RelocationKind::Relative
+ }
+ (macho::X86_64_RELOC_BRANCH, true) => {
+ encoding = RelocationEncoding::X86Branch;
+ RelocationKind::Relative
+ }
+ (macho::X86_64_RELOC_GOT, true) => RelocationKind::GotRelative,
+ (macho::X86_64_RELOC_GOT_LOAD, true) => {
+ encoding = RelocationEncoding::X86RipRelativeMovq;
+ RelocationKind::GotRelative
+ }
+ _ => RelocationKind::MachO {
+ value: reloc.r_type,
+ relative: reloc.r_pcrel,
+ },
+ },
+ _ => RelocationKind::MachO {
+ value: reloc.r_type,
+ relative: reloc.r_pcrel,
+ },
+ };
+ let size = 8 << reloc.r_length;
+ let target = if reloc.r_extern {
+ RelocationTarget::Symbol(SymbolIndex(reloc.r_symbolnum as usize))
+ } else {
+ RelocationTarget::Section(SectionIndex(reloc.r_symbolnum as usize))
+ };
+ let addend = if reloc.r_pcrel { -4 } else { 0 };
+ return Some((
+ reloc.r_address as u64,
+ Relocation {
+ kind,
+ encoding,
+ size,
+ target,
+ addend,
+ implicit_addend: true,
+ },
+ ));
+ }
+ }
+}
+
+impl<'data, 'file, Mach, R> fmt::Debug for MachORelocationIterator<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("MachORelocationIterator").finish()
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/macho/section.rs b/vendor/object-0.26.2/src/read/macho/section.rs
new file mode 100644
index 000000000..7b467da2d
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/macho/section.rs
@@ -0,0 +1,366 @@
+use core::fmt::Debug;
+use core::{fmt, result, slice, str};
+
+use crate::endian::{self, Endianness};
+use crate::macho;
+use crate::pod::Pod;
+use crate::read::{
+ self, CompressedData, CompressedFileRange, ObjectSection, ReadError, ReadRef, Result,
+ SectionFlags, SectionIndex, SectionKind,
+};
+
+use super::{MachHeader, MachOFile, MachORelocationIterator};
+
+/// An iterator over the sections of a `MachOFile32`.
+pub type MachOSectionIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSectionIterator<'data, 'file, macho::MachHeader32<Endian>, R>;
+/// An iterator over the sections of a `MachOFile64`.
+pub type MachOSectionIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSectionIterator<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// An iterator over the sections of a `MachOFile`.
+pub struct MachOSectionIterator<'data, 'file, Mach, R = &'data [u8]>
+where
+ 'data: 'file,
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file MachOFile<'data, Mach, R>,
+ pub(super) iter: slice::Iter<'file, MachOSectionInternal<'data, Mach>>,
+}
+
+impl<'data, 'file, Mach, R> fmt::Debug for MachOSectionIterator<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ // It's painful to do much better than this
+ f.debug_struct("MachOSectionIterator").finish()
+ }
+}
+
+impl<'data, 'file, Mach, R> Iterator for MachOSectionIterator<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ type Item = MachOSection<'data, 'file, Mach, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.iter.next().map(|&internal| MachOSection {
+ file: self.file,
+ internal,
+ })
+ }
+}
+
+/// A section of a `MachOFile32`.
+pub type MachOSection32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSection<'data, 'file, macho::MachHeader32<Endian>, R>;
+/// A section of a `MachOFile64`.
+pub type MachOSection64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSection<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// A section of a `MachOFile`.
+#[derive(Debug)]
+pub struct MachOSection<'data, 'file, Mach, R = &'data [u8]>
+where
+ 'data: 'file,
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file MachOFile<'data, Mach, R>,
+ pub(super) internal: MachOSectionInternal<'data, Mach>,
+}
+
+impl<'data, 'file, Mach, R> MachOSection<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ fn bytes(&self) -> Result<&'data [u8]> {
+ self.internal
+ .section
+ .data(self.file.endian, self.file.data)
+ .read_error("Invalid Mach-O section size or offset")
+ }
+}
+
+impl<'data, 'file, Mach, R> read::private::Sealed for MachOSection<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Mach, R> ObjectSection<'data> for MachOSection<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ type RelocationIterator = MachORelocationIterator<'data, 'file, Mach, R>;
+
+ #[inline]
+ fn index(&self) -> SectionIndex {
+ self.internal.index
+ }
+
+ #[inline]
+ fn address(&self) -> u64 {
+ self.internal.section.addr(self.file.endian).into()
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ self.internal.section.size(self.file.endian).into()
+ }
+
+ #[inline]
+ fn align(&self) -> u64 {
+ 1 << self.internal.section.align(self.file.endian)
+ }
+
+ #[inline]
+ fn file_range(&self) -> Option<(u64, u64)> {
+ self.internal.section.file_range(self.file.endian)
+ }
+
+ #[inline]
+ fn data(&self) -> Result<&'data [u8]> {
+ self.bytes()
+ }
+
+ fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
+ Ok(read::util::data_range(
+ self.bytes()?,
+ self.address(),
+ address,
+ size,
+ ))
+ }
+
+ #[inline]
+ fn compressed_file_range(&self) -> Result<CompressedFileRange> {
+ Ok(CompressedFileRange::none(self.file_range()))
+ }
+
+ #[inline]
+ fn compressed_data(&self) -> Result<CompressedData<'data>> {
+ self.data().map(CompressedData::none)
+ }
+
+ #[inline]
+ fn name(&self) -> Result<&str> {
+ str::from_utf8(self.internal.section.name())
+ .ok()
+ .read_error("Non UTF-8 Mach-O section name")
+ }
+
+ #[inline]
+ fn segment_name(&self) -> Result<Option<&str>> {
+ Ok(Some(
+ str::from_utf8(self.internal.section.segment_name())
+ .ok()
+ .read_error("Non UTF-8 Mach-O segment name")?,
+ ))
+ }
+
+ fn kind(&self) -> SectionKind {
+ self.internal.kind
+ }
+
+ fn relocations(&self) -> MachORelocationIterator<'data, 'file, Mach, R> {
+ MachORelocationIterator {
+ file: self.file,
+ relocations: self
+ .internal
+ .section
+ .relocations(self.file.endian, self.file.data)
+ .unwrap_or(&[])
+ .iter(),
+ }
+ }
+
+ fn flags(&self) -> SectionFlags {
+ SectionFlags::MachO {
+ flags: self.internal.section.flags(self.file.endian),
+ }
+ }
+}
+
+#[derive(Debug, Clone, Copy)]
+pub(super) struct MachOSectionInternal<'data, Mach: MachHeader> {
+ pub index: SectionIndex,
+ pub kind: SectionKind,
+ pub section: &'data Mach::Section,
+}
+
+impl<'data, Mach: MachHeader> MachOSectionInternal<'data, Mach> {
+ pub(super) fn parse(index: SectionIndex, section: &'data Mach::Section) -> Self {
+ // TODO: we don't validate flags, should we?
+ let kind = match (section.segment_name(), section.name()) {
+ (b"__TEXT", b"__text") => SectionKind::Text,
+ (b"__TEXT", b"__const") => SectionKind::ReadOnlyData,
+ (b"__TEXT", b"__cstring") => SectionKind::ReadOnlyString,
+ (b"__TEXT", b"__literal4") => SectionKind::ReadOnlyData,
+ (b"__TEXT", b"__literal8") => SectionKind::ReadOnlyData,
+ (b"__TEXT", b"__literal16") => SectionKind::ReadOnlyData,
+ (b"__TEXT", b"__eh_frame") => SectionKind::ReadOnlyData,
+ (b"__TEXT", b"__gcc_except_tab") => SectionKind::ReadOnlyData,
+ (b"__DATA", b"__data") => SectionKind::Data,
+ (b"__DATA", b"__const") => SectionKind::ReadOnlyData,
+ (b"__DATA", b"__bss") => SectionKind::UninitializedData,
+ (b"__DATA", b"__common") => SectionKind::Common,
+ (b"__DATA", b"__thread_data") => SectionKind::Tls,
+ (b"__DATA", b"__thread_bss") => SectionKind::UninitializedTls,
+ (b"__DATA", b"__thread_vars") => SectionKind::TlsVariables,
+ (b"__DWARF", _) => SectionKind::Debug,
+ _ => SectionKind::Unknown,
+ };
+ MachOSectionInternal {
+ index,
+ kind,
+ section,
+ }
+ }
+}
+
+/// A trait for generic access to `Section32` and `Section64`.
+#[allow(missing_docs)]
+pub trait Section: Debug + Pod {
+ type Word: Into<u64>;
+ type Endian: endian::Endian;
+
+ fn sectname(&self) -> &[u8; 16];
+ fn segname(&self) -> &[u8; 16];
+ fn addr(&self, endian: Self::Endian) -> Self::Word;
+ fn size(&self, endian: Self::Endian) -> Self::Word;
+ fn offset(&self, endian: Self::Endian) -> u32;
+ fn align(&self, endian: Self::Endian) -> u32;
+ fn reloff(&self, endian: Self::Endian) -> u32;
+ fn nreloc(&self, endian: Self::Endian) -> u32;
+ fn flags(&self, endian: Self::Endian) -> u32;
+
+ /// Return the `sectname` bytes up until the null terminator.
+ fn name(&self) -> &[u8] {
+ let sectname = &self.sectname()[..];
+ match memchr::memchr(b'\0', sectname) {
+ Some(end) => &sectname[..end],
+ None => sectname,
+ }
+ }
+
+ /// Return the `segname` bytes up until the null terminator.
+ fn segment_name(&self) -> &[u8] {
+ let segname = &self.segname()[..];
+ match memchr::memchr(b'\0', segname) {
+ Some(end) => &segname[..end],
+ None => segname,
+ }
+ }
+
+ /// Return the offset and size of the section in the file.
+ ///
+ /// Returns `None` for sections that have no data in the file.
+ fn file_range(&self, endian: Self::Endian) -> Option<(u64, u64)> {
+ match self.flags(endian) & macho::SECTION_TYPE {
+ macho::S_ZEROFILL | macho::S_GB_ZEROFILL | macho::S_THREAD_LOCAL_ZEROFILL => None,
+ _ => Some((self.offset(endian).into(), self.size(endian).into())),
+ }
+ }
+
+ /// Return the section data.
+ ///
+ /// Returns `Ok(&[])` if the section has no data.
+ /// Returns `Err` for invalid values.
+ fn data<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> result::Result<&'data [u8], ()> {
+ if let Some((offset, size)) = self.file_range(endian) {
+ data.read_bytes_at(offset, size)
+ } else {
+ Ok(&[])
+ }
+ }
+
+ /// Return the relocation array.
+ ///
+ /// Returns `Err` for invalid values.
+ fn relocations<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> Result<&'data [macho::Relocation<Self::Endian>]> {
+ data.read_slice_at(self.reloff(endian).into(), self.nreloc(endian) as usize)
+ .read_error("Invalid Mach-O relocations offset or number")
+ }
+}
+
+impl<Endian: endian::Endian> Section for macho::Section32<Endian> {
+ type Word = u32;
+ type Endian = Endian;
+
+ fn sectname(&self) -> &[u8; 16] {
+ &self.sectname
+ }
+ fn segname(&self) -> &[u8; 16] {
+ &self.segname
+ }
+ fn addr(&self, endian: Self::Endian) -> Self::Word {
+ self.addr.get(endian)
+ }
+ fn size(&self, endian: Self::Endian) -> Self::Word {
+ self.size.get(endian)
+ }
+ fn offset(&self, endian: Self::Endian) -> u32 {
+ self.offset.get(endian)
+ }
+ fn align(&self, endian: Self::Endian) -> u32 {
+ self.align.get(endian)
+ }
+ fn reloff(&self, endian: Self::Endian) -> u32 {
+ self.reloff.get(endian)
+ }
+ fn nreloc(&self, endian: Self::Endian) -> u32 {
+ self.nreloc.get(endian)
+ }
+ fn flags(&self, endian: Self::Endian) -> u32 {
+ self.flags.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> Section for macho::Section64<Endian> {
+ type Word = u64;
+ type Endian = Endian;
+
+ fn sectname(&self) -> &[u8; 16] {
+ &self.sectname
+ }
+ fn segname(&self) -> &[u8; 16] {
+ &self.segname
+ }
+ fn addr(&self, endian: Self::Endian) -> Self::Word {
+ self.addr.get(endian)
+ }
+ fn size(&self, endian: Self::Endian) -> Self::Word {
+ self.size.get(endian)
+ }
+ fn offset(&self, endian: Self::Endian) -> u32 {
+ self.offset.get(endian)
+ }
+ fn align(&self, endian: Self::Endian) -> u32 {
+ self.align.get(endian)
+ }
+ fn reloff(&self, endian: Self::Endian) -> u32 {
+ self.reloff.get(endian)
+ }
+ fn nreloc(&self, endian: Self::Endian) -> u32 {
+ self.nreloc.get(endian)
+ }
+ fn flags(&self, endian: Self::Endian) -> u32 {
+ self.flags.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/macho/segment.rs b/vendor/object-0.26.2/src/read/macho/segment.rs
new file mode 100644
index 000000000..d0e90b021
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/macho/segment.rs
@@ -0,0 +1,284 @@
+use core::fmt::Debug;
+use core::{result, str};
+
+use crate::endian::{self, Endianness};
+use crate::macho;
+use crate::pod::Pod;
+use crate::read::{self, ObjectSegment, ReadError, ReadRef, Result};
+
+use super::{LoadCommandData, LoadCommandIterator, MachHeader, MachOFile, Section};
+
+/// An iterator over the segments of a `MachOFile32`.
+pub type MachOSegmentIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSegmentIterator<'data, 'file, macho::MachHeader32<Endian>, R>;
+/// An iterator over the segments of a `MachOFile64`.
+pub type MachOSegmentIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSegmentIterator<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// An iterator over the segments of a `MachOFile`.
+#[derive(Debug)]
+pub struct MachOSegmentIterator<'data, 'file, Mach, R = &'data [u8]>
+where
+ 'data: 'file,
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file MachOFile<'data, Mach, R>,
+ pub(super) commands: LoadCommandIterator<'data, Mach::Endian>,
+}
+
+impl<'data, 'file, Mach, R> Iterator for MachOSegmentIterator<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ type Item = MachOSegment<'data, 'file, Mach, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ loop {
+ let command = self.commands.next().ok()??;
+ if let Ok(Some((segment, _))) = Mach::Segment::from_command(command) {
+ return Some(MachOSegment {
+ file: self.file,
+ segment,
+ });
+ }
+ }
+ }
+}
+
+/// A segment of a `MachOFile32`.
+pub type MachOSegment32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSegment<'data, 'file, macho::MachHeader32<Endian>, R>;
+/// A segment of a `MachOFile64`.
+pub type MachOSegment64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSegment<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// A segment of a `MachOFile`.
+#[derive(Debug)]
+pub struct MachOSegment<'data, 'file, Mach, R = &'data [u8]>
+where
+ 'data: 'file,
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ file: &'file MachOFile<'data, Mach, R>,
+ segment: &'data Mach::Segment,
+}
+
+impl<'data, 'file, Mach, R> MachOSegment<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ fn bytes(&self) -> Result<&'data [u8]> {
+ self.segment
+ .data(self.file.endian, self.file.data)
+ .read_error("Invalid Mach-O segment size or offset")
+ }
+}
+
+impl<'data, 'file, Mach, R> read::private::Sealed for MachOSegment<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Mach, R> ObjectSegment<'data> for MachOSegment<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ #[inline]
+ fn address(&self) -> u64 {
+ self.segment.vmaddr(self.file.endian).into()
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ self.segment.vmsize(self.file.endian).into()
+ }
+
+ #[inline]
+ fn align(&self) -> u64 {
+ // Page size.
+ 0x1000
+ }
+
+ #[inline]
+ fn file_range(&self) -> (u64, u64) {
+ self.segment.file_range(self.file.endian)
+ }
+
+ fn data(&self) -> Result<&'data [u8]> {
+ self.bytes()
+ }
+
+ fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
+ Ok(read::util::data_range(
+ self.bytes()?,
+ self.address(),
+ address,
+ size,
+ ))
+ }
+
+ #[inline]
+ fn name(&self) -> Result<Option<&str>> {
+ Ok(Some(
+ str::from_utf8(self.segment.name())
+ .ok()
+ .read_error("Non UTF-8 Mach-O segment name")?,
+ ))
+ }
+}
+
+/// A trait for generic access to `SegmentCommand32` and `SegmentCommand64`.
+#[allow(missing_docs)]
+pub trait Segment: Debug + Pod {
+ type Word: Into<u64>;
+ type Endian: endian::Endian;
+ type Section: Section<Endian = Self::Endian>;
+
+ fn from_command(command: LoadCommandData<Self::Endian>) -> Result<Option<(&Self, &[u8])>>;
+
+ fn cmd(&self, endian: Self::Endian) -> u32;
+ fn cmdsize(&self, endian: Self::Endian) -> u32;
+ fn segname(&self) -> &[u8; 16];
+ fn vmaddr(&self, endian: Self::Endian) -> Self::Word;
+ fn vmsize(&self, endian: Self::Endian) -> Self::Word;
+ fn fileoff(&self, endian: Self::Endian) -> Self::Word;
+ fn filesize(&self, endian: Self::Endian) -> Self::Word;
+ fn maxprot(&self, endian: Self::Endian) -> u32;
+ fn initprot(&self, endian: Self::Endian) -> u32;
+ fn nsects(&self, endian: Self::Endian) -> u32;
+ fn flags(&self, endian: Self::Endian) -> u32;
+
+ /// Return the `segname` bytes up until the null terminator.
+ fn name(&self) -> &[u8] {
+ let segname = &self.segname()[..];
+ match memchr::memchr(b'\0', segname) {
+ Some(end) => &segname[..end],
+ None => segname,
+ }
+ }
+
+ /// Return the offset and size of the segment in the file.
+ fn file_range(&self, endian: Self::Endian) -> (u64, u64) {
+ (self.fileoff(endian).into(), self.filesize(endian).into())
+ }
+
+ /// Get the segment data from the file data.
+ ///
+ /// Returns `Err` for invalid values.
+ fn data<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ data: R,
+ ) -> result::Result<&'data [u8], ()> {
+ let (offset, size) = self.file_range(endian);
+ data.read_bytes_at(offset, size)
+ }
+
+ /// Get the array of sections from the data following the segment command.
+ ///
+ /// Returns `Err` for invalid values.
+ fn sections<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ section_data: R,
+ ) -> Result<&'data [Self::Section]> {
+ section_data
+ .read_slice_at(0, self.nsects(endian) as usize)
+ .read_error("Invalid Mach-O number of sections")
+ }
+}
+
+impl<Endian: endian::Endian> Segment for macho::SegmentCommand32<Endian> {
+ type Word = u32;
+ type Endian = Endian;
+ type Section = macho::Section32<Self::Endian>;
+
+ fn from_command(command: LoadCommandData<Self::Endian>) -> Result<Option<(&Self, &[u8])>> {
+ command.segment_32()
+ }
+
+ fn cmd(&self, endian: Self::Endian) -> u32 {
+ self.cmd.get(endian)
+ }
+ fn cmdsize(&self, endian: Self::Endian) -> u32 {
+ self.cmdsize.get(endian)
+ }
+ fn segname(&self) -> &[u8; 16] {
+ &self.segname
+ }
+ fn vmaddr(&self, endian: Self::Endian) -> Self::Word {
+ self.vmaddr.get(endian)
+ }
+ fn vmsize(&self, endian: Self::Endian) -> Self::Word {
+ self.vmsize.get(endian)
+ }
+ fn fileoff(&self, endian: Self::Endian) -> Self::Word {
+ self.fileoff.get(endian)
+ }
+ fn filesize(&self, endian: Self::Endian) -> Self::Word {
+ self.filesize.get(endian)
+ }
+ fn maxprot(&self, endian: Self::Endian) -> u32 {
+ self.maxprot.get(endian)
+ }
+ fn initprot(&self, endian: Self::Endian) -> u32 {
+ self.initprot.get(endian)
+ }
+ fn nsects(&self, endian: Self::Endian) -> u32 {
+ self.nsects.get(endian)
+ }
+ fn flags(&self, endian: Self::Endian) -> u32 {
+ self.flags.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> Segment for macho::SegmentCommand64<Endian> {
+ type Word = u64;
+ type Endian = Endian;
+ type Section = macho::Section64<Self::Endian>;
+
+ fn from_command(command: LoadCommandData<Self::Endian>) -> Result<Option<(&Self, &[u8])>> {
+ command.segment_64()
+ }
+
+ fn cmd(&self, endian: Self::Endian) -> u32 {
+ self.cmd.get(endian)
+ }
+ fn cmdsize(&self, endian: Self::Endian) -> u32 {
+ self.cmdsize.get(endian)
+ }
+ fn segname(&self) -> &[u8; 16] {
+ &self.segname
+ }
+ fn vmaddr(&self, endian: Self::Endian) -> Self::Word {
+ self.vmaddr.get(endian)
+ }
+ fn vmsize(&self, endian: Self::Endian) -> Self::Word {
+ self.vmsize.get(endian)
+ }
+ fn fileoff(&self, endian: Self::Endian) -> Self::Word {
+ self.fileoff.get(endian)
+ }
+ fn filesize(&self, endian: Self::Endian) -> Self::Word {
+ self.filesize.get(endian)
+ }
+ fn maxprot(&self, endian: Self::Endian) -> u32 {
+ self.maxprot.get(endian)
+ }
+ fn initprot(&self, endian: Self::Endian) -> u32 {
+ self.initprot.get(endian)
+ }
+ fn nsects(&self, endian: Self::Endian) -> u32 {
+ self.nsects.get(endian)
+ }
+ fn flags(&self, endian: Self::Endian) -> u32 {
+ self.flags.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/macho/symbol.rs b/vendor/object-0.26.2/src/read/macho/symbol.rs
new file mode 100644
index 000000000..1528d52eb
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/macho/symbol.rs
@@ -0,0 +1,486 @@
+use alloc::vec::Vec;
+use core::fmt::Debug;
+use core::{fmt, slice, str};
+
+use crate::endian::{self, Endianness};
+use crate::macho;
+use crate::pod::Pod;
+use crate::read::util::StringTable;
+use crate::read::{
+ self, ObjectMap, ObjectMapEntry, ObjectSymbol, ObjectSymbolTable, ReadError, ReadRef, Result,
+ SectionIndex, SectionKind, SymbolFlags, SymbolIndex, SymbolKind, SymbolMap, SymbolMapEntry,
+ SymbolScope, SymbolSection,
+};
+
+use super::{MachHeader, MachOFile};
+
+/// A table of symbol entries in a Mach-O file.
+///
+/// Also includes the string table used for the symbol names.
+#[derive(Debug, Clone, Copy)]
+pub struct SymbolTable<'data, Mach: MachHeader, R = &'data [u8]>
+where
+ R: ReadRef<'data>,
+{
+ symbols: &'data [Mach::Nlist],
+ strings: StringTable<'data, R>,
+}
+
+impl<'data, Mach: MachHeader, R: ReadRef<'data>> Default for SymbolTable<'data, Mach, R> {
+ fn default() -> Self {
+ SymbolTable {
+ symbols: &[],
+ strings: Default::default(),
+ }
+ }
+}
+
+impl<'data, Mach: MachHeader, R: ReadRef<'data>> SymbolTable<'data, Mach, R> {
+ #[inline]
+ pub(super) fn new(symbols: &'data [Mach::Nlist], strings: StringTable<'data, R>) -> Self {
+ SymbolTable { symbols, strings }
+ }
+
+ /// Return the string table used for the symbol names.
+ #[inline]
+ pub fn strings(&self) -> StringTable<'data, R> {
+ self.strings
+ }
+
+ /// Iterate over the symbols.
+ #[inline]
+ pub fn iter(&self) -> slice::Iter<'data, Mach::Nlist> {
+ self.symbols.iter()
+ }
+
+ /// Return true if the symbol table is empty.
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.symbols.is_empty()
+ }
+
+ /// The number of symbols.
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.symbols.len()
+ }
+
+ /// Return the symbol at the given index.
+ pub fn symbol(&self, index: usize) -> Result<&'data Mach::Nlist> {
+ self.symbols
+ .get(index)
+ .read_error("Invalid Mach-O symbol index")
+ }
+
+ /// Construct a map from addresses to a user-defined map entry.
+ pub fn map<Entry: SymbolMapEntry, F: Fn(&'data Mach::Nlist) -> Option<Entry>>(
+ &self,
+ f: F,
+ ) -> SymbolMap<Entry> {
+ let mut symbols = Vec::new();
+ for nlist in self.symbols {
+ if !nlist.is_definition() {
+ continue;
+ }
+ if let Some(entry) = f(nlist) {
+ symbols.push(entry);
+ }
+ }
+ SymbolMap::new(symbols)
+ }
+
+ /// Construct a map from addresses to symbol names and object file names.
+ pub fn object_map(&self, endian: Mach::Endian) -> ObjectMap<'data> {
+ let mut symbols = Vec::new();
+ let mut objects = Vec::new();
+ let mut object = None;
+ let mut current_function = None;
+ // Each module starts with one or two N_SO symbols (path, or directory + filename)
+ // and one N_OSO symbol. The module is terminated by an empty N_SO symbol.
+ for nlist in self.symbols {
+ let n_type = nlist.n_type();
+ if n_type & macho::N_STAB == 0 {
+ continue;
+ }
+ // TODO: includes variables too (N_GSYM, N_STSYM). These may need to get their
+ // address from regular symbols though.
+ match n_type {
+ macho::N_SO => {
+ object = None;
+ }
+ macho::N_OSO => {
+ object = None;
+ if let Ok(name) = nlist.name(endian, self.strings) {
+ if !name.is_empty() {
+ object = Some(objects.len());
+ objects.push(name);
+ }
+ }
+ }
+ macho::N_FUN => {
+ if let Ok(name) = nlist.name(endian, self.strings) {
+ if !name.is_empty() {
+ current_function = Some((name, nlist.n_value(endian).into()))
+ } else if let Some((name, address)) = current_function.take() {
+ if let Some(object) = object {
+ symbols.push(ObjectMapEntry {
+ address,
+ size: nlist.n_value(endian).into(),
+ name,
+ object,
+ });
+ }
+ }
+ }
+ }
+ _ => {}
+ }
+ }
+ ObjectMap {
+ symbols: SymbolMap::new(symbols),
+ objects,
+ }
+ }
+}
+
+/// An iterator over the symbols of a `MachOFile32`.
+pub type MachOSymbolTable32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSymbolTable<'data, 'file, macho::MachHeader32<Endian>, R>;
+/// An iterator over the symbols of a `MachOFile64`.
+pub type MachOSymbolTable64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSymbolTable<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// A symbol table of a `MachOFile`.
+#[derive(Debug, Clone, Copy)]
+pub struct MachOSymbolTable<'data, 'file, Mach, R = &'data [u8]>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file MachOFile<'data, Mach, R>,
+}
+
+impl<'data, 'file, Mach, R> read::private::Sealed for MachOSymbolTable<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Mach, R> ObjectSymbolTable<'data> for MachOSymbolTable<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ type Symbol = MachOSymbol<'data, 'file, Mach, R>;
+ type SymbolIterator = MachOSymbolIterator<'data, 'file, Mach, R>;
+
+ fn symbols(&self) -> Self::SymbolIterator {
+ MachOSymbolIterator {
+ file: self.file,
+ index: 0,
+ }
+ }
+
+ fn symbol_by_index(&self, index: SymbolIndex) -> Result<Self::Symbol> {
+ let nlist = self.file.symbols.symbol(index.0)?;
+ MachOSymbol::new(self.file, index, nlist).read_error("Unsupported Mach-O symbol index")
+ }
+}
+
+/// An iterator over the symbols of a `MachOFile32`.
+pub type MachOSymbolIterator32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSymbolIterator<'data, 'file, macho::MachHeader32<Endian>, R>;
+/// An iterator over the symbols of a `MachOFile64`.
+pub type MachOSymbolIterator64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSymbolIterator<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// An iterator over the symbols of a `MachOFile`.
+pub struct MachOSymbolIterator<'data, 'file, Mach, R = &'data [u8]>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file MachOFile<'data, Mach, R>,
+ pub(super) index: usize,
+}
+
+impl<'data, 'file, Mach, R> fmt::Debug for MachOSymbolIterator<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+ f.debug_struct("MachOSymbolIterator").finish()
+ }
+}
+
+impl<'data, 'file, Mach, R> Iterator for MachOSymbolIterator<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ type Item = MachOSymbol<'data, 'file, Mach, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ loop {
+ let index = self.index;
+ let nlist = self.file.symbols.symbols.get(index)?;
+ self.index += 1;
+ if let Some(symbol) = MachOSymbol::new(self.file, SymbolIndex(index), nlist) {
+ return Some(symbol);
+ }
+ }
+ }
+}
+
+/// A symbol of a `MachOFile32`.
+pub type MachOSymbol32<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSymbol<'data, 'file, macho::MachHeader32<Endian>, R>;
+/// A symbol of a `MachOFile64`.
+pub type MachOSymbol64<'data, 'file, Endian = Endianness, R = &'data [u8]> =
+ MachOSymbol<'data, 'file, macho::MachHeader64<Endian>, R>;
+
+/// A symbol of a `MachOFile`.
+#[derive(Debug, Clone, Copy)]
+pub struct MachOSymbol<'data, 'file, Mach, R = &'data [u8]>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ file: &'file MachOFile<'data, Mach, R>,
+ index: SymbolIndex,
+ nlist: &'data Mach::Nlist,
+}
+
+impl<'data, 'file, Mach, R> MachOSymbol<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ pub(super) fn new(
+ file: &'file MachOFile<'data, Mach, R>,
+ index: SymbolIndex,
+ nlist: &'data Mach::Nlist,
+ ) -> Option<Self> {
+ if nlist.n_type() & macho::N_STAB != 0 {
+ return None;
+ }
+ Some(MachOSymbol { file, index, nlist })
+ }
+}
+
+impl<'data, 'file, Mach, R> read::private::Sealed for MachOSymbol<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Mach, R> ObjectSymbol<'data> for MachOSymbol<'data, 'file, Mach, R>
+where
+ Mach: MachHeader,
+ R: ReadRef<'data>,
+{
+ #[inline]
+ fn index(&self) -> SymbolIndex {
+ self.index
+ }
+
+ fn name(&self) -> Result<&'data str> {
+ let name = self
+ .nlist
+ .name(self.file.endian, self.file.symbols.strings)?;
+ str::from_utf8(name)
+ .ok()
+ .read_error("Non UTF-8 Mach-O symbol name")
+ }
+
+ #[inline]
+ fn address(&self) -> u64 {
+ self.nlist.n_value(self.file.endian).into()
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ 0
+ }
+
+ fn kind(&self) -> SymbolKind {
+ self.section()
+ .index()
+ .and_then(|index| self.file.section_internal(index).ok())
+ .map(|section| match section.kind {
+ SectionKind::Text => SymbolKind::Text,
+ SectionKind::Data
+ | SectionKind::ReadOnlyData
+ | SectionKind::ReadOnlyString
+ | SectionKind::UninitializedData
+ | SectionKind::Common => SymbolKind::Data,
+ SectionKind::Tls | SectionKind::UninitializedTls | SectionKind::TlsVariables => {
+ SymbolKind::Tls
+ }
+ _ => SymbolKind::Unknown,
+ })
+ .unwrap_or(SymbolKind::Unknown)
+ }
+
+ fn section(&self) -> SymbolSection {
+ match self.nlist.n_type() & macho::N_TYPE {
+ macho::N_UNDF => SymbolSection::Undefined,
+ macho::N_ABS => SymbolSection::Absolute,
+ macho::N_SECT => {
+ let n_sect = self.nlist.n_sect();
+ if n_sect != 0 {
+ SymbolSection::Section(SectionIndex(n_sect as usize))
+ } else {
+ SymbolSection::Unknown
+ }
+ }
+ _ => SymbolSection::Unknown,
+ }
+ }
+
+ #[inline]
+ fn is_undefined(&self) -> bool {
+ self.nlist.n_type() & macho::N_TYPE == macho::N_UNDF
+ }
+
+ #[inline]
+ fn is_definition(&self) -> bool {
+ self.nlist.is_definition()
+ }
+
+ #[inline]
+ fn is_common(&self) -> bool {
+ // Mach-O common symbols are based on section, not symbol
+ false
+ }
+
+ #[inline]
+ fn is_weak(&self) -> bool {
+ self.nlist.n_desc(self.file.endian) & (macho::N_WEAK_REF | macho::N_WEAK_DEF) != 0
+ }
+
+ fn scope(&self) -> SymbolScope {
+ let n_type = self.nlist.n_type();
+ if n_type & macho::N_TYPE == macho::N_UNDF {
+ SymbolScope::Unknown
+ } else if n_type & macho::N_EXT == 0 {
+ SymbolScope::Compilation
+ } else if n_type & macho::N_PEXT != 0 {
+ SymbolScope::Linkage
+ } else {
+ SymbolScope::Dynamic
+ }
+ }
+
+ #[inline]
+ fn is_global(&self) -> bool {
+ self.scope() != SymbolScope::Compilation
+ }
+
+ #[inline]
+ fn is_local(&self) -> bool {
+ self.scope() == SymbolScope::Compilation
+ }
+
+ #[inline]
+ fn flags(&self) -> SymbolFlags<SectionIndex> {
+ let n_desc = self.nlist.n_desc(self.file.endian);
+ SymbolFlags::MachO { n_desc }
+ }
+}
+
+/// A trait for generic access to `Nlist32` and `Nlist64`.
+#[allow(missing_docs)]
+pub trait Nlist: Debug + Pod {
+ type Word: Into<u64>;
+ type Endian: endian::Endian;
+
+ fn n_strx(&self, endian: Self::Endian) -> u32;
+ fn n_type(&self) -> u8;
+ fn n_sect(&self) -> u8;
+ fn n_desc(&self, endian: Self::Endian) -> u16;
+ fn n_value(&self, endian: Self::Endian) -> Self::Word;
+
+ fn name<'data, R: ReadRef<'data>>(
+ &self,
+ endian: Self::Endian,
+ strings: StringTable<'data, R>,
+ ) -> Result<&'data [u8]> {
+ strings
+ .get(self.n_strx(endian))
+ .read_error("Invalid Mach-O symbol name offset")
+ }
+
+ /// Return true if this is a STAB symbol.
+ ///
+ /// This determines the meaning of the `n_type` field.
+ fn is_stab(&self) -> bool {
+ self.n_type() & macho::N_STAB != 0
+ }
+
+ /// Return true if this is an undefined symbol.
+ fn is_undefined(&self) -> bool {
+ let n_type = self.n_type();
+ n_type & macho::N_STAB == 0 && n_type & macho::N_TYPE == macho::N_UNDF
+ }
+
+ /// Return true if the symbol is a definition of a function or data object.
+ fn is_definition(&self) -> bool {
+ let n_type = self.n_type();
+ n_type & macho::N_STAB == 0 && n_type & macho::N_TYPE != macho::N_UNDF
+ }
+
+ /// Return the library ordinal.
+ ///
+ /// This is either a 1-based index into the dylib load commands,
+ /// or a special ordinal.
+ #[inline]
+ fn library_ordinal(&self, endian: Self::Endian) -> u8 {
+ (self.n_desc(endian) >> 8) as u8
+ }
+}
+
+impl<Endian: endian::Endian> Nlist for macho::Nlist32<Endian> {
+ type Word = u32;
+ type Endian = Endian;
+
+ fn n_strx(&self, endian: Self::Endian) -> u32 {
+ self.n_strx.get(endian)
+ }
+ fn n_type(&self) -> u8 {
+ self.n_type
+ }
+ fn n_sect(&self) -> u8 {
+ self.n_sect
+ }
+ fn n_desc(&self, endian: Self::Endian) -> u16 {
+ self.n_desc.get(endian)
+ }
+ fn n_value(&self, endian: Self::Endian) -> Self::Word {
+ self.n_value.get(endian)
+ }
+}
+
+impl<Endian: endian::Endian> Nlist for macho::Nlist64<Endian> {
+ type Word = u64;
+ type Endian = Endian;
+
+ fn n_strx(&self, endian: Self::Endian) -> u32 {
+ self.n_strx.get(endian)
+ }
+ fn n_type(&self) -> u8 {
+ self.n_type
+ }
+ fn n_sect(&self) -> u8 {
+ self.n_sect
+ }
+ fn n_desc(&self, endian: Self::Endian) -> u16 {
+ self.n_desc.get(endian)
+ }
+ fn n_value(&self, endian: Self::Endian) -> Self::Word {
+ self.n_value.get(endian)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/mod.rs b/vendor/object-0.26.2/src/read/mod.rs
new file mode 100644
index 000000000..75814eef6
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/mod.rs
@@ -0,0 +1,694 @@
+//! Interface for reading object files.
+
+use alloc::borrow::Cow;
+use alloc::vec::Vec;
+use core::{fmt, result};
+
+use crate::common::*;
+
+mod read_ref;
+pub use read_ref::*;
+
+#[cfg(feature = "std")]
+mod read_cache;
+#[cfg(feature = "std")]
+pub use read_cache::*;
+
+mod util;
+pub use util::*;
+
+#[cfg(any(
+ feature = "coff",
+ feature = "elf",
+ feature = "macho",
+ feature = "pe",
+ feature = "wasm"
+))]
+mod any;
+#[cfg(any(
+ feature = "coff",
+ feature = "elf",
+ feature = "macho",
+ feature = "pe",
+ feature = "wasm"
+))]
+pub use any::*;
+
+#[cfg(feature = "archive")]
+pub mod archive;
+
+#[cfg(feature = "coff")]
+pub mod coff;
+
+#[cfg(feature = "elf")]
+pub mod elf;
+
+#[cfg(feature = "macho")]
+pub mod macho;
+
+#[cfg(feature = "pe")]
+pub mod pe;
+
+mod traits;
+pub use traits::*;
+
+#[cfg(feature = "wasm")]
+pub mod wasm;
+
+mod private {
+ pub trait Sealed {}
+}
+
+/// The error type used within the read module.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Error(&'static str);
+
+impl fmt::Display for Error {
+ #[inline]
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.write_str(self.0)
+ }
+}
+
+#[cfg(feature = "std")]
+impl std::error::Error for Error {}
+
+/// The result type used within the read module.
+pub type Result<T> = result::Result<T, Error>;
+
+trait ReadError<T> {
+ fn read_error(self, error: &'static str) -> Result<T>;
+}
+
+impl<T> ReadError<T> for result::Result<T, ()> {
+ fn read_error(self, error: &'static str) -> Result<T> {
+ self.map_err(|()| Error(error))
+ }
+}
+
+impl<T> ReadError<T> for result::Result<T, Error> {
+ fn read_error(self, error: &'static str) -> Result<T> {
+ self.map_err(|_| Error(error))
+ }
+}
+
+impl<T> ReadError<T> for Option<T> {
+ fn read_error(self, error: &'static str) -> Result<T> {
+ self.ok_or(Error(error))
+ }
+}
+
+/// The native executable file for the target platform.
+#[cfg(all(
+ unix,
+ not(target_os = "macos"),
+ target_pointer_width = "32",
+ feature = "elf"
+))]
+pub type NativeFile<'data, R = &'data [u8]> = elf::ElfFile32<'data, crate::Endianness, R>;
+
+/// The native executable file for the target platform.
+#[cfg(all(
+ unix,
+ not(target_os = "macos"),
+ target_pointer_width = "64",
+ feature = "elf"
+))]
+pub type NativeFile<'data, R = &'data [u8]> = elf::ElfFile64<'data, crate::Endianness, R>;
+
+/// The native executable file for the target platform.
+#[cfg(all(target_os = "macos", target_pointer_width = "32", feature = "macho"))]
+pub type NativeFile<'data, R = &'data [u8]> = macho::MachOFile32<'data, crate::Endianness, R>;
+
+/// The native executable file for the target platform.
+#[cfg(all(target_os = "macos", target_pointer_width = "64", feature = "macho"))]
+pub type NativeFile<'data, R = &'data [u8]> = macho::MachOFile64<'data, crate::Endianness, R>;
+
+/// The native executable file for the target platform.
+#[cfg(all(target_os = "windows", target_pointer_width = "32", feature = "pe"))]
+pub type NativeFile<'data, R = &'data [u8]> = pe::PeFile32<'data, R>;
+
+/// The native executable file for the target platform.
+#[cfg(all(target_os = "windows", target_pointer_width = "64", feature = "pe"))]
+pub type NativeFile<'data, R = &'data [u8]> = pe::PeFile64<'data, R>;
+
+/// The native executable file for the target platform.
+#[cfg(all(feature = "wasm", target_arch = "wasm32", feature = "wasm"))]
+pub type NativeFile<'data, R = &'data [u8]> = wasm::WasmFile<'data, R>;
+
+/// An object file kind.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum FileKind {
+ /// A Unix archive.
+ #[cfg(feature = "archive")]
+ Archive,
+ /// A COFF object file.
+ #[cfg(feature = "coff")]
+ Coff,
+ /// A dyld cache file containing Mach-O images.
+ #[cfg(feature = "macho")]
+ DyldCache,
+ /// A 32-bit ELF file.
+ #[cfg(feature = "elf")]
+ Elf32,
+ /// A 64-bit ELF file.
+ #[cfg(feature = "elf")]
+ Elf64,
+ /// A 32-bit Mach-O file.
+ #[cfg(feature = "macho")]
+ MachO32,
+ /// A 64-bit Mach-O file.
+ #[cfg(feature = "macho")]
+ MachO64,
+ /// A 32-bit Mach-O fat binary.
+ #[cfg(feature = "macho")]
+ MachOFat32,
+ /// A 64-bit Mach-O fat binary.
+ #[cfg(feature = "macho")]
+ MachOFat64,
+ /// A 32-bit PE file.
+ #[cfg(feature = "pe")]
+ Pe32,
+ /// A 64-bit PE file.
+ #[cfg(feature = "pe")]
+ Pe64,
+ /// A Wasm file.
+ #[cfg(feature = "wasm")]
+ Wasm,
+}
+
+impl FileKind {
+ /// Determine a file kind by parsing the start of the file.
+ pub fn parse<'data, R: ReadRef<'data>>(data: R) -> Result<FileKind> {
+ Self::parse_at(data, 0)
+ }
+
+ /// Determine a file kind by parsing at the given offset.
+ pub fn parse_at<'data, R: ReadRef<'data>>(data: R, offset: u64) -> Result<FileKind> {
+ let magic = data
+ .read_bytes_at(offset, 16)
+ .read_error("Could not read file magic")?;
+ if magic.len() < 16 {
+ return Err(Error("File too short"));
+ }
+
+ let kind = match [magic[0], magic[1], magic[2], magic[3], magic[4], magic[5], magic[6], magic[7]] {
+ #[cfg(feature = "archive")]
+ [b'!', b'<', b'a', b'r', b'c', b'h', b'>', b'\n'] => FileKind::Archive,
+ #[cfg(feature = "macho")]
+ [b'd', b'y', b'l', b'd', b'_', b'v', b'1', b' '] => FileKind::DyldCache,
+ #[cfg(feature = "elf")]
+ [0x7f, b'E', b'L', b'F', 1, ..] => FileKind::Elf32,
+ #[cfg(feature = "elf")]
+ [0x7f, b'E', b'L', b'F', 2, ..] => FileKind::Elf64,
+ #[cfg(feature = "macho")]
+ [0xfe, 0xed, 0xfa, 0xce, ..]
+ | [0xce, 0xfa, 0xed, 0xfe, ..] => FileKind::MachO32,
+ #[cfg(feature = "macho")]
+ | [0xfe, 0xed, 0xfa, 0xcf, ..]
+ | [0xcf, 0xfa, 0xed, 0xfe, ..] => FileKind::MachO64,
+ #[cfg(feature = "macho")]
+ [0xca, 0xfe, 0xba, 0xbe, ..] => FileKind::MachOFat32,
+ #[cfg(feature = "macho")]
+ [0xca, 0xfe, 0xba, 0xbf, ..] => FileKind::MachOFat64,
+ #[cfg(feature = "wasm")]
+ [0x00, b'a', b's', b'm', ..] => FileKind::Wasm,
+ #[cfg(feature = "pe")]
+ [b'M', b'Z', ..] => {
+ match pe::optional_header_magic(data) {
+ Ok(crate::pe::IMAGE_NT_OPTIONAL_HDR32_MAGIC) => {
+ FileKind::Pe32
+ }
+ Ok(crate::pe::IMAGE_NT_OPTIONAL_HDR64_MAGIC) => {
+ FileKind::Pe64
+ }
+ _ => return Err(Error("Unknown MS-DOS file")),
+ }
+ }
+ // TODO: more COFF machines
+ #[cfg(feature = "coff")]
+ // COFF arm
+ [0xc4, 0x01, ..]
+ // COFF arm64
+ | [0x64, 0xaa, ..]
+ // COFF x86
+ | [0x4c, 0x01, ..]
+ // COFF x86-64
+ | [0x64, 0x86, ..] => FileKind::Coff,
+ _ => return Err(Error("Unknown file magic")),
+ };
+ Ok(kind)
+ }
+}
+
+/// The index used to identify a section of a file.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct SectionIndex(pub usize);
+
+/// The index used to identify a symbol of a file.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct SymbolIndex(pub usize);
+
+/// The section where a symbol is defined.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum SymbolSection {
+ /// The section is unknown.
+ Unknown,
+ /// The section is not applicable for this symbol (such as file symbols).
+ None,
+ /// The symbol is undefined.
+ Undefined,
+ /// The symbol has an absolute value.
+ Absolute,
+ /// The symbol is a zero-initialized symbol that will be combined with duplicate definitions.
+ Common,
+ /// The symbol is defined in the given section.
+ Section(SectionIndex),
+}
+
+impl SymbolSection {
+ /// Returns the section index for the section where the symbol is defined.
+ ///
+ /// May return `None` if the symbol is not defined in a section.
+ #[inline]
+ pub fn index(self) -> Option<SectionIndex> {
+ if let SymbolSection::Section(index) = self {
+ Some(index)
+ } else {
+ None
+ }
+ }
+}
+
+/// An entry in a `SymbolMap`.
+pub trait SymbolMapEntry {
+ /// The symbol address.
+ fn address(&self) -> u64;
+}
+
+/// A map from addresses to symbols.
+#[derive(Debug, Default, Clone)]
+pub struct SymbolMap<T: SymbolMapEntry> {
+ symbols: Vec<T>,
+}
+
+impl<T: SymbolMapEntry> SymbolMap<T> {
+ /// Construct a new symbol map.
+ ///
+ /// This function will sort the symbols by address.
+ pub fn new(mut symbols: Vec<T>) -> Self {
+ symbols.sort_unstable_by_key(|s| s.address());
+ SymbolMap { symbols }
+ }
+
+ /// Get the symbol before the given address.
+ pub fn get(&self, address: u64) -> Option<&T> {
+ let index = match self
+ .symbols
+ .binary_search_by_key(&address, |symbol| symbol.address())
+ {
+ Ok(index) => index,
+ Err(index) => index.checked_sub(1)?,
+ };
+ self.symbols.get(index)
+ }
+
+ /// Get all symbols in the map.
+ #[inline]
+ pub fn symbols(&self) -> &[T] {
+ &self.symbols
+ }
+}
+
+/// A `SymbolMap` entry for symbol names.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct SymbolMapName<'data> {
+ address: u64,
+ name: &'data str,
+}
+
+impl<'data> SymbolMapName<'data> {
+ /// Construct a `SymbolMapName`.
+ pub fn new(address: u64, name: &'data str) -> Self {
+ SymbolMapName { address, name }
+ }
+
+ /// The symbol address.
+ #[inline]
+ pub fn address(&self) -> u64 {
+ self.address
+ }
+
+ /// The symbol name.
+ #[inline]
+ pub fn name(&self) -> &'data str {
+ self.name
+ }
+}
+
+impl<'data> SymbolMapEntry for SymbolMapName<'data> {
+ #[inline]
+ fn address(&self) -> u64 {
+ self.address
+ }
+}
+
+/// A map from addresses to symbol names and object files.
+///
+/// This is derived from STAB entries in Mach-O files.
+#[derive(Debug, Default, Clone)]
+pub struct ObjectMap<'data> {
+ symbols: SymbolMap<ObjectMapEntry<'data>>,
+ objects: Vec<&'data [u8]>,
+}
+
+impl<'data> ObjectMap<'data> {
+ /// Get the entry containing the given address.
+ pub fn get(&self, address: u64) -> Option<&ObjectMapEntry<'data>> {
+ self.symbols
+ .get(address)
+ .filter(|entry| entry.size == 0 || address.wrapping_sub(entry.address) < entry.size)
+ }
+
+ /// Get all symbols in the map.
+ #[inline]
+ pub fn symbols(&self) -> &[ObjectMapEntry<'data>] {
+ self.symbols.symbols()
+ }
+
+ /// Get all objects in the map.
+ #[inline]
+ pub fn objects(&self) -> &[&'data [u8]] {
+ &self.objects
+ }
+}
+
+/// A `ObjectMap` entry.
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct ObjectMapEntry<'data> {
+ address: u64,
+ size: u64,
+ name: &'data [u8],
+ object: usize,
+}
+
+impl<'data> ObjectMapEntry<'data> {
+ /// Get the symbol address.
+ #[inline]
+ pub fn address(&self) -> u64 {
+ self.address
+ }
+
+ /// Get the symbol size.
+ ///
+ /// This may be 0 if the size is unknown.
+ #[inline]
+ pub fn size(&self) -> u64 {
+ self.size
+ }
+
+ /// Get the symbol name.
+ #[inline]
+ pub fn name(&self) -> &'data [u8] {
+ self.name
+ }
+
+ /// Get the index of the object file name.
+ #[inline]
+ pub fn object_index(&self) -> usize {
+ self.object
+ }
+
+ /// Get the object file name.
+ #[inline]
+ pub fn object(&self, map: &ObjectMap<'data>) -> &'data [u8] {
+ map.objects[self.object]
+ }
+}
+
+impl<'data> SymbolMapEntry for ObjectMapEntry<'data> {
+ #[inline]
+ fn address(&self) -> u64 {
+ self.address
+ }
+}
+
+/// An imported symbol.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Import<'data> {
+ // TODO: or ordinal
+ name: ByteString<'data>,
+ library: ByteString<'data>,
+}
+
+impl<'data> Import<'data> {
+ /// The symbol name.
+ #[inline]
+ pub fn name(&self) -> &'data [u8] {
+ self.name.0
+ }
+
+ /// The name of the library to import the symbol from.
+ #[inline]
+ pub fn library(&self) -> &'data [u8] {
+ self.library.0
+ }
+}
+
+/// An exported symbol.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct Export<'data> {
+ // TODO: and ordinal?
+ name: ByteString<'data>,
+ address: u64,
+}
+
+impl<'data> Export<'data> {
+ /// The symbol name.
+ #[inline]
+ pub fn name(&self) -> &'data [u8] {
+ self.name.0
+ }
+
+ /// The virtual address of the symbol.
+ #[inline]
+ pub fn address(&self) -> u64 {
+ self.address
+ }
+}
+
+/// PDB Information
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct CodeView<'data> {
+ guid: [u8; 16],
+ path: ByteString<'data>,
+ age: u32,
+}
+
+impl<'data> CodeView<'data> {
+ /// The path to the PDB as stored in CodeView
+ #[inline]
+ pub fn path(&self) -> &'data [u8] {
+ self.path.0
+ }
+
+ /// The age of the PDB
+ #[inline]
+ pub fn age(&self) -> u32 {
+ self.age
+ }
+
+ /// The GUID of the PDB.
+ #[inline]
+ pub fn guid(&self) -> [u8; 16] {
+ self.guid
+ }
+}
+
+/// The target referenced by a relocation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum RelocationTarget {
+ /// The target is a symbol.
+ Symbol(SymbolIndex),
+ /// The target is a section.
+ Section(SectionIndex),
+ /// The offset is an absolute address.
+ Absolute,
+}
+
+/// A relocation entry.
+#[derive(Debug)]
+pub struct Relocation {
+ kind: RelocationKind,
+ encoding: RelocationEncoding,
+ size: u8,
+ target: RelocationTarget,
+ addend: i64,
+ implicit_addend: bool,
+}
+
+impl Relocation {
+ /// The operation used to calculate the result of the relocation.
+ #[inline]
+ pub fn kind(&self) -> RelocationKind {
+ self.kind
+ }
+
+ /// Information about how the result of the relocation operation is encoded in the place.
+ #[inline]
+ pub fn encoding(&self) -> RelocationEncoding {
+ self.encoding
+ }
+
+ /// The size in bits of the place of the relocation.
+ ///
+ /// If 0, then the size is determined by the relocation kind.
+ #[inline]
+ pub fn size(&self) -> u8 {
+ self.size
+ }
+
+ /// The target of the relocation.
+ #[inline]
+ pub fn target(&self) -> RelocationTarget {
+ self.target
+ }
+
+ /// The addend to use in the relocation calculation.
+ #[inline]
+ pub fn addend(&self) -> i64 {
+ self.addend
+ }
+
+ /// Set the addend to use in the relocation calculation.
+ #[inline]
+ pub fn set_addend(&mut self, addend: i64) {
+ self.addend = addend
+ }
+
+ /// Returns true if there is an implicit addend stored in the data at the offset
+ /// to be relocated.
+ #[inline]
+ pub fn has_implicit_addend(&self) -> bool {
+ self.implicit_addend
+ }
+}
+
+/// A data compression format.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum CompressionFormat {
+ /// The data is uncompressed.
+ None,
+ /// The data is compressed, but the compression format is unknown.
+ Unknown,
+ /// ZLIB/DEFLATE.
+ ///
+ /// Used for ELF compression and GNU compressed debug information.
+ Zlib,
+}
+
+/// A range in a file that may be compressed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct CompressedFileRange {
+ /// The data compression format.
+ pub format: CompressionFormat,
+ /// The file offset of the compressed data.
+ pub offset: u64,
+ /// The compressed data size.
+ pub compressed_size: u64,
+ /// The uncompressed data size.
+ pub uncompressed_size: u64,
+}
+
+impl CompressedFileRange {
+ /// Data that is uncompressed.
+ #[inline]
+ pub fn none(range: Option<(u64, u64)>) -> Self {
+ if let Some((offset, size)) = range {
+ CompressedFileRange {
+ format: CompressionFormat::None,
+ offset,
+ compressed_size: size,
+ uncompressed_size: size,
+ }
+ } else {
+ CompressedFileRange {
+ format: CompressionFormat::None,
+ offset: 0,
+ compressed_size: 0,
+ uncompressed_size: 0,
+ }
+ }
+ }
+
+ /// Convert to `CompressedData` by reading from the file.
+ pub fn data<'data, R: ReadRef<'data>>(self, file: R) -> Result<CompressedData<'data>> {
+ let data = file
+ .read_bytes_at(self.offset, self.compressed_size)
+ .read_error("Invalid compressed data size or offset")?;
+ Ok(CompressedData {
+ format: self.format,
+ data,
+ uncompressed_size: self.uncompressed_size,
+ })
+ }
+}
+
+/// Data that may be compressed.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct CompressedData<'data> {
+ /// The data compression format.
+ pub format: CompressionFormat,
+ /// The compressed data.
+ pub data: &'data [u8],
+ /// The uncompressed data size.
+ pub uncompressed_size: u64,
+}
+
+impl<'data> CompressedData<'data> {
+ /// Data that is uncompressed.
+ #[inline]
+ pub fn none(data: &'data [u8]) -> Self {
+ CompressedData {
+ format: CompressionFormat::None,
+ data,
+ uncompressed_size: data.len() as u64,
+ }
+ }
+
+ /// Return the uncompressed data.
+ ///
+ /// Returns an error for invalid data or unsupported compression.
+ /// This includes if the data is compressed but the `compression` feature
+ /// for this crate is disabled.
+ pub fn decompress(self) -> Result<Cow<'data, [u8]>> {
+ match self.format {
+ CompressionFormat::None => Ok(Cow::Borrowed(self.data)),
+ #[cfg(feature = "compression")]
+ CompressionFormat::Zlib => {
+ use core::convert::TryInto;
+ let size = self
+ .uncompressed_size
+ .try_into()
+ .ok()
+ .read_error("Uncompressed data size is too large.")?;
+ let mut decompressed = Vec::with_capacity(size);
+ let mut decompress = flate2::Decompress::new(true);
+ decompress
+ .decompress_vec(
+ self.data,
+ &mut decompressed,
+ flate2::FlushDecompress::Finish,
+ )
+ .ok()
+ .read_error("Invalid zlib compressed data")?;
+ Ok(Cow::Owned(decompressed))
+ }
+ _ => Err(Error("Unsupported compressed data.")),
+ }
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/pe/file.rs b/vendor/object-0.26.2/src/read/pe/file.rs
new file mode 100644
index 000000000..429db9b70
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/pe/file.rs
@@ -0,0 +1,1057 @@
+use alloc::vec::Vec;
+use core::fmt::Debug;
+use core::{mem, str};
+
+use core::convert::TryInto;
+
+use crate::read::coff::{CoffCommon, CoffSymbol, CoffSymbolIterator, CoffSymbolTable, SymbolTable};
+use crate::read::{
+ self, Architecture, ComdatKind, Error, Export, FileFlags, Import, NoDynamicRelocationIterator,
+ Object, ObjectComdat, ReadError, ReadRef, Result, SectionIndex, SymbolIndex,
+};
+use crate::{
+ pe, ByteString, Bytes, CodeView, LittleEndian as LE, Pod, U16Bytes, U32Bytes, U32, U64,
+};
+
+use super::{PeSection, PeSectionIterator, PeSegment, PeSegmentIterator, SectionTable};
+
+/// A PE32 (32-bit) image file.
+pub type PeFile32<'data, R = &'data [u8]> = PeFile<'data, pe::ImageNtHeaders32, R>;
+/// A PE32+ (64-bit) image file.
+pub type PeFile64<'data, R = &'data [u8]> = PeFile<'data, pe::ImageNtHeaders64, R>;
+
+/// A PE object file.
+#[derive(Debug)]
+pub struct PeFile<'data, Pe, R = &'data [u8]>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ pub(super) dos_header: &'data pe::ImageDosHeader,
+ pub(super) nt_headers: &'data Pe,
+ pub(super) data_directories: &'data [pe::ImageDataDirectory],
+ pub(super) common: CoffCommon<'data, R>,
+ pub(super) data: R,
+}
+
+impl<'data, Pe, R> PeFile<'data, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ /// Parse the raw PE file data.
+ pub fn parse(data: R) -> Result<Self> {
+ let dos_header = pe::ImageDosHeader::parse(data)?;
+ let mut offset = dos_header.nt_headers_offset().into();
+ let (nt_headers, data_directories) = Pe::parse(data, &mut offset)?;
+ let sections = nt_headers.sections(data, offset)?;
+ let symbols = nt_headers.symbols(data)?;
+ let image_base = nt_headers.optional_header().image_base();
+
+ Ok(PeFile {
+ dos_header,
+ nt_headers,
+ data_directories,
+ common: CoffCommon {
+ sections,
+ symbols,
+ image_base,
+ },
+ data,
+ })
+ }
+
+ pub(super) fn section_alignment(&self) -> u64 {
+ u64::from(self.nt_headers.optional_header().section_alignment())
+ }
+
+ /// Return the DOS header of this file
+ pub fn dos_header(&self) -> &'data pe::ImageDosHeader {
+ self.dos_header
+ }
+
+ /// Return the NT Headers of this file
+ pub fn nt_headers(&self) -> &'data Pe {
+ self.nt_headers
+ }
+
+ /// Returns the section table of this binary.
+ pub fn section_table(&self) -> SectionTable<'data> {
+ self.common.sections
+ }
+
+ /// Returns the data directory at the given index.
+ pub fn data_directory(&self, id: usize) -> Option<&'data pe::ImageDataDirectory> {
+ self.data_directories
+ .get(id)
+ .filter(|d| d.size.get(LE) != 0)
+ }
+
+ fn data_at(&self, va: u32) -> Option<Bytes<'data>> {
+ self.common.sections.pe_data_at(self.data, va).map(Bytes)
+ }
+
+ /// Returns this binary data.
+ pub fn data(&self) -> R {
+ self.data
+ }
+}
+
+impl<'data, Pe, R> read::private::Sealed for PeFile<'data, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Pe, R> Object<'data, 'file> for PeFile<'data, Pe, R>
+where
+ 'data: 'file,
+ Pe: ImageNtHeaders,
+ R: 'file + ReadRef<'data>,
+{
+ type Segment = PeSegment<'data, 'file, Pe, R>;
+ type SegmentIterator = PeSegmentIterator<'data, 'file, Pe, R>;
+ type Section = PeSection<'data, 'file, Pe, R>;
+ type SectionIterator = PeSectionIterator<'data, 'file, Pe, R>;
+ type Comdat = PeComdat<'data, 'file, Pe, R>;
+ type ComdatIterator = PeComdatIterator<'data, 'file, Pe, R>;
+ type Symbol = CoffSymbol<'data, 'file, R>;
+ type SymbolIterator = CoffSymbolIterator<'data, 'file, R>;
+ type SymbolTable = CoffSymbolTable<'data, 'file, R>;
+ type DynamicRelocationIterator = NoDynamicRelocationIterator;
+
+ fn architecture(&self) -> Architecture {
+ match self.nt_headers.file_header().machine.get(LE) {
+ pe::IMAGE_FILE_MACHINE_ARMNT => Architecture::Arm,
+ pe::IMAGE_FILE_MACHINE_ARM64 => Architecture::Aarch64,
+ pe::IMAGE_FILE_MACHINE_I386 => Architecture::I386,
+ pe::IMAGE_FILE_MACHINE_AMD64 => Architecture::X86_64,
+ _ => Architecture::Unknown,
+ }
+ }
+
+ #[inline]
+ fn is_little_endian(&self) -> bool {
+ // Only little endian is supported.
+ true
+ }
+
+ #[inline]
+ fn is_64(&self) -> bool {
+ self.nt_headers.is_type_64()
+ }
+
+ fn segments(&'file self) -> PeSegmentIterator<'data, 'file, Pe, R> {
+ PeSegmentIterator {
+ file: self,
+ iter: self.common.sections.iter(),
+ }
+ }
+
+ fn section_by_name(&'file self, section_name: &str) -> Option<PeSection<'data, 'file, Pe, R>> {
+ self.common
+ .sections
+ .section_by_name(self.common.symbols.strings(), section_name.as_bytes())
+ .map(|(index, section)| PeSection {
+ file: self,
+ index: SectionIndex(index),
+ section,
+ })
+ }
+
+ fn section_by_index(
+ &'file self,
+ index: SectionIndex,
+ ) -> Result<PeSection<'data, 'file, Pe, R>> {
+ let section = self.common.sections.section(index.0)?;
+ Ok(PeSection {
+ file: self,
+ index,
+ section,
+ })
+ }
+
+ fn sections(&'file self) -> PeSectionIterator<'data, 'file, Pe, R> {
+ PeSectionIterator {
+ file: self,
+ iter: self.common.sections.iter().enumerate(),
+ }
+ }
+
+ fn comdats(&'file self) -> PeComdatIterator<'data, 'file, Pe, R> {
+ PeComdatIterator { file: self }
+ }
+
+ fn symbol_by_index(&'file self, index: SymbolIndex) -> Result<CoffSymbol<'data, 'file, R>> {
+ let symbol = self.common.symbols.symbol(index.0)?;
+ Ok(CoffSymbol {
+ file: &self.common,
+ index,
+ symbol,
+ })
+ }
+
+ fn symbols(&'file self) -> CoffSymbolIterator<'data, 'file, R> {
+ CoffSymbolIterator {
+ file: &self.common,
+ index: 0,
+ }
+ }
+
+ fn symbol_table(&'file self) -> Option<CoffSymbolTable<'data, 'file, R>> {
+ Some(CoffSymbolTable { file: &self.common })
+ }
+
+ fn dynamic_symbols(&'file self) -> CoffSymbolIterator<'data, 'file, R> {
+ CoffSymbolIterator {
+ file: &self.common,
+ // Hack: don't return any.
+ index: self.common.symbols.len(),
+ }
+ }
+
+ fn dynamic_symbol_table(&'file self) -> Option<CoffSymbolTable<'data, 'file, R>> {
+ None
+ }
+
+ fn dynamic_relocations(&'file self) -> Option<NoDynamicRelocationIterator> {
+ None
+ }
+
+ fn imports(&self) -> Result<Vec<Import<'data>>> {
+ let data_dir = match self.data_directory(pe::IMAGE_DIRECTORY_ENTRY_IMPORT) {
+ Some(data_dir) => data_dir,
+ None => return Ok(Vec::new()),
+ };
+ let mut import_descriptors = data_dir.data(self.data, &self.common.sections).map(Bytes)?;
+ let mut imports = Vec::new();
+ loop {
+ let import_desc = import_descriptors
+ .read::<pe::ImageImportDescriptor>()
+ .read_error("Missing PE null import descriptor")?;
+ if import_desc.original_first_thunk.get(LE) == 0 {
+ break;
+ }
+
+ let library = self
+ .data_at(import_desc.name.get(LE))
+ .read_error("Invalid PE import descriptor name")?
+ .read_string()
+ .read_error("Invalid PE import descriptor name")?;
+
+ let thunk_va = import_desc.original_first_thunk.get(LE);
+ let mut thunk_data = self
+ .data_at(thunk_va)
+ .read_error("Invalid PE import thunk address")?;
+ loop {
+ let hint_name = if self.is_64() {
+ let thunk = thunk_data
+ .read::<U64<_>>()
+ .read_error("Missing PE null import thunk")?
+ .get(LE);
+ if thunk == 0 {
+ break;
+ }
+ if thunk & pe::IMAGE_ORDINAL_FLAG64 != 0 {
+ // TODO: handle import by ordinal
+ continue;
+ }
+ thunk as u32
+ } else {
+ let thunk = thunk_data
+ .read::<U32<_>>()
+ .read_error("Missing PE null import thunk")?
+ .get(LE);
+ if thunk == 0 {
+ break;
+ }
+ if thunk & pe::IMAGE_ORDINAL_FLAG32 != 0 {
+ // TODO: handle import by ordinal
+ continue;
+ }
+ thunk
+ };
+ let name = self
+ .data_at(hint_name)
+ .read_error("Invalid PE import thunk name")?
+ .read_string_at(2)
+ .read_error("Invalid PE import thunk name")?;
+
+ imports.push(Import {
+ name: ByteString(name),
+ library: ByteString(library),
+ });
+ }
+ }
+ Ok(imports)
+ }
+
+ fn exports(&self) -> Result<Vec<Export<'data>>> {
+ let data_dir = match self.data_directory(pe::IMAGE_DIRECTORY_ENTRY_EXPORT) {
+ Some(data_dir) => data_dir,
+ None => return Ok(Vec::new()),
+ };
+ let export_va = data_dir.virtual_address.get(LE);
+ let export_size = data_dir.size.get(LE);
+ let export_data = data_dir.data(self.data, &self.common.sections).map(Bytes)?;
+ let export_dir = export_data
+ .read_at::<pe::ImageExportDirectory>(0)
+ .read_error("Invalid PE export dir size")?;
+ let addresses = export_data
+ .read_slice_at::<U32Bytes<_>>(
+ export_dir
+ .address_of_functions
+ .get(LE)
+ .wrapping_sub(export_va) as usize,
+ export_dir.number_of_functions.get(LE) as usize,
+ )
+ .read_error("Invalid PE export address table")?;
+ let number = export_dir.number_of_names.get(LE) as usize;
+ let names = export_data
+ .read_slice_at::<U32Bytes<_>>(
+ export_dir.address_of_names.get(LE).wrapping_sub(export_va) as usize,
+ number,
+ )
+ .read_error("Invalid PE export name table")?;
+ let ordinals = export_data
+ .read_slice_at::<U16Bytes<_>>(
+ export_dir
+ .address_of_name_ordinals
+ .get(LE)
+ .wrapping_sub(export_va) as usize,
+ number,
+ )
+ .read_error("Invalid PE export ordinal table")?;
+
+ let mut exports = Vec::new();
+ for (name, ordinal) in names.iter().zip(ordinals.iter()) {
+ let name = export_data
+ .read_string_at(name.get(LE).wrapping_sub(export_va) as usize)
+ .read_error("Invalid PE export name entry")?;
+ let address = addresses
+ .get(ordinal.get(LE) as usize)
+ .read_error("Invalid PE export ordinal entry")?
+ .get(LE);
+ // Check for export address (vs forwarder address).
+ if address < export_va || (address - export_va) >= export_size {
+ exports.push(Export {
+ name: ByteString(name),
+ address: self.common.image_base.wrapping_add(address.into()),
+ })
+ }
+ }
+ Ok(exports)
+ }
+
+ fn pdb_info(&self) -> Result<Option<CodeView>> {
+ let data_dir = match self.data_directory(pe::IMAGE_DIRECTORY_ENTRY_DEBUG) {
+ Some(data_dir) => data_dir,
+ None => return Ok(None),
+ };
+ let debug_data = data_dir.data(self.data, &self.common.sections).map(Bytes)?;
+ let debug_dir = debug_data
+ .read_at::<pe::ImageDebugDirectory>(0)
+ .read_error("Invalid PE debug dir size")?;
+
+ if debug_dir.typ.get(LE) != pe::IMAGE_DEBUG_TYPE_CODEVIEW {
+ return Ok(None);
+ }
+
+ let info = self
+ .data
+ .read_slice_at::<u8>(
+ debug_dir.pointer_to_raw_data.get(LE) as u64,
+ debug_dir.size_of_data.get(LE) as usize,
+ )
+ .read_error("Invalid CodeView Info address")?;
+
+ let mut info = Bytes(info);
+
+ let sig = info
+ .read_bytes(4)
+ .read_error("Invalid CodeView signature")?;
+ if sig.0 != b"RSDS" {
+ return Ok(None);
+ }
+
+ let guid: [u8; 16] = info
+ .read_bytes(16)
+ .read_error("Invalid CodeView GUID")?
+ .0
+ .try_into()
+ .unwrap();
+
+ let age = info.read::<U32<LE>>().read_error("Invalid CodeView Age")?;
+
+ let path = info
+ .read_string()
+ .read_error("Invalid CodeView file path")?;
+
+ Ok(Some(CodeView {
+ path: ByteString(path),
+ guid,
+ age: age.get(LE),
+ }))
+ }
+
+ fn has_debug_symbols(&self) -> bool {
+ self.section_by_name(".debug_info").is_some()
+ }
+
+ fn relative_address_base(&self) -> u64 {
+ self.common.image_base
+ }
+
+ fn entry(&self) -> u64 {
+ u64::from(self.nt_headers.optional_header().address_of_entry_point())
+ .wrapping_add(self.common.image_base)
+ }
+
+ fn flags(&self) -> FileFlags {
+ FileFlags::Coff {
+ characteristics: self.nt_headers.file_header().characteristics.get(LE),
+ }
+ }
+}
+
+/// An iterator over the COMDAT section groups of a `PeFile32`.
+pub type PeComdatIterator32<'data, 'file, R = &'data [u8]> =
+ PeComdatIterator<'data, 'file, pe::ImageNtHeaders32, R>;
+/// An iterator over the COMDAT section groups of a `PeFile64`.
+pub type PeComdatIterator64<'data, 'file, R = &'data [u8]> =
+ PeComdatIterator<'data, 'file, pe::ImageNtHeaders64, R>;
+
+/// An iterator over the COMDAT section groups of a `PeFile`.
+#[derive(Debug)]
+pub struct PeComdatIterator<'data, 'file, Pe, R = &'data [u8]>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ file: &'file PeFile<'data, Pe, R>,
+}
+
+impl<'data, 'file, Pe, R> Iterator for PeComdatIterator<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ type Item = PeComdat<'data, 'file, Pe, R>;
+
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
+
+/// A COMDAT section group of a `PeFile32`.
+pub type PeComdat32<'data, 'file, R = &'data [u8]> =
+ PeComdat<'data, 'file, pe::ImageNtHeaders32, R>;
+/// A COMDAT section group of a `PeFile64`.
+pub type PeComdat64<'data, 'file, R = &'data [u8]> =
+ PeComdat<'data, 'file, pe::ImageNtHeaders64, R>;
+
+/// A COMDAT section group of a `PeFile`.
+#[derive(Debug)]
+pub struct PeComdat<'data, 'file, Pe, R = &'data [u8]>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ file: &'file PeFile<'data, Pe, R>,
+}
+
+impl<'data, 'file, Pe, R> read::private::Sealed for PeComdat<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Pe, R> ObjectComdat<'data> for PeComdat<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ type SectionIterator = PeComdatSectionIterator<'data, 'file, Pe, R>;
+
+ #[inline]
+ fn kind(&self) -> ComdatKind {
+ unreachable!();
+ }
+
+ #[inline]
+ fn symbol(&self) -> SymbolIndex {
+ unreachable!();
+ }
+
+ #[inline]
+ fn name(&self) -> Result<&str> {
+ unreachable!();
+ }
+
+ #[inline]
+ fn sections(&self) -> Self::SectionIterator {
+ unreachable!();
+ }
+}
+
+/// An iterator over the sections in a COMDAT section group of a `PeFile32`.
+pub type PeComdatSectionIterator32<'data, 'file, R = &'data [u8]> =
+ PeComdatSectionIterator<'data, 'file, pe::ImageNtHeaders32, R>;
+/// An iterator over the sections in a COMDAT section group of a `PeFile64`.
+pub type PeComdatSectionIterator64<'data, 'file, R = &'data [u8]> =
+ PeComdatSectionIterator<'data, 'file, pe::ImageNtHeaders64, R>;
+
+/// An iterator over the sections in a COMDAT section group of a `PeFile`.
+#[derive(Debug)]
+pub struct PeComdatSectionIterator<'data, 'file, Pe, R = &'data [u8]>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ file: &'file PeFile<'data, Pe, R>,
+}
+
+impl<'data, 'file, Pe, R> Iterator for PeComdatSectionIterator<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ type Item = SectionIndex;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
+
+impl pe::ImageDosHeader {
+ /// Read the DOS header.
+ ///
+ /// Also checks that the `e_magic` field in the header is valid.
+ pub fn parse<'data, R: ReadRef<'data>>(data: R) -> read::Result<&'data Self> {
+ // DOS header comes first.
+ let dos_header = data
+ .read_at::<pe::ImageDosHeader>(0)
+ .read_error("Invalid DOS header size or alignment")?;
+ if dos_header.e_magic.get(LE) != pe::IMAGE_DOS_SIGNATURE {
+ return Err(Error("Invalid DOS magic"));
+ }
+ Ok(dos_header)
+ }
+
+ /// Return the file offset of the nt_headers.
+ #[inline]
+ pub fn nt_headers_offset(&self) -> u32 {
+ self.e_lfanew.get(LE)
+ }
+}
+
+/// Find the optional header and read the `optional_header.magic`.
+///
+/// It can be useful to know this magic value before trying to
+/// fully parse the NT headers.
+pub fn optional_header_magic<'data, R: ReadRef<'data>>(data: R) -> Result<u16> {
+ let dos_header = pe::ImageDosHeader::parse(data)?;
+ // NT headers are at an offset specified in the DOS header.
+ let offset = dos_header.nt_headers_offset().into();
+ // It doesn't matter which NT header type is used for the purpose
+ // of reading the optional header magic.
+ let nt_headers = data
+ .read_at::<pe::ImageNtHeaders32>(offset)
+ .read_error("Invalid NT headers offset, size, or alignment")?;
+ if nt_headers.signature() != pe::IMAGE_NT_SIGNATURE {
+ return Err(Error("Invalid PE magic"));
+ }
+ Ok(nt_headers.optional_header().magic())
+}
+
+/// A trait for generic access to `ImageNtHeaders32` and `ImageNtHeaders64`.
+#[allow(missing_docs)]
+pub trait ImageNtHeaders: Debug + Pod {
+ type ImageOptionalHeader: ImageOptionalHeader;
+
+ /// Return true if this type is a 64-bit header.
+ ///
+ /// This is a property of the type, not a value in the header data.
+ fn is_type_64(&self) -> bool;
+
+ /// Return true if the magic field in the optional header is valid.
+ fn is_valid_optional_magic(&self) -> bool;
+
+ /// Return the signature
+ fn signature(&self) -> u32;
+
+ /// Return the file header.
+ fn file_header(&self) -> &pe::ImageFileHeader;
+
+ /// Return the optional header.
+ fn optional_header(&self) -> &Self::ImageOptionalHeader;
+
+ // Provided methods.
+
+ /// Read the NT headers, including the data directories.
+ ///
+ /// `data` must be for the entire file.
+ ///
+ /// `offset` must be headers offset, which can be obtained from `ImageDosHeader::nt_headers_offset`.
+ /// It is updated to point after the optional header, which is where the section headers are located.
+ ///
+ /// Also checks that the `signature` and `magic` fields in the headers are valid.
+ fn parse<'data, R: ReadRef<'data>>(
+ data: R,
+ offset: &mut u64,
+ ) -> read::Result<(&'data Self, &'data [pe::ImageDataDirectory])> {
+ // Note that this does not include the data directories in the optional header.
+ let nt_headers = data
+ .read::<Self>(offset)
+ .read_error("Invalid PE headers offset or size")?;
+ if nt_headers.signature() != pe::IMAGE_NT_SIGNATURE {
+ return Err(Error("Invalid PE magic"));
+ }
+ if !nt_headers.is_valid_optional_magic() {
+ return Err(Error("Invalid PE optional header magic"));
+ }
+
+ // Read the rest of the optional header, and then read the data directories from that.
+ let optional_data_size =
+ u64::from(nt_headers.file_header().size_of_optional_header.get(LE))
+ .checked_sub(mem::size_of::<Self::ImageOptionalHeader>() as u64)
+ .read_error("PE optional header size is too small")?;
+ let mut optional_data = data
+ .read_bytes(offset, optional_data_size)
+ .read_error("Invalid PE optional header size")
+ .map(Bytes)?;
+ let data_directories = optional_data
+ .read_slice(nt_headers.optional_header().number_of_rva_and_sizes() as usize)
+ .read_error("Invalid PE number of RVA and sizes")?;
+
+ Ok((nt_headers, data_directories))
+ }
+
+ /// Read the section table.
+ ///
+ /// `data` must be for the entire file.
+ /// `offset` must be after the optional file header.
+ #[inline]
+ fn sections<'data, R: ReadRef<'data>>(
+ &self,
+ data: R,
+ offset: u64,
+ ) -> read::Result<SectionTable<'data>> {
+ SectionTable::parse(self.file_header(), data, offset)
+ }
+
+ /// Read the symbol table and string table.
+ ///
+ /// `data` must be the entire file data.
+ #[inline]
+ fn symbols<'data, R: ReadRef<'data>>(&self, data: R) -> read::Result<SymbolTable<'data, R>> {
+ SymbolTable::parse(self.file_header(), data)
+ }
+}
+
+/// A trait for generic access to `ImageOptionalHeader32` and `ImageOptionalHeader64`.
+#[allow(missing_docs)]
+pub trait ImageOptionalHeader: Debug + Pod {
+ // Standard fields.
+ fn magic(&self) -> u16;
+ fn major_linker_version(&self) -> u8;
+ fn minor_linker_version(&self) -> u8;
+ fn size_of_code(&self) -> u32;
+ fn size_of_initialized_data(&self) -> u32;
+ fn size_of_uninitialized_data(&self) -> u32;
+ fn address_of_entry_point(&self) -> u32;
+ fn base_of_code(&self) -> u32;
+
+ // NT additional fields.
+ fn image_base(&self) -> u64;
+ fn section_alignment(&self) -> u32;
+ fn file_alignment(&self) -> u32;
+ fn major_operating_system_version(&self) -> u16;
+ fn minor_operating_system_version(&self) -> u16;
+ fn major_image_version(&self) -> u16;
+ fn minor_image_version(&self) -> u16;
+ fn major_subsystem_version(&self) -> u16;
+ fn minor_subsystem_version(&self) -> u16;
+ fn win32_version_value(&self) -> u32;
+ fn size_of_image(&self) -> u32;
+ fn size_of_headers(&self) -> u32;
+ fn check_sum(&self) -> u32;
+ fn subsystem(&self) -> u16;
+ fn dll_characteristics(&self) -> u16;
+ fn size_of_stack_reserve(&self) -> u64;
+ fn size_of_stack_commit(&self) -> u64;
+ fn size_of_heap_reserve(&self) -> u64;
+ fn size_of_heap_commit(&self) -> u64;
+ fn loader_flags(&self) -> u32;
+ fn number_of_rva_and_sizes(&self) -> u32;
+}
+
+impl ImageNtHeaders for pe::ImageNtHeaders32 {
+ type ImageOptionalHeader = pe::ImageOptionalHeader32;
+
+ #[inline]
+ fn is_type_64(&self) -> bool {
+ false
+ }
+
+ #[inline]
+ fn is_valid_optional_magic(&self) -> bool {
+ self.optional_header.magic.get(LE) == pe::IMAGE_NT_OPTIONAL_HDR32_MAGIC
+ }
+
+ #[inline]
+ fn signature(&self) -> u32 {
+ self.signature.get(LE)
+ }
+
+ #[inline]
+ fn file_header(&self) -> &pe::ImageFileHeader {
+ &self.file_header
+ }
+
+ #[inline]
+ fn optional_header(&self) -> &Self::ImageOptionalHeader {
+ &self.optional_header
+ }
+}
+
+impl ImageOptionalHeader for pe::ImageOptionalHeader32 {
+ #[inline]
+ fn magic(&self) -> u16 {
+ self.magic.get(LE)
+ }
+
+ #[inline]
+ fn major_linker_version(&self) -> u8 {
+ self.major_linker_version
+ }
+
+ #[inline]
+ fn minor_linker_version(&self) -> u8 {
+ self.minor_linker_version
+ }
+
+ #[inline]
+ fn size_of_code(&self) -> u32 {
+ self.size_of_code.get(LE)
+ }
+
+ #[inline]
+ fn size_of_initialized_data(&self) -> u32 {
+ self.size_of_initialized_data.get(LE)
+ }
+
+ #[inline]
+ fn size_of_uninitialized_data(&self) -> u32 {
+ self.size_of_uninitialized_data.get(LE)
+ }
+
+ #[inline]
+ fn address_of_entry_point(&self) -> u32 {
+ self.address_of_entry_point.get(LE)
+ }
+
+ #[inline]
+ fn base_of_code(&self) -> u32 {
+ self.base_of_code.get(LE)
+ }
+
+ #[inline]
+ fn image_base(&self) -> u64 {
+ self.image_base.get(LE).into()
+ }
+
+ #[inline]
+ fn section_alignment(&self) -> u32 {
+ self.section_alignment.get(LE)
+ }
+
+ #[inline]
+ fn file_alignment(&self) -> u32 {
+ self.file_alignment.get(LE)
+ }
+
+ #[inline]
+ fn major_operating_system_version(&self) -> u16 {
+ self.major_operating_system_version.get(LE)
+ }
+
+ #[inline]
+ fn minor_operating_system_version(&self) -> u16 {
+ self.minor_operating_system_version.get(LE)
+ }
+
+ #[inline]
+ fn major_image_version(&self) -> u16 {
+ self.major_image_version.get(LE)
+ }
+
+ #[inline]
+ fn minor_image_version(&self) -> u16 {
+ self.minor_image_version.get(LE)
+ }
+
+ #[inline]
+ fn major_subsystem_version(&self) -> u16 {
+ self.major_subsystem_version.get(LE)
+ }
+
+ #[inline]
+ fn minor_subsystem_version(&self) -> u16 {
+ self.minor_subsystem_version.get(LE)
+ }
+
+ #[inline]
+ fn win32_version_value(&self) -> u32 {
+ self.win32_version_value.get(LE)
+ }
+
+ #[inline]
+ fn size_of_image(&self) -> u32 {
+ self.size_of_image.get(LE)
+ }
+
+ #[inline]
+ fn size_of_headers(&self) -> u32 {
+ self.size_of_headers.get(LE)
+ }
+
+ #[inline]
+ fn check_sum(&self) -> u32 {
+ self.check_sum.get(LE)
+ }
+
+ #[inline]
+ fn subsystem(&self) -> u16 {
+ self.subsystem.get(LE)
+ }
+
+ #[inline]
+ fn dll_characteristics(&self) -> u16 {
+ self.dll_characteristics.get(LE)
+ }
+
+ #[inline]
+ fn size_of_stack_reserve(&self) -> u64 {
+ self.size_of_stack_reserve.get(LE).into()
+ }
+
+ #[inline]
+ fn size_of_stack_commit(&self) -> u64 {
+ self.size_of_stack_commit.get(LE).into()
+ }
+
+ #[inline]
+ fn size_of_heap_reserve(&self) -> u64 {
+ self.size_of_heap_reserve.get(LE).into()
+ }
+
+ #[inline]
+ fn size_of_heap_commit(&self) -> u64 {
+ self.size_of_heap_commit.get(LE).into()
+ }
+
+ #[inline]
+ fn loader_flags(&self) -> u32 {
+ self.loader_flags.get(LE)
+ }
+
+ #[inline]
+ fn number_of_rva_and_sizes(&self) -> u32 {
+ self.number_of_rva_and_sizes.get(LE)
+ }
+}
+
+impl ImageNtHeaders for pe::ImageNtHeaders64 {
+ type ImageOptionalHeader = pe::ImageOptionalHeader64;
+
+ #[inline]
+ fn is_type_64(&self) -> bool {
+ true
+ }
+
+ #[inline]
+ fn is_valid_optional_magic(&self) -> bool {
+ self.optional_header.magic.get(LE) == pe::IMAGE_NT_OPTIONAL_HDR64_MAGIC
+ }
+
+ #[inline]
+ fn signature(&self) -> u32 {
+ self.signature.get(LE)
+ }
+
+ #[inline]
+ fn file_header(&self) -> &pe::ImageFileHeader {
+ &self.file_header
+ }
+
+ #[inline]
+ fn optional_header(&self) -> &Self::ImageOptionalHeader {
+ &self.optional_header
+ }
+}
+
+impl ImageOptionalHeader for pe::ImageOptionalHeader64 {
+ #[inline]
+ fn magic(&self) -> u16 {
+ self.magic.get(LE)
+ }
+
+ #[inline]
+ fn major_linker_version(&self) -> u8 {
+ self.major_linker_version
+ }
+
+ #[inline]
+ fn minor_linker_version(&self) -> u8 {
+ self.minor_linker_version
+ }
+
+ #[inline]
+ fn size_of_code(&self) -> u32 {
+ self.size_of_code.get(LE)
+ }
+
+ #[inline]
+ fn size_of_initialized_data(&self) -> u32 {
+ self.size_of_initialized_data.get(LE)
+ }
+
+ #[inline]
+ fn size_of_uninitialized_data(&self) -> u32 {
+ self.size_of_uninitialized_data.get(LE)
+ }
+
+ #[inline]
+ fn address_of_entry_point(&self) -> u32 {
+ self.address_of_entry_point.get(LE)
+ }
+
+ #[inline]
+ fn base_of_code(&self) -> u32 {
+ self.base_of_code.get(LE)
+ }
+
+ #[inline]
+ fn image_base(&self) -> u64 {
+ self.image_base.get(LE)
+ }
+
+ #[inline]
+ fn section_alignment(&self) -> u32 {
+ self.section_alignment.get(LE)
+ }
+
+ #[inline]
+ fn file_alignment(&self) -> u32 {
+ self.file_alignment.get(LE)
+ }
+
+ #[inline]
+ fn major_operating_system_version(&self) -> u16 {
+ self.major_operating_system_version.get(LE)
+ }
+
+ #[inline]
+ fn minor_operating_system_version(&self) -> u16 {
+ self.minor_operating_system_version.get(LE)
+ }
+
+ #[inline]
+ fn major_image_version(&self) -> u16 {
+ self.major_image_version.get(LE)
+ }
+
+ #[inline]
+ fn minor_image_version(&self) -> u16 {
+ self.minor_image_version.get(LE)
+ }
+
+ #[inline]
+ fn major_subsystem_version(&self) -> u16 {
+ self.major_subsystem_version.get(LE)
+ }
+
+ #[inline]
+ fn minor_subsystem_version(&self) -> u16 {
+ self.minor_subsystem_version.get(LE)
+ }
+
+ #[inline]
+ fn win32_version_value(&self) -> u32 {
+ self.win32_version_value.get(LE)
+ }
+
+ #[inline]
+ fn size_of_image(&self) -> u32 {
+ self.size_of_image.get(LE)
+ }
+
+ #[inline]
+ fn size_of_headers(&self) -> u32 {
+ self.size_of_headers.get(LE)
+ }
+
+ #[inline]
+ fn check_sum(&self) -> u32 {
+ self.check_sum.get(LE)
+ }
+
+ #[inline]
+ fn subsystem(&self) -> u16 {
+ self.subsystem.get(LE)
+ }
+
+ #[inline]
+ fn dll_characteristics(&self) -> u16 {
+ self.dll_characteristics.get(LE)
+ }
+
+ #[inline]
+ fn size_of_stack_reserve(&self) -> u64 {
+ self.size_of_stack_reserve.get(LE)
+ }
+
+ #[inline]
+ fn size_of_stack_commit(&self) -> u64 {
+ self.size_of_stack_commit.get(LE)
+ }
+
+ #[inline]
+ fn size_of_heap_reserve(&self) -> u64 {
+ self.size_of_heap_reserve.get(LE)
+ }
+
+ #[inline]
+ fn size_of_heap_commit(&self) -> u64 {
+ self.size_of_heap_commit.get(LE)
+ }
+
+ #[inline]
+ fn loader_flags(&self) -> u32 {
+ self.loader_flags.get(LE)
+ }
+
+ #[inline]
+ fn number_of_rva_and_sizes(&self) -> u32 {
+ self.number_of_rva_and_sizes.get(LE)
+ }
+}
+
+impl pe::ImageDataDirectory {
+ /// Get the data referenced by this directory entry.
+ pub fn data<'data, R: ReadRef<'data>>(
+ &self,
+ data: R,
+ sections: &SectionTable<'data>,
+ ) -> Result<&'data [u8]> {
+ sections
+ .pe_data_at(data, self.virtual_address.get(LE))
+ .read_error("Invalid data dir virtual address or size")?
+ .get(..self.size.get(LE) as usize)
+ .read_error("Invalid data dir size")
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/pe/mod.rs b/vendor/object-0.26.2/src/read/pe/mod.rs
new file mode 100644
index 000000000..2a0b68126
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/pe/mod.rs
@@ -0,0 +1,16 @@
+//! Support for reading PE files.
+//!
+//! Defines traits to abstract over the difference between PE32/PE32+,
+//! and implements read functionality in terms of these traits.
+//!
+//! This module reuses some of the COFF functionality.
+//!
+//! Also provides `PeFile` and related types which implement the `Object` trait.
+
+mod file;
+pub use file::*;
+
+mod section;
+pub use section::*;
+
+pub use super::coff::{SectionTable, SymbolTable};
diff --git a/vendor/object-0.26.2/src/read/pe/section.rs b/vendor/object-0.26.2/src/read/pe/section.rs
new file mode 100644
index 000000000..32e0a825d
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/pe/section.rs
@@ -0,0 +1,343 @@
+use core::marker::PhantomData;
+use core::{cmp, iter, result, slice, str};
+
+use crate::endian::LittleEndian as LE;
+use crate::pe;
+use crate::read::{
+ self, CompressedData, CompressedFileRange, ObjectSection, ObjectSegment, ReadError, ReadRef,
+ Relocation, Result, SectionFlags, SectionIndex, SectionKind,
+};
+
+use super::{ImageNtHeaders, PeFile, SectionTable};
+
+/// An iterator over the loadable sections of a `PeFile32`.
+pub type PeSegmentIterator32<'data, 'file, R = &'data [u8]> =
+ PeSegmentIterator<'data, 'file, pe::ImageNtHeaders32, R>;
+/// An iterator over the loadable sections of a `PeFile64`.
+pub type PeSegmentIterator64<'data, 'file, R = &'data [u8]> =
+ PeSegmentIterator<'data, 'file, pe::ImageNtHeaders64, R>;
+
+/// An iterator over the loadable sections of a `PeFile`.
+#[derive(Debug)]
+pub struct PeSegmentIterator<'data, 'file, Pe, R = &'data [u8]>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file PeFile<'data, Pe, R>,
+ pub(super) iter: slice::Iter<'data, pe::ImageSectionHeader>,
+}
+
+impl<'data, 'file, Pe, R> Iterator for PeSegmentIterator<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ type Item = PeSegment<'data, 'file, Pe, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.iter.next().map(|section| PeSegment {
+ file: self.file,
+ section,
+ })
+ }
+}
+
+/// A loadable section of a `PeFile32`.
+pub type PeSegment32<'data, 'file, R = &'data [u8]> =
+ PeSegment<'data, 'file, pe::ImageNtHeaders32, R>;
+/// A loadable section of a `PeFile64`.
+pub type PeSegment64<'data, 'file, R = &'data [u8]> =
+ PeSegment<'data, 'file, pe::ImageNtHeaders64, R>;
+
+/// A loadable section of a `PeFile`.
+#[derive(Debug)]
+pub struct PeSegment<'data, 'file, Pe, R = &'data [u8]>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ file: &'file PeFile<'data, Pe, R>,
+ section: &'data pe::ImageSectionHeader,
+}
+
+impl<'data, 'file, Pe, R> PeSegment<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ fn bytes(&self) -> Result<&'data [u8]> {
+ self.section
+ .pe_data(self.file.data)
+ .read_error("Invalid PE section offset or size")
+ }
+}
+
+impl<'data, 'file, Pe, R> read::private::Sealed for PeSegment<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Pe, R> ObjectSegment<'data> for PeSegment<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ #[inline]
+ fn address(&self) -> u64 {
+ u64::from(self.section.virtual_address.get(LE)).wrapping_add(self.file.common.image_base)
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ u64::from(self.section.virtual_size.get(LE))
+ }
+
+ #[inline]
+ fn align(&self) -> u64 {
+ self.file.section_alignment()
+ }
+
+ #[inline]
+ fn file_range(&self) -> (u64, u64) {
+ let (offset, size) = self.section.pe_file_range();
+ (u64::from(offset), u64::from(size))
+ }
+
+ fn data(&self) -> Result<&'data [u8]> {
+ self.bytes()
+ }
+
+ fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
+ Ok(read::util::data_range(
+ self.bytes()?,
+ self.address(),
+ address,
+ size,
+ ))
+ }
+
+ #[inline]
+ fn name(&self) -> Result<Option<&str>> {
+ let name = self.section.name(self.file.common.symbols.strings())?;
+ Ok(Some(
+ str::from_utf8(name)
+ .ok()
+ .read_error("Non UTF-8 PE section name")?,
+ ))
+ }
+}
+
+/// An iterator over the sections of a `PeFile32`.
+pub type PeSectionIterator32<'data, 'file, R = &'data [u8]> =
+ PeSectionIterator<'data, 'file, pe::ImageNtHeaders32, R>;
+/// An iterator over the sections of a `PeFile64`.
+pub type PeSectionIterator64<'data, 'file, R = &'data [u8]> =
+ PeSectionIterator<'data, 'file, pe::ImageNtHeaders64, R>;
+
+/// An iterator over the sections of a `PeFile`.
+#[derive(Debug)]
+pub struct PeSectionIterator<'data, 'file, Pe, R = &'data [u8]>
+where
+ 'data: 'file,
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file PeFile<'data, Pe, R>,
+ pub(super) iter: iter::Enumerate<slice::Iter<'data, pe::ImageSectionHeader>>,
+}
+
+impl<'data, 'file, Pe, R> Iterator for PeSectionIterator<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ type Item = PeSection<'data, 'file, Pe, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ self.iter.next().map(|(index, section)| PeSection {
+ file: self.file,
+ index: SectionIndex(index + 1),
+ section,
+ })
+ }
+}
+
+/// A section of a `PeFile32`.
+pub type PeSection32<'data, 'file, R = &'data [u8]> =
+ PeSection<'data, 'file, pe::ImageNtHeaders32, R>;
+/// A section of a `PeFile64`.
+pub type PeSection64<'data, 'file, R = &'data [u8]> =
+ PeSection<'data, 'file, pe::ImageNtHeaders64, R>;
+
+/// A section of a `PeFile`.
+#[derive(Debug)]
+pub struct PeSection<'data, 'file, Pe, R = &'data [u8]>
+where
+ 'data: 'file,
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ pub(super) file: &'file PeFile<'data, Pe, R>,
+ pub(super) index: SectionIndex,
+ pub(super) section: &'data pe::ImageSectionHeader,
+}
+
+impl<'data, 'file, Pe, R> PeSection<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ fn bytes(&self) -> Result<&'data [u8]> {
+ self.section
+ .pe_data(self.file.data)
+ .read_error("Invalid PE section offset or size")
+ }
+}
+
+impl<'data, 'file, Pe, R> read::private::Sealed for PeSection<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+}
+
+impl<'data, 'file, Pe, R> ObjectSection<'data> for PeSection<'data, 'file, Pe, R>
+where
+ Pe: ImageNtHeaders,
+ R: ReadRef<'data>,
+{
+ type RelocationIterator = PeRelocationIterator<'data, 'file, R>;
+
+ #[inline]
+ fn index(&self) -> SectionIndex {
+ self.index
+ }
+
+ #[inline]
+ fn address(&self) -> u64 {
+ u64::from(self.section.virtual_address.get(LE)).wrapping_add(self.file.common.image_base)
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ u64::from(self.section.virtual_size.get(LE))
+ }
+
+ #[inline]
+ fn align(&self) -> u64 {
+ self.file.section_alignment()
+ }
+
+ #[inline]
+ fn file_range(&self) -> Option<(u64, u64)> {
+ let (offset, size) = self.section.pe_file_range();
+ if size == 0 {
+ None
+ } else {
+ Some((u64::from(offset), u64::from(size)))
+ }
+ }
+
+ fn data(&self) -> Result<&'data [u8]> {
+ self.bytes()
+ }
+
+ fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>> {
+ Ok(read::util::data_range(
+ self.bytes()?,
+ self.address(),
+ address,
+ size,
+ ))
+ }
+
+ #[inline]
+ fn compressed_file_range(&self) -> Result<CompressedFileRange> {
+ Ok(CompressedFileRange::none(self.file_range()))
+ }
+
+ #[inline]
+ fn compressed_data(&self) -> Result<CompressedData<'data>> {
+ self.data().map(CompressedData::none)
+ }
+
+ #[inline]
+ fn name(&self) -> Result<&str> {
+ let name = self.section.name(self.file.common.symbols.strings())?;
+ str::from_utf8(name)
+ .ok()
+ .read_error("Non UTF-8 PE section name")
+ }
+
+ #[inline]
+ fn segment_name(&self) -> Result<Option<&str>> {
+ Ok(None)
+ }
+
+ #[inline]
+ fn kind(&self) -> SectionKind {
+ self.section.kind()
+ }
+
+ fn relocations(&self) -> PeRelocationIterator<'data, 'file, R> {
+ PeRelocationIterator(PhantomData)
+ }
+
+ fn flags(&self) -> SectionFlags {
+ SectionFlags::Coff {
+ characteristics: self.section.characteristics.get(LE),
+ }
+ }
+}
+
+impl<'data> SectionTable<'data> {
+ /// Return the data at the given virtual address in a PE file.
+ pub fn pe_data_at<R: ReadRef<'data>>(&self, data: R, va: u32) -> Option<&'data [u8]> {
+ self.iter()
+ .filter_map(|section| section.pe_data_at(data, va))
+ .next()
+ }
+}
+
+impl pe::ImageSectionHeader {
+ /// Return the offset and size of the section in a PE file.
+ ///
+ /// Returns `None` for sections that have no data in the file.
+ pub fn pe_file_range(&self) -> (u32, u32) {
+ // Pointer and size will be zero for uninitialized data; we don't need to validate this.
+ let offset = self.pointer_to_raw_data.get(LE);
+ let size = cmp::min(self.virtual_size.get(LE), self.size_of_raw_data.get(LE));
+ (offset, size)
+ }
+
+ /// Return the section data in a PE file.
+ pub fn pe_data<'data, R: ReadRef<'data>>(&self, data: R) -> result::Result<&'data [u8], ()> {
+ let (offset, size) = self.pe_file_range();
+ data.read_bytes_at(offset.into(), size.into())
+ }
+
+ /// Return the data at the given virtual address if this section contains it.
+ pub fn pe_data_at<'data, R: ReadRef<'data>>(&self, data: R, va: u32) -> Option<&'data [u8]> {
+ let section_va = self.virtual_address.get(LE);
+ let offset = va.checked_sub(section_va)?;
+ let section_data = self.pe_data(data).ok()?;
+ section_data.get(offset as usize..)
+ }
+}
+
+/// An iterator over the relocations in an `PeSection`.
+#[derive(Debug)]
+pub struct PeRelocationIterator<'data, 'file, R = &'data [u8]>(
+ PhantomData<(&'data (), &'file (), R)>,
+);
+
+impl<'data, 'file, R> Iterator for PeRelocationIterator<'data, 'file, R> {
+ type Item = (u64, Relocation);
+
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/read_cache.rs b/vendor/object-0.26.2/src/read/read_cache.rs
new file mode 100644
index 000000000..19a98a44d
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/read_cache.rs
@@ -0,0 +1,185 @@
+use core::ops::Range;
+use std::boxed::Box;
+use std::cell::RefCell;
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::convert::TryInto;
+use std::io::{Read, Seek, SeekFrom};
+use std::mem;
+use std::vec::Vec;
+
+use crate::read::ReadRef;
+
+/// An implementation of `ReadRef` for data in a stream that implements
+/// `Read + Seek`.
+///
+/// Contains a cache of read-only blocks of data, allowing references to
+/// them to be returned. Entries in the cache are never removed.
+/// Entries are keyed on the offset and size of the read.
+/// Currently overlapping reads are considered separate reads.
+#[derive(Debug)]
+pub struct ReadCache<R: Read + Seek> {
+ cache: RefCell<ReadCacheInternal<R>>,
+}
+
+#[derive(Debug)]
+struct ReadCacheInternal<R: Read + Seek> {
+ read: R,
+ bufs: HashMap<(u64, u64), Box<[u8]>>,
+ strings: HashMap<(u64, u8), Box<[u8]>>,
+}
+
+impl<R: Read + Seek> ReadCache<R> {
+ /// Create an empty `ReadCache` for the given stream.
+ pub fn new(read: R) -> Self {
+ ReadCache {
+ cache: RefCell::new(ReadCacheInternal {
+ read,
+ bufs: HashMap::new(),
+ strings: HashMap::new(),
+ }),
+ }
+ }
+
+ /// Return an implementation of `ReadRef` that restricts reads
+ /// to the given range of the stream.
+ pub fn range(&self, offset: u64, size: u64) -> ReadCacheRange<'_, R> {
+ ReadCacheRange {
+ r: self,
+ offset,
+ size,
+ }
+ }
+
+ /// Free buffers used by the cache.
+ pub fn clear(&mut self) {
+ self.cache.borrow_mut().bufs.clear();
+ }
+
+ /// Unwrap this `ReadCache<R>`, returning the underlying reader.
+ pub fn into_inner(self) -> R {
+ self.cache.into_inner().read
+ }
+}
+
+impl<'a, R: Read + Seek> ReadRef<'a> for &'a ReadCache<R> {
+ fn len(self) -> Result<u64, ()> {
+ let cache = &mut *self.cache.borrow_mut();
+ cache.read.seek(SeekFrom::End(0)).map_err(|_| ())
+ }
+
+ fn read_bytes_at(self, offset: u64, size: u64) -> Result<&'a [u8], ()> {
+ if size == 0 {
+ return Ok(&[]);
+ }
+ let cache = &mut *self.cache.borrow_mut();
+ let buf = match cache.bufs.entry((offset, size)) {
+ Entry::Occupied(entry) => entry.into_mut(),
+ Entry::Vacant(entry) => {
+ let size = size.try_into().map_err(|_| ())?;
+ cache
+ .read
+ .seek(SeekFrom::Start(offset as u64))
+ .map_err(|_| ())?;
+ let mut bytes = vec![0; size].into_boxed_slice();
+ cache.read.read_exact(&mut bytes).map_err(|_| ())?;
+ entry.insert(bytes)
+ }
+ };
+ // Extend the lifetime to that of self.
+ // This is OK because we never mutate or remove entries.
+ Ok(unsafe { mem::transmute::<&[u8], &[u8]>(buf) })
+ }
+
+ fn read_bytes_at_until(self, range: Range<u64>, delimiter: u8) -> Result<&'a [u8], ()> {
+ let cache = &mut *self.cache.borrow_mut();
+ let buf = match cache.strings.entry((range.start, delimiter)) {
+ Entry::Occupied(entry) => entry.into_mut(),
+ Entry::Vacant(entry) => {
+ cache
+ .read
+ .seek(SeekFrom::Start(range.start))
+ .map_err(|_| ())?;
+
+ let max_check: usize = (range.end - range.start).try_into().map_err(|_| ())?;
+ // Strings should be relatively small.
+ // TODO: make this configurable?
+ let max_check = max_check.min(4096);
+
+ let mut bytes = Vec::new();
+ let mut checked = 0;
+ loop {
+ bytes.resize((checked + 256).min(max_check), 0);
+ let read = cache.read.read(&mut bytes[checked..]).map_err(|_| ())?;
+ if read == 0 {
+ return Err(());
+ }
+ if let Some(len) = memchr::memchr(delimiter, &bytes[checked..][..read]) {
+ bytes.truncate(checked + len);
+ break entry.insert(bytes.into_boxed_slice());
+ }
+ checked += read;
+ if checked >= max_check {
+ return Err(());
+ }
+ }
+ }
+ };
+ // Extend the lifetime to that of self.
+ // This is OK because we never mutate or remove entries.
+ Ok(unsafe { mem::transmute::<&[u8], &[u8]>(buf) })
+ }
+}
+
+/// An implementation of `ReadRef` for a range of data in a stream that
+/// implements `Read + Seek`.
+///
+/// Shares an underlying `ReadCache` with a lifetime of `'a`.
+#[derive(Debug)]
+pub struct ReadCacheRange<'a, R: Read + Seek> {
+ r: &'a ReadCache<R>,
+ offset: u64,
+ size: u64,
+}
+
+impl<'a, R: Read + Seek> Clone for ReadCacheRange<'a, R> {
+ fn clone(&self) -> Self {
+ Self {
+ r: self.r,
+ offset: self.offset,
+ size: self.size,
+ }
+ }
+}
+
+impl<'a, R: Read + Seek> Copy for ReadCacheRange<'a, R> {}
+
+impl<'a, R: Read + Seek> ReadRef<'a> for ReadCacheRange<'a, R> {
+ fn len(self) -> Result<u64, ()> {
+ Ok(self.size)
+ }
+
+ fn read_bytes_at(self, offset: u64, size: u64) -> Result<&'a [u8], ()> {
+ if size == 0 {
+ return Ok(&[]);
+ }
+ let end = offset.checked_add(size).ok_or(())?;
+ if end > self.size {
+ return Err(());
+ }
+ let r_offset = self.offset.checked_add(offset).ok_or(())?;
+ self.r.read_bytes_at(r_offset, size)
+ }
+
+ fn read_bytes_at_until(self, range: Range<u64>, delimiter: u8) -> Result<&'a [u8], ()> {
+ let r_start = self.offset.checked_add(range.start).ok_or(())?;
+ let r_end = self.offset.checked_add(range.end).ok_or(())?;
+ let bytes = self.r.read_bytes_at_until(r_start..r_end, delimiter)?;
+ let size = bytes.len().try_into().map_err(|_| ())?;
+ let end = range.start.checked_add(size).ok_or(())?;
+ if end > self.size {
+ return Err(());
+ }
+ Ok(bytes)
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/read_ref.rs b/vendor/object-0.26.2/src/read/read_ref.rs
new file mode 100644
index 000000000..2f547a4e2
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/read_ref.rs
@@ -0,0 +1,137 @@
+#![allow(clippy::len_without_is_empty)]
+
+use core::convert::TryInto;
+use core::ops::Range;
+use core::{mem, result};
+
+use crate::pod::{from_bytes, slice_from_bytes, Pod};
+
+type Result<T> = result::Result<T, ()>;
+
+/// A trait for reading references to `Pod` types from a block of data.
+///
+/// This allows parsers to handle both of these cases:
+/// - the block of data exists in memory, and it is desirable
+/// to use references to this block instead of copying it,
+/// - the block of data exists in storage, and it is desirable
+/// to read on demand to minimize I/O and memory usage.
+///
+/// The methods accept `self` by value because `Self` is expected to behave
+/// similar to a reference: it may be a reference with a lifetime of `'a`,
+/// or it may be a wrapper of a reference.
+///
+/// The `Clone` and `Copy` bounds are for convenience, and since `Self` is
+/// expected to be similar to a reference, these are easily satisfied.
+///
+/// Object file parsers typically use offsets to locate the structures
+/// in the block, and will most commonly use the `*_at` methods to
+/// read a structure at a known offset.
+///
+/// Occasionally file parsers will need to treat the block as a stream,
+/// and so convenience methods are provided that update an offset with
+/// the size that was read.
+//
+// An alternative would be for methods to accept `&mut self` and use a
+// `seek` method instead of the `offset` parameters, but this is less
+// convenient for implementers.
+pub trait ReadRef<'a>: Clone + Copy {
+ /// The total size of the block of data.
+ fn len(self) -> Result<u64>;
+
+ /// Get a reference to a `u8` slice at the given offset.
+ ///
+ /// Returns an error if offset or size are out of bounds.
+ fn read_bytes_at(self, offset: u64, size: u64) -> Result<&'a [u8]>;
+
+ /// Get a reference to a delimited `u8` slice which starts at range.start.
+ ///
+ /// Does not include the delimiter.
+ ///
+ /// Returns an error if the range is out of bounds or the delimiter is
+ /// not found in the range.
+ fn read_bytes_at_until(self, range: Range<u64>, delimiter: u8) -> Result<&'a [u8]>;
+
+ /// Get a reference to a `u8` slice at the given offset, and update the offset.
+ ///
+ /// Returns an error if offset or size are out of bounds.
+ fn read_bytes(self, offset: &mut u64, size: u64) -> Result<&'a [u8]> {
+ let bytes = self.read_bytes_at(*offset, size)?;
+ *offset = offset.wrapping_add(size);
+ Ok(bytes)
+ }
+
+ /// Get a reference to a `Pod` type at the given offset, and update the offset.
+ ///
+ /// Returns an error if offset or size are out of bounds.
+ ///
+ /// The default implementation uses `read_bytes`, and returns an error if
+ /// `read_bytes` does not return bytes with the correct alignment for `T`.
+ /// Implementors may want to provide their own implementation that ensures
+ /// the alignment can be satisified. Alternatively, only use this method with
+ /// types that do not need alignment (see the `unaligned` feature of this crate).
+ fn read<T: Pod>(self, offset: &mut u64) -> Result<&'a T> {
+ let size = mem::size_of::<T>().try_into().map_err(|_| ())?;
+ let bytes = self.read_bytes(offset, size)?;
+ let (t, _) = from_bytes(bytes)?;
+ Ok(t)
+ }
+
+ /// Get a reference to a `Pod` type at the given offset.
+ ///
+ /// Returns an error if offset or size are out of bounds.
+ ///
+ /// Also see the `read` method for information regarding alignment of `T`.
+ fn read_at<T: Pod>(self, mut offset: u64) -> Result<&'a T> {
+ self.read(&mut offset)
+ }
+
+ /// Get a reference to a slice of a `Pod` type at the given offset, and update the offset.
+ ///
+ /// Returns an error if offset or size are out of bounds.
+ ///
+ /// Also see the `read` method for information regarding alignment of `T`.
+ fn read_slice<T: Pod>(self, offset: &mut u64, count: usize) -> Result<&'a [T]> {
+ let size = count
+ .checked_mul(mem::size_of::<T>())
+ .ok_or(())?
+ .try_into()
+ .map_err(|_| ())?;
+ let bytes = self.read_bytes(offset, size)?;
+ let (t, _) = slice_from_bytes(bytes, count)?;
+ Ok(t)
+ }
+
+ /// Get a reference to a slice of a `Pod` type at the given offset.
+ ///
+ /// Returns an error if offset or size are out of bounds.
+ ///
+ /// Also see the `read` method for information regarding alignment of `T`.
+ fn read_slice_at<T: Pod>(self, mut offset: u64, count: usize) -> Result<&'a [T]> {
+ self.read_slice(&mut offset, count)
+ }
+}
+
+impl<'a> ReadRef<'a> for &'a [u8] {
+ fn len(self) -> Result<u64> {
+ self.len().try_into().map_err(|_| ())
+ }
+
+ fn read_bytes_at(self, offset: u64, size: u64) -> Result<&'a [u8]> {
+ let offset: usize = offset.try_into().map_err(|_| ())?;
+ let size: usize = size.try_into().map_err(|_| ())?;
+ self.get(offset..).ok_or(())?.get(..size).ok_or(())
+ }
+
+ fn read_bytes_at_until(self, range: Range<u64>, delimiter: u8) -> Result<&'a [u8]> {
+ let start: usize = range.start.try_into().map_err(|_| ())?;
+ let end: usize = range.end.try_into().map_err(|_| ())?;
+ let bytes = self.get(start..end).ok_or(())?;
+ match memchr::memchr(delimiter, bytes) {
+ Some(len) => {
+ // This will never fail.
+ bytes.get(..len).ok_or(())
+ }
+ None => Err(()),
+ }
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/traits.rs b/vendor/object-0.26.2/src/read/traits.rs
new file mode 100644
index 000000000..4cc497b9b
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/traits.rs
@@ -0,0 +1,429 @@
+use alloc::borrow::Cow;
+use alloc::vec::Vec;
+
+use crate::read::{
+ self, Architecture, CodeView, ComdatKind, CompressedData, CompressedFileRange, Export,
+ FileFlags, Import, ObjectMap, Relocation, Result, SectionFlags, SectionIndex, SectionKind,
+ SymbolFlags, SymbolIndex, SymbolKind, SymbolMap, SymbolMapName, SymbolScope, SymbolSection,
+};
+use crate::Endianness;
+
+/// An object file.
+pub trait Object<'data: 'file, 'file>: read::private::Sealed {
+ /// A segment in the object file.
+ type Segment: ObjectSegment<'data>;
+
+ /// An iterator over the segments in the object file.
+ type SegmentIterator: Iterator<Item = Self::Segment>;
+
+ /// A section in the object file.
+ type Section: ObjectSection<'data>;
+
+ /// An iterator over the sections in the object file.
+ type SectionIterator: Iterator<Item = Self::Section>;
+
+ /// A COMDAT section group in the object file.
+ type Comdat: ObjectComdat<'data>;
+
+ /// An iterator over the COMDAT section groups in the object file.
+ type ComdatIterator: Iterator<Item = Self::Comdat>;
+
+ /// A symbol in the object file.
+ type Symbol: ObjectSymbol<'data>;
+
+ /// An iterator over symbols in the object file.
+ type SymbolIterator: Iterator<Item = Self::Symbol>;
+
+ /// A symbol table in the object file.
+ type SymbolTable: ObjectSymbolTable<
+ 'data,
+ Symbol = Self::Symbol,
+ SymbolIterator = Self::SymbolIterator,
+ >;
+
+ /// An iterator over dynamic relocations in the file.
+ ///
+ /// The first field in the item tuple is the address
+ /// that the relocation applies to.
+ type DynamicRelocationIterator: Iterator<Item = (u64, Relocation)>;
+
+ /// Get the architecture type of the file.
+ fn architecture(&self) -> Architecture;
+
+ /// Get the endianness of the file.
+ #[inline]
+ fn endianness(&self) -> Endianness {
+ if self.is_little_endian() {
+ Endianness::Little
+ } else {
+ Endianness::Big
+ }
+ }
+
+ /// Return true if the file is little endian, false if it is big endian.
+ fn is_little_endian(&self) -> bool;
+
+ /// Return true if the file can contain 64-bit addresses.
+ fn is_64(&self) -> bool;
+
+ /// Get an iterator over the segments in the file.
+ fn segments(&'file self) -> Self::SegmentIterator;
+
+ /// Get the section named `section_name`, if such a section exists.
+ ///
+ /// If `section_name` starts with a '.' then it is treated as a system section name,
+ /// and is compared using the conventions specific to the object file format. This
+ /// includes:
+ /// - if ".debug_str_offsets" is requested for a Mach-O object file, then the actual
+ /// section name that is searched for is "__debug_str_offs".
+ /// - if ".debug_info" is requested for an ELF object file, then
+ /// ".zdebug_info" may be returned (and similarly for other debug sections).
+ ///
+ /// For some object files, multiple segments may contain sections with the same
+ /// name. In this case, the first matching section will be used.
+ ///
+ /// This method skips over sections with invalid names.
+ fn section_by_name(&'file self, section_name: &str) -> Option<Self::Section>;
+
+ /// Get the section at the given index.
+ ///
+ /// The meaning of the index depends on the object file.
+ ///
+ /// For some object files, this requires iterating through all sections.
+ ///
+ /// Returns an error if the index is invalid.
+ fn section_by_index(&'file self, index: SectionIndex) -> Result<Self::Section>;
+
+ /// Get an iterator over the sections in the file.
+ fn sections(&'file self) -> Self::SectionIterator;
+
+ /// Get an iterator over the COMDAT section groups in the file.
+ fn comdats(&'file self) -> Self::ComdatIterator;
+
+ /// Get the symbol table, if any.
+ fn symbol_table(&'file self) -> Option<Self::SymbolTable>;
+
+ /// Get the debugging symbol at the given index.
+ ///
+ /// The meaning of the index depends on the object file.
+ ///
+ /// Returns an error if the index is invalid.
+ fn symbol_by_index(&'file self, index: SymbolIndex) -> Result<Self::Symbol>;
+
+ /// Get an iterator over the debugging symbols in the file.
+ ///
+ /// This may skip over symbols that are malformed or unsupported.
+ ///
+ /// For Mach-O files, this does not include STAB entries.
+ fn symbols(&'file self) -> Self::SymbolIterator;
+
+ /// Get the dynamic linking symbol table, if any.
+ ///
+ /// Only ELF has a separate dynamic linking symbol table.
+ fn dynamic_symbol_table(&'file self) -> Option<Self::SymbolTable>;
+
+ /// Get an iterator over the dynamic linking symbols in the file.
+ ///
+ /// This may skip over symbols that are malformed or unsupported.
+ ///
+ /// Only ELF has separate dynamic linking symbols.
+ /// Other file formats will return an empty iterator.
+ fn dynamic_symbols(&'file self) -> Self::SymbolIterator;
+
+ /// Get the dynamic relocations for this file.
+ ///
+ /// Symbol indices in these relocations refer to the dynamic symbol table.
+ ///
+ /// Only ELF has dynamic relocations.
+ fn dynamic_relocations(&'file self) -> Option<Self::DynamicRelocationIterator>;
+
+ /// Construct a map from addresses to symbol names.
+ ///
+ /// The map will only contain defined text and data symbols.
+ /// The dynamic symbol table will only be used if there are no debugging symbols.
+ fn symbol_map(&'file self) -> SymbolMap<SymbolMapName<'data>> {
+ let mut symbols = Vec::new();
+ if let Some(table) = self.symbol_table().or_else(|| self.dynamic_symbol_table()) {
+ for symbol in table.symbols() {
+ if !symbol.is_definition() {
+ continue;
+ }
+ if let Ok(name) = symbol.name() {
+ symbols.push(SymbolMapName::new(symbol.address(), name));
+ }
+ }
+ }
+ SymbolMap::new(symbols)
+ }
+
+ /// Construct a map from addresses to symbol names and object file names.
+ ///
+ /// This is derived from Mach-O STAB entries.
+ fn object_map(&'file self) -> ObjectMap<'data> {
+ ObjectMap::default()
+ }
+
+ /// Get the imported symbols.
+ fn imports(&self) -> Result<Vec<Import<'data>>>;
+
+ /// Get the exported symbols.
+ fn exports(&self) -> Result<Vec<Export<'data>>>;
+
+ /// Return true if the file contains debug information sections, false if not.
+ fn has_debug_symbols(&self) -> bool;
+
+ /// The UUID from a Mach-O `LC_UUID` load command.
+ #[inline]
+ fn mach_uuid(&self) -> Result<Option<[u8; 16]>> {
+ Ok(None)
+ }
+
+ /// The build ID from an ELF `NT_GNU_BUILD_ID` note.
+ #[inline]
+ fn build_id(&self) -> Result<Option<&'data [u8]>> {
+ Ok(None)
+ }
+
+ /// The filename and CRC from a `.gnu_debuglink` section.
+ #[inline]
+ fn gnu_debuglink(&self) -> Result<Option<(&'data [u8], u32)>> {
+ Ok(None)
+ }
+
+ /// The filename and build ID from a `.gnu_debugaltlink` section.
+ #[inline]
+ fn gnu_debugaltlink(&self) -> Result<Option<(&'data [u8], &'data [u8])>> {
+ Ok(None)
+ }
+
+ /// The filename and GUID from the PE CodeView section
+ #[inline]
+ fn pdb_info(&self) -> Result<Option<CodeView>> {
+ Ok(None)
+ }
+
+ /// Get the base address used for relative virtual addresses.
+ ///
+ /// Currently this is only non-zero for PE.
+ fn relative_address_base(&'file self) -> u64;
+
+ /// Get the virtual address of the entry point of the binary
+ fn entry(&'file self) -> u64;
+
+ /// File flags that are specific to each file format.
+ fn flags(&self) -> FileFlags;
+}
+
+/// A loadable segment defined in an object file.
+///
+/// For ELF, this is a program header with type `PT_LOAD`.
+/// For Mach-O, this is a load command with type `LC_SEGMENT` or `LC_SEGMENT_64`.
+pub trait ObjectSegment<'data>: read::private::Sealed {
+ /// Returns the virtual address of the segment.
+ fn address(&self) -> u64;
+
+ /// Returns the size of the segment in memory.
+ fn size(&self) -> u64;
+
+ /// Returns the alignment of the segment in memory.
+ fn align(&self) -> u64;
+
+ /// Returns the offset and size of the segment in the file.
+ fn file_range(&self) -> (u64, u64);
+
+ /// Returns a reference to the file contents of the segment.
+ ///
+ /// The length of this data may be different from the size of the
+ /// segment in memory.
+ fn data(&self) -> Result<&'data [u8]>;
+
+ /// Return the segment data in the given range.
+ ///
+ /// Returns `Ok(None)` if the segment does not contain the given range.
+ fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>>;
+
+ /// Returns the name of the segment.
+ fn name(&self) -> Result<Option<&str>>;
+}
+
+/// A section defined in an object file.
+pub trait ObjectSection<'data>: read::private::Sealed {
+ /// An iterator over the relocations for a section.
+ ///
+ /// The first field in the item tuple is the section offset
+ /// that the relocation applies to.
+ type RelocationIterator: Iterator<Item = (u64, Relocation)>;
+
+ /// Returns the section index.
+ fn index(&self) -> SectionIndex;
+
+ /// Returns the address of the section.
+ fn address(&self) -> u64;
+
+ /// Returns the size of the section in memory.
+ fn size(&self) -> u64;
+
+ /// Returns the alignment of the section in memory.
+ fn align(&self) -> u64;
+
+ /// Returns offset and size of on-disk segment (if any).
+ fn file_range(&self) -> Option<(u64, u64)>;
+
+ /// Returns the raw contents of the section.
+ ///
+ /// The length of this data may be different from the size of the
+ /// section in memory.
+ ///
+ /// This does not do any decompression.
+ fn data(&self) -> Result<&'data [u8]>;
+
+ /// Return the raw contents of the section data in the given range.
+ ///
+ /// This does not do any decompression.
+ ///
+ /// Returns `Ok(None)` if the section does not contain the given range.
+ fn data_range(&self, address: u64, size: u64) -> Result<Option<&'data [u8]>>;
+
+ /// Returns the potentially compressed file range of the section,
+ /// along with information about the compression.
+ fn compressed_file_range(&self) -> Result<CompressedFileRange>;
+
+ /// Returns the potentially compressed contents of the section,
+ /// along with information about the compression.
+ fn compressed_data(&self) -> Result<CompressedData<'data>>;
+
+ /// Returns the uncompressed contents of the section.
+ ///
+ /// The length of this data may be different from the size of the
+ /// section in memory.
+ ///
+ /// If no compression is detected, then returns the data unchanged.
+ /// Returns `Err` if decompression fails.
+ fn uncompressed_data(&self) -> Result<Cow<'data, [u8]>> {
+ self.compressed_data()?.decompress()
+ }
+
+ /// Returns the name of the section.
+ fn name(&self) -> Result<&str>;
+
+ /// Returns the name of the segment for this section.
+ fn segment_name(&self) -> Result<Option<&str>>;
+
+ /// Return the kind of this section.
+ fn kind(&self) -> SectionKind;
+
+ /// Get the relocations for this section.
+ fn relocations(&self) -> Self::RelocationIterator;
+
+ /// Section flags that are specific to each file format.
+ fn flags(&self) -> SectionFlags;
+}
+
+/// A COMDAT section group defined in an object file.
+pub trait ObjectComdat<'data>: read::private::Sealed {
+ /// An iterator over the sections in the object file.
+ type SectionIterator: Iterator<Item = SectionIndex>;
+
+ /// Returns the COMDAT selection kind.
+ fn kind(&self) -> ComdatKind;
+
+ /// Returns the index of the symbol used for the name of COMDAT section group.
+ fn symbol(&self) -> SymbolIndex;
+
+ /// Returns the name of the COMDAT section group.
+ fn name(&self) -> Result<&str>;
+
+ /// Get the sections in this section group.
+ fn sections(&self) -> Self::SectionIterator;
+}
+
+/// A symbol table.
+pub trait ObjectSymbolTable<'data>: read::private::Sealed {
+ /// A symbol table entry.
+ type Symbol: ObjectSymbol<'data>;
+
+ /// An iterator over the symbols in a symbol table.
+ type SymbolIterator: Iterator<Item = Self::Symbol>;
+
+ /// Get an iterator over the symbols in the table.
+ ///
+ /// This may skip over symbols that are malformed or unsupported.
+ fn symbols(&self) -> Self::SymbolIterator;
+
+ /// Get the symbol at the given index.
+ ///
+ /// The meaning of the index depends on the object file.
+ ///
+ /// Returns an error if the index is invalid.
+ fn symbol_by_index(&self, index: SymbolIndex) -> Result<Self::Symbol>;
+}
+
+/// A symbol table entry.
+pub trait ObjectSymbol<'data>: read::private::Sealed {
+ /// The index of the symbol.
+ fn index(&self) -> SymbolIndex;
+
+ /// The name of the symbol.
+ fn name(&self) -> Result<&'data str>;
+
+ /// The address of the symbol. May be zero if the address is unknown.
+ fn address(&self) -> u64;
+
+ /// The size of the symbol. May be zero if the size is unknown.
+ fn size(&self) -> u64;
+
+ /// Return the kind of this symbol.
+ fn kind(&self) -> SymbolKind;
+
+ /// Returns the section where the symbol is defined.
+ fn section(&self) -> SymbolSection;
+
+ /// Returns the section index for the section containing this symbol.
+ ///
+ /// May return `None` if the symbol is not defined in a section.
+ fn section_index(&self) -> Option<SectionIndex> {
+ self.section().index()
+ }
+
+ /// Return true if the symbol is undefined.
+ fn is_undefined(&self) -> bool;
+
+ /// Return true if the symbol is a definition of a function or data object
+ /// that has a known address.
+ fn is_definition(&self) -> bool;
+
+ /// Return true if the symbol is common data.
+ ///
+ /// Note: does not check for `SymbolSection::Section` with `SectionKind::Common`.
+ fn is_common(&self) -> bool;
+
+ /// Return true if the symbol is weak.
+ fn is_weak(&self) -> bool;
+
+ /// Returns the symbol scope.
+ fn scope(&self) -> SymbolScope;
+
+ /// Return true if the symbol visible outside of the compilation unit.
+ ///
+ /// This treats `SymbolScope::Unknown` as global.
+ fn is_global(&self) -> bool;
+
+ /// Return true if the symbol is only visible within the compilation unit.
+ fn is_local(&self) -> bool;
+
+ /// Symbol flags that are specific to each file format.
+ fn flags(&self) -> SymbolFlags<SectionIndex>;
+}
+
+/// An iterator for files that don't have dynamic relocations.
+#[derive(Debug)]
+pub struct NoDynamicRelocationIterator;
+
+impl Iterator for NoDynamicRelocationIterator {
+ type Item = (u64, Relocation);
+
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/util.rs b/vendor/object-0.26.2/src/read/util.rs
new file mode 100644
index 000000000..842bd6ca1
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/util.rs
@@ -0,0 +1,383 @@
+use alloc::string::String;
+use core::convert::TryInto;
+use core::fmt;
+use core::marker::PhantomData;
+
+use crate::pod::{from_bytes, slice_from_bytes, Pod};
+use crate::ReadRef;
+
+/// A newtype for byte slices.
+///
+/// It has these important features:
+/// - no methods that can panic, such as `Index`
+/// - convenience methods for `Pod` types
+/// - a useful `Debug` implementation
+#[derive(Default, Clone, Copy, PartialEq, Eq)]
+pub struct Bytes<'data>(pub &'data [u8]);
+
+impl<'data> fmt::Debug for Bytes<'data> {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ debug_list_bytes(self.0, fmt)
+ }
+}
+
+impl<'data> Bytes<'data> {
+ /// Return the length of the byte slice.
+ #[inline]
+ pub fn len(&self) -> usize {
+ self.0.len()
+ }
+
+ /// Return true if the byte slice is empty.
+ #[inline]
+ pub fn is_empty(&self) -> bool {
+ self.0.is_empty()
+ }
+
+ /// Skip over the given number of bytes at the start of the byte slice.
+ ///
+ /// Modifies the byte slice to start after the bytes.
+ ///
+ /// Returns an error if there are too few bytes.
+ #[inline]
+ pub fn skip(&mut self, offset: usize) -> Result<(), ()> {
+ match self.0.get(offset..) {
+ Some(tail) => {
+ self.0 = tail;
+ Ok(())
+ }
+ None => {
+ self.0 = &[];
+ Err(())
+ }
+ }
+ }
+
+ /// Return a reference to the given number of bytes at the start of the byte slice.
+ ///
+ /// Modifies the byte slice to start after the bytes.
+ ///
+ /// Returns an error if there are too few bytes.
+ #[inline]
+ pub fn read_bytes(&mut self, count: usize) -> Result<Bytes<'data>, ()> {
+ match (self.0.get(..count), self.0.get(count..)) {
+ (Some(head), Some(tail)) => {
+ self.0 = tail;
+ Ok(Bytes(head))
+ }
+ _ => {
+ self.0 = &[];
+ Err(())
+ }
+ }
+ }
+
+ /// Return a reference to the given number of bytes at the given offset of the byte slice.
+ ///
+ /// Returns an error if the offset is invalid or there are too few bytes.
+ #[inline]
+ pub fn read_bytes_at(mut self, offset: usize, count: usize) -> Result<Bytes<'data>, ()> {
+ self.skip(offset)?;
+ self.read_bytes(count)
+ }
+
+ /// Return a reference to a `Pod` struct at the start of the byte slice.
+ ///
+ /// Modifies the byte slice to start after the bytes.
+ ///
+ /// Returns an error if there are too few bytes or the slice is incorrectly aligned.
+ #[inline]
+ pub fn read<T: Pod>(&mut self) -> Result<&'data T, ()> {
+ match from_bytes(self.0) {
+ Ok((value, tail)) => {
+ self.0 = tail;
+ Ok(value)
+ }
+ Err(()) => {
+ self.0 = &[];
+ Err(())
+ }
+ }
+ }
+
+ /// Return a reference to a `Pod` struct at the given offset of the byte slice.
+ ///
+ /// Returns an error if there are too few bytes or the offset is incorrectly aligned.
+ #[inline]
+ pub fn read_at<T: Pod>(mut self, offset: usize) -> Result<&'data T, ()> {
+ self.skip(offset)?;
+ self.read()
+ }
+
+ /// Return a reference to a slice of `Pod` structs at the start of the byte slice.
+ ///
+ /// Modifies the byte slice to start after the bytes.
+ ///
+ /// Returns an error if there are too few bytes or the offset is incorrectly aligned.
+ #[inline]
+ pub fn read_slice<T: Pod>(&mut self, count: usize) -> Result<&'data [T], ()> {
+ match slice_from_bytes(self.0, count) {
+ Ok((value, tail)) => {
+ self.0 = tail;
+ Ok(value)
+ }
+ Err(()) => {
+ self.0 = &[];
+ Err(())
+ }
+ }
+ }
+
+ /// Return a reference to a slice of `Pod` structs at the given offset of the byte slice.
+ ///
+ /// Returns an error if there are too few bytes or the offset is incorrectly aligned.
+ #[inline]
+ pub fn read_slice_at<T: Pod>(mut self, offset: usize, count: usize) -> Result<&'data [T], ()> {
+ self.skip(offset)?;
+ self.read_slice(count)
+ }
+
+ /// Read a null terminated string.
+ ///
+ /// Does not assume any encoding.
+ /// Reads past the null byte, but doesn't return it.
+ #[inline]
+ pub fn read_string(&mut self) -> Result<&'data [u8], ()> {
+ match memchr::memchr(b'\0', self.0) {
+ Some(null) => {
+ // These will never fail.
+ let bytes = self.read_bytes(null)?;
+ self.skip(1)?;
+ Ok(bytes.0)
+ }
+ None => {
+ self.0 = &[];
+ Err(())
+ }
+ }
+ }
+
+ /// Read a null terminated string at an offset.
+ ///
+ /// Does not assume any encoding. Does not return the null byte.
+ #[inline]
+ pub fn read_string_at(mut self, offset: usize) -> Result<&'data [u8], ()> {
+ self.skip(offset)?;
+ self.read_string()
+ }
+}
+
+// Only for Debug impl of `Bytes`.
+fn debug_list_bytes(bytes: &[u8], fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ let mut list = fmt.debug_list();
+ list.entries(bytes.iter().take(8).copied().map(DebugByte));
+ if bytes.len() > 8 {
+ list.entry(&DebugLen(bytes.len()));
+ }
+ list.finish()
+}
+
+struct DebugByte(u8);
+
+impl fmt::Debug for DebugByte {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(fmt, "0x{:02x}", self.0)
+ }
+}
+
+struct DebugLen(usize);
+
+impl fmt::Debug for DebugLen {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(fmt, "...; {}", self.0)
+ }
+}
+
+/// A newtype for byte strings.
+///
+/// For byte slices that are strings of an unknown encoding.
+///
+/// Provides a `Debug` implementation that interprets the bytes as UTF-8.
+#[derive(Default, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct ByteString<'data>(pub &'data [u8]);
+
+impl<'data> fmt::Debug for ByteString<'data> {
+ fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
+ write!(fmt, "\"{}\"", String::from_utf8_lossy(self.0))
+ }
+}
+
+#[allow(dead_code)]
+#[inline]
+pub(crate) fn align(offset: usize, size: usize) -> usize {
+ (offset + (size - 1)) & !(size - 1)
+}
+
+#[allow(dead_code)]
+pub(crate) fn data_range(
+ data: &[u8],
+ data_address: u64,
+ range_address: u64,
+ size: u64,
+) -> Option<&[u8]> {
+ let offset = range_address.checked_sub(data_address)?;
+ data.get(offset.try_into().ok()?..)?
+ .get(..size.try_into().ok()?)
+}
+
+/// A table of zero-terminated strings.
+///
+/// This is used for most file formats.
+#[derive(Debug, Clone, Copy)]
+pub struct StringTable<'data, R = &'data [u8]>
+where
+ R: ReadRef<'data>,
+{
+ data: Option<R>,
+ start: u64,
+ end: u64,
+ marker: PhantomData<&'data ()>,
+}
+
+impl<'data, R: ReadRef<'data>> StringTable<'data, R> {
+ /// Interpret the given data as a string table.
+ pub fn new(data: R, start: u64, end: u64) -> Self {
+ StringTable {
+ data: Some(data),
+ start,
+ end,
+ marker: PhantomData,
+ }
+ }
+
+ /// Return the string at the given offset.
+ pub fn get(&self, offset: u32) -> Result<&'data [u8], ()> {
+ match self.data {
+ Some(data) => {
+ let r_start = self.start.checked_add(offset.into()).ok_or(())?;
+ data.read_bytes_at_until(r_start..self.end, 0)
+ }
+ None => Err(()),
+ }
+ }
+}
+
+impl<'data, R: ReadRef<'data>> Default for StringTable<'data, R> {
+ fn default() -> Self {
+ StringTable {
+ data: None,
+ start: 0,
+ end: 0,
+ marker: PhantomData,
+ }
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+ use crate::pod::bytes_of;
+
+ #[test]
+ fn bytes() {
+ let x = u32::to_be(0x0123_4567);
+ let data = Bytes(bytes_of(&x));
+
+ let mut bytes = data;
+ assert_eq!(bytes.skip(0), Ok(()));
+ assert_eq!(bytes, data);
+
+ let mut bytes = data;
+ assert_eq!(bytes.skip(4), Ok(()));
+ assert_eq!(bytes, Bytes(&[]));
+
+ let mut bytes = data;
+ assert_eq!(bytes.skip(5), Err(()));
+ assert_eq!(bytes, Bytes(&[]));
+
+ let mut bytes = data;
+ assert_eq!(bytes.read_bytes(0), Ok(Bytes(&[])));
+ assert_eq!(bytes, data);
+
+ let mut bytes = data;
+ assert_eq!(bytes.read_bytes(4), Ok(data));
+ assert_eq!(bytes, Bytes(&[]));
+
+ let mut bytes = data;
+ assert_eq!(bytes.read_bytes(5), Err(()));
+ assert_eq!(bytes, Bytes(&[]));
+
+ assert_eq!(data.read_bytes_at(0, 0), Ok(Bytes(&[])));
+ assert_eq!(data.read_bytes_at(4, 0), Ok(Bytes(&[])));
+ assert_eq!(data.read_bytes_at(0, 4), Ok(data));
+ assert_eq!(data.read_bytes_at(1, 4), Err(()));
+
+ let mut bytes = data;
+ assert_eq!(bytes.read::<u16>(), Ok(&u16::to_be(0x0123)));
+ assert_eq!(bytes, Bytes(&[0x45, 0x67]));
+ assert_eq!(data.read_at::<u16>(2), Ok(&u16::to_be(0x4567)));
+ assert_eq!(data.read_at::<u16>(3), Err(()));
+ assert_eq!(data.read_at::<u16>(4), Err(()));
+
+ let mut bytes = data;
+ assert_eq!(bytes.read::<u32>(), Ok(&x));
+ assert_eq!(bytes, Bytes(&[]));
+
+ let mut bytes = data;
+ assert_eq!(bytes.read::<u64>(), Err(()));
+ assert_eq!(bytes, Bytes(&[]));
+
+ let mut bytes = data;
+ assert_eq!(bytes.read_slice::<u8>(0), Ok(&[][..]));
+ assert_eq!(bytes, data);
+
+ let mut bytes = data;
+ assert_eq!(bytes.read_slice::<u8>(4), Ok(data.0));
+ assert_eq!(bytes, Bytes(&[]));
+
+ let mut bytes = data;
+ assert_eq!(bytes.read_slice::<u8>(5), Err(()));
+ assert_eq!(bytes, Bytes(&[]));
+
+ assert_eq!(data.read_slice_at::<u8>(0, 0), Ok(&[][..]));
+ assert_eq!(data.read_slice_at::<u8>(4, 0), Ok(&[][..]));
+ assert_eq!(data.read_slice_at::<u8>(0, 4), Ok(data.0));
+ assert_eq!(data.read_slice_at::<u8>(1, 4), Err(()));
+
+ let data = Bytes(&[0x01, 0x02, 0x00, 0x04]);
+
+ let mut bytes = data;
+ assert_eq!(bytes.read_string(), Ok(&data.0[..2]));
+ assert_eq!(bytes.0, &data.0[3..]);
+
+ let mut bytes = data;
+ bytes.skip(3).unwrap();
+ assert_eq!(bytes.read_string(), Err(()));
+ assert_eq!(bytes.0, &[]);
+
+ assert_eq!(data.read_string_at(0), Ok(&data.0[..2]));
+ assert_eq!(data.read_string_at(1), Ok(&data.0[1..2]));
+ assert_eq!(data.read_string_at(2), Ok(&[][..]));
+ assert_eq!(data.read_string_at(3), Err(()));
+ }
+
+ #[test]
+ fn bytes_debug() {
+ assert_eq!(format!("{:?}", Bytes(&[])), "[]");
+ assert_eq!(format!("{:?}", Bytes(&[0x01])), "[0x01]");
+ assert_eq!(
+ format!(
+ "{:?}",
+ Bytes(&[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08])
+ ),
+ "[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08]"
+ );
+ assert_eq!(
+ format!(
+ "{:?}",
+ Bytes(&[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09])
+ ),
+ "[0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, ...; 9]"
+ );
+ }
+}
diff --git a/vendor/object-0.26.2/src/read/wasm.rs b/vendor/object-0.26.2/src/read/wasm.rs
new file mode 100644
index 000000000..93e9184b6
--- /dev/null
+++ b/vendor/object-0.26.2/src/read/wasm.rs
@@ -0,0 +1,859 @@
+//! Support for reading Wasm files.
+//!
+//! Provides `WasmFile` and related types which implement the `Object` trait.
+//!
+//! Currently implements the minimum required to access DWARF debugging information.
+use alloc::boxed::Box;
+use alloc::vec::Vec;
+use core::marker::PhantomData;
+use core::{slice, str};
+use wasmparser as wp;
+
+use crate::read::{
+ self, Architecture, ComdatKind, CompressedData, CompressedFileRange, Error, Export, FileFlags,
+ Import, NoDynamicRelocationIterator, Object, ObjectComdat, ObjectSection, ObjectSegment,
+ ObjectSymbol, ObjectSymbolTable, ReadError, ReadRef, Relocation, Result, SectionFlags,
+ SectionIndex, SectionKind, SymbolFlags, SymbolIndex, SymbolKind, SymbolScope, SymbolSection,
+};
+
+const SECTION_CUSTOM: usize = 0;
+const SECTION_TYPE: usize = 1;
+const SECTION_IMPORT: usize = 2;
+const SECTION_FUNCTION: usize = 3;
+const SECTION_TABLE: usize = 4;
+const SECTION_MEMORY: usize = 5;
+const SECTION_GLOBAL: usize = 6;
+const SECTION_EXPORT: usize = 7;
+const SECTION_START: usize = 8;
+const SECTION_ELEMENT: usize = 9;
+const SECTION_CODE: usize = 10;
+const SECTION_DATA: usize = 11;
+const SECTION_DATA_COUNT: usize = 12;
+// Update this constant when adding new section id:
+const MAX_SECTION_ID: usize = SECTION_DATA_COUNT;
+
+/// A WebAssembly object file.
+#[derive(Debug)]
+pub struct WasmFile<'data, R = &'data [u8]> {
+ // All sections, including custom sections.
+ sections: Vec<wp::Section<'data>>,
+ // Indices into `sections` of sections with a non-zero id.
+ id_sections: Box<[Option<usize>; MAX_SECTION_ID + 1]>,
+ // Whether the file has DWARF information.
+ has_debug_symbols: bool,
+ // Symbols collected from imports, exports, code and name sections.
+ symbols: Vec<WasmSymbolInternal<'data>>,
+ // Address of the function body for the entry point.
+ entry: u64,
+ marker: PhantomData<R>,
+}
+
+#[derive(Clone)]
+enum LocalFunctionKind {
+ Unknown,
+ Exported { symbol_ids: Vec<u32> },
+ Local { symbol_id: u32 },
+}
+
+impl<T> ReadError<T> for wasmparser::Result<T> {
+ fn read_error(self, error: &'static str) -> Result<T> {
+ self.map_err(|_| Error(error))
+ }
+}
+
+impl<'data, R: ReadRef<'data>> WasmFile<'data, R> {
+ /// Parse the raw wasm data.
+ pub fn parse(data: R) -> Result<Self> {
+ let len = data.len().read_error("Unknown Wasm file size")?;
+ let data = data.read_bytes_at(0, len).read_error("Wasm read failed")?;
+ let module = wp::ModuleReader::new(data).read_error("Invalid Wasm header")?;
+
+ let mut file = WasmFile {
+ sections: Vec::new(),
+ id_sections: Default::default(),
+ has_debug_symbols: false,
+ symbols: Vec::new(),
+ entry: 0,
+ marker: PhantomData,
+ };
+
+ let mut main_file_symbol = Some(WasmSymbolInternal {
+ name: "",
+ address: 0,
+ size: 0,
+ kind: SymbolKind::File,
+ section: SymbolSection::None,
+ scope: SymbolScope::Compilation,
+ });
+
+ let mut imported_funcs_count = 0;
+ let mut local_func_kinds = Vec::new();
+ let mut entry_func_id = None;
+
+ for section in module {
+ let section = section.read_error("Invalid Wasm section header")?;
+
+ match section.code {
+ wp::SectionCode::Import => {
+ let mut last_module_name = None;
+
+ for import in section
+ .get_import_section_reader()
+ .read_error("Couldn't read header of the import section")?
+ {
+ let import = import.read_error("Couldn't read an import item")?;
+ let module_name = import.module;
+
+ if last_module_name != Some(module_name) {
+ file.symbols.push(WasmSymbolInternal {
+ name: module_name,
+ address: 0,
+ size: 0,
+ kind: SymbolKind::File,
+ section: SymbolSection::None,
+ scope: SymbolScope::Dynamic,
+ });
+ last_module_name = Some(module_name);
+ }
+
+ let kind = match import.ty {
+ wp::ImportSectionEntryType::Function(_) => {
+ imported_funcs_count += 1;
+ SymbolKind::Text
+ }
+ wp::ImportSectionEntryType::Table(_)
+ | wp::ImportSectionEntryType::Memory(_)
+ | wp::ImportSectionEntryType::Global(_) => SymbolKind::Data,
+ };
+
+ file.symbols.push(WasmSymbolInternal {
+ name: import.field,
+ address: 0,
+ size: 0,
+ kind,
+ section: SymbolSection::Undefined,
+ scope: SymbolScope::Dynamic,
+ });
+ }
+ }
+ wp::SectionCode::Function => {
+ local_func_kinds = vec![
+ LocalFunctionKind::Unknown;
+ section
+ .get_function_section_reader()
+ .read_error("Couldn't read header of the function section")?
+ .get_count() as usize
+ ];
+ }
+ wp::SectionCode::Export => {
+ if let Some(main_file_symbol) = main_file_symbol.take() {
+ file.symbols.push(main_file_symbol);
+ }
+
+ for export in section
+ .get_export_section_reader()
+ .read_error("Couldn't read header of the export section")?
+ {
+ let export = export.read_error("Couldn't read an export item")?;
+
+ let (kind, section_idx) = match export.kind {
+ wp::ExternalKind::Function => {
+ if let Some(local_func_id) =
+ export.index.checked_sub(imported_funcs_count)
+ {
+ let local_func_kind =
+ &mut local_func_kinds[local_func_id as usize];
+ if let LocalFunctionKind::Unknown = local_func_kind {
+ *local_func_kind = LocalFunctionKind::Exported {
+ symbol_ids: Vec::new(),
+ };
+ }
+ let symbol_ids = match local_func_kind {
+ LocalFunctionKind::Exported { symbol_ids } => symbol_ids,
+ _ => unreachable!(),
+ };
+ symbol_ids.push(file.symbols.len() as u32);
+ }
+ (SymbolKind::Text, SECTION_CODE)
+ }
+ wp::ExternalKind::Table
+ | wp::ExternalKind::Memory
+ | wp::ExternalKind::Global => (SymbolKind::Data, SECTION_DATA),
+ };
+
+ file.symbols.push(WasmSymbolInternal {
+ name: export.field,
+ address: 0,
+ size: 0,
+ kind,
+ section: SymbolSection::Section(SectionIndex(section_idx)),
+ scope: SymbolScope::Dynamic,
+ });
+ }
+ }
+ wp::SectionCode::Start => {
+ entry_func_id = Some(
+ section
+ .get_start_section_content()
+ .read_error("Couldn't read contents of the start section")?,
+ );
+ }
+ wp::SectionCode::Code => {
+ if let Some(main_file_symbol) = main_file_symbol.take() {
+ file.symbols.push(main_file_symbol);
+ }
+
+ for (i, (body, local_func_kind)) in section
+ .get_code_section_reader()
+ .read_error("Couldn't read header of the code section")?
+ .into_iter()
+ .zip(&mut local_func_kinds)
+ .enumerate()
+ {
+ let body = body.read_error("Couldn't read a function body")?;
+ let range = body.range();
+
+ let address = range.start as u64 - section.range().start as u64;
+ let size = (range.end - range.start) as u64;
+
+ if entry_func_id == Some(i as u32) {
+ file.entry = address;
+ }
+
+ match local_func_kind {
+ LocalFunctionKind::Unknown => {
+ *local_func_kind = LocalFunctionKind::Local {
+ symbol_id: file.symbols.len() as u32,
+ };
+ file.symbols.push(WasmSymbolInternal {
+ name: "",
+ address,
+ size,
+ kind: SymbolKind::Text,
+ section: SymbolSection::Section(SectionIndex(SECTION_CODE)),
+ scope: SymbolScope::Compilation,
+ });
+ }
+ LocalFunctionKind::Exported { symbol_ids } => {
+ for symbol_id in core::mem::replace(symbol_ids, Vec::new()) {
+ let export_symbol = &mut file.symbols[symbol_id as usize];
+ export_symbol.address = address;
+ export_symbol.size = size;
+ }
+ }
+ _ => unreachable!(),
+ }
+ }
+ }
+ wp::SectionCode::Custom {
+ kind: wp::CustomSectionKind::Name,
+ ..
+ } => {
+ for name in section
+ .get_name_section_reader()
+ .read_error("Couldn't read header of the name section")?
+ {
+ let name =
+ match name.read_error("Couldn't read header of a name subsection")? {
+ wp::Name::Function(name) => name,
+ _ => continue,
+ };
+ let mut name_map = name
+ .get_map()
+ .read_error("Couldn't read header of the function name subsection")?;
+ for _ in 0..name_map.get_count() {
+ let naming = name_map
+ .read()
+ .read_error("Couldn't read a function name")?;
+ if let Some(local_index) =
+ naming.index.checked_sub(imported_funcs_count)
+ {
+ if let LocalFunctionKind::Local { symbol_id } =
+ local_func_kinds[local_index as usize]
+ {
+ file.symbols[symbol_id as usize].name = naming.name;
+ }
+ }
+ }
+ }
+ }
+ wp::SectionCode::Custom { name, .. } if name.starts_with(".debug_") => {
+ file.has_debug_symbols = true;
+ }
+ _ => {}
+ }
+
+ let id = section_code_to_id(section.code);
+ file.id_sections[id] = Some(file.sections.len());
+
+ file.sections.push(section);
+ }
+
+ Ok(file)
+ }
+}
+
+impl<'data, R> read::private::Sealed for WasmFile<'data, R> {}
+
+impl<'data, 'file, R> Object<'data, 'file> for WasmFile<'data, R>
+where
+ 'data: 'file,
+ R: 'file,
+{
+ type Segment = WasmSegment<'data, 'file, R>;
+ type SegmentIterator = WasmSegmentIterator<'data, 'file, R>;
+ type Section = WasmSection<'data, 'file, R>;
+ type SectionIterator = WasmSectionIterator<'data, 'file, R>;
+ type Comdat = WasmComdat<'data, 'file, R>;
+ type ComdatIterator = WasmComdatIterator<'data, 'file, R>;
+ type Symbol = WasmSymbol<'data, 'file>;
+ type SymbolIterator = WasmSymbolIterator<'data, 'file>;
+ type SymbolTable = WasmSymbolTable<'data, 'file>;
+ type DynamicRelocationIterator = NoDynamicRelocationIterator;
+
+ #[inline]
+ fn architecture(&self) -> Architecture {
+ Architecture::Wasm32
+ }
+
+ #[inline]
+ fn is_little_endian(&self) -> bool {
+ true
+ }
+
+ #[inline]
+ fn is_64(&self) -> bool {
+ false
+ }
+
+ fn segments(&'file self) -> Self::SegmentIterator {
+ WasmSegmentIterator { file: self }
+ }
+
+ fn section_by_name(&'file self, section_name: &str) -> Option<WasmSection<'data, 'file, R>> {
+ self.sections()
+ .find(|section| section.name() == Ok(section_name))
+ }
+
+ fn section_by_index(&'file self, index: SectionIndex) -> Result<WasmSection<'data, 'file, R>> {
+ // TODO: Missing sections should return an empty section.
+ let id_section = self
+ .id_sections
+ .get(index.0)
+ .and_then(|x| *x)
+ .read_error("Invalid Wasm section index")?;
+ let section = self.sections.get(id_section).unwrap();
+ Ok(WasmSection {
+ section,
+ marker: PhantomData,
+ })
+ }
+
+ fn sections(&'file self) -> Self::SectionIterator {
+ WasmSectionIterator {
+ sections: self.sections.iter(),
+ marker: PhantomData,
+ }
+ }
+
+ fn comdats(&'file self) -> Self::ComdatIterator {
+ WasmComdatIterator { file: self }
+ }
+
+ #[inline]
+ fn symbol_by_index(&'file self, index: SymbolIndex) -> Result<WasmSymbol<'data, 'file>> {
+ let symbol = self
+ .symbols
+ .get(index.0)
+ .read_error("Invalid Wasm symbol index")?;
+ Ok(WasmSymbol { index, symbol })
+ }
+
+ fn symbols(&'file self) -> Self::SymbolIterator {
+ WasmSymbolIterator {
+ symbols: self.symbols.iter().enumerate(),
+ }
+ }
+
+ fn symbol_table(&'file self) -> Option<WasmSymbolTable<'data, 'file>> {
+ Some(WasmSymbolTable {
+ symbols: &self.symbols,
+ })
+ }
+
+ fn dynamic_symbols(&'file self) -> Self::SymbolIterator {
+ WasmSymbolIterator {
+ symbols: [].iter().enumerate(),
+ }
+ }
+
+ #[inline]
+ fn dynamic_symbol_table(&'file self) -> Option<WasmSymbolTable<'data, 'file>> {
+ None
+ }
+
+ #[inline]
+ fn dynamic_relocations(&self) -> Option<NoDynamicRelocationIterator> {
+ None
+ }
+
+ fn imports(&self) -> Result<Vec<Import<'data>>> {
+ // TODO: return entries in the import section
+ Ok(Vec::new())
+ }
+
+ fn exports(&self) -> Result<Vec<Export<'data>>> {
+ // TODO: return entries in the export section
+ Ok(Vec::new())
+ }
+
+ fn has_debug_symbols(&self) -> bool {
+ self.has_debug_symbols
+ }
+
+ fn relative_address_base(&self) -> u64 {
+ 0
+ }
+
+ #[inline]
+ fn entry(&'file self) -> u64 {
+ self.entry
+ }
+
+ #[inline]
+ fn flags(&self) -> FileFlags {
+ FileFlags::None
+ }
+}
+
+/// An iterator over the segments of a `WasmFile`.
+#[derive(Debug)]
+pub struct WasmSegmentIterator<'data, 'file, R = &'data [u8]> {
+ file: &'file WasmFile<'data, R>,
+}
+
+impl<'data, 'file, R> Iterator for WasmSegmentIterator<'data, 'file, R> {
+ type Item = WasmSegment<'data, 'file, R>;
+
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
+
+/// A segment of a `WasmFile`.
+#[derive(Debug)]
+pub struct WasmSegment<'data, 'file, R = &'data [u8]> {
+ file: &'file WasmFile<'data, R>,
+}
+
+impl<'data, 'file, R> read::private::Sealed for WasmSegment<'data, 'file, R> {}
+
+impl<'data, 'file, R> ObjectSegment<'data> for WasmSegment<'data, 'file, R> {
+ #[inline]
+ fn address(&self) -> u64 {
+ unreachable!()
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ unreachable!()
+ }
+
+ #[inline]
+ fn align(&self) -> u64 {
+ unreachable!()
+ }
+
+ #[inline]
+ fn file_range(&self) -> (u64, u64) {
+ unreachable!()
+ }
+
+ fn data(&self) -> Result<&'data [u8]> {
+ unreachable!()
+ }
+
+ fn data_range(&self, _address: u64, _size: u64) -> Result<Option<&'data [u8]>> {
+ unreachable!()
+ }
+
+ #[inline]
+ fn name(&self) -> Result<Option<&str>> {
+ unreachable!()
+ }
+}
+
+/// An iterator over the sections of a `WasmFile`.
+#[derive(Debug)]
+pub struct WasmSectionIterator<'data, 'file, R = &'data [u8]> {
+ sections: slice::Iter<'file, wp::Section<'data>>,
+ marker: PhantomData<R>,
+}
+
+impl<'data, 'file, R> Iterator for WasmSectionIterator<'data, 'file, R> {
+ type Item = WasmSection<'data, 'file, R>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let section = self.sections.next()?;
+ Some(WasmSection {
+ section,
+ marker: PhantomData,
+ })
+ }
+}
+
+/// A section of a `WasmFile`.
+#[derive(Debug)]
+pub struct WasmSection<'data, 'file, R = &'data [u8]> {
+ section: &'file wp::Section<'data>,
+ marker: PhantomData<R>,
+}
+
+impl<'data, 'file, R> read::private::Sealed for WasmSection<'data, 'file, R> {}
+
+impl<'data, 'file, R> ObjectSection<'data> for WasmSection<'data, 'file, R> {
+ type RelocationIterator = WasmRelocationIterator<'data, 'file, R>;
+
+ #[inline]
+ fn index(&self) -> SectionIndex {
+ // Note that we treat all custom sections as index 0.
+ // This is ok because they are never looked up by index.
+ SectionIndex(section_code_to_id(self.section.code))
+ }
+
+ #[inline]
+ fn address(&self) -> u64 {
+ 0
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ let range = self.section.range();
+ (range.end - range.start) as u64
+ }
+
+ #[inline]
+ fn align(&self) -> u64 {
+ 1
+ }
+
+ #[inline]
+ fn file_range(&self) -> Option<(u64, u64)> {
+ let range = self.section.range();
+ Some((range.start as _, range.end as _))
+ }
+
+ #[inline]
+ fn data(&self) -> Result<&'data [u8]> {
+ let mut reader = self.section.get_binary_reader();
+ // TODO: raise a feature request upstream to be able
+ // to get remaining slice from a BinaryReader directly.
+ Ok(reader.read_bytes(reader.bytes_remaining()).unwrap())
+ }
+
+ fn data_range(&self, _address: u64, _size: u64) -> Result<Option<&'data [u8]>> {
+ unimplemented!()
+ }
+
+ #[inline]
+ fn compressed_file_range(&self) -> Result<CompressedFileRange> {
+ Ok(CompressedFileRange::none(self.file_range()))
+ }
+
+ #[inline]
+ fn compressed_data(&self) -> Result<CompressedData<'data>> {
+ self.data().map(CompressedData::none)
+ }
+
+ #[inline]
+ fn name(&self) -> Result<&str> {
+ Ok(match self.section.code {
+ wp::SectionCode::Custom { name, .. } => name,
+ wp::SectionCode::Type => "<type>",
+ wp::SectionCode::Import => "<import>",
+ wp::SectionCode::Function => "<function>",
+ wp::SectionCode::Table => "<table>",
+ wp::SectionCode::Memory => "<memory>",
+ wp::SectionCode::Global => "<global>",
+ wp::SectionCode::Export => "<export>",
+ wp::SectionCode::Start => "<start>",
+ wp::SectionCode::Element => "<element>",
+ wp::SectionCode::Code => "<code>",
+ wp::SectionCode::Data => "<data>",
+ wp::SectionCode::DataCount => "<data_count>",
+ })
+ }
+
+ #[inline]
+ fn segment_name(&self) -> Result<Option<&str>> {
+ Ok(None)
+ }
+
+ #[inline]
+ fn kind(&self) -> SectionKind {
+ match self.section.code {
+ wp::SectionCode::Custom { kind, .. } => match kind {
+ wp::CustomSectionKind::Reloc | wp::CustomSectionKind::Linking => {
+ SectionKind::Linker
+ }
+ _ => SectionKind::Other,
+ },
+ wp::SectionCode::Type => SectionKind::Metadata,
+ wp::SectionCode::Import => SectionKind::Linker,
+ wp::SectionCode::Function => SectionKind::Metadata,
+ wp::SectionCode::Table => SectionKind::UninitializedData,
+ wp::SectionCode::Memory => SectionKind::UninitializedData,
+ wp::SectionCode::Global => SectionKind::Data,
+ wp::SectionCode::Export => SectionKind::Linker,
+ wp::SectionCode::Start => SectionKind::Linker,
+ wp::SectionCode::Element => SectionKind::Data,
+ wp::SectionCode::Code => SectionKind::Text,
+ wp::SectionCode::Data => SectionKind::Data,
+ wp::SectionCode::DataCount => SectionKind::UninitializedData,
+ }
+ }
+
+ #[inline]
+ fn relocations(&self) -> WasmRelocationIterator<'data, 'file, R> {
+ WasmRelocationIterator(PhantomData)
+ }
+
+ #[inline]
+ fn flags(&self) -> SectionFlags {
+ SectionFlags::None
+ }
+}
+
+/// An iterator over the COMDAT section groups of a `WasmFile`.
+#[derive(Debug)]
+pub struct WasmComdatIterator<'data, 'file, R = &'data [u8]> {
+ file: &'file WasmFile<'data, R>,
+}
+
+impl<'data, 'file, R> Iterator for WasmComdatIterator<'data, 'file, R> {
+ type Item = WasmComdat<'data, 'file, R>;
+
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
+
+/// A COMDAT section group of a `WasmFile`.
+#[derive(Debug)]
+pub struct WasmComdat<'data, 'file, R = &'data [u8]> {
+ file: &'file WasmFile<'data, R>,
+}
+
+impl<'data, 'file, R> read::private::Sealed for WasmComdat<'data, 'file, R> {}
+
+impl<'data, 'file, R> ObjectComdat<'data> for WasmComdat<'data, 'file, R> {
+ type SectionIterator = WasmComdatSectionIterator<'data, 'file, R>;
+
+ #[inline]
+ fn kind(&self) -> ComdatKind {
+ unreachable!();
+ }
+
+ #[inline]
+ fn symbol(&self) -> SymbolIndex {
+ unreachable!();
+ }
+
+ #[inline]
+ fn name(&self) -> Result<&str> {
+ unreachable!();
+ }
+
+ #[inline]
+ fn sections(&self) -> Self::SectionIterator {
+ unreachable!();
+ }
+}
+
+/// An iterator over the sections in a COMDAT section group of a `WasmFile`.
+#[derive(Debug)]
+pub struct WasmComdatSectionIterator<'data, 'file, R = &'data [u8]>
+where
+ 'data: 'file,
+{
+ file: &'file WasmFile<'data, R>,
+}
+
+impl<'data, 'file, R> Iterator for WasmComdatSectionIterator<'data, 'file, R> {
+ type Item = SectionIndex;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
+
+/// A symbol table of a `WasmFile`.
+#[derive(Debug)]
+pub struct WasmSymbolTable<'data, 'file> {
+ symbols: &'file [WasmSymbolInternal<'data>],
+}
+
+impl<'data, 'file> read::private::Sealed for WasmSymbolTable<'data, 'file> {}
+
+impl<'data, 'file> ObjectSymbolTable<'data> for WasmSymbolTable<'data, 'file> {
+ type Symbol = WasmSymbol<'data, 'file>;
+ type SymbolIterator = WasmSymbolIterator<'data, 'file>;
+
+ fn symbols(&self) -> Self::SymbolIterator {
+ WasmSymbolIterator {
+ symbols: self.symbols.iter().enumerate(),
+ }
+ }
+
+ fn symbol_by_index(&self, index: SymbolIndex) -> Result<Self::Symbol> {
+ let symbol = self
+ .symbols
+ .get(index.0)
+ .read_error("Invalid Wasm symbol index")?;
+ Ok(WasmSymbol { index, symbol })
+ }
+}
+
+/// An iterator over the symbols of a `WasmFile`.
+#[derive(Debug)]
+pub struct WasmSymbolIterator<'data, 'file> {
+ symbols: core::iter::Enumerate<slice::Iter<'file, WasmSymbolInternal<'data>>>,
+}
+
+impl<'data, 'file> Iterator for WasmSymbolIterator<'data, 'file> {
+ type Item = WasmSymbol<'data, 'file>;
+
+ fn next(&mut self) -> Option<Self::Item> {
+ let (index, symbol) = self.symbols.next()?;
+ Some(WasmSymbol {
+ index: SymbolIndex(index),
+ symbol,
+ })
+ }
+}
+
+/// A symbol of a `WasmFile`.
+#[derive(Clone, Copy, Debug)]
+pub struct WasmSymbol<'data, 'file> {
+ index: SymbolIndex,
+ symbol: &'file WasmSymbolInternal<'data>,
+}
+
+#[derive(Clone, Debug)]
+struct WasmSymbolInternal<'data> {
+ name: &'data str,
+ address: u64,
+ size: u64,
+ kind: SymbolKind,
+ section: SymbolSection,
+ scope: SymbolScope,
+}
+
+impl<'data, 'file> read::private::Sealed for WasmSymbol<'data, 'file> {}
+
+impl<'data, 'file> ObjectSymbol<'data> for WasmSymbol<'data, 'file> {
+ #[inline]
+ fn index(&self) -> SymbolIndex {
+ self.index
+ }
+
+ #[inline]
+ fn name(&self) -> read::Result<&'data str> {
+ Ok(self.symbol.name)
+ }
+
+ #[inline]
+ fn address(&self) -> u64 {
+ self.symbol.address
+ }
+
+ #[inline]
+ fn size(&self) -> u64 {
+ self.symbol.size
+ }
+
+ #[inline]
+ fn kind(&self) -> SymbolKind {
+ self.symbol.kind
+ }
+
+ #[inline]
+ fn section(&self) -> SymbolSection {
+ self.symbol.section
+ }
+
+ #[inline]
+ fn is_undefined(&self) -> bool {
+ self.symbol.section == SymbolSection::Undefined
+ }
+
+ #[inline]
+ fn is_definition(&self) -> bool {
+ self.symbol.kind == SymbolKind::Text && self.symbol.section != SymbolSection::Undefined
+ }
+
+ #[inline]
+ fn is_common(&self) -> bool {
+ self.symbol.section == SymbolSection::Common
+ }
+
+ #[inline]
+ fn is_weak(&self) -> bool {
+ false
+ }
+
+ #[inline]
+ fn scope(&self) -> SymbolScope {
+ self.symbol.scope
+ }
+
+ #[inline]
+ fn is_global(&self) -> bool {
+ self.symbol.scope != SymbolScope::Compilation
+ }
+
+ #[inline]
+ fn is_local(&self) -> bool {
+ self.symbol.scope == SymbolScope::Compilation
+ }
+
+ #[inline]
+ fn flags(&self) -> SymbolFlags<SectionIndex> {
+ SymbolFlags::None
+ }
+}
+
+/// An iterator over the relocations in a `WasmSection`.
+#[derive(Debug)]
+pub struct WasmRelocationIterator<'data, 'file, R = &'data [u8]>(
+ PhantomData<(&'data (), &'file (), R)>,
+);
+
+impl<'data, 'file, R> Iterator for WasmRelocationIterator<'data, 'file, R> {
+ type Item = (u64, Relocation);
+
+ #[inline]
+ fn next(&mut self) -> Option<Self::Item> {
+ None
+ }
+}
+
+fn section_code_to_id(code: wp::SectionCode) -> usize {
+ match code {
+ wp::SectionCode::Custom { .. } => SECTION_CUSTOM,
+ wp::SectionCode::Type => SECTION_TYPE,
+ wp::SectionCode::Import => SECTION_IMPORT,
+ wp::SectionCode::Function => SECTION_FUNCTION,
+ wp::SectionCode::Table => SECTION_TABLE,
+ wp::SectionCode::Memory => SECTION_MEMORY,
+ wp::SectionCode::Global => SECTION_GLOBAL,
+ wp::SectionCode::Export => SECTION_EXPORT,
+ wp::SectionCode::Start => SECTION_START,
+ wp::SectionCode::Element => SECTION_ELEMENT,
+ wp::SectionCode::Code => SECTION_CODE,
+ wp::SectionCode::Data => SECTION_DATA,
+ wp::SectionCode::DataCount => SECTION_DATA_COUNT,
+ }
+}
diff --git a/vendor/object-0.26.2/src/write/coff.rs b/vendor/object-0.26.2/src/write/coff.rs
new file mode 100644
index 000000000..c8516c102
--- /dev/null
+++ b/vendor/object-0.26.2/src/write/coff.rs
@@ -0,0 +1,626 @@
+use std::mem;
+use std::vec::Vec;
+
+use crate::endian::{LittleEndian as LE, U16Bytes, U32Bytes, U16, U32};
+use crate::pe as coff;
+use crate::write::string::*;
+use crate::write::util::*;
+use crate::write::*;
+
+#[derive(Default, Clone, Copy)]
+struct SectionOffsets {
+ offset: usize,
+ str_id: Option<StringId>,
+ reloc_offset: usize,
+ selection: u8,
+ associative_section: u16,
+}
+
+#[derive(Default, Clone, Copy)]
+struct SymbolOffsets {
+ index: usize,
+ str_id: Option<StringId>,
+ aux_count: u8,
+}
+
+impl Object {
+ pub(crate) fn coff_section_info(
+ &self,
+ section: StandardSection,
+ ) -> (&'static [u8], &'static [u8], SectionKind) {
+ match section {
+ StandardSection::Text => (&[], &b".text"[..], SectionKind::Text),
+ StandardSection::Data => (&[], &b".data"[..], SectionKind::Data),
+ StandardSection::ReadOnlyData
+ | StandardSection::ReadOnlyDataWithRel
+ | StandardSection::ReadOnlyString => (&[], &b".rdata"[..], SectionKind::ReadOnlyData),
+ StandardSection::UninitializedData => {
+ (&[], &b".bss"[..], SectionKind::UninitializedData)
+ }
+ // TLS sections are data sections with a special name.
+ StandardSection::Tls => (&[], &b".tls$"[..], SectionKind::Data),
+ StandardSection::UninitializedTls => {
+ // Unsupported section.
+ (&[], &[], SectionKind::UninitializedTls)
+ }
+ StandardSection::TlsVariables => {
+ // Unsupported section.
+ (&[], &[], SectionKind::TlsVariables)
+ }
+ StandardSection::Common => {
+ // Unsupported section.
+ (&[], &[], SectionKind::Common)
+ }
+ }
+ }
+
+ pub(crate) fn coff_subsection_name(&self, section: &[u8], value: &[u8]) -> Vec<u8> {
+ let mut name = section.to_vec();
+ name.push(b'$');
+ name.extend_from_slice(value);
+ name
+ }
+
+ pub(crate) fn coff_fixup_relocation(&mut self, mut relocation: &mut Relocation) -> i64 {
+ if relocation.kind == RelocationKind::GotRelative {
+ // Use a stub symbol for the relocation instead.
+ // This isn't really a GOT, but it's a similar purpose.
+ // TODO: need to handle DLL imports differently?
+ relocation.kind = RelocationKind::Relative;
+ relocation.symbol = self.coff_add_stub_symbol(relocation.symbol);
+ } else if relocation.kind == RelocationKind::PltRelative {
+ // Windows doesn't need a separate relocation type for
+ // references to functions in import libraries.
+ // For convenience, treat this the same as Relative.
+ relocation.kind = RelocationKind::Relative;
+ }
+
+ let constant = match self.architecture {
+ Architecture::I386 => match relocation.kind {
+ RelocationKind::Relative => {
+ // IMAGE_REL_I386_REL32
+ relocation.addend + 4
+ }
+ _ => relocation.addend,
+ },
+ Architecture::X86_64 => match relocation.kind {
+ RelocationKind::Relative => {
+ // IMAGE_REL_AMD64_REL32 through to IMAGE_REL_AMD64_REL32_5
+ if relocation.addend <= -4 && relocation.addend >= -9 {
+ 0
+ } else {
+ relocation.addend + 4
+ }
+ }
+ _ => relocation.addend,
+ },
+ _ => unimplemented!(),
+ };
+ relocation.addend -= constant;
+ constant
+ }
+
+ fn coff_add_stub_symbol(&mut self, symbol_id: SymbolId) -> SymbolId {
+ if let Some(stub_id) = self.stub_symbols.get(&symbol_id) {
+ return *stub_id;
+ }
+ let stub_size = self.architecture.address_size().unwrap().bytes();
+
+ let mut name = b".rdata$.refptr.".to_vec();
+ name.extend_from_slice(&self.symbols[symbol_id.0].name);
+ let section_id = self.add_section(Vec::new(), name, SectionKind::ReadOnlyData);
+ let section = self.section_mut(section_id);
+ section.set_data(vec![0; stub_size as usize], u64::from(stub_size));
+ section.relocations = vec![Relocation {
+ offset: 0,
+ size: stub_size * 8,
+ kind: RelocationKind::Absolute,
+ encoding: RelocationEncoding::Generic,
+ symbol: symbol_id,
+ addend: 0,
+ }];
+
+ let mut name = b".refptr.".to_vec();
+ name.extend_from_slice(&self.symbol(symbol_id).name);
+ let stub_id = self.add_raw_symbol(Symbol {
+ name,
+ value: 0,
+ size: u64::from(stub_size),
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Compilation,
+ weak: false,
+ section: SymbolSection::Section(section_id),
+ flags: SymbolFlags::None,
+ });
+ self.stub_symbols.insert(symbol_id, stub_id);
+
+ stub_id
+ }
+
+ pub(crate) fn coff_write(&self, buffer: &mut dyn WritableBuffer) -> Result<()> {
+ // Calculate offsets of everything, and build strtab.
+ let mut offset = 0;
+ let mut strtab = StringTable::default();
+
+ // COFF header.
+ offset += mem::size_of::<coff::ImageFileHeader>();
+
+ // Section headers.
+ offset += self.sections.len() * mem::size_of::<coff::ImageSectionHeader>();
+
+ // Calculate size of section data and add section strings to strtab.
+ let mut section_offsets = vec![SectionOffsets::default(); self.sections.len()];
+ for (index, section) in self.sections.iter().enumerate() {
+ if section.name.len() > 8 {
+ section_offsets[index].str_id = Some(strtab.add(&section.name));
+ }
+
+ let len = section.data.len();
+ if len != 0 {
+ // TODO: not sure what alignment is required here, but this seems to match LLVM
+ offset = align(offset, 4);
+ section_offsets[index].offset = offset;
+ offset += len;
+ } else {
+ section_offsets[index].offset = 0;
+ }
+
+ // Calculate size of relocations.
+ let count = section.relocations.len();
+ if count != 0 {
+ section_offsets[index].reloc_offset = offset;
+ offset += count * mem::size_of::<coff::ImageRelocation>();
+ }
+ }
+
+ // Set COMDAT flags.
+ for comdat in &self.comdats {
+ let symbol = &self.symbols[comdat.symbol.0];
+ let comdat_section = match symbol.section {
+ SymbolSection::Section(id) => id.0,
+ _ => {
+ return Err(Error(format!(
+ "unsupported COMDAT symbol `{}` section {:?}",
+ symbol.name().unwrap_or(""),
+ symbol.section
+ )));
+ }
+ };
+ section_offsets[comdat_section].selection = match comdat.kind {
+ ComdatKind::NoDuplicates => coff::IMAGE_COMDAT_SELECT_NODUPLICATES,
+ ComdatKind::Any => coff::IMAGE_COMDAT_SELECT_ANY,
+ ComdatKind::SameSize => coff::IMAGE_COMDAT_SELECT_SAME_SIZE,
+ ComdatKind::ExactMatch => coff::IMAGE_COMDAT_SELECT_EXACT_MATCH,
+ ComdatKind::Largest => coff::IMAGE_COMDAT_SELECT_LARGEST,
+ ComdatKind::Newest => coff::IMAGE_COMDAT_SELECT_NEWEST,
+ ComdatKind::Unknown => {
+ return Err(Error(format!(
+ "unsupported COMDAT symbol `{}` kind {:?}",
+ symbol.name().unwrap_or(""),
+ comdat.kind
+ )));
+ }
+ };
+ for id in &comdat.sections {
+ let section = &self.sections[id.0];
+ if section.symbol.is_none() {
+ return Err(Error(format!(
+ "missing symbol for COMDAT section `{}`",
+ section.name().unwrap_or(""),
+ )));
+ }
+ if id.0 != comdat_section {
+ section_offsets[id.0].selection = coff::IMAGE_COMDAT_SELECT_ASSOCIATIVE;
+ section_offsets[id.0].associative_section = comdat_section as u16 + 1;
+ }
+ }
+ }
+
+ // Calculate size of symbols and add symbol strings to strtab.
+ let mut symbol_offsets = vec![SymbolOffsets::default(); self.symbols.len()];
+ let mut symtab_count = 0;
+ for (index, symbol) in self.symbols.iter().enumerate() {
+ symbol_offsets[index].index = symtab_count;
+ symtab_count += 1;
+ match symbol.kind {
+ SymbolKind::File => {
+ // Name goes in auxilary symbol records.
+ let aux_count = (symbol.name.len() + coff::IMAGE_SIZEOF_SYMBOL - 1)
+ / coff::IMAGE_SIZEOF_SYMBOL;
+ symbol_offsets[index].aux_count = aux_count as u8;
+ symtab_count += aux_count;
+ // Don't add name to strtab.
+ continue;
+ }
+ SymbolKind::Section => {
+ symbol_offsets[index].aux_count = 1;
+ symtab_count += 1;
+ }
+ _ => {}
+ }
+ if symbol.name.len() > 8 {
+ symbol_offsets[index].str_id = Some(strtab.add(&symbol.name));
+ }
+ }
+
+ // Calculate size of symtab.
+ let symtab_offset = offset;
+ let symtab_len = symtab_count * coff::IMAGE_SIZEOF_SYMBOL;
+ offset += symtab_len;
+
+ // Calculate size of strtab.
+ let strtab_offset = offset;
+ let mut strtab_data = Vec::new();
+ // First 4 bytes of strtab are the length.
+ strtab.write(4, &mut strtab_data);
+ let strtab_len = strtab_data.len() + 4;
+ offset += strtab_len;
+
+ // Start writing.
+ buffer
+ .reserve(offset)
+ .map_err(|_| Error(String::from("Cannot allocate buffer")))?;
+
+ // Write file header.
+ let header = coff::ImageFileHeader {
+ machine: U16::new(
+ LE,
+ match self.architecture {
+ Architecture::Arm => coff::IMAGE_FILE_MACHINE_ARMNT,
+ Architecture::Aarch64 => coff::IMAGE_FILE_MACHINE_ARM64,
+ Architecture::I386 => coff::IMAGE_FILE_MACHINE_I386,
+ Architecture::X86_64 => coff::IMAGE_FILE_MACHINE_AMD64,
+ _ => {
+ return Err(Error(format!(
+ "unimplemented architecture {:?}",
+ self.architecture
+ )));
+ }
+ },
+ ),
+ number_of_sections: U16::new(LE, self.sections.len() as u16),
+ time_date_stamp: U32::default(),
+ pointer_to_symbol_table: U32::new(LE, symtab_offset as u32),
+ number_of_symbols: U32::new(LE, symtab_count as u32),
+ size_of_optional_header: U16::default(),
+ characteristics: match self.flags {
+ FileFlags::Coff { characteristics } => U16::new(LE, characteristics),
+ _ => U16::default(),
+ },
+ };
+ buffer.write(&header);
+
+ // Write section headers.
+ for (index, section) in self.sections.iter().enumerate() {
+ let mut characteristics = match section.flags {
+ SectionFlags::Coff {
+ characteristics, ..
+ } => characteristics,
+ _ => 0,
+ };
+ if section_offsets[index].selection != 0 {
+ characteristics |= coff::IMAGE_SCN_LNK_COMDAT;
+ };
+ characteristics |= match section.kind {
+ SectionKind::Text => {
+ coff::IMAGE_SCN_CNT_CODE
+ | coff::IMAGE_SCN_MEM_EXECUTE
+ | coff::IMAGE_SCN_MEM_READ
+ }
+ SectionKind::Data => {
+ coff::IMAGE_SCN_CNT_INITIALIZED_DATA
+ | coff::IMAGE_SCN_MEM_READ
+ | coff::IMAGE_SCN_MEM_WRITE
+ }
+ SectionKind::UninitializedData => {
+ coff::IMAGE_SCN_CNT_UNINITIALIZED_DATA
+ | coff::IMAGE_SCN_MEM_READ
+ | coff::IMAGE_SCN_MEM_WRITE
+ }
+ SectionKind::ReadOnlyData | SectionKind::ReadOnlyString => {
+ coff::IMAGE_SCN_CNT_INITIALIZED_DATA | coff::IMAGE_SCN_MEM_READ
+ }
+ SectionKind::Debug | SectionKind::Other | SectionKind::OtherString => {
+ coff::IMAGE_SCN_CNT_INITIALIZED_DATA
+ | coff::IMAGE_SCN_MEM_READ
+ | coff::IMAGE_SCN_MEM_DISCARDABLE
+ }
+ SectionKind::Linker => coff::IMAGE_SCN_LNK_INFO | coff::IMAGE_SCN_LNK_REMOVE,
+ SectionKind::Common
+ | SectionKind::Tls
+ | SectionKind::UninitializedTls
+ | SectionKind::TlsVariables
+ | SectionKind::Note
+ | SectionKind::Unknown
+ | SectionKind::Metadata
+ | SectionKind::Elf(_) => {
+ return Err(Error(format!(
+ "unimplemented section `{}` kind {:?}",
+ section.name().unwrap_or(""),
+ section.kind
+ )));
+ }
+ } | match section.align {
+ 1 => coff::IMAGE_SCN_ALIGN_1BYTES,
+ 2 => coff::IMAGE_SCN_ALIGN_2BYTES,
+ 4 => coff::IMAGE_SCN_ALIGN_4BYTES,
+ 8 => coff::IMAGE_SCN_ALIGN_8BYTES,
+ 16 => coff::IMAGE_SCN_ALIGN_16BYTES,
+ 32 => coff::IMAGE_SCN_ALIGN_32BYTES,
+ 64 => coff::IMAGE_SCN_ALIGN_64BYTES,
+ 128 => coff::IMAGE_SCN_ALIGN_128BYTES,
+ 256 => coff::IMAGE_SCN_ALIGN_256BYTES,
+ 512 => coff::IMAGE_SCN_ALIGN_512BYTES,
+ 1024 => coff::IMAGE_SCN_ALIGN_1024BYTES,
+ 2048 => coff::IMAGE_SCN_ALIGN_2048BYTES,
+ 4096 => coff::IMAGE_SCN_ALIGN_4096BYTES,
+ 8192 => coff::IMAGE_SCN_ALIGN_8192BYTES,
+ _ => {
+ return Err(Error(format!(
+ "unimplemented section `{}` align {}",
+ section.name().unwrap_or(""),
+ section.align
+ )));
+ }
+ };
+ let mut coff_section = coff::ImageSectionHeader {
+ name: [0; 8],
+ virtual_size: U32::default(),
+ virtual_address: U32::default(),
+ size_of_raw_data: U32::new(LE, section.size as u32),
+ pointer_to_raw_data: U32::new(LE, section_offsets[index].offset as u32),
+ pointer_to_relocations: U32::new(LE, section_offsets[index].reloc_offset as u32),
+ pointer_to_linenumbers: U32::default(),
+ number_of_relocations: U16::new(LE, section.relocations.len() as u16),
+ number_of_linenumbers: U16::default(),
+ characteristics: U32::new(LE, characteristics),
+ };
+ if section.name.len() <= 8 {
+ coff_section.name[..section.name.len()].copy_from_slice(&section.name);
+ } else {
+ let mut str_offset = strtab.get_offset(section_offsets[index].str_id.unwrap());
+ if str_offset <= 9_999_999 {
+ let mut name = [0; 7];
+ let mut len = 0;
+ if str_offset == 0 {
+ name[6] = b'0';
+ len = 1;
+ } else {
+ while str_offset != 0 {
+ let rem = (str_offset % 10) as u8;
+ str_offset /= 10;
+ name[6 - len] = b'0' + rem;
+ len += 1;
+ }
+ }
+ coff_section.name = [0; 8];
+ coff_section.name[0] = b'/';
+ coff_section.name[1..][..len].copy_from_slice(&name[7 - len..]);
+ } else if str_offset as u64 <= 0xf_ffff_ffff {
+ coff_section.name[0] = b'/';
+ coff_section.name[1] = b'/';
+ for i in 0..6 {
+ let rem = (str_offset % 64) as u8;
+ str_offset /= 64;
+ let c = match rem {
+ 0..=25 => b'A' + rem,
+ 26..=51 => b'a' + rem - 26,
+ 52..=61 => b'0' + rem - 52,
+ 62 => b'+',
+ 63 => b'/',
+ _ => unreachable!(),
+ };
+ coff_section.name[7 - i] = c;
+ }
+ } else {
+ return Err(Error(format!("invalid section name offset {}", str_offset)));
+ }
+ }
+ buffer.write(&coff_section);
+ }
+
+ // Write section data and relocations.
+ for (index, section) in self.sections.iter().enumerate() {
+ let len = section.data.len();
+ if len != 0 {
+ write_align(buffer, 4);
+ debug_assert_eq!(section_offsets[index].offset, buffer.len());
+ buffer.write_bytes(&section.data);
+ }
+
+ if !section.relocations.is_empty() {
+ debug_assert_eq!(section_offsets[index].reloc_offset, buffer.len());
+ for reloc in &section.relocations {
+ //assert!(reloc.implicit_addend);
+ let typ = match self.architecture {
+ Architecture::I386 => match (reloc.kind, reloc.size, reloc.addend) {
+ (RelocationKind::Absolute, 16, 0) => coff::IMAGE_REL_I386_DIR16,
+ (RelocationKind::Relative, 16, 0) => coff::IMAGE_REL_I386_REL16,
+ (RelocationKind::Absolute, 32, 0) => coff::IMAGE_REL_I386_DIR32,
+ (RelocationKind::ImageOffset, 32, 0) => coff::IMAGE_REL_I386_DIR32NB,
+ (RelocationKind::SectionIndex, 16, 0) => coff::IMAGE_REL_I386_SECTION,
+ (RelocationKind::SectionOffset, 32, 0) => coff::IMAGE_REL_I386_SECREL,
+ (RelocationKind::SectionOffset, 7, 0) => coff::IMAGE_REL_I386_SECREL7,
+ (RelocationKind::Relative, 32, -4) => coff::IMAGE_REL_I386_REL32,
+ (RelocationKind::Coff(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::X86_64 => match (reloc.kind, reloc.size, reloc.addend) {
+ (RelocationKind::Absolute, 64, 0) => coff::IMAGE_REL_AMD64_ADDR64,
+ (RelocationKind::Absolute, 32, 0) => coff::IMAGE_REL_AMD64_ADDR32,
+ (RelocationKind::ImageOffset, 32, 0) => coff::IMAGE_REL_AMD64_ADDR32NB,
+ (RelocationKind::Relative, 32, -4) => coff::IMAGE_REL_AMD64_REL32,
+ (RelocationKind::Relative, 32, -5) => coff::IMAGE_REL_AMD64_REL32_1,
+ (RelocationKind::Relative, 32, -6) => coff::IMAGE_REL_AMD64_REL32_2,
+ (RelocationKind::Relative, 32, -7) => coff::IMAGE_REL_AMD64_REL32_3,
+ (RelocationKind::Relative, 32, -8) => coff::IMAGE_REL_AMD64_REL32_4,
+ (RelocationKind::Relative, 32, -9) => coff::IMAGE_REL_AMD64_REL32_5,
+ (RelocationKind::SectionIndex, 16, 0) => coff::IMAGE_REL_AMD64_SECTION,
+ (RelocationKind::SectionOffset, 32, 0) => coff::IMAGE_REL_AMD64_SECREL,
+ (RelocationKind::SectionOffset, 7, 0) => coff::IMAGE_REL_AMD64_SECREL7,
+ (RelocationKind::Coff(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ _ => {
+ return Err(Error(format!(
+ "unimplemented architecture {:?}",
+ self.architecture
+ )));
+ }
+ };
+ let coff_relocation = coff::ImageRelocation {
+ virtual_address: U32Bytes::new(LE, reloc.offset as u32),
+ symbol_table_index: U32Bytes::new(
+ LE,
+ symbol_offsets[reloc.symbol.0].index as u32,
+ ),
+ typ: U16Bytes::new(LE, typ),
+ };
+ buffer.write(&coff_relocation);
+ }
+ }
+ }
+
+ // Write symbols.
+ debug_assert_eq!(symtab_offset, buffer.len());
+ for (index, symbol) in self.symbols.iter().enumerate() {
+ let mut name = &symbol.name[..];
+ let section_number = match symbol.section {
+ SymbolSection::None => {
+ debug_assert_eq!(symbol.kind, SymbolKind::File);
+ coff::IMAGE_SYM_DEBUG
+ }
+ SymbolSection::Undefined => coff::IMAGE_SYM_UNDEFINED,
+ SymbolSection::Absolute => coff::IMAGE_SYM_ABSOLUTE,
+ SymbolSection::Common => coff::IMAGE_SYM_UNDEFINED,
+ SymbolSection::Section(id) => id.0 as u16 + 1,
+ };
+ let typ = if symbol.kind == SymbolKind::Text {
+ coff::IMAGE_SYM_DTYPE_FUNCTION << coff::IMAGE_SYM_DTYPE_SHIFT
+ } else {
+ coff::IMAGE_SYM_TYPE_NULL
+ };
+ let storage_class = match symbol.kind {
+ SymbolKind::File => {
+ // Name goes in auxilary symbol records.
+ name = b".file";
+ coff::IMAGE_SYM_CLASS_FILE
+ }
+ SymbolKind::Section => coff::IMAGE_SYM_CLASS_STATIC,
+ SymbolKind::Label => coff::IMAGE_SYM_CLASS_LABEL,
+ SymbolKind::Text | SymbolKind::Data | SymbolKind::Tls => {
+ match symbol.section {
+ SymbolSection::None => {
+ return Err(Error(format!(
+ "missing section for symbol `{}`",
+ symbol.name().unwrap_or("")
+ )));
+ }
+ SymbolSection::Undefined | SymbolSection::Common => {
+ coff::IMAGE_SYM_CLASS_EXTERNAL
+ }
+ SymbolSection::Absolute | SymbolSection::Section(_) => {
+ match symbol.scope {
+ // TODO: does this need aux symbol records too?
+ _ if symbol.weak => coff::IMAGE_SYM_CLASS_WEAK_EXTERNAL,
+ SymbolScope::Unknown => {
+ return Err(Error(format!(
+ "unimplemented symbol `{}` scope {:?}",
+ symbol.name().unwrap_or(""),
+ symbol.scope
+ )));
+ }
+ SymbolScope::Compilation => coff::IMAGE_SYM_CLASS_STATIC,
+ SymbolScope::Linkage | SymbolScope::Dynamic => {
+ coff::IMAGE_SYM_CLASS_EXTERNAL
+ }
+ }
+ }
+ }
+ }
+ SymbolKind::Unknown | SymbolKind::Null => {
+ return Err(Error(format!(
+ "unimplemented symbol `{}` kind {:?}",
+ symbol.name().unwrap_or(""),
+ symbol.kind
+ )));
+ }
+ };
+ let number_of_aux_symbols = symbol_offsets[index].aux_count;
+ let value = if symbol.section == SymbolSection::Common {
+ symbol.size as u32
+ } else {
+ symbol.value as u32
+ };
+ let mut coff_symbol = coff::ImageSymbol {
+ name: [0; 8],
+ value: U32Bytes::new(LE, value),
+ section_number: U16Bytes::new(LE, section_number as u16),
+ typ: U16Bytes::new(LE, typ),
+ storage_class,
+ number_of_aux_symbols,
+ };
+ if name.len() <= 8 {
+ coff_symbol.name[..name.len()].copy_from_slice(name);
+ } else {
+ let str_offset = strtab.get_offset(symbol_offsets[index].str_id.unwrap());
+ coff_symbol.name[4..8].copy_from_slice(&u32::to_le_bytes(str_offset as u32));
+ }
+ buffer.write(&coff_symbol);
+
+ // Write auxiliary symbols.
+ match symbol.kind {
+ SymbolKind::File => {
+ let aux_len = number_of_aux_symbols as usize * coff::IMAGE_SIZEOF_SYMBOL;
+ debug_assert!(aux_len >= symbol.name.len());
+ let old_len = buffer.len();
+ buffer.write_bytes(&symbol.name);
+ buffer.resize(old_len + aux_len, 0);
+ }
+ SymbolKind::Section => {
+ debug_assert_eq!(number_of_aux_symbols, 1);
+ let section_index = symbol.section.id().unwrap().0;
+ let section = &self.sections[section_index];
+ let aux = coff::ImageAuxSymbolSection {
+ length: U32Bytes::new(LE, section.size as u32),
+ number_of_relocations: U16Bytes::new(LE, section.relocations.len() as u16),
+ number_of_linenumbers: U16Bytes::default(),
+ check_sum: U32Bytes::new(LE, checksum(section.data.as_slice())),
+ number: U16Bytes::new(
+ LE,
+ section_offsets[section_index].associative_section,
+ ),
+ selection: section_offsets[section_index].selection,
+ reserved: 0,
+ // TODO: bigobj
+ high_number: U16Bytes::default(),
+ };
+ buffer.write(&aux);
+ }
+ _ => {
+ debug_assert_eq!(number_of_aux_symbols, 0);
+ }
+ }
+ }
+
+ // Write strtab section.
+ debug_assert_eq!(strtab_offset, buffer.len());
+ buffer.write_bytes(&u32::to_le_bytes(strtab_len as u32));
+ buffer.write_bytes(&strtab_data);
+
+ debug_assert_eq!(offset, buffer.len());
+
+ Ok(())
+ }
+}
+
+// JamCRC
+fn checksum(data: &[u8]) -> u32 {
+ let mut hasher = crc32fast::Hasher::new_with_initial(0xffff_ffff);
+ hasher.update(data);
+ !hasher.finalize()
+}
diff --git a/vendor/object-0.26.2/src/write/elf.rs b/vendor/object-0.26.2/src/write/elf.rs
new file mode 100644
index 000000000..34e0abc85
--- /dev/null
+++ b/vendor/object-0.26.2/src/write/elf.rs
@@ -0,0 +1,1314 @@
+use std::mem;
+use std::vec::Vec;
+
+use crate::elf;
+use crate::endian::*;
+use crate::write::string::*;
+use crate::write::util::*;
+use crate::write::*;
+use crate::AddressSize;
+
+#[derive(Default, Clone, Copy)]
+struct ComdatOffsets {
+ offset: usize,
+ str_id: Option<StringId>,
+ len: usize,
+}
+
+#[derive(Default, Clone, Copy)]
+struct SectionOffsets {
+ index: usize,
+ offset: usize,
+ str_id: Option<StringId>,
+ reloc_index: usize,
+ reloc_offset: usize,
+ reloc_len: usize,
+ reloc_str_id: Option<StringId>,
+}
+
+#[derive(Default, Clone, Copy)]
+struct SymbolOffsets {
+ index: usize,
+ str_id: Option<StringId>,
+}
+
+impl Object {
+ pub(crate) fn elf_section_info(
+ &self,
+ section: StandardSection,
+ ) -> (&'static [u8], &'static [u8], SectionKind) {
+ match section {
+ StandardSection::Text => (&[], &b".text"[..], SectionKind::Text),
+ StandardSection::Data => (&[], &b".data"[..], SectionKind::Data),
+ StandardSection::ReadOnlyData | StandardSection::ReadOnlyString => {
+ (&[], &b".rodata"[..], SectionKind::ReadOnlyData)
+ }
+ StandardSection::ReadOnlyDataWithRel => (&[], b".data.rel.ro", SectionKind::Data),
+ StandardSection::UninitializedData => {
+ (&[], &b".bss"[..], SectionKind::UninitializedData)
+ }
+ StandardSection::Tls => (&[], &b".tdata"[..], SectionKind::Tls),
+ StandardSection::UninitializedTls => {
+ (&[], &b".tbss"[..], SectionKind::UninitializedTls)
+ }
+ StandardSection::TlsVariables => {
+ // Unsupported section.
+ (&[], &[], SectionKind::TlsVariables)
+ }
+ StandardSection::Common => {
+ // Unsupported section.
+ (&[], &[], SectionKind::Common)
+ }
+ }
+ }
+
+ pub(crate) fn elf_subsection_name(&self, section: &[u8], value: &[u8]) -> Vec<u8> {
+ let mut name = section.to_vec();
+ name.push(b'.');
+ name.extend_from_slice(value);
+ name
+ }
+
+ fn elf_has_relocation_addend(&self) -> Result<bool> {
+ Ok(match self.architecture {
+ Architecture::Aarch64 => true,
+ Architecture::Arm => false,
+ Architecture::Avr => true,
+ Architecture::Bpf => false,
+ Architecture::I386 => false,
+ Architecture::X86_64 => true,
+ Architecture::X86_64_X32 => true,
+ Architecture::Hexagon => true,
+ Architecture::Mips => false,
+ Architecture::Mips64 => true,
+ Architecture::Msp430 => true,
+ Architecture::PowerPc => true,
+ Architecture::PowerPc64 => true,
+ Architecture::Riscv64 => true,
+ Architecture::Riscv32 => true,
+ Architecture::S390x => true,
+ Architecture::Sparc64 => true,
+ _ => {
+ return Err(Error(format!(
+ "unimplemented architecture {:?}",
+ self.architecture
+ )));
+ }
+ })
+ }
+
+ pub(crate) fn elf_fixup_relocation(&mut self, mut relocation: &mut Relocation) -> Result<i64> {
+ // Return true if we should use a section symbol to avoid preemption.
+ fn want_section_symbol(relocation: &Relocation, symbol: &Symbol) -> bool {
+ if symbol.scope != SymbolScope::Dynamic {
+ // Only dynamic symbols can be preemptible.
+ return false;
+ }
+ match symbol.kind {
+ SymbolKind::Text | SymbolKind::Data => {}
+ _ => return false,
+ }
+ match relocation.kind {
+ // Anything using GOT or PLT is preemptible.
+ // We also require that `Other` relocations must already be correct.
+ RelocationKind::Got
+ | RelocationKind::GotRelative
+ | RelocationKind::GotBaseRelative
+ | RelocationKind::PltRelative
+ | RelocationKind::Elf(_) => return false,
+ // Absolute relocations are preemptible for non-local data.
+ // TODO: not sure if this rule is exactly correct
+ // This rule was added to handle global data references in debuginfo.
+ // Maybe this should be a new relocation kind so that the caller can decide.
+ RelocationKind::Absolute => {
+ if symbol.kind == SymbolKind::Data {
+ return false;
+ }
+ }
+ _ => {}
+ }
+ true
+ }
+
+ // Use section symbols for relocations where required to avoid preemption.
+ // Otherwise, the linker will fail with:
+ // relocation R_X86_64_PC32 against symbol `SomeSymbolName' can not be used when
+ // making a shared object; recompile with -fPIC
+ let symbol = &self.symbols[relocation.symbol.0];
+ if want_section_symbol(relocation, symbol) {
+ if let Some(section) = symbol.section.id() {
+ relocation.addend += symbol.value as i64;
+ relocation.symbol = self.section_symbol(section);
+ }
+ }
+
+ // Determine whether the addend is stored in the relocation or the data.
+ if self.elf_has_relocation_addend()? {
+ Ok(0)
+ } else {
+ let constant = relocation.addend;
+ relocation.addend = 0;
+ Ok(constant)
+ }
+ }
+
+ pub(crate) fn elf_write(&self, buffer: &mut dyn WritableBuffer) -> Result<()> {
+ let address_size = self.architecture.address_size().unwrap();
+ let endian = self.endian;
+ let elf32 = Elf32 { endian };
+ let elf64 = Elf64 { endian };
+ let elf: &dyn Elf = match address_size {
+ AddressSize::U8 | AddressSize::U16 | AddressSize::U32 => &elf32,
+ AddressSize::U64 => &elf64,
+ };
+ let pointer_align = address_size.bytes() as usize;
+ let is_mips64el =
+ self.architecture == Architecture::Mips64 && self.endian == Endianness::Little;
+
+ // Calculate offsets of everything.
+ let mut offset = 0;
+
+ // ELF header.
+ let e_ehsize = elf.file_header_size();
+ offset += e_ehsize;
+
+ // Create reloc section header names.
+ let is_rela = self.elf_has_relocation_addend()?;
+ let reloc_names: Vec<_> = self
+ .sections
+ .iter()
+ .map(|section| {
+ let mut reloc_name = Vec::new();
+ if !section.relocations.is_empty() {
+ reloc_name.extend_from_slice(if is_rela {
+ &b".rela"[..]
+ } else {
+ &b".rel"[..]
+ });
+ reloc_name.extend_from_slice(&section.name);
+ }
+ reloc_name
+ })
+ .collect();
+
+ // Calculate size of section data.
+ let mut shstrtab = StringTable::default();
+ let mut comdat_offsets = vec![ComdatOffsets::default(); self.comdats.len()];
+ let mut section_offsets = vec![SectionOffsets::default(); self.sections.len()];
+ // Null section.
+ let mut section_num = 1;
+ for (index, comdat) in self.comdats.iter().enumerate() {
+ if comdat.kind != ComdatKind::Any {
+ return Err(Error(format!(
+ "unsupported COMDAT symbol `{}` kind {:?}",
+ self.symbols[comdat.symbol.0].name().unwrap_or(""),
+ comdat.kind
+ )));
+ }
+
+ comdat_offsets[index].str_id = Some(shstrtab.add(b".group"));
+ section_num += 1;
+ offset = align(offset, 4);
+ comdat_offsets[index].offset = offset;
+ let len = (comdat.sections.len() + 1) * 4;
+ comdat_offsets[index].len = len;
+ offset += len;
+ }
+ for (index, section) in self.sections.iter().enumerate() {
+ section_offsets[index].str_id = Some(shstrtab.add(&section.name));
+ section_offsets[index].index = section_num;
+ section_num += 1;
+
+ let len = section.data.len();
+ if len != 0 {
+ offset = align(offset, section.align as usize);
+ section_offsets[index].offset = offset;
+ offset += len;
+ } else {
+ section_offsets[index].offset = offset;
+ }
+
+ if !section.relocations.is_empty() {
+ section_offsets[index].reloc_str_id = Some(shstrtab.add(&reloc_names[index]));
+ section_offsets[index].reloc_index = section_num;
+ section_num += 1;
+ }
+ }
+
+ // Calculate index of symbols and add symbol strings to strtab.
+ let mut strtab = StringTable::default();
+ let mut symbol_offsets = vec![SymbolOffsets::default(); self.symbols.len()];
+ // Null symbol.
+ let mut symtab_count = 1;
+ // Local symbols must come before global.
+ for (index, symbol) in self.symbols.iter().enumerate() {
+ if symbol.is_local() {
+ symbol_offsets[index].index = symtab_count;
+ symtab_count += 1;
+ }
+ }
+ let symtab_count_local = symtab_count;
+ for (index, symbol) in self.symbols.iter().enumerate() {
+ if !symbol.is_local() {
+ symbol_offsets[index].index = symtab_count;
+ symtab_count += 1;
+ }
+ }
+ for (index, symbol) in self.symbols.iter().enumerate() {
+ if symbol.kind != SymbolKind::Section && !symbol.name.is_empty() {
+ symbol_offsets[index].str_id = Some(strtab.add(&symbol.name));
+ }
+ }
+
+ // Calculate size of symtab.
+ let symtab_str_id = shstrtab.add(&b".symtab"[..]);
+ offset = align(offset, pointer_align);
+ let symtab_offset = offset;
+ let symtab_len = symtab_count * elf.symbol_size();
+ offset += symtab_len;
+ let symtab_index = section_num;
+ section_num += 1;
+
+ // Calculate size of symtab_shndx.
+ let mut need_symtab_shndx = false;
+ for symbol in &self.symbols {
+ let index = symbol
+ .section
+ .id()
+ .map(|s| section_offsets[s.0].index)
+ .unwrap_or(0);
+ if index >= elf::SHN_LORESERVE as usize {
+ need_symtab_shndx = true;
+ break;
+ }
+ }
+ let symtab_shndx_offset = offset;
+ let mut symtab_shndx_str_id = None;
+ let mut symtab_shndx_len = 0;
+ if need_symtab_shndx {
+ symtab_shndx_str_id = Some(shstrtab.add(&b".symtab_shndx"[..]));
+ symtab_shndx_len = symtab_count * 4;
+ offset += symtab_shndx_len;
+ section_num += 1;
+ }
+
+ // Calculate size of strtab.
+ let strtab_str_id = shstrtab.add(&b".strtab"[..]);
+ let strtab_offset = offset;
+ // Start with null name.
+ let mut strtab_data = vec![0];
+ strtab.write(1, &mut strtab_data);
+ offset += strtab_data.len();
+ let strtab_index = section_num;
+ section_num += 1;
+
+ // Calculate size of relocations.
+ for (index, section) in self.sections.iter().enumerate() {
+ let count = section.relocations.len();
+ if count != 0 {
+ offset = align(offset, pointer_align);
+ section_offsets[index].reloc_offset = offset;
+ let len = count * elf.rel_size(is_rela);
+ section_offsets[index].reloc_len = len;
+ offset += len;
+ }
+ }
+
+ // Calculate size of shstrtab.
+ let shstrtab_str_id = shstrtab.add(&b".shstrtab"[..]);
+ let shstrtab_offset = offset;
+ // Start with null section name.
+ let mut shstrtab_data = vec![0];
+ shstrtab.write(1, &mut shstrtab_data);
+ offset += shstrtab_data.len();
+ let shstrtab_index = section_num;
+ section_num += 1;
+
+ // Calculate size of section headers.
+ offset = align(offset, pointer_align);
+ let e_shoff = offset;
+ let e_shentsize = elf.section_header_size();
+ offset += section_num * e_shentsize;
+
+ // Start writing.
+ buffer
+ .reserve(offset)
+ .map_err(|_| Error(String::from("Cannot allocate buffer")))?;
+
+ // Write file header.
+ let e_ident = elf::Ident {
+ magic: elf::ELFMAG,
+ class: match address_size {
+ AddressSize::U8 | AddressSize::U16 | AddressSize::U32 => elf::ELFCLASS32,
+ AddressSize::U64 => elf::ELFCLASS64,
+ },
+ data: if endian.is_little_endian() {
+ elf::ELFDATA2LSB
+ } else {
+ elf::ELFDATA2MSB
+ },
+ version: elf::EV_CURRENT,
+ os_abi: elf::ELFOSABI_NONE,
+ abi_version: 0,
+ padding: [0; 7],
+ };
+ let e_type = elf::ET_REL;
+ let e_machine = match self.architecture {
+ Architecture::Aarch64 => elf::EM_AARCH64,
+ Architecture::Arm => elf::EM_ARM,
+ Architecture::Avr => elf::EM_AVR,
+ Architecture::Bpf => elf::EM_BPF,
+ Architecture::I386 => elf::EM_386,
+ Architecture::X86_64 => elf::EM_X86_64,
+ Architecture::X86_64_X32 => elf::EM_X86_64,
+ Architecture::Hexagon => elf::EM_HEXAGON,
+ Architecture::Mips => elf::EM_MIPS,
+ Architecture::Mips64 => elf::EM_MIPS,
+ Architecture::Msp430 => elf::EM_MSP430,
+ Architecture::PowerPc => elf::EM_PPC,
+ Architecture::PowerPc64 => elf::EM_PPC64,
+ Architecture::Riscv32 => elf::EM_RISCV,
+ Architecture::Riscv64 => elf::EM_RISCV,
+ Architecture::S390x => elf::EM_S390,
+ Architecture::Sparc64 => elf::EM_SPARCV9,
+ _ => {
+ return Err(Error(format!(
+ "unimplemented architecture {:?}",
+ self.architecture
+ )));
+ }
+ };
+ let e_flags = if let FileFlags::Elf { e_flags } = self.flags {
+ e_flags
+ } else {
+ 0
+ };
+ let e_shnum = if section_num >= elf::SHN_LORESERVE as usize {
+ 0
+ } else {
+ section_num as u16
+ };
+ let e_shstrndx = if shstrtab_index >= elf::SHN_LORESERVE as usize {
+ elf::SHN_XINDEX
+ } else {
+ shstrtab_index as u16
+ };
+
+ elf.write_file_header(
+ buffer,
+ FileHeader {
+ e_ident,
+ e_type,
+ e_machine,
+ e_version: elf::EV_CURRENT.into(),
+ e_entry: 0,
+ e_phoff: 0,
+ e_shoff: e_shoff as u64,
+ e_flags,
+ e_ehsize: e_ehsize as u16,
+ e_phentsize: 0,
+ e_phnum: 0,
+ e_shentsize: e_shentsize as u16,
+ e_shnum,
+ e_shstrndx,
+ },
+ );
+
+ // Write section data.
+ for (index, comdat) in self.comdats.iter().enumerate() {
+ let mut data = Vec::new();
+ data.write_pod(&U32::new(self.endian, elf::GRP_COMDAT));
+ for section in &comdat.sections {
+ data.write_pod(&U32::new(
+ self.endian,
+ section_offsets[section.0].index as u32,
+ ));
+ }
+
+ write_align(buffer, 4);
+ debug_assert_eq!(comdat_offsets[index].offset, buffer.len());
+ debug_assert_eq!(comdat_offsets[index].len, data.len());
+ buffer.write_bytes(&data);
+ }
+ for (index, section) in self.sections.iter().enumerate() {
+ let len = section.data.len();
+ if len != 0 {
+ write_align(buffer, section.align as usize);
+ debug_assert_eq!(section_offsets[index].offset, buffer.len());
+ buffer.write_bytes(&section.data);
+ }
+ }
+
+ // Write symbols.
+ write_align(buffer, pointer_align);
+ debug_assert_eq!(symtab_offset, buffer.len());
+ elf.write_symbol(
+ buffer,
+ Sym {
+ st_name: 0,
+ st_info: 0,
+ st_other: 0,
+ st_shndx: 0,
+ st_value: 0,
+ st_size: 0,
+ },
+ );
+ let mut symtab_shndx = Vec::new();
+ if need_symtab_shndx {
+ symtab_shndx.write_pod(&U32::new(endian, 0));
+ }
+ let mut write_symbol = |index: usize, symbol: &Symbol| -> Result<()> {
+ let st_info = if let SymbolFlags::Elf { st_info, .. } = symbol.flags {
+ st_info
+ } else {
+ let st_type = match symbol.kind {
+ SymbolKind::Null => elf::STT_NOTYPE,
+ SymbolKind::Text => {
+ if symbol.is_undefined() {
+ elf::STT_NOTYPE
+ } else {
+ elf::STT_FUNC
+ }
+ }
+ SymbolKind::Data => {
+ if symbol.is_undefined() {
+ elf::STT_NOTYPE
+ } else if symbol.is_common() {
+ elf::STT_COMMON
+ } else {
+ elf::STT_OBJECT
+ }
+ }
+ SymbolKind::Section => elf::STT_SECTION,
+ SymbolKind::File => elf::STT_FILE,
+ SymbolKind::Tls => elf::STT_TLS,
+ SymbolKind::Label => elf::STT_NOTYPE,
+ SymbolKind::Unknown => {
+ if symbol.is_undefined() {
+ elf::STT_NOTYPE
+ } else {
+ return Err(Error(format!(
+ "unimplemented symbol `{}` kind {:?}",
+ symbol.name().unwrap_or(""),
+ symbol.kind
+ )));
+ }
+ }
+ };
+ let st_bind = if symbol.weak {
+ elf::STB_WEAK
+ } else if symbol.is_undefined() {
+ elf::STB_GLOBAL
+ } else if symbol.is_local() {
+ elf::STB_LOCAL
+ } else {
+ elf::STB_GLOBAL
+ };
+ (st_bind << 4) + st_type
+ };
+ let st_other = if let SymbolFlags::Elf { st_other, .. } = symbol.flags {
+ st_other
+ } else if symbol.scope == SymbolScope::Linkage {
+ elf::STV_HIDDEN
+ } else {
+ elf::STV_DEFAULT
+ };
+ let (st_shndx, xindex) = match symbol.section {
+ SymbolSection::None => {
+ debug_assert_eq!(symbol.kind, SymbolKind::File);
+ (elf::SHN_ABS, 0)
+ }
+ SymbolSection::Undefined => (elf::SHN_UNDEF, 0),
+ SymbolSection::Absolute => (elf::SHN_ABS, 0),
+ SymbolSection::Common => (elf::SHN_COMMON, 0),
+ SymbolSection::Section(id) => {
+ let index = section_offsets[id.0].index as u32;
+ (
+ if index >= elf::SHN_LORESERVE as u32 {
+ elf::SHN_XINDEX
+ } else {
+ index as u16
+ },
+ index,
+ )
+ }
+ };
+ let st_name = symbol_offsets[index]
+ .str_id
+ .map(|id| strtab.get_offset(id))
+ .unwrap_or(0) as u32;
+ elf.write_symbol(
+ buffer,
+ Sym {
+ st_name,
+ st_info,
+ st_other,
+ st_shndx,
+ st_value: symbol.value,
+ st_size: symbol.size,
+ },
+ );
+ if need_symtab_shndx {
+ symtab_shndx.write_pod(&U32::new(endian, xindex));
+ }
+ Ok(())
+ };
+ for (index, symbol) in self.symbols.iter().enumerate() {
+ if symbol.is_local() {
+ write_symbol(index, symbol)?;
+ }
+ }
+ for (index, symbol) in self.symbols.iter().enumerate() {
+ if !symbol.is_local() {
+ write_symbol(index, symbol)?;
+ }
+ }
+ if need_symtab_shndx {
+ debug_assert_eq!(symtab_shndx_offset, buffer.len());
+ debug_assert_eq!(symtab_shndx_len, symtab_shndx.len());
+ buffer.write_bytes(&symtab_shndx);
+ }
+
+ // Write strtab section.
+ debug_assert_eq!(strtab_offset, buffer.len());
+ buffer.write_bytes(&strtab_data);
+
+ // Write relocations.
+ for (index, section) in self.sections.iter().enumerate() {
+ if !section.relocations.is_empty() {
+ write_align(buffer, pointer_align);
+ debug_assert_eq!(section_offsets[index].reloc_offset, buffer.len());
+ for reloc in &section.relocations {
+ let r_type = match self.architecture {
+ Architecture::Aarch64 => match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, RelocationEncoding::Generic, 64) => {
+ elf::R_AARCH64_ABS64
+ }
+ (RelocationKind::Absolute, RelocationEncoding::Generic, 32) => {
+ elf::R_AARCH64_ABS32
+ }
+ (RelocationKind::Absolute, RelocationEncoding::Generic, 16) => {
+ elf::R_AARCH64_ABS16
+ }
+ (RelocationKind::Relative, RelocationEncoding::Generic, 64) => {
+ elf::R_AARCH64_PREL64
+ }
+ (RelocationKind::Relative, RelocationEncoding::Generic, 32) => {
+ elf::R_AARCH64_PREL32
+ }
+ (RelocationKind::Relative, RelocationEncoding::Generic, 16) => {
+ elf::R_AARCH64_PREL16
+ }
+ (RelocationKind::Relative, RelocationEncoding::AArch64Call, 26)
+ | (RelocationKind::PltRelative, RelocationEncoding::AArch64Call, 26) => {
+ elf::R_AARCH64_CALL26
+ }
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::Arm => match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, _, 32) => elf::R_ARM_ABS32,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::Avr => match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, _, 32) => elf::R_AVR_32,
+ (RelocationKind::Absolute, _, 16) => elf::R_AVR_16,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::Bpf => match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, _, 64) => elf::R_BPF_64_64,
+ (RelocationKind::Absolute, _, 32) => elf::R_BPF_64_32,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::I386 => match (reloc.kind, reloc.size) {
+ (RelocationKind::Absolute, 32) => elf::R_386_32,
+ (RelocationKind::Relative, 32) => elf::R_386_PC32,
+ (RelocationKind::Got, 32) => elf::R_386_GOT32,
+ (RelocationKind::PltRelative, 32) => elf::R_386_PLT32,
+ (RelocationKind::GotBaseOffset, 32) => elf::R_386_GOTOFF,
+ (RelocationKind::GotBaseRelative, 32) => elf::R_386_GOTPC,
+ (RelocationKind::Absolute, 16) => elf::R_386_16,
+ (RelocationKind::Relative, 16) => elf::R_386_PC16,
+ (RelocationKind::Absolute, 8) => elf::R_386_8,
+ (RelocationKind::Relative, 8) => elf::R_386_PC8,
+ (RelocationKind::Elf(x), _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::X86_64 | Architecture::X86_64_X32 => {
+ match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, RelocationEncoding::Generic, 64) => {
+ elf::R_X86_64_64
+ }
+ (RelocationKind::Relative, _, 32) => elf::R_X86_64_PC32,
+ (RelocationKind::Got, _, 32) => elf::R_X86_64_GOT32,
+ (RelocationKind::PltRelative, _, 32) => elf::R_X86_64_PLT32,
+ (RelocationKind::GotRelative, _, 32) => elf::R_X86_64_GOTPCREL,
+ (RelocationKind::Absolute, RelocationEncoding::Generic, 32) => {
+ elf::R_X86_64_32
+ }
+ (RelocationKind::Absolute, RelocationEncoding::X86Signed, 32) => {
+ elf::R_X86_64_32S
+ }
+ (RelocationKind::Absolute, _, 16) => elf::R_X86_64_16,
+ (RelocationKind::Relative, _, 16) => elf::R_X86_64_PC16,
+ (RelocationKind::Absolute, _, 8) => elf::R_X86_64_8,
+ (RelocationKind::Relative, _, 8) => elf::R_X86_64_PC8,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!(
+ "unimplemented relocation {:?}",
+ reloc
+ )));
+ }
+ }
+ }
+ Architecture::Hexagon => match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, _, 32) => elf::R_HEX_32,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::Mips | Architecture::Mips64 => {
+ match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, _, 16) => elf::R_MIPS_16,
+ (RelocationKind::Absolute, _, 32) => elf::R_MIPS_32,
+ (RelocationKind::Absolute, _, 64) => elf::R_MIPS_64,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!(
+ "unimplemented relocation {:?}",
+ reloc
+ )));
+ }
+ }
+ }
+ Architecture::Msp430 => match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, _, 32) => elf::R_MSP430_32,
+ (RelocationKind::Absolute, _, 16) => elf::R_MSP430_16_BYTE,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::PowerPc => match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, _, 32) => elf::R_PPC_ADDR32,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::PowerPc64 => match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, _, 32) => elf::R_PPC64_ADDR32,
+ (RelocationKind::Absolute, _, 64) => elf::R_PPC64_ADDR64,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::Riscv32 | Architecture::Riscv64 => {
+ match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, _, 32) => elf::R_RISCV_32,
+ (RelocationKind::Absolute, _, 64) => elf::R_RISCV_64,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!(
+ "unimplemented relocation {:?}",
+ reloc
+ )));
+ }
+ }
+ }
+ Architecture::S390x => match (reloc.kind, reloc.encoding, reloc.size) {
+ (RelocationKind::Absolute, RelocationEncoding::Generic, 8) => {
+ elf::R_390_8
+ }
+ (RelocationKind::Absolute, RelocationEncoding::Generic, 16) => {
+ elf::R_390_16
+ }
+ (RelocationKind::Absolute, RelocationEncoding::Generic, 32) => {
+ elf::R_390_32
+ }
+ (RelocationKind::Absolute, RelocationEncoding::Generic, 64) => {
+ elf::R_390_64
+ }
+ (RelocationKind::Relative, RelocationEncoding::Generic, 16) => {
+ elf::R_390_PC16
+ }
+ (RelocationKind::Relative, RelocationEncoding::Generic, 32) => {
+ elf::R_390_PC32
+ }
+ (RelocationKind::Relative, RelocationEncoding::Generic, 64) => {
+ elf::R_390_PC64
+ }
+ (RelocationKind::Relative, RelocationEncoding::S390xDbl, 16) => {
+ elf::R_390_PC16DBL
+ }
+ (RelocationKind::Relative, RelocationEncoding::S390xDbl, 32) => {
+ elf::R_390_PC32DBL
+ }
+ (RelocationKind::PltRelative, RelocationEncoding::S390xDbl, 16) => {
+ elf::R_390_PLT16DBL
+ }
+ (RelocationKind::PltRelative, RelocationEncoding::S390xDbl, 32) => {
+ elf::R_390_PLT32DBL
+ }
+ (RelocationKind::Got, RelocationEncoding::Generic, 16) => {
+ elf::R_390_GOT16
+ }
+ (RelocationKind::Got, RelocationEncoding::Generic, 32) => {
+ elf::R_390_GOT32
+ }
+ (RelocationKind::Got, RelocationEncoding::Generic, 64) => {
+ elf::R_390_GOT64
+ }
+ (RelocationKind::GotRelative, RelocationEncoding::S390xDbl, 32) => {
+ elf::R_390_GOTENT
+ }
+ (RelocationKind::GotBaseOffset, RelocationEncoding::Generic, 16) => {
+ elf::R_390_GOTOFF16
+ }
+ (RelocationKind::GotBaseOffset, RelocationEncoding::Generic, 32) => {
+ elf::R_390_GOTOFF32
+ }
+ (RelocationKind::GotBaseOffset, RelocationEncoding::Generic, 64) => {
+ elf::R_390_GOTOFF64
+ }
+ (RelocationKind::GotBaseRelative, RelocationEncoding::Generic, 64) => {
+ elf::R_390_GOTPC
+ }
+ (RelocationKind::GotBaseRelative, RelocationEncoding::S390xDbl, 32) => {
+ elf::R_390_GOTPCDBL
+ }
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::Sparc64 => match (reloc.kind, reloc.encoding, reloc.size) {
+ // TODO: use R_SPARC_32/R_SPARC_64 if aligned.
+ (RelocationKind::Absolute, _, 32) => elf::R_SPARC_UA32,
+ (RelocationKind::Absolute, _, 64) => elf::R_SPARC_UA64,
+ (RelocationKind::Elf(x), _, _) => x,
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ _ => {
+ if let RelocationKind::Elf(x) = reloc.kind {
+ x
+ } else {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ }
+ };
+ let r_sym = symbol_offsets[reloc.symbol.0].index as u32;
+ elf.write_rel(
+ buffer,
+ is_mips64el,
+ is_rela,
+ Rel {
+ r_offset: reloc.offset,
+ r_sym,
+ r_type,
+ r_addend: reloc.addend,
+ },
+ );
+ }
+ }
+ }
+
+ // Write shstrtab section.
+ debug_assert_eq!(shstrtab_offset, buffer.len());
+ buffer.write_bytes(&shstrtab_data);
+
+ // Write section headers.
+ write_align(buffer, pointer_align);
+ debug_assert_eq!(e_shoff, buffer.len());
+ elf.write_section_header(
+ buffer,
+ SectionHeader {
+ sh_name: 0,
+ sh_type: 0,
+ sh_flags: 0,
+ sh_addr: 0,
+ sh_offset: 0,
+ sh_size: if section_num >= elf::SHN_LORESERVE as usize {
+ section_num as u64
+ } else {
+ 0
+ },
+ sh_link: if shstrtab_index >= elf::SHN_LORESERVE as usize {
+ shstrtab_index as u32
+ } else {
+ 0
+ },
+ // TODO: e_phnum overflow
+ sh_info: 0,
+ sh_addralign: 0,
+ sh_entsize: 0,
+ },
+ );
+ for (index, comdat) in self.comdats.iter().enumerate() {
+ let sh_name = comdat_offsets[index]
+ .str_id
+ .map(|id| shstrtab.get_offset(id))
+ .unwrap_or(0) as u32;
+ elf.write_section_header(
+ buffer,
+ SectionHeader {
+ sh_name,
+ sh_type: elf::SHT_GROUP,
+ sh_flags: 0,
+ sh_addr: 0,
+ sh_offset: comdat_offsets[index].offset as u64,
+ sh_size: comdat_offsets[index].len as u64,
+ sh_link: symtab_index as u32,
+ sh_info: symbol_offsets[comdat.symbol.0].index as u32,
+ sh_addralign: 4,
+ sh_entsize: 4,
+ },
+ );
+ }
+ for (index, section) in self.sections.iter().enumerate() {
+ let sh_type = match section.kind {
+ SectionKind::UninitializedData | SectionKind::UninitializedTls => elf::SHT_NOBITS,
+ SectionKind::Note => elf::SHT_NOTE,
+ SectionKind::Elf(sh_type) => sh_type,
+ _ => elf::SHT_PROGBITS,
+ };
+ let sh_flags = if let SectionFlags::Elf { sh_flags } = section.flags {
+ sh_flags
+ } else {
+ match section.kind {
+ SectionKind::Text => elf::SHF_ALLOC | elf::SHF_EXECINSTR,
+ SectionKind::Data => elf::SHF_ALLOC | elf::SHF_WRITE,
+ SectionKind::Tls => elf::SHF_ALLOC | elf::SHF_WRITE | elf::SHF_TLS,
+ SectionKind::UninitializedData => elf::SHF_ALLOC | elf::SHF_WRITE,
+ SectionKind::UninitializedTls => elf::SHF_ALLOC | elf::SHF_WRITE | elf::SHF_TLS,
+ SectionKind::ReadOnlyData => elf::SHF_ALLOC,
+ SectionKind::ReadOnlyString => {
+ elf::SHF_ALLOC | elf::SHF_STRINGS | elf::SHF_MERGE
+ }
+ SectionKind::OtherString => elf::SHF_STRINGS | elf::SHF_MERGE,
+ SectionKind::Other
+ | SectionKind::Debug
+ | SectionKind::Metadata
+ | SectionKind::Linker
+ | SectionKind::Note
+ | SectionKind::Elf(_) => 0,
+ SectionKind::Unknown | SectionKind::Common | SectionKind::TlsVariables => {
+ return Err(Error(format!(
+ "unimplemented section `{}` kind {:?}",
+ section.name().unwrap_or(""),
+ section.kind
+ )));
+ }
+ }
+ .into()
+ };
+ // TODO: not sure if this is correct, maybe user should determine this
+ let sh_entsize = match section.kind {
+ SectionKind::ReadOnlyString | SectionKind::OtherString => 1,
+ _ => 0,
+ };
+ let sh_name = section_offsets[index]
+ .str_id
+ .map(|id| shstrtab.get_offset(id))
+ .unwrap_or(0) as u32;
+ elf.write_section_header(
+ buffer,
+ SectionHeader {
+ sh_name,
+ sh_type,
+ sh_flags,
+ sh_addr: 0,
+ sh_offset: section_offsets[index].offset as u64,
+ sh_size: section.size,
+ sh_link: 0,
+ sh_info: 0,
+ sh_addralign: section.align,
+ sh_entsize,
+ },
+ );
+
+ if !section.relocations.is_empty() {
+ let sh_name = section_offsets[index]
+ .reloc_str_id
+ .map(|id| shstrtab.get_offset(id))
+ .unwrap_or(0);
+ elf.write_section_header(
+ buffer,
+ SectionHeader {
+ sh_name: sh_name as u32,
+ sh_type: if is_rela { elf::SHT_RELA } else { elf::SHT_REL },
+ sh_flags: elf::SHF_INFO_LINK.into(),
+ sh_addr: 0,
+ sh_offset: section_offsets[index].reloc_offset as u64,
+ sh_size: section_offsets[index].reloc_len as u64,
+ sh_link: symtab_index as u32,
+ sh_info: section_offsets[index].index as u32,
+ sh_addralign: pointer_align as u64,
+ sh_entsize: elf.rel_size(is_rela) as u64,
+ },
+ );
+ }
+ }
+
+ // Write symtab section header.
+ elf.write_section_header(
+ buffer,
+ SectionHeader {
+ sh_name: shstrtab.get_offset(symtab_str_id) as u32,
+ sh_type: elf::SHT_SYMTAB,
+ sh_flags: 0,
+ sh_addr: 0,
+ sh_offset: symtab_offset as u64,
+ sh_size: symtab_len as u64,
+ sh_link: strtab_index as u32,
+ sh_info: symtab_count_local as u32,
+ sh_addralign: pointer_align as u64,
+ sh_entsize: elf.symbol_size() as u64,
+ },
+ );
+
+ // Write symtab_shndx section header.
+ if need_symtab_shndx {
+ elf.write_section_header(
+ buffer,
+ SectionHeader {
+ sh_name: shstrtab.get_offset(symtab_shndx_str_id.unwrap()) as u32,
+ sh_type: elf::SHT_SYMTAB_SHNDX,
+ sh_flags: 0,
+ sh_addr: 0,
+ sh_offset: symtab_shndx_offset as u64,
+ sh_size: symtab_shndx_len as u64,
+ sh_link: symtab_index as u32,
+ sh_info: symtab_count_local as u32,
+ sh_addralign: 4,
+ sh_entsize: 4,
+ },
+ );
+ }
+
+ // Write strtab section header.
+ elf.write_section_header(
+ buffer,
+ SectionHeader {
+ sh_name: shstrtab.get_offset(strtab_str_id) as u32,
+ sh_type: elf::SHT_STRTAB,
+ sh_flags: 0,
+ sh_addr: 0,
+ sh_offset: strtab_offset as u64,
+ sh_size: strtab_data.len() as u64,
+ sh_link: 0,
+ sh_info: 0,
+ sh_addralign: 1,
+ sh_entsize: 0,
+ },
+ );
+
+ // Write shstrtab section header.
+ elf.write_section_header(
+ buffer,
+ SectionHeader {
+ sh_name: shstrtab.get_offset(shstrtab_str_id) as u32,
+ sh_type: elf::SHT_STRTAB,
+ sh_flags: 0,
+ sh_addr: 0,
+ sh_offset: shstrtab_offset as u64,
+ sh_size: shstrtab_data.len() as u64,
+ sh_link: 0,
+ sh_info: 0,
+ sh_addralign: 1,
+ sh_entsize: 0,
+ },
+ );
+
+ debug_assert_eq!(offset, buffer.len());
+
+ Ok(())
+ }
+}
+
+/// Native endian version of `FileHeader64`.
+struct FileHeader {
+ e_ident: elf::Ident,
+ e_type: u16,
+ e_machine: u16,
+ e_version: u32,
+ e_entry: u64,
+ e_phoff: u64,
+ e_shoff: u64,
+ e_flags: u32,
+ e_ehsize: u16,
+ e_phentsize: u16,
+ e_phnum: u16,
+ e_shentsize: u16,
+ e_shnum: u16,
+ e_shstrndx: u16,
+}
+
+/// Native endian version of `SectionHeader64`.
+struct SectionHeader {
+ sh_name: u32,
+ sh_type: u32,
+ sh_flags: u64,
+ sh_addr: u64,
+ sh_offset: u64,
+ sh_size: u64,
+ sh_link: u32,
+ sh_info: u32,
+ sh_addralign: u64,
+ sh_entsize: u64,
+}
+
+/// Native endian version of `Sym64`.
+struct Sym {
+ st_name: u32,
+ st_info: u8,
+ st_other: u8,
+ st_shndx: u16,
+ st_value: u64,
+ st_size: u64,
+}
+
+/// Unified native endian version of `Rel*`.
+struct Rel {
+ r_offset: u64,
+ r_sym: u32,
+ r_type: u32,
+ r_addend: i64,
+}
+
+trait Elf {
+ fn file_header_size(&self) -> usize;
+ fn section_header_size(&self) -> usize;
+ fn symbol_size(&self) -> usize;
+ fn rel_size(&self, is_rela: bool) -> usize;
+ fn write_file_header(&self, buffer: &mut dyn WritableBuffer, section: FileHeader);
+ fn write_section_header(&self, buffer: &mut dyn WritableBuffer, section: SectionHeader);
+ fn write_symbol(&self, buffer: &mut dyn WritableBuffer, symbol: Sym);
+ fn write_rel(
+ &self,
+ buffer: &mut dyn WritableBuffer,
+ is_mips64el: bool,
+ is_rela: bool,
+ rel: Rel,
+ );
+}
+
+struct Elf32<E> {
+ endian: E,
+}
+
+impl<E: Endian> Elf for Elf32<E> {
+ fn file_header_size(&self) -> usize {
+ mem::size_of::<elf::FileHeader32<E>>()
+ }
+
+ fn section_header_size(&self) -> usize {
+ mem::size_of::<elf::SectionHeader32<E>>()
+ }
+
+ fn symbol_size(&self) -> usize {
+ mem::size_of::<elf::Sym32<E>>()
+ }
+
+ fn rel_size(&self, is_rela: bool) -> usize {
+ if is_rela {
+ mem::size_of::<elf::Rela32<E>>()
+ } else {
+ mem::size_of::<elf::Rel32<E>>()
+ }
+ }
+
+ fn write_file_header(&self, buffer: &mut dyn WritableBuffer, file: FileHeader) {
+ let endian = self.endian;
+ let file = elf::FileHeader32 {
+ e_ident: file.e_ident,
+ e_type: U16::new(endian, file.e_type),
+ e_machine: U16::new(endian, file.e_machine),
+ e_version: U32::new(endian, file.e_version),
+ e_entry: U32::new(endian, file.e_entry as u32),
+ e_phoff: U32::new(endian, file.e_phoff as u32),
+ e_shoff: U32::new(endian, file.e_shoff as u32),
+ e_flags: U32::new(endian, file.e_flags),
+ e_ehsize: U16::new(endian, file.e_ehsize),
+ e_phentsize: U16::new(endian, file.e_phentsize),
+ e_phnum: U16::new(endian, file.e_phnum),
+ e_shentsize: U16::new(endian, file.e_shentsize),
+ e_shnum: U16::new(endian, file.e_shnum),
+ e_shstrndx: U16::new(endian, file.e_shstrndx),
+ };
+ buffer.write(&file);
+ }
+
+ fn write_section_header(&self, buffer: &mut dyn WritableBuffer, section: SectionHeader) {
+ let endian = self.endian;
+ let section = elf::SectionHeader32 {
+ sh_name: U32::new(endian, section.sh_name),
+ sh_type: U32::new(endian, section.sh_type),
+ sh_flags: U32::new(endian, section.sh_flags as u32),
+ sh_addr: U32::new(endian, section.sh_addr as u32),
+ sh_offset: U32::new(endian, section.sh_offset as u32),
+ sh_size: U32::new(endian, section.sh_size as u32),
+ sh_link: U32::new(endian, section.sh_link),
+ sh_info: U32::new(endian, section.sh_info),
+ sh_addralign: U32::new(endian, section.sh_addralign as u32),
+ sh_entsize: U32::new(endian, section.sh_entsize as u32),
+ };
+ buffer.write(&section);
+ }
+
+ fn write_symbol(&self, buffer: &mut dyn WritableBuffer, symbol: Sym) {
+ let endian = self.endian;
+ let symbol = elf::Sym32 {
+ st_name: U32::new(endian, symbol.st_name),
+ st_info: symbol.st_info,
+ st_other: symbol.st_other,
+ st_shndx: U16::new(endian, symbol.st_shndx),
+ st_value: U32::new(endian, symbol.st_value as u32),
+ st_size: U32::new(endian, symbol.st_size as u32),
+ };
+ buffer.write(&symbol);
+ }
+
+ fn write_rel(
+ &self,
+ buffer: &mut dyn WritableBuffer,
+ _is_mips64el: bool,
+ is_rela: bool,
+ rel: Rel,
+ ) {
+ let endian = self.endian;
+ if is_rela {
+ let rel = elf::Rela32 {
+ r_offset: U32::new(endian, rel.r_offset as u32),
+ r_info: elf::Rel32::r_info(endian, rel.r_sym, rel.r_type as u8),
+ r_addend: I32::new(endian, rel.r_addend as i32),
+ };
+ buffer.write(&rel);
+ } else {
+ let rel = elf::Rel32 {
+ r_offset: U32::new(endian, rel.r_offset as u32),
+ r_info: elf::Rel32::r_info(endian, rel.r_sym, rel.r_type as u8),
+ };
+ buffer.write(&rel);
+ }
+ }
+}
+
+struct Elf64<E> {
+ endian: E,
+}
+
+impl<E: Endian> Elf for Elf64<E> {
+ fn file_header_size(&self) -> usize {
+ mem::size_of::<elf::FileHeader64<E>>()
+ }
+
+ fn section_header_size(&self) -> usize {
+ mem::size_of::<elf::SectionHeader64<E>>()
+ }
+
+ fn symbol_size(&self) -> usize {
+ mem::size_of::<elf::Sym64<E>>()
+ }
+
+ fn rel_size(&self, is_rela: bool) -> usize {
+ if is_rela {
+ mem::size_of::<elf::Rela64<E>>()
+ } else {
+ mem::size_of::<elf::Rel64<E>>()
+ }
+ }
+
+ fn write_file_header(&self, buffer: &mut dyn WritableBuffer, file: FileHeader) {
+ let endian = self.endian;
+ let file = elf::FileHeader64 {
+ e_ident: file.e_ident,
+ e_type: U16::new(endian, file.e_type),
+ e_machine: U16::new(endian, file.e_machine),
+ e_version: U32::new(endian, file.e_version),
+ e_entry: U64::new(endian, file.e_entry),
+ e_phoff: U64::new(endian, file.e_phoff),
+ e_shoff: U64::new(endian, file.e_shoff),
+ e_flags: U32::new(endian, file.e_flags),
+ e_ehsize: U16::new(endian, file.e_ehsize),
+ e_phentsize: U16::new(endian, file.e_phentsize),
+ e_phnum: U16::new(endian, file.e_phnum),
+ e_shentsize: U16::new(endian, file.e_shentsize),
+ e_shnum: U16::new(endian, file.e_shnum),
+ e_shstrndx: U16::new(endian, file.e_shstrndx),
+ };
+ buffer.write(&file)
+ }
+
+ fn write_section_header(&self, buffer: &mut dyn WritableBuffer, section: SectionHeader) {
+ let endian = self.endian;
+ let section = elf::SectionHeader64 {
+ sh_name: U32::new(endian, section.sh_name),
+ sh_type: U32::new(endian, section.sh_type),
+ sh_flags: U64::new(endian, section.sh_flags),
+ sh_addr: U64::new(endian, section.sh_addr),
+ sh_offset: U64::new(endian, section.sh_offset),
+ sh_size: U64::new(endian, section.sh_size),
+ sh_link: U32::new(endian, section.sh_link),
+ sh_info: U32::new(endian, section.sh_info),
+ sh_addralign: U64::new(endian, section.sh_addralign),
+ sh_entsize: U64::new(endian, section.sh_entsize),
+ };
+ buffer.write(&section);
+ }
+
+ fn write_symbol(&self, buffer: &mut dyn WritableBuffer, symbol: Sym) {
+ let endian = self.endian;
+ let symbol = elf::Sym64 {
+ st_name: U32::new(endian, symbol.st_name),
+ st_info: symbol.st_info,
+ st_other: symbol.st_other,
+ st_shndx: U16::new(endian, symbol.st_shndx),
+ st_value: U64::new(endian, symbol.st_value),
+ st_size: U64::new(endian, symbol.st_size),
+ };
+ buffer.write(&symbol);
+ }
+
+ fn write_rel(
+ &self,
+ buffer: &mut dyn WritableBuffer,
+ is_mips64el: bool,
+ is_rela: bool,
+ rel: Rel,
+ ) {
+ let endian = self.endian;
+ if is_rela {
+ let rel = elf::Rela64 {
+ r_offset: U64::new(endian, rel.r_offset),
+ r_info: elf::Rela64::r_info(endian, is_mips64el, rel.r_sym, rel.r_type),
+ r_addend: I64::new(endian, rel.r_addend),
+ };
+ buffer.write(&rel);
+ } else {
+ let rel = elf::Rel64 {
+ r_offset: U64::new(endian, rel.r_offset),
+ r_info: elf::Rel64::r_info(endian, rel.r_sym, rel.r_type),
+ };
+ buffer.write(&rel);
+ }
+ }
+}
diff --git a/vendor/object-0.26.2/src/write/macho.rs b/vendor/object-0.26.2/src/write/macho.rs
new file mode 100644
index 000000000..ed25950d9
--- /dev/null
+++ b/vendor/object-0.26.2/src/write/macho.rs
@@ -0,0 +1,844 @@
+use std::mem;
+
+use crate::endian::*;
+use crate::macho;
+use crate::write::string::*;
+use crate::write::util::*;
+use crate::write::*;
+use crate::AddressSize;
+
+#[derive(Default, Clone, Copy)]
+struct SectionOffsets {
+ index: usize,
+ offset: usize,
+ address: u64,
+ reloc_offset: usize,
+}
+
+#[derive(Default, Clone, Copy)]
+struct SymbolOffsets {
+ emit: bool,
+ index: usize,
+ str_id: Option<StringId>,
+}
+
+impl Object {
+ pub(crate) fn macho_set_subsections_via_symbols(&mut self) {
+ let flags = match self.flags {
+ FileFlags::MachO { flags } => flags,
+ _ => 0,
+ };
+ self.flags = FileFlags::MachO {
+ flags: flags | macho::MH_SUBSECTIONS_VIA_SYMBOLS,
+ };
+ }
+
+ pub(crate) fn macho_segment_name(&self, segment: StandardSegment) -> &'static [u8] {
+ match segment {
+ StandardSegment::Text => &b"__TEXT"[..],
+ StandardSegment::Data => &b"__DATA"[..],
+ StandardSegment::Debug => &b"__DWARF"[..],
+ }
+ }
+
+ pub(crate) fn macho_section_info(
+ &self,
+ section: StandardSection,
+ ) -> (&'static [u8], &'static [u8], SectionKind) {
+ match section {
+ StandardSection::Text => (&b"__TEXT"[..], &b"__text"[..], SectionKind::Text),
+ StandardSection::Data => (&b"__DATA"[..], &b"__data"[..], SectionKind::Data),
+ StandardSection::ReadOnlyData => {
+ (&b"__TEXT"[..], &b"__const"[..], SectionKind::ReadOnlyData)
+ }
+ StandardSection::ReadOnlyDataWithRel => {
+ (&b"__DATA"[..], &b"__const"[..], SectionKind::ReadOnlyData)
+ }
+ StandardSection::ReadOnlyString => (
+ &b"__TEXT"[..],
+ &b"__cstring"[..],
+ SectionKind::ReadOnlyString,
+ ),
+ StandardSection::UninitializedData => (
+ &b"__DATA"[..],
+ &b"__bss"[..],
+ SectionKind::UninitializedData,
+ ),
+ StandardSection::Tls => (&b"__DATA"[..], &b"__thread_data"[..], SectionKind::Tls),
+ StandardSection::UninitializedTls => (
+ &b"__DATA"[..],
+ &b"__thread_bss"[..],
+ SectionKind::UninitializedTls,
+ ),
+ StandardSection::TlsVariables => (
+ &b"__DATA"[..],
+ &b"__thread_vars"[..],
+ SectionKind::TlsVariables,
+ ),
+ StandardSection::Common => (&b"__DATA"[..], &b"__common"[..], SectionKind::Common),
+ }
+ }
+
+ fn macho_tlv_bootstrap(&mut self) -> SymbolId {
+ match self.tlv_bootstrap {
+ Some(id) => id,
+ None => {
+ let id = self.add_symbol(Symbol {
+ name: b"_tlv_bootstrap".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Text,
+ scope: SymbolScope::Dynamic,
+ weak: false,
+ section: SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ self.tlv_bootstrap = Some(id);
+ id
+ }
+ }
+ }
+
+ /// Create the `__thread_vars` entry for a TLS variable.
+ ///
+ /// The symbol given by `symbol_id` will be updated to point to this entry.
+ ///
+ /// A new `SymbolId` will be returned. The caller must update this symbol
+ /// to point to the initializer.
+ ///
+ /// If `symbol_id` is not for a TLS variable, then it is returned unchanged.
+ pub(crate) fn macho_add_thread_var(&mut self, symbol_id: SymbolId) -> SymbolId {
+ let symbol = self.symbol_mut(symbol_id);
+ if symbol.kind != SymbolKind::Tls {
+ return symbol_id;
+ }
+
+ // Create the initializer symbol.
+ let mut name = symbol.name.clone();
+ name.extend_from_slice(b"$tlv$init");
+ let init_symbol_id = self.add_raw_symbol(Symbol {
+ name,
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Tls,
+ scope: SymbolScope::Compilation,
+ weak: false,
+ section: SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+
+ // Add the tlv entry.
+ // Three pointers in size:
+ // - __tlv_bootstrap - used to make sure support exists
+ // - spare pointer - used when mapped by the runtime
+ // - pointer to symbol initializer
+ let section = self.section_id(StandardSection::TlsVariables);
+ let address_size = self.architecture.address_size().unwrap().bytes();
+ let size = u64::from(address_size) * 3;
+ let data = vec![0; size as usize];
+ let offset = self.append_section_data(section, &data, u64::from(address_size));
+
+ let tlv_bootstrap = self.macho_tlv_bootstrap();
+ self.add_relocation(
+ section,
+ Relocation {
+ offset,
+ size: address_size * 8,
+ kind: RelocationKind::Absolute,
+ encoding: RelocationEncoding::Generic,
+ symbol: tlv_bootstrap,
+ addend: 0,
+ },
+ )
+ .unwrap();
+ self.add_relocation(
+ section,
+ Relocation {
+ offset: offset + u64::from(address_size) * 2,
+ size: address_size * 8,
+ kind: RelocationKind::Absolute,
+ encoding: RelocationEncoding::Generic,
+ symbol: init_symbol_id,
+ addend: 0,
+ },
+ )
+ .unwrap();
+
+ // Update the symbol to point to the tlv.
+ let symbol = self.symbol_mut(symbol_id);
+ symbol.value = offset;
+ symbol.size = size;
+ symbol.section = SymbolSection::Section(section);
+
+ init_symbol_id
+ }
+
+ pub(crate) fn macho_fixup_relocation(&mut self, mut relocation: &mut Relocation) -> i64 {
+ let constant = match relocation.kind {
+ RelocationKind::Relative
+ | RelocationKind::GotRelative
+ | RelocationKind::PltRelative => relocation.addend + 4,
+ _ => relocation.addend,
+ };
+ relocation.addend -= constant;
+ constant
+ }
+
+ pub(crate) fn macho_write(&self, buffer: &mut dyn WritableBuffer) -> Result<()> {
+ let address_size = self.architecture.address_size().unwrap();
+ let endian = self.endian;
+ let macho32 = MachO32 { endian };
+ let macho64 = MachO64 { endian };
+ let macho: &dyn MachO = match address_size {
+ AddressSize::U8 | AddressSize::U16 | AddressSize::U32 => &macho32,
+ AddressSize::U64 => &macho64,
+ };
+ let pointer_align = address_size.bytes() as usize;
+
+ // Calculate offsets of everything, and build strtab.
+ let mut offset = 0;
+
+ // Calculate size of Mach-O header.
+ offset += macho.mach_header_size();
+
+ // Calculate size of commands.
+ let mut ncmds = 0;
+ let command_offset = offset;
+
+ // Calculate size of segment command and section headers.
+ let segment_command_offset = offset;
+ let segment_command_len =
+ macho.segment_command_size() + self.sections.len() * macho.section_header_size();
+ offset += segment_command_len;
+ ncmds += 1;
+
+ // Calculate size of symtab command.
+ let symtab_command_offset = offset;
+ let symtab_command_len = mem::size_of::<macho::SymtabCommand<Endianness>>();
+ offset += symtab_command_len;
+ ncmds += 1;
+
+ let sizeofcmds = offset - command_offset;
+
+ // Calculate size of section data.
+ let mut segment_file_offset = None;
+ let mut section_offsets = vec![SectionOffsets::default(); self.sections.len()];
+ let mut address = 0;
+ for (index, section) in self.sections.iter().enumerate() {
+ section_offsets[index].index = 1 + index;
+ if !section.is_bss() {
+ let len = section.data.len();
+ if len != 0 {
+ offset = align(offset, section.align as usize);
+ section_offsets[index].offset = offset;
+ if segment_file_offset.is_none() {
+ segment_file_offset = Some(offset);
+ }
+ offset += len;
+ } else {
+ section_offsets[index].offset = offset;
+ }
+ address = align_u64(address, section.align);
+ section_offsets[index].address = address;
+ address += section.size;
+ }
+ }
+ for (index, section) in self.sections.iter().enumerate() {
+ if section.kind.is_bss() {
+ assert!(section.data.is_empty());
+ address = align_u64(address, section.align);
+ section_offsets[index].address = address;
+ address += section.size;
+ }
+ }
+ let segment_file_offset = segment_file_offset.unwrap_or(offset);
+ let segment_file_size = offset - segment_file_offset;
+ debug_assert!(segment_file_size as u64 <= address);
+
+ // Count symbols and add symbol strings to strtab.
+ let mut strtab = StringTable::default();
+ let mut symbol_offsets = vec![SymbolOffsets::default(); self.symbols.len()];
+ let mut nsyms = 0;
+ for (index, symbol) in self.symbols.iter().enumerate() {
+ // The unified API allows creating symbols that we don't emit, so filter
+ // them out here.
+ //
+ // Since we don't actually emit the symbol kind, we validate it here too.
+ match symbol.kind {
+ SymbolKind::Text | SymbolKind::Data | SymbolKind::Tls => {}
+ SymbolKind::File | SymbolKind::Section => continue,
+ SymbolKind::Unknown => {
+ if symbol.section != SymbolSection::Undefined {
+ return Err(Error(format!(
+ "defined symbol `{}` with unknown kind",
+ symbol.name().unwrap_or(""),
+ )));
+ }
+ }
+ SymbolKind::Null | SymbolKind::Label => {
+ return Err(Error(format!(
+ "unimplemented symbol `{}` kind {:?}",
+ symbol.name().unwrap_or(""),
+ symbol.kind
+ )));
+ }
+ }
+ symbol_offsets[index].emit = true;
+ symbol_offsets[index].index = nsyms;
+ nsyms += 1;
+ if !symbol.name.is_empty() {
+ symbol_offsets[index].str_id = Some(strtab.add(&symbol.name));
+ }
+ }
+
+ // Calculate size of symtab.
+ offset = align(offset, pointer_align);
+ let symtab_offset = offset;
+ let symtab_len = nsyms * macho.nlist_size();
+ offset += symtab_len;
+
+ // Calculate size of strtab.
+ let strtab_offset = offset;
+ // Start with null name.
+ let mut strtab_data = vec![0];
+ strtab.write(1, &mut strtab_data);
+ offset += strtab_data.len();
+
+ // Calculate size of relocations.
+ for (index, section) in self.sections.iter().enumerate() {
+ let count = section.relocations.len();
+ if count != 0 {
+ offset = align(offset, 4);
+ section_offsets[index].reloc_offset = offset;
+ let len = count * mem::size_of::<macho::Relocation<Endianness>>();
+ offset += len;
+ }
+ }
+
+ // Start writing.
+ buffer
+ .reserve(offset)
+ .map_err(|_| Error(String::from("Cannot allocate buffer")))?;
+
+ // Write file header.
+ let (cputype, cpusubtype) = match self.architecture {
+ Architecture::Arm => (macho::CPU_TYPE_ARM, macho::CPU_SUBTYPE_ARM_ALL),
+ Architecture::Aarch64 => (macho::CPU_TYPE_ARM64, macho::CPU_SUBTYPE_ARM64_ALL),
+ Architecture::I386 => (macho::CPU_TYPE_X86, macho::CPU_SUBTYPE_I386_ALL),
+ Architecture::X86_64 => (macho::CPU_TYPE_X86_64, macho::CPU_SUBTYPE_X86_64_ALL),
+ _ => {
+ return Err(Error(format!(
+ "unimplemented architecture {:?}",
+ self.architecture
+ )));
+ }
+ };
+
+ let flags = match self.flags {
+ FileFlags::MachO { flags } => flags,
+ _ => 0,
+ };
+ macho.write_mach_header(
+ buffer,
+ MachHeader {
+ cputype,
+ cpusubtype,
+ filetype: macho::MH_OBJECT,
+ ncmds,
+ sizeofcmds: sizeofcmds as u32,
+ flags,
+ },
+ );
+
+ // Write segment command.
+ debug_assert_eq!(segment_command_offset, buffer.len());
+ macho.write_segment_command(
+ buffer,
+ SegmentCommand {
+ cmdsize: segment_command_len as u32,
+ segname: [0; 16],
+ vmaddr: 0,
+ vmsize: address,
+ fileoff: segment_file_offset as u64,
+ filesize: segment_file_size as u64,
+ maxprot: macho::VM_PROT_READ | macho::VM_PROT_WRITE | macho::VM_PROT_EXECUTE,
+ initprot: macho::VM_PROT_READ | macho::VM_PROT_WRITE | macho::VM_PROT_EXECUTE,
+ nsects: self.sections.len() as u32,
+ flags: 0,
+ },
+ );
+
+ // Write section headers.
+ for (index, section) in self.sections.iter().enumerate() {
+ let mut sectname = [0; 16];
+ sectname
+ .get_mut(..section.name.len())
+ .ok_or_else(|| {
+ Error(format!(
+ "section name `{}` is too long",
+ section.name().unwrap_or(""),
+ ))
+ })?
+ .copy_from_slice(&section.name);
+ let mut segname = [0; 16];
+ segname
+ .get_mut(..section.segment.len())
+ .ok_or_else(|| {
+ Error(format!(
+ "segment name `{}` is too long",
+ section.segment().unwrap_or(""),
+ ))
+ })?
+ .copy_from_slice(&section.segment);
+ let flags = if let SectionFlags::MachO { flags } = section.flags {
+ flags
+ } else {
+ match section.kind {
+ SectionKind::Text => {
+ macho::S_ATTR_PURE_INSTRUCTIONS | macho::S_ATTR_SOME_INSTRUCTIONS
+ }
+ SectionKind::Data => 0,
+ SectionKind::ReadOnlyData => 0,
+ SectionKind::ReadOnlyString => macho::S_CSTRING_LITERALS,
+ SectionKind::UninitializedData | SectionKind::Common => macho::S_ZEROFILL,
+ SectionKind::Tls => macho::S_THREAD_LOCAL_REGULAR,
+ SectionKind::UninitializedTls => macho::S_THREAD_LOCAL_ZEROFILL,
+ SectionKind::TlsVariables => macho::S_THREAD_LOCAL_VARIABLES,
+ SectionKind::Debug => macho::S_ATTR_DEBUG,
+ SectionKind::OtherString => macho::S_CSTRING_LITERALS,
+ SectionKind::Other | SectionKind::Linker | SectionKind::Metadata => 0,
+ SectionKind::Note | SectionKind::Unknown | SectionKind::Elf(_) => {
+ return Err(Error(format!(
+ "unimplemented section `{}` kind {:?}",
+ section.name().unwrap_or(""),
+ section.kind
+ )));
+ }
+ }
+ };
+ macho.write_section(
+ buffer,
+ SectionHeader {
+ sectname,
+ segname,
+ addr: section_offsets[index].address,
+ size: section.size,
+ offset: section_offsets[index].offset as u32,
+ align: section.align.trailing_zeros(),
+ reloff: section_offsets[index].reloc_offset as u32,
+ nreloc: section.relocations.len() as u32,
+ flags,
+ },
+ );
+ }
+
+ // Write symtab command.
+ debug_assert_eq!(symtab_command_offset, buffer.len());
+ let symtab_command = macho::SymtabCommand {
+ cmd: U32::new(endian, macho::LC_SYMTAB),
+ cmdsize: U32::new(endian, symtab_command_len as u32),
+ symoff: U32::new(endian, symtab_offset as u32),
+ nsyms: U32::new(endian, nsyms as u32),
+ stroff: U32::new(endian, strtab_offset as u32),
+ strsize: U32::new(endian, strtab_data.len() as u32),
+ };
+ buffer.write(&symtab_command);
+
+ // Write section data.
+ for (index, section) in self.sections.iter().enumerate() {
+ let len = section.data.len();
+ if len != 0 {
+ write_align(buffer, section.align as usize);
+ debug_assert_eq!(section_offsets[index].offset, buffer.len());
+ buffer.write_bytes(&section.data);
+ }
+ }
+ debug_assert_eq!(segment_file_offset + segment_file_size, buffer.len());
+
+ // Write symtab.
+ write_align(buffer, pointer_align);
+ debug_assert_eq!(symtab_offset, buffer.len());
+ for (index, symbol) in self.symbols.iter().enumerate() {
+ if !symbol_offsets[index].emit {
+ continue;
+ }
+ // TODO: N_STAB
+ let (mut n_type, n_sect) = match symbol.section {
+ SymbolSection::Undefined => (macho::N_UNDF | macho::N_EXT, 0),
+ SymbolSection::Absolute => (macho::N_ABS, 0),
+ SymbolSection::Section(id) => (macho::N_SECT, id.0 + 1),
+ SymbolSection::None | SymbolSection::Common => {
+ return Err(Error(format!(
+ "unimplemented symbol `{}` section {:?}",
+ symbol.name().unwrap_or(""),
+ symbol.section
+ )));
+ }
+ };
+ match symbol.scope {
+ SymbolScope::Unknown | SymbolScope::Compilation => {}
+ SymbolScope::Linkage => {
+ n_type |= macho::N_EXT | macho::N_PEXT;
+ }
+ SymbolScope::Dynamic => {
+ n_type |= macho::N_EXT;
+ }
+ }
+
+ let n_desc = if let SymbolFlags::MachO { n_desc } = symbol.flags {
+ n_desc
+ } else {
+ let mut n_desc = 0;
+ if symbol.weak {
+ if symbol.is_undefined() {
+ n_desc |= macho::N_WEAK_REF;
+ } else {
+ n_desc |= macho::N_WEAK_DEF;
+ }
+ }
+ n_desc
+ };
+
+ let n_value = match symbol.section.id() {
+ Some(section) => section_offsets[section.0].address + symbol.value,
+ None => symbol.value,
+ };
+
+ let n_strx = symbol_offsets[index]
+ .str_id
+ .map(|id| strtab.get_offset(id))
+ .unwrap_or(0);
+
+ macho.write_nlist(
+ buffer,
+ Nlist {
+ n_strx: n_strx as u32,
+ n_type,
+ n_sect: n_sect as u8,
+ n_desc,
+ n_value,
+ },
+ );
+ }
+
+ // Write strtab.
+ debug_assert_eq!(strtab_offset, buffer.len());
+ buffer.write_bytes(&strtab_data);
+
+ // Write relocations.
+ for (index, section) in self.sections.iter().enumerate() {
+ if !section.relocations.is_empty() {
+ write_align(buffer, 4);
+ debug_assert_eq!(section_offsets[index].reloc_offset, buffer.len());
+ for reloc in &section.relocations {
+ let r_extern;
+ let r_symbolnum;
+ let symbol = &self.symbols[reloc.symbol.0];
+ if symbol.kind == SymbolKind::Section {
+ r_symbolnum = section_offsets[symbol.section.id().unwrap().0].index as u32;
+ r_extern = false;
+ } else {
+ r_symbolnum = symbol_offsets[reloc.symbol.0].index as u32;
+ r_extern = true;
+ }
+ let r_length = match reloc.size {
+ 8 => 0,
+ 16 => 1,
+ 32 => 2,
+ 64 => 3,
+ _ => return Err(Error(format!("unimplemented reloc size {:?}", reloc))),
+ };
+ let (r_pcrel, r_type) = match self.architecture {
+ Architecture::I386 => match reloc.kind {
+ RelocationKind::Absolute => (false, macho::GENERIC_RELOC_VANILLA),
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ Architecture::X86_64 => match (reloc.kind, reloc.encoding, reloc.addend) {
+ (RelocationKind::Absolute, RelocationEncoding::Generic, 0) => {
+ (false, macho::X86_64_RELOC_UNSIGNED)
+ }
+ (RelocationKind::Relative, RelocationEncoding::Generic, -4) => {
+ (true, macho::X86_64_RELOC_SIGNED)
+ }
+ (RelocationKind::Relative, RelocationEncoding::X86RipRelative, -4) => {
+ (true, macho::X86_64_RELOC_SIGNED)
+ }
+ (RelocationKind::Relative, RelocationEncoding::X86Branch, -4) => {
+ (true, macho::X86_64_RELOC_BRANCH)
+ }
+ (RelocationKind::PltRelative, RelocationEncoding::X86Branch, -4) => {
+ (true, macho::X86_64_RELOC_BRANCH)
+ }
+ (RelocationKind::GotRelative, RelocationEncoding::Generic, -4) => {
+ (true, macho::X86_64_RELOC_GOT)
+ }
+ (
+ RelocationKind::GotRelative,
+ RelocationEncoding::X86RipRelativeMovq,
+ -4,
+ ) => (true, macho::X86_64_RELOC_GOT_LOAD),
+ (RelocationKind::MachO { value, relative }, _, _) => (relative, value),
+ _ => {
+ return Err(Error(format!("unimplemented relocation {:?}", reloc)));
+ }
+ },
+ _ => {
+ return Err(Error(format!(
+ "unimplemented architecture {:?}",
+ self.architecture
+ )));
+ }
+ };
+ let reloc_info = macho::RelocationInfo {
+ r_address: reloc.offset as u32,
+ r_symbolnum,
+ r_pcrel,
+ r_length,
+ r_extern,
+ r_type,
+ };
+ buffer.write(&reloc_info.relocation(endian));
+ }
+ }
+ }
+
+ debug_assert_eq!(offset, buffer.len());
+
+ Ok(())
+ }
+}
+
+struct MachHeader {
+ cputype: u32,
+ cpusubtype: u32,
+ filetype: u32,
+ ncmds: u32,
+ sizeofcmds: u32,
+ flags: u32,
+}
+
+struct SegmentCommand {
+ cmdsize: u32,
+ segname: [u8; 16],
+ vmaddr: u64,
+ vmsize: u64,
+ fileoff: u64,
+ filesize: u64,
+ maxprot: u32,
+ initprot: u32,
+ nsects: u32,
+ flags: u32,
+}
+
+pub struct SectionHeader {
+ sectname: [u8; 16],
+ segname: [u8; 16],
+ addr: u64,
+ size: u64,
+ offset: u32,
+ align: u32,
+ reloff: u32,
+ nreloc: u32,
+ flags: u32,
+}
+
+struct Nlist {
+ n_strx: u32,
+ n_type: u8,
+ n_sect: u8,
+ n_desc: u16,
+ n_value: u64,
+}
+
+trait MachO {
+ fn mach_header_size(&self) -> usize;
+ fn segment_command_size(&self) -> usize;
+ fn section_header_size(&self) -> usize;
+ fn nlist_size(&self) -> usize;
+ fn write_mach_header(&self, buffer: &mut dyn WritableBuffer, section: MachHeader);
+ fn write_segment_command(&self, buffer: &mut dyn WritableBuffer, segment: SegmentCommand);
+ fn write_section(&self, buffer: &mut dyn WritableBuffer, section: SectionHeader);
+ fn write_nlist(&self, buffer: &mut dyn WritableBuffer, nlist: Nlist);
+}
+
+struct MachO32<E> {
+ endian: E,
+}
+
+impl<E: Endian> MachO for MachO32<E> {
+ fn mach_header_size(&self) -> usize {
+ mem::size_of::<macho::MachHeader32<E>>()
+ }
+
+ fn segment_command_size(&self) -> usize {
+ mem::size_of::<macho::SegmentCommand32<E>>()
+ }
+
+ fn section_header_size(&self) -> usize {
+ mem::size_of::<macho::Section32<E>>()
+ }
+
+ fn nlist_size(&self) -> usize {
+ mem::size_of::<macho::Nlist32<E>>()
+ }
+
+ fn write_mach_header(&self, buffer: &mut dyn WritableBuffer, header: MachHeader) {
+ let endian = self.endian;
+ let magic = if endian.is_big_endian() {
+ macho::MH_MAGIC
+ } else {
+ macho::MH_CIGAM
+ };
+ let header = macho::MachHeader32 {
+ magic: U32::new(BigEndian, magic),
+ cputype: U32::new(endian, header.cputype),
+ cpusubtype: U32::new(endian, header.cpusubtype),
+ filetype: U32::new(endian, header.filetype),
+ ncmds: U32::new(endian, header.ncmds),
+ sizeofcmds: U32::new(endian, header.sizeofcmds),
+ flags: U32::new(endian, header.flags),
+ };
+ buffer.write(&header);
+ }
+
+ fn write_segment_command(&self, buffer: &mut dyn WritableBuffer, segment: SegmentCommand) {
+ let endian = self.endian;
+ let segment = macho::SegmentCommand32 {
+ cmd: U32::new(endian, macho::LC_SEGMENT),
+ cmdsize: U32::new(endian, segment.cmdsize),
+ segname: segment.segname,
+ vmaddr: U32::new(endian, segment.vmaddr as u32),
+ vmsize: U32::new(endian, segment.vmsize as u32),
+ fileoff: U32::new(endian, segment.fileoff as u32),
+ filesize: U32::new(endian, segment.filesize as u32),
+ maxprot: U32::new(endian, segment.maxprot),
+ initprot: U32::new(endian, segment.initprot),
+ nsects: U32::new(endian, segment.nsects),
+ flags: U32::new(endian, segment.flags),
+ };
+ buffer.write(&segment);
+ }
+
+ fn write_section(&self, buffer: &mut dyn WritableBuffer, section: SectionHeader) {
+ let endian = self.endian;
+ let section = macho::Section32 {
+ sectname: section.sectname,
+ segname: section.segname,
+ addr: U32::new(endian, section.addr as u32),
+ size: U32::new(endian, section.size as u32),
+ offset: U32::new(endian, section.offset),
+ align: U32::new(endian, section.align),
+ reloff: U32::new(endian, section.reloff),
+ nreloc: U32::new(endian, section.nreloc),
+ flags: U32::new(endian, section.flags),
+ reserved1: U32::default(),
+ reserved2: U32::default(),
+ };
+ buffer.write(&section);
+ }
+
+ fn write_nlist(&self, buffer: &mut dyn WritableBuffer, nlist: Nlist) {
+ let endian = self.endian;
+ let nlist = macho::Nlist32 {
+ n_strx: U32::new(endian, nlist.n_strx),
+ n_type: nlist.n_type,
+ n_sect: nlist.n_sect,
+ n_desc: U16::new(endian, nlist.n_desc),
+ n_value: U32::new(endian, nlist.n_value as u32),
+ };
+ buffer.write(&nlist);
+ }
+}
+
+struct MachO64<E> {
+ endian: E,
+}
+
+impl<E: Endian> MachO for MachO64<E> {
+ fn mach_header_size(&self) -> usize {
+ mem::size_of::<macho::MachHeader64<E>>()
+ }
+
+ fn segment_command_size(&self) -> usize {
+ mem::size_of::<macho::SegmentCommand64<E>>()
+ }
+
+ fn section_header_size(&self) -> usize {
+ mem::size_of::<macho::Section64<E>>()
+ }
+
+ fn nlist_size(&self) -> usize {
+ mem::size_of::<macho::Nlist64<E>>()
+ }
+
+ fn write_mach_header(&self, buffer: &mut dyn WritableBuffer, header: MachHeader) {
+ let endian = self.endian;
+ let magic = if endian.is_big_endian() {
+ macho::MH_MAGIC_64
+ } else {
+ macho::MH_CIGAM_64
+ };
+ let header = macho::MachHeader64 {
+ magic: U32::new(BigEndian, magic),
+ cputype: U32::new(endian, header.cputype),
+ cpusubtype: U32::new(endian, header.cpusubtype),
+ filetype: U32::new(endian, header.filetype),
+ ncmds: U32::new(endian, header.ncmds),
+ sizeofcmds: U32::new(endian, header.sizeofcmds),
+ flags: U32::new(endian, header.flags),
+ reserved: U32::default(),
+ };
+ buffer.write(&header);
+ }
+
+ fn write_segment_command(&self, buffer: &mut dyn WritableBuffer, segment: SegmentCommand) {
+ let endian = self.endian;
+ let segment = macho::SegmentCommand64 {
+ cmd: U32::new(endian, macho::LC_SEGMENT_64),
+ cmdsize: U32::new(endian, segment.cmdsize),
+ segname: segment.segname,
+ vmaddr: U64::new(endian, segment.vmaddr),
+ vmsize: U64::new(endian, segment.vmsize),
+ fileoff: U64::new(endian, segment.fileoff),
+ filesize: U64::new(endian, segment.filesize),
+ maxprot: U32::new(endian, segment.maxprot),
+ initprot: U32::new(endian, segment.initprot),
+ nsects: U32::new(endian, segment.nsects),
+ flags: U32::new(endian, segment.flags),
+ };
+ buffer.write(&segment);
+ }
+
+ fn write_section(&self, buffer: &mut dyn WritableBuffer, section: SectionHeader) {
+ let endian = self.endian;
+ let section = macho::Section64 {
+ sectname: section.sectname,
+ segname: section.segname,
+ addr: U64::new(endian, section.addr),
+ size: U64::new(endian, section.size),
+ offset: U32::new(endian, section.offset),
+ align: U32::new(endian, section.align),
+ reloff: U32::new(endian, section.reloff),
+ nreloc: U32::new(endian, section.nreloc),
+ flags: U32::new(endian, section.flags),
+ reserved1: U32::default(),
+ reserved2: U32::default(),
+ reserved3: U32::default(),
+ };
+ buffer.write(&section);
+ }
+
+ fn write_nlist(&self, buffer: &mut dyn WritableBuffer, nlist: Nlist) {
+ let endian = self.endian;
+ let nlist = macho::Nlist64 {
+ n_strx: U32::new(endian, nlist.n_strx),
+ n_type: nlist.n_type,
+ n_sect: nlist.n_sect,
+ n_desc: U16::new(endian, nlist.n_desc),
+ n_value: U64Bytes::new(endian, nlist.n_value),
+ };
+ buffer.write(&nlist);
+ }
+}
diff --git a/vendor/object-0.26.2/src/write/mod.rs b/vendor/object-0.26.2/src/write/mod.rs
new file mode 100644
index 000000000..747e2a02e
--- /dev/null
+++ b/vendor/object-0.26.2/src/write/mod.rs
@@ -0,0 +1,858 @@
+//! Interface for writing object files.
+
+use std::collections::HashMap;
+use std::string::String;
+use std::vec::Vec;
+use std::{error, fmt, result, str};
+
+use crate::endian::{Endianness, U32, U64};
+use crate::{
+ Architecture, BinaryFormat, ComdatKind, FileFlags, RelocationEncoding, RelocationKind,
+ SectionFlags, SectionKind, SymbolFlags, SymbolKind, SymbolScope,
+};
+
+#[cfg(feature = "coff")]
+mod coff;
+#[cfg(feature = "elf")]
+mod elf;
+#[cfg(feature = "macho")]
+mod macho;
+mod string;
+mod util;
+pub use util::*;
+
+/// The error type used within the write module.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct Error(String);
+
+impl fmt::Display for Error {
+ #[inline]
+ fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+ f.write_str(&self.0)
+ }
+}
+
+impl error::Error for Error {}
+
+/// The result type used within the write module.
+pub type Result<T> = result::Result<T, Error>;
+
+/// A writable object file.
+#[derive(Debug)]
+pub struct Object {
+ format: BinaryFormat,
+ architecture: Architecture,
+ endian: Endianness,
+ sections: Vec<Section>,
+ standard_sections: HashMap<StandardSection, SectionId>,
+ symbols: Vec<Symbol>,
+ symbol_map: HashMap<Vec<u8>, SymbolId>,
+ stub_symbols: HashMap<SymbolId, SymbolId>,
+ comdats: Vec<Comdat>,
+ /// File flags that are specific to each file format.
+ pub flags: FileFlags,
+ /// The symbol name mangling scheme.
+ pub mangling: Mangling,
+ /// Mach-O "_tlv_bootstrap" symbol.
+ tlv_bootstrap: Option<SymbolId>,
+}
+
+impl Object {
+ /// Create an empty object file.
+ pub fn new(format: BinaryFormat, architecture: Architecture, endian: Endianness) -> Object {
+ Object {
+ format,
+ architecture,
+ endian,
+ sections: Vec::new(),
+ standard_sections: HashMap::new(),
+ symbols: Vec::new(),
+ symbol_map: HashMap::new(),
+ stub_symbols: HashMap::new(),
+ comdats: Vec::new(),
+ flags: FileFlags::None,
+ mangling: Mangling::default(format, architecture),
+ tlv_bootstrap: None,
+ }
+ }
+
+ /// Return the file format.
+ #[inline]
+ pub fn format(&self) -> BinaryFormat {
+ self.format
+ }
+
+ /// Return the architecture.
+ #[inline]
+ pub fn architecture(&self) -> Architecture {
+ self.architecture
+ }
+
+ /// Return the current mangling setting.
+ #[inline]
+ pub fn mangling(&self) -> Mangling {
+ self.mangling
+ }
+
+ /// Specify the mangling setting.
+ #[inline]
+ pub fn set_mangling(&mut self, mangling: Mangling) {
+ self.mangling = mangling;
+ }
+
+ /// Return the name for a standard segment.
+ ///
+ /// This will vary based on the file format.
+ #[allow(unused_variables)]
+ pub fn segment_name(&self, segment: StandardSegment) -> &'static [u8] {
+ match self.format {
+ #[cfg(feature = "coff")]
+ BinaryFormat::Coff => &[],
+ #[cfg(feature = "elf")]
+ BinaryFormat::Elf => &[],
+ #[cfg(feature = "macho")]
+ BinaryFormat::MachO => self.macho_segment_name(segment),
+ _ => unimplemented!(),
+ }
+ }
+
+ /// Get the section with the given `SectionId`.
+ #[inline]
+ pub fn section(&self, section: SectionId) -> &Section {
+ &self.sections[section.0]
+ }
+
+ /// Mutably get the section with the given `SectionId`.
+ #[inline]
+ pub fn section_mut(&mut self, section: SectionId) -> &mut Section {
+ &mut self.sections[section.0]
+ }
+
+ /// Append data to an existing section. Returns the section offset of the data.
+ pub fn append_section_data(&mut self, section: SectionId, data: &[u8], align: u64) -> u64 {
+ self.sections[section.0].append_data(data, align)
+ }
+
+ /// Append zero-initialized data to an existing section. Returns the section offset of the data.
+ pub fn append_section_bss(&mut self, section: SectionId, size: u64, align: u64) -> u64 {
+ self.sections[section.0].append_bss(size, align)
+ }
+
+ /// Return the `SectionId` of a standard section.
+ ///
+ /// If the section doesn't already exist then it is created.
+ pub fn section_id(&mut self, section: StandardSection) -> SectionId {
+ self.standard_sections
+ .get(&section)
+ .cloned()
+ .unwrap_or_else(|| {
+ let (segment, name, kind) = self.section_info(section);
+ self.add_section(segment.to_vec(), name.to_vec(), kind)
+ })
+ }
+
+ /// Add a new section and return its `SectionId`.
+ ///
+ /// This also creates a section symbol.
+ pub fn add_section(&mut self, segment: Vec<u8>, name: Vec<u8>, kind: SectionKind) -> SectionId {
+ let id = SectionId(self.sections.len());
+ self.sections.push(Section {
+ segment,
+ name,
+ kind,
+ size: 0,
+ align: 1,
+ data: Vec::new(),
+ relocations: Vec::new(),
+ symbol: None,
+ flags: SectionFlags::None,
+ });
+
+ // Add to self.standard_sections if required. This may match multiple standard sections.
+ let section = &self.sections[id.0];
+ for standard_section in StandardSection::all() {
+ if !self.standard_sections.contains_key(standard_section) {
+ let (segment, name, kind) = self.section_info(*standard_section);
+ if segment == &*section.segment && name == &*section.name && kind == section.kind {
+ self.standard_sections.insert(*standard_section, id);
+ }
+ }
+ }
+
+ id
+ }
+
+ fn section_info(
+ &self,
+ section: StandardSection,
+ ) -> (&'static [u8], &'static [u8], SectionKind) {
+ match self.format {
+ #[cfg(feature = "coff")]
+ BinaryFormat::Coff => self.coff_section_info(section),
+ #[cfg(feature = "elf")]
+ BinaryFormat::Elf => self.elf_section_info(section),
+ #[cfg(feature = "macho")]
+ BinaryFormat::MachO => self.macho_section_info(section),
+ _ => unimplemented!(),
+ }
+ }
+
+ /// Add a subsection. Returns the `SectionId` and section offset of the data.
+ pub fn add_subsection(
+ &mut self,
+ section: StandardSection,
+ name: &[u8],
+ data: &[u8],
+ align: u64,
+ ) -> (SectionId, u64) {
+ let section_id = if self.has_subsections_via_symbols() {
+ self.set_subsections_via_symbols();
+ self.section_id(section)
+ } else {
+ let (segment, name, kind) = self.subsection_info(section, name);
+ self.add_section(segment.to_vec(), name, kind)
+ };
+ let offset = self.append_section_data(section_id, data, align);
+ (section_id, offset)
+ }
+
+ fn has_subsections_via_symbols(&self) -> bool {
+ match self.format {
+ BinaryFormat::Coff | BinaryFormat::Elf => false,
+ BinaryFormat::MachO => true,
+ _ => unimplemented!(),
+ }
+ }
+
+ fn set_subsections_via_symbols(&mut self) {
+ match self.format {
+ #[cfg(feature = "macho")]
+ BinaryFormat::MachO => self.macho_set_subsections_via_symbols(),
+ _ => unimplemented!(),
+ }
+ }
+
+ fn subsection_info(
+ &self,
+ section: StandardSection,
+ value: &[u8],
+ ) -> (&'static [u8], Vec<u8>, SectionKind) {
+ let (segment, section, kind) = self.section_info(section);
+ let name = self.subsection_name(section, value);
+ (segment, name, kind)
+ }
+
+ #[allow(unused_variables)]
+ fn subsection_name(&self, section: &[u8], value: &[u8]) -> Vec<u8> {
+ debug_assert!(!self.has_subsections_via_symbols());
+ match self.format {
+ #[cfg(feature = "coff")]
+ BinaryFormat::Coff => self.coff_subsection_name(section, value),
+ #[cfg(feature = "elf")]
+ BinaryFormat::Elf => self.elf_subsection_name(section, value),
+ _ => unimplemented!(),
+ }
+ }
+
+ /// Get the COMDAT section group with the given `ComdatId`.
+ #[inline]
+ pub fn comdat(&self, comdat: ComdatId) -> &Comdat {
+ &self.comdats[comdat.0]
+ }
+
+ /// Mutably get the COMDAT section group with the given `ComdatId`.
+ #[inline]
+ pub fn comdat_mut(&mut self, comdat: ComdatId) -> &mut Comdat {
+ &mut self.comdats[comdat.0]
+ }
+
+ /// Add a new COMDAT section group and return its `ComdatId`.
+ pub fn add_comdat(&mut self, comdat: Comdat) -> ComdatId {
+ let comdat_id = ComdatId(self.comdats.len());
+ self.comdats.push(comdat);
+ comdat_id
+ }
+
+ /// Get the `SymbolId` of the symbol with the given name.
+ pub fn symbol_id(&self, name: &[u8]) -> Option<SymbolId> {
+ self.symbol_map.get(name).cloned()
+ }
+
+ /// Get the symbol with the given `SymbolId`.
+ #[inline]
+ pub fn symbol(&self, symbol: SymbolId) -> &Symbol {
+ &self.symbols[symbol.0]
+ }
+
+ /// Mutably get the symbol with the given `SymbolId`.
+ #[inline]
+ pub fn symbol_mut(&mut self, symbol: SymbolId) -> &mut Symbol {
+ &mut self.symbols[symbol.0]
+ }
+
+ /// Add a new symbol and return its `SymbolId`.
+ pub fn add_symbol(&mut self, mut symbol: Symbol) -> SymbolId {
+ // Defined symbols must have a scope.
+ debug_assert!(symbol.is_undefined() || symbol.scope != SymbolScope::Unknown);
+ if symbol.kind == SymbolKind::Section {
+ // There can only be one section symbol, but update its flags, since
+ // the automatically generated section symbol will have none.
+ let symbol_id = self.section_symbol(symbol.section.id().unwrap());
+ if symbol.flags != SymbolFlags::None {
+ self.symbol_mut(symbol_id).flags = symbol.flags;
+ }
+ return symbol_id;
+ }
+ if !symbol.name.is_empty()
+ && (symbol.kind == SymbolKind::Text
+ || symbol.kind == SymbolKind::Data
+ || symbol.kind == SymbolKind::Tls)
+ {
+ let unmangled_name = symbol.name.clone();
+ if let Some(prefix) = self.mangling.global_prefix() {
+ symbol.name.insert(0, prefix);
+ }
+ let symbol_id = self.add_raw_symbol(symbol);
+ self.symbol_map.insert(unmangled_name, symbol_id);
+ symbol_id
+ } else {
+ self.add_raw_symbol(symbol)
+ }
+ }
+
+ fn add_raw_symbol(&mut self, symbol: Symbol) -> SymbolId {
+ let symbol_id = SymbolId(self.symbols.len());
+ self.symbols.push(symbol);
+ symbol_id
+ }
+
+ /// Return true if the file format supports `StandardSection::UninitializedTls`.
+ #[inline]
+ pub fn has_uninitialized_tls(&self) -> bool {
+ self.format != BinaryFormat::Coff
+ }
+
+ /// Return true if the file format supports `StandardSection::Common`.
+ #[inline]
+ pub fn has_common(&self) -> bool {
+ self.format == BinaryFormat::MachO
+ }
+
+ /// Add a new common symbol and return its `SymbolId`.
+ ///
+ /// For Mach-O, this appends the symbol to the `__common` section.
+ pub fn add_common_symbol(&mut self, mut symbol: Symbol, size: u64, align: u64) -> SymbolId {
+ if self.has_common() {
+ let symbol_id = self.add_symbol(symbol);
+ let section = self.section_id(StandardSection::Common);
+ self.add_symbol_bss(symbol_id, section, size, align);
+ symbol_id
+ } else {
+ symbol.section = SymbolSection::Common;
+ symbol.size = size;
+ self.add_symbol(symbol)
+ }
+ }
+
+ /// Add a new file symbol and return its `SymbolId`.
+ pub fn add_file_symbol(&mut self, name: Vec<u8>) -> SymbolId {
+ self.add_raw_symbol(Symbol {
+ name,
+ value: 0,
+ size: 0,
+ kind: SymbolKind::File,
+ scope: SymbolScope::Compilation,
+ weak: false,
+ section: SymbolSection::None,
+ flags: SymbolFlags::None,
+ })
+ }
+
+ /// Get the symbol for a section.
+ pub fn section_symbol(&mut self, section_id: SectionId) -> SymbolId {
+ let section = &mut self.sections[section_id.0];
+ if let Some(symbol) = section.symbol {
+ return symbol;
+ }
+ let name = if self.format == BinaryFormat::Coff {
+ section.name.clone()
+ } else {
+ Vec::new()
+ };
+ let symbol_id = SymbolId(self.symbols.len());
+ self.symbols.push(Symbol {
+ name,
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Section,
+ scope: SymbolScope::Compilation,
+ weak: false,
+ section: SymbolSection::Section(section_id),
+ flags: SymbolFlags::None,
+ });
+ section.symbol = Some(symbol_id);
+ symbol_id
+ }
+
+ /// Append data to an existing section, and update a symbol to refer to it.
+ ///
+ /// For Mach-O, this also creates a `__thread_vars` entry for TLS symbols, and the
+ /// symbol will indirectly point to the added data via the `__thread_vars` entry.
+ ///
+ /// Returns the section offset of the data.
+ pub fn add_symbol_data(
+ &mut self,
+ symbol_id: SymbolId,
+ section: SectionId,
+ data: &[u8],
+ align: u64,
+ ) -> u64 {
+ let offset = self.append_section_data(section, data, align);
+ self.set_symbol_data(symbol_id, section, offset, data.len() as u64);
+ offset
+ }
+
+ /// Append zero-initialized data to an existing section, and update a symbol to refer to it.
+ ///
+ /// For Mach-O, this also creates a `__thread_vars` entry for TLS symbols, and the
+ /// symbol will indirectly point to the added data via the `__thread_vars` entry.
+ ///
+ /// Returns the section offset of the data.
+ pub fn add_symbol_bss(
+ &mut self,
+ symbol_id: SymbolId,
+ section: SectionId,
+ size: u64,
+ align: u64,
+ ) -> u64 {
+ let offset = self.append_section_bss(section, size, align);
+ self.set_symbol_data(symbol_id, section, offset, size);
+ offset
+ }
+
+ /// Update a symbol to refer to the given data within a section.
+ ///
+ /// For Mach-O, this also creates a `__thread_vars` entry for TLS symbols, and the
+ /// symbol will indirectly point to the data via the `__thread_vars` entry.
+ #[allow(unused_mut)]
+ pub fn set_symbol_data(
+ &mut self,
+ mut symbol_id: SymbolId,
+ section: SectionId,
+ offset: u64,
+ size: u64,
+ ) {
+ // Defined symbols must have a scope.
+ debug_assert!(self.symbol(symbol_id).scope != SymbolScope::Unknown);
+ match self.format {
+ #[cfg(feature = "macho")]
+ BinaryFormat::MachO => symbol_id = self.macho_add_thread_var(symbol_id),
+ _ => {}
+ }
+ let symbol = self.symbol_mut(symbol_id);
+ symbol.value = offset;
+ symbol.size = size;
+ symbol.section = SymbolSection::Section(section);
+ }
+
+ /// Convert a symbol to a section symbol and offset.
+ ///
+ /// Returns `None` if the symbol does not have a section.
+ pub fn symbol_section_and_offset(&mut self, symbol_id: SymbolId) -> Option<(SymbolId, u64)> {
+ let symbol = self.symbol(symbol_id);
+ if symbol.kind == SymbolKind::Section {
+ return Some((symbol_id, 0));
+ }
+ let symbol_offset = symbol.value;
+ let section = symbol.section.id()?;
+ let section_symbol = self.section_symbol(section);
+ Some((section_symbol, symbol_offset))
+ }
+
+ /// Add a relocation to a section.
+ ///
+ /// Relocations must only be added after the referenced symbols have been added
+ /// and defined (if applicable).
+ pub fn add_relocation(&mut self, section: SectionId, mut relocation: Relocation) -> Result<()> {
+ let addend = match self.format {
+ #[cfg(feature = "coff")]
+ BinaryFormat::Coff => self.coff_fixup_relocation(&mut relocation),
+ #[cfg(feature = "elf")]
+ BinaryFormat::Elf => self.elf_fixup_relocation(&mut relocation)?,
+ #[cfg(feature = "macho")]
+ BinaryFormat::MachO => self.macho_fixup_relocation(&mut relocation),
+ _ => unimplemented!(),
+ };
+ if addend != 0 {
+ self.write_relocation_addend(section, &relocation, addend)?;
+ }
+ self.sections[section.0].relocations.push(relocation);
+ Ok(())
+ }
+
+ fn write_relocation_addend(
+ &mut self,
+ section: SectionId,
+ relocation: &Relocation,
+ addend: i64,
+ ) -> Result<()> {
+ let data = &mut self.sections[section.0].data;
+ let offset = relocation.offset as usize;
+ match relocation.size {
+ 32 => data.write_at(offset, &U32::new(self.endian, addend as u32)),
+ 64 => data.write_at(offset, &U64::new(self.endian, addend as u64)),
+ _ => {
+ return Err(Error(format!(
+ "unimplemented relocation addend {:?}",
+ relocation
+ )));
+ }
+ }
+ .map_err(|_| {
+ Error(format!(
+ "invalid relocation offset {}+{} (max {})",
+ relocation.offset,
+ relocation.size,
+ data.len()
+ ))
+ })
+ }
+
+ /// Write the object to a `Vec`.
+ pub fn write(&self) -> Result<Vec<u8>> {
+ let mut buffer = Vec::new();
+ self.emit(&mut buffer)?;
+ Ok(buffer)
+ }
+
+ /// Write the object to a `WritableBuffer`.
+ pub fn emit(&self, buffer: &mut dyn WritableBuffer) -> Result<()> {
+ match self.format {
+ #[cfg(feature = "coff")]
+ BinaryFormat::Coff => self.coff_write(buffer),
+ #[cfg(feature = "elf")]
+ BinaryFormat::Elf => self.elf_write(buffer),
+ #[cfg(feature = "macho")]
+ BinaryFormat::MachO => self.macho_write(buffer),
+ _ => unimplemented!(),
+ }
+ }
+}
+
+/// A standard segment kind.
+#[allow(missing_docs)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[non_exhaustive]
+pub enum StandardSegment {
+ Text,
+ Data,
+ Debug,
+}
+
+/// A standard section kind.
+#[allow(missing_docs)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[non_exhaustive]
+pub enum StandardSection {
+ Text,
+ Data,
+ ReadOnlyData,
+ ReadOnlyDataWithRel,
+ ReadOnlyString,
+ UninitializedData,
+ Tls,
+ /// Zero-fill TLS initializers. Unsupported for COFF.
+ UninitializedTls,
+ /// TLS variable structures. Only supported for Mach-O.
+ TlsVariables,
+ /// Common data. Only supported for Mach-O.
+ Common,
+}
+
+impl StandardSection {
+ /// Return the section kind of a standard section.
+ pub fn kind(self) -> SectionKind {
+ match self {
+ StandardSection::Text => SectionKind::Text,
+ StandardSection::Data => SectionKind::Data,
+ StandardSection::ReadOnlyData | StandardSection::ReadOnlyDataWithRel => {
+ SectionKind::ReadOnlyData
+ }
+ StandardSection::ReadOnlyString => SectionKind::ReadOnlyString,
+ StandardSection::UninitializedData => SectionKind::UninitializedData,
+ StandardSection::Tls => SectionKind::Tls,
+ StandardSection::UninitializedTls => SectionKind::UninitializedTls,
+ StandardSection::TlsVariables => SectionKind::TlsVariables,
+ StandardSection::Common => SectionKind::Common,
+ }
+ }
+
+ // TODO: remembering to update this is error-prone, can we do better?
+ fn all() -> &'static [StandardSection] {
+ &[
+ StandardSection::Text,
+ StandardSection::Data,
+ StandardSection::ReadOnlyData,
+ StandardSection::ReadOnlyDataWithRel,
+ StandardSection::ReadOnlyString,
+ StandardSection::UninitializedData,
+ StandardSection::Tls,
+ StandardSection::UninitializedTls,
+ StandardSection::TlsVariables,
+ StandardSection::Common,
+ ]
+ }
+}
+
+/// An identifier used to reference a section.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct SectionId(usize);
+
+/// A section in an object file.
+#[derive(Debug)]
+pub struct Section {
+ segment: Vec<u8>,
+ name: Vec<u8>,
+ kind: SectionKind,
+ size: u64,
+ align: u64,
+ data: Vec<u8>,
+ relocations: Vec<Relocation>,
+ symbol: Option<SymbolId>,
+ /// Section flags that are specific to each file format.
+ pub flags: SectionFlags,
+}
+
+impl Section {
+ /// Try to convert the name to a utf8 string.
+ #[inline]
+ pub fn name(&self) -> Option<&str> {
+ str::from_utf8(&self.name).ok()
+ }
+
+ /// Try to convert the segment to a utf8 string.
+ #[inline]
+ pub fn segment(&self) -> Option<&str> {
+ str::from_utf8(&self.segment).ok()
+ }
+
+ /// Return true if this section contains zerofill data.
+ #[inline]
+ pub fn is_bss(&self) -> bool {
+ self.kind.is_bss()
+ }
+
+ /// Set the data for a section.
+ ///
+ /// Must not be called for sections that already have data, or that contain uninitialized data.
+ pub fn set_data(&mut self, data: Vec<u8>, align: u64) {
+ debug_assert!(!self.is_bss());
+ debug_assert_eq!(align & (align - 1), 0);
+ debug_assert!(self.data.is_empty());
+ self.size = data.len() as u64;
+ self.data = data;
+ self.align = align;
+ }
+
+ /// Append data to a section.
+ ///
+ /// Must not be called for sections that contain uninitialized data.
+ pub fn append_data(&mut self, data: &[u8], align: u64) -> u64 {
+ debug_assert!(!self.is_bss());
+ debug_assert_eq!(align & (align - 1), 0);
+ if self.align < align {
+ self.align = align;
+ }
+ let align = align as usize;
+ let mut offset = self.data.len();
+ if offset & (align - 1) != 0 {
+ offset += align - (offset & (align - 1));
+ self.data.resize(offset, 0);
+ }
+ self.data.extend_from_slice(data);
+ self.size = self.data.len() as u64;
+ offset as u64
+ }
+
+ /// Append unitialized data to a section.
+ ///
+ /// Must not be called for sections that contain initialized data.
+ pub fn append_bss(&mut self, size: u64, align: u64) -> u64 {
+ debug_assert!(self.is_bss());
+ debug_assert_eq!(align & (align - 1), 0);
+ if self.align < align {
+ self.align = align;
+ }
+ let mut offset = self.size;
+ if offset & (align - 1) != 0 {
+ offset += align - (offset & (align - 1));
+ self.size = offset;
+ }
+ self.size += size;
+ offset as u64
+ }
+}
+
+/// The section where a symbol is defined.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum SymbolSection {
+ /// The section is not applicable for this symbol (such as file symbols).
+ None,
+ /// The symbol is undefined.
+ Undefined,
+ /// The symbol has an absolute value.
+ Absolute,
+ /// The symbol is a zero-initialized symbol that will be combined with duplicate definitions.
+ Common,
+ /// The symbol is defined in the given section.
+ Section(SectionId),
+}
+
+impl SymbolSection {
+ /// Returns the section id for the section where the symbol is defined.
+ ///
+ /// May return `None` if the symbol is not defined in a section.
+ #[inline]
+ pub fn id(self) -> Option<SectionId> {
+ if let SymbolSection::Section(id) = self {
+ Some(id)
+ } else {
+ None
+ }
+ }
+}
+
+/// An identifier used to reference a symbol.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct SymbolId(usize);
+
+/// A symbol in an object file.
+#[derive(Debug)]
+pub struct Symbol {
+ /// The name of the symbol.
+ pub name: Vec<u8>,
+ /// The value of the symbol.
+ ///
+ /// If the symbol defined in a section, then this is the section offset of the symbol.
+ pub value: u64,
+ /// The size of the symbol.
+ pub size: u64,
+ /// The kind of the symbol.
+ pub kind: SymbolKind,
+ /// The scope of the symbol.
+ pub scope: SymbolScope,
+ /// Whether the symbol has weak binding.
+ pub weak: bool,
+ /// The section containing the symbol.
+ pub section: SymbolSection,
+ /// Symbol flags that are specific to each file format.
+ pub flags: SymbolFlags<SectionId>,
+}
+
+impl Symbol {
+ /// Try to convert the name to a utf8 string.
+ #[inline]
+ pub fn name(&self) -> Option<&str> {
+ str::from_utf8(&self.name).ok()
+ }
+
+ /// Return true if the symbol is undefined.
+ #[inline]
+ pub fn is_undefined(&self) -> bool {
+ self.section == SymbolSection::Undefined
+ }
+
+ /// Return true if the symbol is common data.
+ ///
+ /// Note: does not check for `SymbolSection::Section` with `SectionKind::Common`.
+ #[inline]
+ pub fn is_common(&self) -> bool {
+ self.section == SymbolSection::Common
+ }
+
+ /// Return true if the symbol scope is local.
+ #[inline]
+ pub fn is_local(&self) -> bool {
+ self.scope == SymbolScope::Compilation
+ }
+}
+
+/// A relocation in an object file.
+#[derive(Debug)]
+pub struct Relocation {
+ /// The section offset of the place of the relocation.
+ pub offset: u64,
+ /// The size in bits of the place of relocation.
+ pub size: u8,
+ /// The operation used to calculate the result of the relocation.
+ pub kind: RelocationKind,
+ /// Information about how the result of the relocation operation is encoded in the place.
+ pub encoding: RelocationEncoding,
+ /// The symbol referred to by the relocation.
+ ///
+ /// This may be a section symbol.
+ pub symbol: SymbolId,
+ /// The addend to use in the relocation calculation.
+ ///
+ /// This may be in addition to an implicit addend stored at the place of the relocation.
+ pub addend: i64,
+}
+
+/// An identifier used to reference a COMDAT section group.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct ComdatId(usize);
+
+/// A COMDAT section group.
+#[derive(Debug)]
+pub struct Comdat {
+ /// The COMDAT selection kind.
+ ///
+ /// This determines the way in which the linker resolves multiple definitions of the COMDAT
+ /// sections.
+ pub kind: ComdatKind,
+ /// The COMDAT symbol.
+ ///
+ /// If this symbol is referenced, then all sections in the group will be included by the
+ /// linker.
+ pub symbol: SymbolId,
+ /// The sections in the group.
+ pub sections: Vec<SectionId>,
+}
+
+/// The symbol name mangling scheme.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum Mangling {
+ /// No symbol mangling.
+ None,
+ /// Windows COFF symbol mangling.
+ Coff,
+ /// Windows COFF i386 symbol mangling.
+ CoffI386,
+ /// ELF symbol mangling.
+ Elf,
+ /// Mach-O symbol mangling.
+ MachO,
+}
+
+impl Mangling {
+ /// Return the default symboling mangling for the given format and architecture.
+ pub fn default(format: BinaryFormat, architecture: Architecture) -> Self {
+ match (format, architecture) {
+ (BinaryFormat::Coff, Architecture::I386) => Mangling::CoffI386,
+ (BinaryFormat::Coff, _) => Mangling::Coff,
+ (BinaryFormat::Elf, _) => Mangling::Elf,
+ (BinaryFormat::MachO, _) => Mangling::MachO,
+ _ => Mangling::None,
+ }
+ }
+
+ /// Return the prefix to use for global symbols.
+ pub fn global_prefix(self) -> Option<u8> {
+ match self {
+ Mangling::None | Mangling::Elf | Mangling::Coff => None,
+ Mangling::CoffI386 | Mangling::MachO => Some(b'_'),
+ }
+ }
+}
diff --git a/vendor/object-0.26.2/src/write/string.rs b/vendor/object-0.26.2/src/write/string.rs
new file mode 100644
index 000000000..c27934e60
--- /dev/null
+++ b/vendor/object-0.26.2/src/write/string.rs
@@ -0,0 +1,139 @@
+use indexmap::IndexSet;
+use std::vec::Vec;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub(crate) struct StringId(usize);
+
+#[derive(Debug, Default)]
+pub(crate) struct StringTable<'a> {
+ strings: IndexSet<&'a [u8]>,
+ offsets: Vec<usize>,
+}
+
+impl<'a> StringTable<'a> {
+ /// Add a string to the string table.
+ ///
+ /// Panics if the string table has already been written, or
+ /// if the string contains a null byte.
+ pub fn add(&mut self, string: &'a [u8]) -> StringId {
+ assert!(self.offsets.is_empty());
+ assert!(!string.contains(&0));
+ let id = self.strings.insert_full(string).0;
+ StringId(id)
+ }
+
+ /// Return the offset of the given string.
+ ///
+ /// Panics if the string table has not been written, or
+ /// if the string is not in the string table.
+ pub fn get_offset(&self, id: StringId) -> usize {
+ self.offsets[id.0]
+ }
+
+ /// Append the string table to the given `Vec`, and
+ /// calculate the list of string offsets.
+ ///
+ /// `base` is the initial string table offset. For example,
+ /// this should be 1 for ELF, to account for the initial
+ /// null byte (which must have been written by the caller).
+ pub fn write(&mut self, base: usize, w: &mut Vec<u8>) {
+ assert!(self.offsets.is_empty());
+
+ let mut ids: Vec<_> = (0..self.strings.len()).collect();
+ sort(&mut ids, 1, &self.strings);
+
+ self.offsets = vec![0; ids.len()];
+ let mut offset = base;
+ let mut previous = &[][..];
+ for id in ids {
+ let string = self.strings.get_index(id).unwrap();
+ if previous.ends_with(string) {
+ self.offsets[id] = offset - string.len() - 1;
+ } else {
+ self.offsets[id] = offset;
+ w.extend_from_slice(string);
+ w.push(0);
+ offset += string.len() + 1;
+ previous = string;
+ }
+ }
+ }
+}
+
+// Multi-key quicksort.
+//
+// Ordering is such that if a string is a suffix of at least one other string,
+// then it is placed immediately after one of those strings. That is:
+// - comparison starts at the end of the string
+// - shorter strings come later
+//
+// Based on the implementation in LLVM.
+fn sort(mut ids: &mut [usize], mut pos: usize, strings: &IndexSet<&[u8]>) {
+ loop {
+ if ids.len() <= 1 {
+ return;
+ }
+
+ let pivot = byte(ids[0], pos, strings);
+ let mut lower = 0;
+ let mut upper = ids.len();
+ let mut i = 1;
+ while i < upper {
+ let b = byte(ids[i], pos, strings);
+ if b > pivot {
+ ids.swap(lower, i);
+ lower += 1;
+ i += 1;
+ } else if b < pivot {
+ upper -= 1;
+ ids.swap(upper, i);
+ } else {
+ i += 1;
+ }
+ }
+
+ sort(&mut ids[..lower], pos, strings);
+ sort(&mut ids[upper..], pos, strings);
+
+ if pivot == 0 {
+ return;
+ }
+ ids = &mut ids[lower..upper];
+ pos += 1;
+ }
+}
+
+fn byte(id: usize, pos: usize, strings: &IndexSet<&[u8]>) -> u8 {
+ let string = strings.get_index(id).unwrap();
+ let len = string.len();
+ if len >= pos {
+ string[len - pos]
+ } else {
+ // We know the strings don't contain null bytes.
+ 0
+ }
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn string_table() {
+ let mut table = StringTable::default();
+ let id0 = table.add(b"");
+ let id1 = table.add(b"foo");
+ let id2 = table.add(b"bar");
+ let id3 = table.add(b"foobar");
+
+ let mut data = Vec::new();
+ data.push(0);
+ table.write(1, &mut data);
+ assert_eq!(data, b"\0foobar\0foo\0");
+
+ assert_eq!(table.get_offset(id0), 11);
+ assert_eq!(table.get_offset(id1), 8);
+ assert_eq!(table.get_offset(id2), 4);
+ assert_eq!(table.get_offset(id3), 1);
+ }
+}
diff --git a/vendor/object-0.26.2/src/write/util.rs b/vendor/object-0.26.2/src/write/util.rs
new file mode 100644
index 000000000..bb6b8597b
--- /dev/null
+++ b/vendor/object-0.26.2/src/write/util.rs
@@ -0,0 +1,129 @@
+use std::vec::Vec;
+
+use crate::pod::{bytes_of, bytes_of_slice, Pod};
+
+/// Trait for writable buffer.
+#[allow(clippy::len_without_is_empty)]
+pub trait WritableBuffer {
+ /// Returns position/offset for data to be written at.
+ fn len(&self) -> usize;
+
+ /// Reserves specified number of bytes in the buffer.
+ fn reserve(&mut self, additional: usize) -> Result<(), ()>;
+
+ /// Writes the specified value at the end of the buffer
+ /// until the buffer has the specified length.
+ fn resize(&mut self, new_len: usize, value: u8);
+
+ /// Writes the specified slice of bytes at the end of the buffer.
+ fn write_bytes(&mut self, val: &[u8]);
+
+ /// Writes the specified `Pod` type at the end of the buffer.
+ fn write_pod<T: Pod>(&mut self, val: &T)
+ where
+ Self: Sized,
+ {
+ self.write_bytes(bytes_of(val))
+ }
+
+ /// Writes the specified `Pod` slice at the end of the buffer.
+ fn write_pod_slice<T: Pod>(&mut self, val: &[T])
+ where
+ Self: Sized,
+ {
+ self.write_bytes(bytes_of_slice(val))
+ }
+}
+
+impl<'a> dyn WritableBuffer + 'a {
+ /// Writes the specified `Pod` type at the end of the buffer.
+ pub fn write<T: Pod>(&mut self, val: &T) {
+ self.write_bytes(bytes_of(val))
+ }
+
+ /// Writes the specified `Pod` slice at the end of the buffer.
+ pub fn write_slice<T: Pod>(&mut self, val: &[T]) {
+ self.write_bytes(bytes_of_slice(val))
+ }
+}
+
+impl WritableBuffer for Vec<u8> {
+ #[inline]
+ fn len(&self) -> usize {
+ self.len()
+ }
+
+ #[inline]
+ fn reserve(&mut self, additional: usize) -> Result<(), ()> {
+ self.reserve(additional);
+ Ok(())
+ }
+
+ #[inline]
+ fn resize(&mut self, new_len: usize, value: u8) {
+ self.resize(new_len, value);
+ }
+
+ #[inline]
+ fn write_bytes(&mut self, val: &[u8]) {
+ self.extend_from_slice(val)
+ }
+}
+
+/// A trait for mutable byte slices.
+///
+/// It provides convenience methods for `Pod` types.
+pub(crate) trait BytesMut {
+ fn write_at<T: Pod>(self, offset: usize, val: &T) -> Result<(), ()>;
+}
+
+impl<'a> BytesMut for &'a mut [u8] {
+ #[inline]
+ fn write_at<T: Pod>(self, offset: usize, val: &T) -> Result<(), ()> {
+ let src = bytes_of(val);
+ let dest = self.get_mut(offset..).ok_or(())?;
+ let dest = dest.get_mut(..src.len()).ok_or(())?;
+ dest.copy_from_slice(src);
+ Ok(())
+ }
+}
+
+pub(crate) fn align(offset: usize, size: usize) -> usize {
+ (offset + (size - 1)) & !(size - 1)
+}
+
+#[allow(dead_code)]
+pub(crate) fn align_u64(offset: u64, size: u64) -> u64 {
+ (offset + (size - 1)) & !(size - 1)
+}
+
+pub(crate) fn write_align(buffer: &mut dyn WritableBuffer, size: usize) {
+ let new_len = align(buffer.len(), size);
+ buffer.resize(new_len, 0);
+}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn bytes_mut() {
+ let data = vec![0x01, 0x23, 0x45, 0x67];
+
+ let mut bytes = data.clone();
+ bytes.extend_from_slice(bytes_of(&u16::to_be(0x89ab)));
+ assert_eq!(bytes, [0x01, 0x23, 0x45, 0x67, 0x89, 0xab]);
+
+ let mut bytes = data.clone();
+ assert_eq!(bytes.write_at(0, &u16::to_be(0x89ab)), Ok(()));
+ assert_eq!(bytes, [0x89, 0xab, 0x45, 0x67]);
+
+ let mut bytes = data.clone();
+ assert_eq!(bytes.write_at(2, &u16::to_be(0x89ab)), Ok(()));
+ assert_eq!(bytes, [0x01, 0x23, 0x89, 0xab]);
+
+ assert_eq!(bytes.write_at(3, &u16::to_be(0x89ab)), Err(()));
+ assert_eq!(bytes.write_at(4, &u16::to_be(0x89ab)), Err(()));
+ assert_eq!(vec![].write_at(0, &u32::to_be(0x89ab)), Err(()));
+ }
+}
diff --git a/vendor/object-0.26.2/tests/integration.rs b/vendor/object-0.26.2/tests/integration.rs
new file mode 100644
index 000000000..ee859f2c3
--- /dev/null
+++ b/vendor/object-0.26.2/tests/integration.rs
@@ -0,0 +1 @@
+mod round_trip;
diff --git a/vendor/object-0.26.2/tests/parse_self.rs b/vendor/object-0.26.2/tests/parse_self.rs
new file mode 100644
index 000000000..1e7df6715
--- /dev/null
+++ b/vendor/object-0.26.2/tests/parse_self.rs
@@ -0,0 +1,25 @@
+#![cfg(feature = "read")]
+use object::{File, Object};
+use std::{env, fs};
+
+#[test]
+fn parse_self() {
+ let exe = env::current_exe().unwrap();
+ let data = fs::read(exe).unwrap();
+ let object = File::parse(&*data).unwrap();
+ assert!(object.entry() != 0);
+ assert!(object.sections().count() != 0);
+}
+
+#[cfg(feature = "std")]
+#[test]
+fn parse_self_cache() {
+ use object::read::{ReadCache, ReadRef};
+ let exe = env::current_exe().unwrap();
+ let file = fs::File::open(exe).unwrap();
+ let cache = ReadCache::new(file);
+ let data = cache.range(0, cache.len().unwrap());
+ let object = File::parse(data).unwrap();
+ assert!(object.entry() != 0);
+ assert!(object.sections().count() != 0);
+}
diff --git a/vendor/object-0.26.2/tests/round_trip/bss.rs b/vendor/object-0.26.2/tests/round_trip/bss.rs
new file mode 100644
index 000000000..1354fcc78
--- /dev/null
+++ b/vendor/object-0.26.2/tests/round_trip/bss.rs
@@ -0,0 +1,255 @@
+#![cfg(all(feature = "read", feature = "write"))]
+
+use object::read::{Object, ObjectSection, ObjectSymbol};
+use object::{read, write};
+use object::{
+ Architecture, BinaryFormat, Endianness, SectionKind, SymbolFlags, SymbolKind, SymbolScope,
+};
+
+#[test]
+fn coff_x86_64_bss() {
+ let mut object =
+ write::Object::new(BinaryFormat::Coff, Architecture::X86_64, Endianness::Little);
+
+ let section = object.section_id(write::StandardSection::UninitializedData);
+
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"v1".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_bss(symbol, section, 18, 4);
+
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"v2".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_bss(symbol, section, 34, 8);
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"bss.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Coff);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut sections = object.sections();
+
+ let bss = sections.next().unwrap();
+ println!("{:?}", bss);
+ let bss_index = bss.index();
+ assert_eq!(bss.name(), Ok(".bss"));
+ assert_eq!(bss.kind(), SectionKind::UninitializedData);
+ assert_eq!(bss.size(), 58);
+ assert_eq!(bss.data(), Ok(&[][..]));
+
+ let section = sections.next();
+ assert!(section.is_none(), "unexpected section {:?}", section);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("v1"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section_index(), Some(bss_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 0);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("v2"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section_index(), Some(bss_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 24);
+
+ let symbol = symbols.next();
+ assert!(symbol.is_none(), "unexpected symbol {:?}", symbol);
+}
+
+#[test]
+fn elf_x86_64_bss() {
+ let mut object =
+ write::Object::new(BinaryFormat::Elf, Architecture::X86_64, Endianness::Little);
+
+ let section = object.section_id(write::StandardSection::UninitializedData);
+
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"v1".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_bss(symbol, section, 18, 4);
+
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"v2".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_bss(symbol, section, 34, 8);
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"bss.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Elf);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut sections = object.sections();
+
+ let section = sections.next().unwrap();
+ println!("{:?}", section);
+ assert_eq!(section.name(), Ok(""));
+ assert_eq!(section.kind(), SectionKind::Metadata);
+ assert_eq!(section.address(), 0);
+ assert_eq!(section.size(), 0);
+
+ let bss = sections.next().unwrap();
+ println!("{:?}", bss);
+ let bss_index = bss.index();
+ assert_eq!(bss.name(), Ok(".bss"));
+ assert_eq!(bss.kind(), SectionKind::UninitializedData);
+ assert_eq!(bss.size(), 58);
+ assert_eq!(bss.data(), Ok(&[][..]));
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok(""));
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("v1"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section_index(), Some(bss_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 0);
+ assert_eq!(symbol.size(), 18);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("v2"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section_index(), Some(bss_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 24);
+ assert_eq!(symbol.size(), 34);
+
+ let symbol = symbols.next();
+ assert!(symbol.is_none(), "unexpected symbol {:?}", symbol);
+}
+
+#[test]
+fn macho_x86_64_bss() {
+ let mut object = write::Object::new(
+ BinaryFormat::MachO,
+ Architecture::X86_64,
+ Endianness::Little,
+ );
+
+ let section = object.section_id(write::StandardSection::UninitializedData);
+
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"v1".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_bss(symbol, section, 18, 4);
+
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"v2".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_bss(symbol, section, 34, 8);
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"bss.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::MachO);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut sections = object.sections();
+
+ let bss = sections.next().unwrap();
+ println!("{:?}", bss);
+ let bss_index = bss.index();
+ assert_eq!(bss.name(), Ok("__bss"));
+ assert_eq!(bss.segment_name(), Ok(Some("__DATA")));
+ assert_eq!(bss.kind(), SectionKind::UninitializedData);
+ assert_eq!(bss.size(), 58);
+ assert_eq!(bss.data(), Ok(&[][..]));
+
+ let section = sections.next();
+ assert!(section.is_none(), "unexpected section {:?}", section);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("_v1"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section_index(), Some(bss_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 0);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("_v2"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section_index(), Some(bss_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 24);
+
+ let symbol = symbols.next();
+ assert!(symbol.is_none(), "unexpected symbol {:?}", symbol);
+}
diff --git a/vendor/object-0.26.2/tests/round_trip/comdat.rs b/vendor/object-0.26.2/tests/round_trip/comdat.rs
new file mode 100644
index 000000000..c71904a44
--- /dev/null
+++ b/vendor/object-0.26.2/tests/round_trip/comdat.rs
@@ -0,0 +1,225 @@
+#![cfg(all(feature = "read", feature = "write"))]
+
+use object::pe;
+use object::read::{Object, ObjectComdat, ObjectSection, ObjectSymbol};
+use object::{read, write};
+use object::{
+ Architecture, BinaryFormat, ComdatKind, Endianness, SectionKind, SymbolFlags, SymbolKind,
+ SymbolScope,
+};
+
+#[test]
+fn coff_x86_64_comdat() {
+ let mut object =
+ write::Object::new(BinaryFormat::Coff, Architecture::X86_64, Endianness::Little);
+
+ let (section1, offset) =
+ object.add_subsection(write::StandardSection::Text, b"s1", &[0, 1, 2, 3], 4);
+ object.section_symbol(section1);
+ let (section2, _) =
+ object.add_subsection(write::StandardSection::Data, b"s1", &[0, 1, 2, 3], 4);
+ object.section_symbol(section2);
+
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"s1".to_vec(),
+ value: offset,
+ size: 4,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Section(section1),
+ flags: SymbolFlags::None,
+ });
+
+ object.add_comdat(write::Comdat {
+ kind: ComdatKind::NoDuplicates,
+ symbol,
+ sections: vec![section1, section2],
+ });
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"comdat.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Coff);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut sections = object.sections();
+
+ let section1 = sections.next().unwrap();
+ println!("{:?}", section1);
+ let section1_index = section1.index();
+ assert_eq!(section1.name(), Ok(".text$s1"));
+ assert_eq!(section1.kind(), SectionKind::Text);
+ assert_eq!(section1.address(), 0);
+ assert_eq!(section1.size(), 4);
+
+ let section2 = sections.next().unwrap();
+ println!("{:?}", section2);
+ let section2_index = section2.index();
+ assert_eq!(section2.name(), Ok(".data$s1"));
+ assert_eq!(section2.kind(), SectionKind::Data);
+ assert_eq!(section2.address(), 0);
+ assert_eq!(section2.size(), 4);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok(".text$s1"));
+ assert_eq!(symbol.kind(), SymbolKind::Section);
+ assert_eq!(
+ symbol.section(),
+ read::SymbolSection::Section(section1.index())
+ );
+ assert_eq!(
+ symbol.flags(),
+ SymbolFlags::CoffSection {
+ selection: pe::IMAGE_COMDAT_SELECT_NODUPLICATES,
+ associative_section: None
+ }
+ );
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok(".data$s1"));
+ assert_eq!(symbol.kind(), SymbolKind::Section);
+ assert_eq!(
+ symbol.section(),
+ read::SymbolSection::Section(section2.index())
+ );
+ assert_eq!(
+ symbol.flags(),
+ SymbolFlags::CoffSection {
+ selection: pe::IMAGE_COMDAT_SELECT_ASSOCIATIVE,
+ associative_section: Some(section1_index)
+ }
+ );
+
+ let symbol = symbols.next().unwrap();
+ let symbol_index = symbol.index();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("s1"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(
+ symbol.section(),
+ read::SymbolSection::Section(section1.index())
+ );
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 0);
+
+ let symbol = symbols.next();
+ assert!(symbol.is_none(), "unexpected symbol {:?}", symbol);
+
+ let mut comdats = object.comdats();
+
+ let comdat = comdats.next().unwrap();
+ println!("{:?}", comdat);
+ assert_eq!(comdat.kind(), ComdatKind::NoDuplicates);
+ assert_eq!(comdat.symbol(), symbol_index);
+
+ let mut comdat_sections = comdat.sections();
+ assert_eq!(comdat_sections.next(), Some(section1_index));
+ assert_eq!(comdat_sections.next(), Some(section2_index));
+ assert_eq!(comdat_sections.next(), None);
+}
+
+#[test]
+fn elf_x86_64_common() {
+ let mut object =
+ write::Object::new(BinaryFormat::Elf, Architecture::X86_64, Endianness::Little);
+
+ let (section1, offset) =
+ object.add_subsection(write::StandardSection::Text, b"s1", &[0, 1, 2, 3], 4);
+ let (section2, _) =
+ object.add_subsection(write::StandardSection::Data, b"s1", &[0, 1, 2, 3], 4);
+
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"s1".to_vec(),
+ value: offset,
+ size: 4,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Section(section1),
+ flags: SymbolFlags::None,
+ });
+
+ object.add_comdat(write::Comdat {
+ kind: ComdatKind::Any,
+ symbol,
+ sections: vec![section1, section2],
+ });
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"comdat.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Elf);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut sections = object.sections();
+
+ let section = sections.next().unwrap();
+ println!("{:?}", section);
+ assert_eq!(section.name(), Ok(""));
+
+ let section = sections.next().unwrap();
+ println!("{:?}", section);
+ assert_eq!(section.name(), Ok(".group"));
+
+ let section1 = sections.next().unwrap();
+ println!("{:?}", section1);
+ let section1_index = section1.index();
+ assert_eq!(section1.name(), Ok(".text.s1"));
+ assert_eq!(section1.kind(), SectionKind::Text);
+ assert_eq!(section1.address(), 0);
+ assert_eq!(section1.size(), 4);
+
+ let section2 = sections.next().unwrap();
+ println!("{:?}", section2);
+ let section2_index = section2.index();
+ assert_eq!(section2.name(), Ok(".data.s1"));
+ assert_eq!(section2.kind(), SectionKind::Data);
+ assert_eq!(section2.address(), 0);
+ assert_eq!(section2.size(), 4);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok(""));
+
+ let symbol = symbols.next().unwrap();
+ let symbol_index = symbol.index();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("s1"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(
+ symbol.section(),
+ read::SymbolSection::Section(section1.index())
+ );
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 0);
+
+ let symbol = symbols.next();
+ assert!(symbol.is_none(), "unexpected symbol {:?}", symbol);
+
+ let mut comdats = object.comdats();
+
+ let comdat = comdats.next().unwrap();
+ println!("{:?}", comdat);
+ assert_eq!(comdat.kind(), ComdatKind::Any);
+ assert_eq!(comdat.symbol(), symbol_index);
+
+ let mut comdat_sections = comdat.sections();
+ assert_eq!(comdat_sections.next(), Some(section1_index));
+ assert_eq!(comdat_sections.next(), Some(section2_index));
+ assert_eq!(comdat_sections.next(), None);
+}
diff --git a/vendor/object-0.26.2/tests/round_trip/common.rs b/vendor/object-0.26.2/tests/round_trip/common.rs
new file mode 100644
index 000000000..74d443830
--- /dev/null
+++ b/vendor/object-0.26.2/tests/round_trip/common.rs
@@ -0,0 +1,245 @@
+#![cfg(all(feature = "read", feature = "write"))]
+
+use object::read::{Object, ObjectSection, ObjectSymbol};
+use object::{read, write};
+use object::{
+ Architecture, BinaryFormat, Endianness, SectionKind, SymbolFlags, SymbolKind, SymbolScope,
+};
+
+#[test]
+fn coff_x86_64_common() {
+ let mut object =
+ write::Object::new(BinaryFormat::Coff, Architecture::X86_64, Endianness::Little);
+
+ let symbol = write::Symbol {
+ name: b"v1".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ };
+ object.add_common_symbol(symbol, 4, 4);
+
+ let symbol = write::Symbol {
+ name: b"v2".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ };
+ object.add_common_symbol(symbol, 8, 8);
+
+ // Also check undefined symbols, which are very similar.
+ let symbol = write::Symbol {
+ name: b"v3".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ };
+ object.add_symbol(symbol);
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"common.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Coff);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("v1"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section(), read::SymbolSection::Common);
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 0);
+ assert_eq!(symbol.size(), 4);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("v2"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section(), read::SymbolSection::Common);
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 0);
+ assert_eq!(symbol.size(), 8);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("v3"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section(), read::SymbolSection::Undefined);
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), true);
+ assert_eq!(symbol.address(), 0);
+ assert_eq!(symbol.size(), 0);
+
+ let symbol = symbols.next();
+ assert!(symbol.is_none(), "unexpected symbol {:?}", symbol);
+}
+
+#[test]
+fn elf_x86_64_common() {
+ let mut object =
+ write::Object::new(BinaryFormat::Elf, Architecture::X86_64, Endianness::Little);
+
+ let symbol = write::Symbol {
+ name: b"v1".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ };
+ object.add_common_symbol(symbol, 4, 4);
+
+ let symbol = write::Symbol {
+ name: b"v2".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ };
+ object.add_common_symbol(symbol, 8, 8);
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"common.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Elf);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok(""));
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("v1"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section(), read::SymbolSection::Common);
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 0);
+ assert_eq!(symbol.size(), 4);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("v2"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section(), read::SymbolSection::Common);
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 0);
+ assert_eq!(symbol.size(), 8);
+
+ let symbol = symbols.next();
+ assert!(symbol.is_none(), "unexpected symbol {:?}", symbol);
+}
+
+#[test]
+fn macho_x86_64_common() {
+ let mut object = write::Object::new(
+ BinaryFormat::MachO,
+ Architecture::X86_64,
+ Endianness::Little,
+ );
+
+ let symbol = write::Symbol {
+ name: b"v1".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ };
+ object.add_common_symbol(symbol, 4, 4);
+
+ let symbol = write::Symbol {
+ name: b"v2".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Data,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ };
+ object.add_common_symbol(symbol, 8, 8);
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"common.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::MachO);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut sections = object.sections();
+
+ let common = sections.next().unwrap();
+ println!("{:?}", common);
+ let common_index = common.index();
+ assert_eq!(common.name(), Ok("__common"));
+ assert_eq!(common.segment_name(), Ok(Some("__DATA")));
+ assert_eq!(common.kind(), SectionKind::Common);
+ assert_eq!(common.size(), 16);
+ assert_eq!(common.data(), Ok(&[][..]));
+
+ let section = sections.next();
+ assert!(section.is_none(), "unexpected section {:?}", section);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("_v1"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section_index(), Some(common_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 0);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("_v2"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section_index(), Some(common_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.address(), 8);
+
+ let symbol = symbols.next();
+ assert!(symbol.is_none(), "unexpected symbol {:?}", symbol);
+}
diff --git a/vendor/object-0.26.2/tests/round_trip/elf.rs b/vendor/object-0.26.2/tests/round_trip/elf.rs
new file mode 100644
index 000000000..501748cf8
--- /dev/null
+++ b/vendor/object-0.26.2/tests/round_trip/elf.rs
@@ -0,0 +1,218 @@
+use object::read::elf::{FileHeader, SectionHeader};
+use object::read::{Object, ObjectSymbol};
+use object::{
+ elf, read, write, Architecture, BinaryFormat, Endianness, LittleEndian, SectionIndex,
+ SectionKind, SymbolFlags, SymbolKind, SymbolScope, SymbolSection, U32,
+};
+use std::io::Write;
+
+#[test]
+fn symtab_shndx() {
+ let mut object =
+ write::Object::new(BinaryFormat::Elf, Architecture::X86_64, Endianness::Little);
+
+ for i in 0..0x10000 {
+ let name = format!("func{}", i).into_bytes();
+ let (section, offset) =
+ object.add_subsection(write::StandardSection::Text, &name, &[0xcc], 1);
+ object.add_symbol(write::Symbol {
+ name,
+ value: offset,
+ size: 1,
+ kind: SymbolKind::Text,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Section(section),
+ flags: SymbolFlags::None,
+ });
+ }
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"symtab_shndx.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Elf);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ for symbol in object.symbols().skip(1) {
+ assert_eq!(
+ symbol.section(),
+ SymbolSection::Section(SectionIndex(symbol.index().0))
+ );
+ }
+}
+
+#[cfg(feature = "compression")]
+#[test]
+fn compression_zlib() {
+ use object::read::ObjectSection;
+ use object::LittleEndian as LE;
+
+ let data = b"test data data data";
+ let len = data.len() as u64;
+
+ let mut ch = object::elf::CompressionHeader64::<LE>::default();
+ ch.ch_type.set(LE, object::elf::ELFCOMPRESS_ZLIB);
+ ch.ch_size.set(LE, len);
+ ch.ch_addralign.set(LE, 1);
+
+ let mut buf = Vec::new();
+ buf.write(object::bytes_of(&ch)).unwrap();
+ let mut encoder = flate2::write::ZlibEncoder::new(buf, flate2::Compression::default());
+ encoder.write_all(data).unwrap();
+ let compressed = encoder.finish().unwrap();
+
+ let mut object =
+ write::Object::new(BinaryFormat::Elf, Architecture::X86_64, Endianness::Little);
+ let section = object.add_section(
+ Vec::new(),
+ b".debug_info".to_vec(),
+ object::SectionKind::Other,
+ );
+ object.section_mut(section).set_data(compressed, 1);
+ object.section_mut(section).flags = object::SectionFlags::Elf {
+ sh_flags: object::elf::SHF_COMPRESSED.into(),
+ };
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"compression.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Elf);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let section = object.section_by_name(".debug_info").unwrap();
+ let uncompressed = section.uncompressed_data().unwrap();
+ assert_eq!(data, &*uncompressed);
+}
+
+#[cfg(feature = "compression")]
+#[test]
+fn compression_gnu() {
+ use object::read::ObjectSection;
+ use std::io::Write;
+
+ let data = b"test data data data";
+ let len = data.len() as u32;
+
+ let mut buf = Vec::new();
+ buf.write_all(b"ZLIB\0\0\0\0").unwrap();
+ buf.write_all(&len.to_be_bytes()).unwrap();
+ let mut encoder = flate2::write::ZlibEncoder::new(buf, flate2::Compression::default());
+ encoder.write_all(data).unwrap();
+ let compressed = encoder.finish().unwrap();
+
+ let mut object =
+ write::Object::new(BinaryFormat::Elf, Architecture::X86_64, Endianness::Little);
+ let section = object.add_section(
+ Vec::new(),
+ b".zdebug_info".to_vec(),
+ object::SectionKind::Other,
+ );
+ object.section_mut(section).set_data(compressed, 1);
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"compression.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Elf);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let section = object.section_by_name(".zdebug_info").unwrap();
+ let uncompressed = section.uncompressed_data().unwrap();
+ assert_eq!(data, &*uncompressed);
+}
+
+#[test]
+fn note() {
+ let endian = Endianness::Little;
+ let mut object = write::Object::new(BinaryFormat::Elf, Architecture::X86_64, endian);
+
+ // Add note section with align = 4.
+ let mut buffer = Vec::new();
+
+ buffer
+ .write(object::bytes_of(&elf::NoteHeader32 {
+ n_namesz: U32::new(endian, 6),
+ n_descsz: U32::new(endian, 11),
+ n_type: U32::new(endian, 1),
+ }))
+ .unwrap();
+ buffer.write(b"name1\0\0\0").unwrap();
+ buffer.write(b"descriptor\0\0").unwrap();
+
+ buffer
+ .write(object::bytes_of(&elf::NoteHeader32 {
+ n_namesz: U32::new(endian, 6),
+ n_descsz: U32::new(endian, 11),
+ n_type: U32::new(endian, 2),
+ }))
+ .unwrap();
+ buffer.write(b"name2\0\0\0").unwrap();
+ buffer.write(b"descriptor\0\0").unwrap();
+
+ let section = object.add_section(Vec::new(), b".note4".to_vec(), SectionKind::Note);
+ object.section_mut(section).set_data(buffer, 4);
+
+ // Add note section with align = 8.
+ let mut buffer = Vec::new();
+
+ buffer
+ .write(object::bytes_of(&elf::NoteHeader32 {
+ n_namesz: U32::new(endian, 6),
+ n_descsz: U32::new(endian, 11),
+ n_type: U32::new(endian, 1),
+ }))
+ .unwrap();
+ buffer.write(b"name1\0\0\0\0\0\0\0").unwrap();
+ buffer.write(b"descriptor\0\0\0\0\0\0").unwrap();
+
+ buffer
+ .write(object::bytes_of(&elf::NoteHeader32 {
+ n_namesz: U32::new(endian, 4),
+ n_descsz: U32::new(endian, 11),
+ n_type: U32::new(endian, 2),
+ }))
+ .unwrap();
+ buffer.write(b"abc\0").unwrap();
+ buffer.write(b"descriptor\0\0\0\0\0\0").unwrap();
+
+ let section = object.add_section(Vec::new(), b".note8".to_vec(), SectionKind::Note);
+ object.section_mut(section).set_data(buffer, 8);
+
+ let bytes = &*object.write().unwrap();
+
+ //std::fs::write(&"note.o", &bytes).unwrap();
+
+ let header = elf::FileHeader64::parse(bytes).unwrap();
+ let endian: LittleEndian = header.endian().unwrap();
+ let sections = header.sections(endian, bytes).unwrap();
+
+ let section = sections.section(1).unwrap();
+ assert_eq!(sections.section_name(endian, section).unwrap(), b".note4");
+ assert_eq!(section.sh_addralign(endian), 4);
+ let mut notes = section.notes(endian, bytes).unwrap().unwrap();
+ let note = notes.next().unwrap().unwrap();
+ assert_eq!(note.name(), b"name1");
+ assert_eq!(note.desc(), b"descriptor\0");
+ assert_eq!(note.n_type(endian), 1);
+ let note = notes.next().unwrap().unwrap();
+ assert_eq!(note.name(), b"name2");
+ assert_eq!(note.desc(), b"descriptor\0");
+ assert_eq!(note.n_type(endian), 2);
+ assert!(notes.next().unwrap().is_none());
+
+ let section = sections.section(2).unwrap();
+ assert_eq!(sections.section_name(endian, section).unwrap(), b".note8");
+ assert_eq!(section.sh_addralign(endian), 8);
+ let mut notes = section.notes(endian, bytes).unwrap().unwrap();
+ let note = notes.next().unwrap().unwrap();
+ assert_eq!(note.name(), b"name1");
+ assert_eq!(note.desc(), b"descriptor\0");
+ assert_eq!(note.n_type(endian), 1);
+ let note = notes.next().unwrap().unwrap();
+ assert_eq!(note.name(), b"abc");
+ assert_eq!(note.desc(), b"descriptor\0");
+ assert_eq!(note.n_type(endian), 2);
+ assert!(notes.next().unwrap().is_none());
+}
diff --git a/vendor/object-0.26.2/tests/round_trip/macho.rs b/vendor/object-0.26.2/tests/round_trip/macho.rs
new file mode 100644
index 000000000..ca3ad5ca2
--- /dev/null
+++ b/vendor/object-0.26.2/tests/round_trip/macho.rs
@@ -0,0 +1,24 @@
+use object::read::macho::MachHeader;
+use object::{macho, write, Architecture, BinaryFormat, Endianness};
+
+#[test]
+// Test that segment size is valid when the first section needs alignment.
+fn issue_286_segment_file_size() {
+ let mut object = write::Object::new(
+ BinaryFormat::MachO,
+ Architecture::X86_64,
+ Endianness::Little,
+ );
+
+ let text = object.section_id(write::StandardSection::Text);
+ object.append_section_data(text, &[1; 30], 0x1000);
+
+ let bytes = &*object.write().unwrap();
+ let header = macho::MachHeader64::parse(bytes, 0).unwrap();
+ let endian: Endianness = header.endian().unwrap();
+ let mut commands = header.load_commands(endian, bytes, 0).unwrap();
+ let command = commands.next().unwrap().unwrap();
+ let (segment, _) = command.segment_64().unwrap().unwrap();
+ assert_eq!(segment.vmsize.get(endian), 30);
+ assert_eq!(segment.filesize.get(endian), 30);
+}
diff --git a/vendor/object-0.26.2/tests/round_trip/mod.rs b/vendor/object-0.26.2/tests/round_trip/mod.rs
new file mode 100644
index 000000000..37050689f
--- /dev/null
+++ b/vendor/object-0.26.2/tests/round_trip/mod.rs
@@ -0,0 +1,445 @@
+#![cfg(all(feature = "read", feature = "write"))]
+
+use object::read::{Object, ObjectSection, ObjectSymbol};
+use object::{read, write};
+use object::{
+ Architecture, BinaryFormat, Endianness, RelocationEncoding, RelocationKind, SectionKind,
+ SymbolFlags, SymbolKind, SymbolScope, SymbolSection,
+};
+
+mod bss;
+mod comdat;
+mod common;
+mod elf;
+mod macho;
+mod tls;
+
+#[test]
+fn coff_x86_64() {
+ let mut object =
+ write::Object::new(BinaryFormat::Coff, Architecture::X86_64, Endianness::Little);
+
+ object.add_file_symbol(b"file.c".to_vec());
+
+ let text = object.section_id(write::StandardSection::Text);
+ object.append_section_data(text, &[1; 30], 4);
+
+ let func1_offset = object.append_section_data(text, &[1; 30], 4);
+ assert_eq!(func1_offset, 32);
+ let func1_symbol = object.add_symbol(write::Symbol {
+ name: b"func1".to_vec(),
+ value: func1_offset,
+ size: 32,
+ kind: SymbolKind::Text,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Section(text),
+ flags: SymbolFlags::None,
+ });
+ object
+ .add_relocation(
+ text,
+ write::Relocation {
+ offset: 8,
+ size: 64,
+ kind: RelocationKind::Absolute,
+ encoding: RelocationEncoding::Generic,
+ symbol: func1_symbol,
+ addend: 0,
+ },
+ )
+ .unwrap();
+
+ let bytes = object.write().unwrap();
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Coff);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+ assert_eq!(object.endianness(), Endianness::Little);
+
+ let mut sections = object.sections();
+
+ let text = sections.next().unwrap();
+ println!("{:?}", text);
+ let text_index = text.index();
+ assert_eq!(text.name(), Ok(".text"));
+ assert_eq!(text.kind(), SectionKind::Text);
+ assert_eq!(text.address(), 0);
+ assert_eq!(text.size(), 62);
+ assert_eq!(&text.data().unwrap()[..30], &[1; 30]);
+ assert_eq!(&text.data().unwrap()[32..62], &[1; 30]);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("file.c"));
+ assert_eq!(symbol.address(), 0);
+ assert_eq!(symbol.kind(), SymbolKind::File);
+ assert_eq!(symbol.section(), SymbolSection::None);
+ assert_eq!(symbol.scope(), SymbolScope::Compilation);
+ assert_eq!(symbol.is_weak(), false);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ let func1_symbol = symbol.index();
+ assert_eq!(symbol.name(), Ok("func1"));
+ assert_eq!(symbol.address(), func1_offset);
+ assert_eq!(symbol.kind(), SymbolKind::Text);
+ assert_eq!(symbol.section_index(), Some(text_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+
+ let mut relocations = text.relocations();
+
+ let (offset, relocation) = relocations.next().unwrap();
+ println!("{:?}", relocation);
+ assert_eq!(offset, 8);
+ assert_eq!(relocation.kind(), RelocationKind::Absolute);
+ assert_eq!(relocation.encoding(), RelocationEncoding::Generic);
+ assert_eq!(relocation.size(), 64);
+ assert_eq!(
+ relocation.target(),
+ read::RelocationTarget::Symbol(func1_symbol)
+ );
+ assert_eq!(relocation.addend(), 0);
+
+ let map = object.symbol_map();
+ let symbol = map.get(func1_offset + 1).unwrap();
+ assert_eq!(symbol.address(), func1_offset);
+ assert_eq!(symbol.name(), "func1");
+ assert_eq!(map.get(func1_offset - 1), None);
+}
+
+#[test]
+fn elf_x86_64() {
+ let mut object =
+ write::Object::new(BinaryFormat::Elf, Architecture::X86_64, Endianness::Little);
+
+ object.add_file_symbol(b"file.c".to_vec());
+
+ let text = object.section_id(write::StandardSection::Text);
+ object.append_section_data(text, &[1; 30], 4);
+
+ let func1_offset = object.append_section_data(text, &[1; 30], 4);
+ assert_eq!(func1_offset, 32);
+ let func1_symbol = object.add_symbol(write::Symbol {
+ name: b"func1".to_vec(),
+ value: func1_offset,
+ size: 32,
+ kind: SymbolKind::Text,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Section(text),
+ flags: SymbolFlags::None,
+ });
+ object
+ .add_relocation(
+ text,
+ write::Relocation {
+ offset: 8,
+ size: 64,
+ kind: RelocationKind::Absolute,
+ encoding: RelocationEncoding::Generic,
+ symbol: func1_symbol,
+ addend: 0,
+ },
+ )
+ .unwrap();
+
+ let bytes = object.write().unwrap();
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Elf);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+ assert_eq!(object.endianness(), Endianness::Little);
+
+ let mut sections = object.sections();
+
+ let section = sections.next().unwrap();
+ println!("{:?}", section);
+ assert_eq!(section.name(), Ok(""));
+ assert_eq!(section.kind(), SectionKind::Metadata);
+ assert_eq!(section.address(), 0);
+ assert_eq!(section.size(), 0);
+
+ let text = sections.next().unwrap();
+ println!("{:?}", text);
+ let text_index = text.index();
+ assert_eq!(text.name(), Ok(".text"));
+ assert_eq!(text.kind(), SectionKind::Text);
+ assert_eq!(text.address(), 0);
+ assert_eq!(text.size(), 62);
+ assert_eq!(&text.data().unwrap()[..30], &[1; 30]);
+ assert_eq!(&text.data().unwrap()[32..62], &[1; 30]);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok(""));
+ assert_eq!(symbol.address(), 0);
+ assert_eq!(symbol.kind(), SymbolKind::Null);
+ assert_eq!(symbol.section_index(), None);
+ assert_eq!(symbol.scope(), SymbolScope::Unknown);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), true);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("file.c"));
+ assert_eq!(symbol.address(), 0);
+ assert_eq!(symbol.kind(), SymbolKind::File);
+ assert_eq!(symbol.section(), SymbolSection::None);
+ assert_eq!(symbol.scope(), SymbolScope::Compilation);
+ assert_eq!(symbol.is_weak(), false);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ let func1_symbol = symbol.index();
+ assert_eq!(symbol.name(), Ok("func1"));
+ assert_eq!(symbol.address(), func1_offset);
+ assert_eq!(symbol.kind(), SymbolKind::Text);
+ assert_eq!(symbol.section_index(), Some(text_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+
+ let mut relocations = text.relocations();
+
+ let (offset, relocation) = relocations.next().unwrap();
+ println!("{:?}", relocation);
+ assert_eq!(offset, 8);
+ assert_eq!(relocation.kind(), RelocationKind::Absolute);
+ assert_eq!(relocation.encoding(), RelocationEncoding::Generic);
+ assert_eq!(relocation.size(), 64);
+ assert_eq!(
+ relocation.target(),
+ read::RelocationTarget::Symbol(func1_symbol)
+ );
+ assert_eq!(relocation.addend(), 0);
+
+ let map = object.symbol_map();
+ let symbol = map.get(func1_offset + 1).unwrap();
+ assert_eq!(symbol.address(), func1_offset);
+ assert_eq!(symbol.name(), "func1");
+ assert_eq!(map.get(func1_offset - 1), None);
+}
+
+#[test]
+fn elf_any() {
+ for (arch, endian) in [
+ (Architecture::Aarch64, Endianness::Little),
+ (Architecture::Arm, Endianness::Little),
+ (Architecture::Avr, Endianness::Little),
+ (Architecture::Bpf, Endianness::Little),
+ (Architecture::I386, Endianness::Little),
+ (Architecture::X86_64, Endianness::Little),
+ (Architecture::X86_64_X32, Endianness::Little),
+ (Architecture::Hexagon, Endianness::Little),
+ (Architecture::Mips, Endianness::Little),
+ (Architecture::Mips64, Endianness::Little),
+ (Architecture::Msp430, Endianness::Little),
+ (Architecture::PowerPc, Endianness::Big),
+ (Architecture::PowerPc64, Endianness::Big),
+ (Architecture::Riscv32, Endianness::Little),
+ (Architecture::Riscv64, Endianness::Little),
+ (Architecture::S390x, Endianness::Big),
+ (Architecture::Sparc64, Endianness::Big),
+ ]
+ .iter()
+ .copied()
+ {
+ let mut object = write::Object::new(BinaryFormat::Elf, arch, endian);
+
+ let section = object.section_id(write::StandardSection::Data);
+ object.append_section_data(section, &[1; 30], 4);
+ let symbol = object.section_symbol(section);
+
+ object
+ .add_relocation(
+ section,
+ write::Relocation {
+ offset: 8,
+ size: 32,
+ kind: RelocationKind::Absolute,
+ encoding: RelocationEncoding::Generic,
+ symbol,
+ addend: 0,
+ },
+ )
+ .unwrap();
+ if arch.address_size().unwrap().bytes() >= 8 {
+ object
+ .add_relocation(
+ section,
+ write::Relocation {
+ offset: 16,
+ size: 64,
+ kind: RelocationKind::Absolute,
+ encoding: RelocationEncoding::Generic,
+ symbol,
+ addend: 0,
+ },
+ )
+ .unwrap();
+ }
+
+ let bytes = object.write().unwrap();
+ let object = read::File::parse(&*bytes).unwrap();
+ println!("{:?}", object.architecture());
+ assert_eq!(object.format(), BinaryFormat::Elf);
+ assert_eq!(object.architecture(), arch);
+ assert_eq!(object.endianness(), endian);
+
+ let mut sections = object.sections();
+
+ let section = sections.next().unwrap();
+ println!("{:?}", section);
+ assert_eq!(section.name(), Ok(""));
+ assert_eq!(section.kind(), SectionKind::Metadata);
+ assert_eq!(section.address(), 0);
+ assert_eq!(section.size(), 0);
+
+ let data = sections.next().unwrap();
+ println!("{:?}", data);
+ assert_eq!(data.name(), Ok(".data"));
+ assert_eq!(data.kind(), SectionKind::Data);
+
+ let mut relocations = data.relocations();
+
+ let (offset, relocation) = relocations.next().unwrap();
+ println!("{:?}", relocation);
+ assert_eq!(offset, 8);
+ assert_eq!(relocation.kind(), RelocationKind::Absolute);
+ assert_eq!(relocation.encoding(), RelocationEncoding::Generic);
+ assert_eq!(relocation.size(), 32);
+ assert_eq!(relocation.addend(), 0);
+
+ if arch.address_size().unwrap().bytes() >= 8 {
+ let (offset, relocation) = relocations.next().unwrap();
+ println!("{:?}", relocation);
+ assert_eq!(offset, 16);
+ assert_eq!(relocation.kind(), RelocationKind::Absolute);
+ assert_eq!(relocation.encoding(), RelocationEncoding::Generic);
+ assert_eq!(relocation.size(), 64);
+ assert_eq!(relocation.addend(), 0);
+ }
+ }
+}
+
+#[test]
+fn macho_x86_64() {
+ let mut object = write::Object::new(
+ BinaryFormat::MachO,
+ Architecture::X86_64,
+ Endianness::Little,
+ );
+
+ object.add_file_symbol(b"file.c".to_vec());
+
+ let text = object.section_id(write::StandardSection::Text);
+ object.append_section_data(text, &[1; 30], 4);
+
+ let func1_offset = object.append_section_data(text, &[1; 30], 4);
+ assert_eq!(func1_offset, 32);
+ let func1_symbol = object.add_symbol(write::Symbol {
+ name: b"func1".to_vec(),
+ value: func1_offset,
+ size: 32,
+ kind: SymbolKind::Text,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Section(text),
+ flags: SymbolFlags::None,
+ });
+ object
+ .add_relocation(
+ text,
+ write::Relocation {
+ offset: 8,
+ size: 64,
+ kind: RelocationKind::Absolute,
+ encoding: RelocationEncoding::Generic,
+ symbol: func1_symbol,
+ addend: 0,
+ },
+ )
+ .unwrap();
+ object
+ .add_relocation(
+ text,
+ write::Relocation {
+ offset: 16,
+ size: 32,
+ kind: RelocationKind::Relative,
+ encoding: RelocationEncoding::Generic,
+ symbol: func1_symbol,
+ addend: -4,
+ },
+ )
+ .unwrap();
+
+ let bytes = object.write().unwrap();
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::MachO);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+ assert_eq!(object.endianness(), Endianness::Little);
+
+ let mut sections = object.sections();
+
+ let text = sections.next().unwrap();
+ println!("{:?}", text);
+ let text_index = text.index();
+ assert_eq!(text.name(), Ok("__text"));
+ assert_eq!(text.segment_name(), Ok(Some("__TEXT")));
+ assert_eq!(text.kind(), SectionKind::Text);
+ assert_eq!(text.address(), 0);
+ assert_eq!(text.size(), 62);
+ assert_eq!(&text.data().unwrap()[..30], &[1; 30]);
+ assert_eq!(&text.data().unwrap()[32..62], &[1; 30]);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ let func1_symbol = symbol.index();
+ assert_eq!(symbol.name(), Ok("_func1"));
+ assert_eq!(symbol.address(), func1_offset);
+ assert_eq!(symbol.kind(), SymbolKind::Text);
+ assert_eq!(symbol.section_index(), Some(text_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+
+ let mut relocations = text.relocations();
+
+ let (offset, relocation) = relocations.next().unwrap();
+ println!("{:?}", relocation);
+ assert_eq!(offset, 8);
+ assert_eq!(relocation.kind(), RelocationKind::Absolute);
+ assert_eq!(relocation.encoding(), RelocationEncoding::Generic);
+ assert_eq!(relocation.size(), 64);
+ assert_eq!(
+ relocation.target(),
+ read::RelocationTarget::Symbol(func1_symbol)
+ );
+ assert_eq!(relocation.addend(), 0);
+
+ let (offset, relocation) = relocations.next().unwrap();
+ println!("{:?}", relocation);
+ assert_eq!(offset, 16);
+ assert_eq!(relocation.kind(), RelocationKind::Relative);
+ assert_eq!(relocation.encoding(), RelocationEncoding::X86RipRelative);
+ assert_eq!(relocation.size(), 32);
+ assert_eq!(
+ relocation.target(),
+ read::RelocationTarget::Symbol(func1_symbol)
+ );
+ assert_eq!(relocation.addend(), -4);
+
+ let map = object.symbol_map();
+ let symbol = map.get(func1_offset + 1).unwrap();
+ assert_eq!(symbol.address(), func1_offset);
+ assert_eq!(symbol.name(), "_func1");
+ assert_eq!(map.get(func1_offset - 1), None);
+}
diff --git a/vendor/object-0.26.2/tests/round_trip/tls.rs b/vendor/object-0.26.2/tests/round_trip/tls.rs
new file mode 100644
index 000000000..999e2f181
--- /dev/null
+++ b/vendor/object-0.26.2/tests/round_trip/tls.rs
@@ -0,0 +1,316 @@
+#![cfg(all(feature = "read", feature = "write"))]
+
+use object::read::{Object, ObjectSection, ObjectSymbol};
+use object::{read, write};
+use object::{
+ Architecture, BinaryFormat, Endianness, RelocationEncoding, RelocationKind, SectionKind,
+ SymbolFlags, SymbolKind, SymbolScope,
+};
+
+#[test]
+fn coff_x86_64_tls() {
+ let mut object =
+ write::Object::new(BinaryFormat::Coff, Architecture::X86_64, Endianness::Little);
+
+ let section = object.section_id(write::StandardSection::Tls);
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"tls1".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Tls,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_data(symbol, section, &[1; 30], 4);
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"tls.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Coff);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut sections = object.sections();
+
+ let section = sections.next().unwrap();
+ println!("{:?}", section);
+ let tls_index = section.index();
+ assert_eq!(section.name(), Ok(".tls$"));
+ assert_eq!(section.kind(), SectionKind::Data);
+ assert_eq!(section.size(), 30);
+ assert_eq!(&section.data().unwrap()[..], &[1; 30]);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("tls1"));
+ assert_eq!(symbol.kind(), SymbolKind::Data);
+ assert_eq!(symbol.section_index(), Some(tls_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+}
+
+#[test]
+fn elf_x86_64_tls() {
+ let mut object =
+ write::Object::new(BinaryFormat::Elf, Architecture::X86_64, Endianness::Little);
+
+ let section = object.section_id(write::StandardSection::Tls);
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"tls1".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Tls,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_data(symbol, section, &[1; 30], 4);
+
+ let section = object.section_id(write::StandardSection::UninitializedTls);
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"tls2".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Tls,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_bss(symbol, section, 31, 4);
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"tls.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::Elf);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut sections = object.sections();
+
+ let section = sections.next().unwrap();
+ println!("{:?}", section);
+ assert_eq!(section.name(), Ok(""));
+
+ let section = sections.next().unwrap();
+ println!("{:?}", section);
+ let tdata_index = section.index();
+ assert_eq!(section.name(), Ok(".tdata"));
+ assert_eq!(section.kind(), SectionKind::Tls);
+ assert_eq!(section.size(), 30);
+ assert_eq!(&section.data().unwrap()[..], &[1; 30]);
+
+ let section = sections.next().unwrap();
+ println!("{:?}", section);
+ let tbss_index = section.index();
+ assert_eq!(section.name(), Ok(".tbss"));
+ assert_eq!(section.kind(), SectionKind::UninitializedTls);
+ assert_eq!(section.size(), 31);
+ assert_eq!(&section.data().unwrap()[..], &[]);
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok(""));
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("tls1"));
+ assert_eq!(symbol.kind(), SymbolKind::Tls);
+ assert_eq!(symbol.section_index(), Some(tdata_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.size(), 30);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("tls2"));
+ assert_eq!(symbol.kind(), SymbolKind::Tls);
+ assert_eq!(symbol.section_index(), Some(tbss_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+ assert_eq!(symbol.size(), 31);
+}
+
+#[test]
+fn macho_x86_64_tls() {
+ let mut object = write::Object::new(
+ BinaryFormat::MachO,
+ Architecture::X86_64,
+ Endianness::Little,
+ );
+
+ let section = object.section_id(write::StandardSection::Tls);
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"tls1".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Tls,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_data(symbol, section, &[1; 30], 4);
+
+ let section = object.section_id(write::StandardSection::UninitializedTls);
+ let symbol = object.add_symbol(write::Symbol {
+ name: b"tls2".to_vec(),
+ value: 0,
+ size: 0,
+ kind: SymbolKind::Tls,
+ scope: SymbolScope::Linkage,
+ weak: false,
+ section: write::SymbolSection::Undefined,
+ flags: SymbolFlags::None,
+ });
+ object.add_symbol_bss(symbol, section, 31, 4);
+
+ let bytes = object.write().unwrap();
+
+ //std::fs::write(&"tls.o", &bytes).unwrap();
+
+ let object = read::File::parse(&*bytes).unwrap();
+ assert_eq!(object.format(), BinaryFormat::MachO);
+ assert_eq!(object.architecture(), Architecture::X86_64);
+
+ let mut sections = object.sections();
+
+ let thread_data = sections.next().unwrap();
+ println!("{:?}", thread_data);
+ let thread_data_index = thread_data.index();
+ assert_eq!(thread_data.name(), Ok("__thread_data"));
+ assert_eq!(thread_data.segment_name(), Ok(Some("__DATA")));
+ assert_eq!(thread_data.kind(), SectionKind::Tls);
+ assert_eq!(thread_data.size(), 30);
+ assert_eq!(&thread_data.data().unwrap()[..], &[1; 30]);
+
+ let thread_vars = sections.next().unwrap();
+ println!("{:?}", thread_vars);
+ let thread_vars_index = thread_vars.index();
+ assert_eq!(thread_vars.name(), Ok("__thread_vars"));
+ assert_eq!(thread_vars.segment_name(), Ok(Some("__DATA")));
+ assert_eq!(thread_vars.kind(), SectionKind::TlsVariables);
+ assert_eq!(thread_vars.size(), 2 * 3 * 8);
+ assert_eq!(&thread_vars.data().unwrap()[..], &[0; 48][..]);
+
+ let thread_bss = sections.next().unwrap();
+ println!("{:?}", thread_bss);
+ let thread_bss_index = thread_bss.index();
+ assert_eq!(thread_bss.name(), Ok("__thread_bss"));
+ assert_eq!(thread_bss.segment_name(), Ok(Some("__DATA")));
+ assert_eq!(thread_bss.kind(), SectionKind::UninitializedTls);
+ assert_eq!(thread_bss.size(), 31);
+ assert_eq!(thread_bss.data(), Ok(&[][..]));
+
+ let mut symbols = object.symbols();
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("_tls1"));
+ assert_eq!(symbol.kind(), SymbolKind::Tls);
+ assert_eq!(symbol.section_index(), Some(thread_vars_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ let tls1_init_symbol = symbol.index();
+ assert_eq!(symbol.name(), Ok("_tls1$tlv$init"));
+ assert_eq!(symbol.kind(), SymbolKind::Tls);
+ assert_eq!(symbol.section_index(), Some(thread_data_index));
+ assert_eq!(symbol.scope(), SymbolScope::Compilation);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ let tlv_bootstrap_symbol = symbol.index();
+ assert_eq!(symbol.name(), Ok("__tlv_bootstrap"));
+ assert_eq!(symbol.kind(), SymbolKind::Unknown);
+ assert_eq!(symbol.section_index(), None);
+ assert_eq!(symbol.scope(), SymbolScope::Unknown);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), true);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ assert_eq!(symbol.name(), Ok("_tls2"));
+ assert_eq!(symbol.kind(), SymbolKind::Tls);
+ assert_eq!(symbol.section_index(), Some(thread_vars_index));
+ assert_eq!(symbol.scope(), SymbolScope::Linkage);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+
+ let symbol = symbols.next().unwrap();
+ println!("{:?}", symbol);
+ let tls2_init_symbol = symbol.index();
+ assert_eq!(symbol.name(), Ok("_tls2$tlv$init"));
+ assert_eq!(symbol.kind(), SymbolKind::Tls);
+ assert_eq!(symbol.section_index(), Some(thread_bss_index));
+ assert_eq!(symbol.scope(), SymbolScope::Compilation);
+ assert_eq!(symbol.is_weak(), false);
+ assert_eq!(symbol.is_undefined(), false);
+
+ let mut relocations = thread_vars.relocations();
+
+ let (offset, relocation) = relocations.next().unwrap();
+ println!("{:?}", relocation);
+ assert_eq!(offset, 0);
+ assert_eq!(relocation.kind(), RelocationKind::Absolute);
+ assert_eq!(relocation.encoding(), RelocationEncoding::Generic);
+ assert_eq!(relocation.size(), 64);
+ assert_eq!(
+ relocation.target(),
+ read::RelocationTarget::Symbol(tlv_bootstrap_symbol)
+ );
+ assert_eq!(relocation.addend(), 0);
+
+ let (offset, relocation) = relocations.next().unwrap();
+ println!("{:?}", relocation);
+ assert_eq!(offset, 16);
+ assert_eq!(relocation.kind(), RelocationKind::Absolute);
+ assert_eq!(relocation.encoding(), RelocationEncoding::Generic);
+ assert_eq!(relocation.size(), 64);
+ assert_eq!(
+ relocation.target(),
+ read::RelocationTarget::Symbol(tls1_init_symbol)
+ );
+ assert_eq!(relocation.addend(), 0);
+
+ let (offset, relocation) = relocations.next().unwrap();
+ println!("{:?}", relocation);
+ assert_eq!(offset, 24);
+ assert_eq!(relocation.kind(), RelocationKind::Absolute);
+ assert_eq!(relocation.encoding(), RelocationEncoding::Generic);
+ assert_eq!(relocation.size(), 64);
+ assert_eq!(
+ relocation.target(),
+ read::RelocationTarget::Symbol(tlv_bootstrap_symbol)
+ );
+ assert_eq!(relocation.addend(), 0);
+
+ let (offset, relocation) = relocations.next().unwrap();
+ println!("{:?}", relocation);
+ assert_eq!(offset, 40);
+ assert_eq!(relocation.kind(), RelocationKind::Absolute);
+ assert_eq!(relocation.encoding(), RelocationEncoding::Generic);
+ assert_eq!(relocation.size(), 64);
+ assert_eq!(
+ relocation.target(),
+ read::RelocationTarget::Symbol(tls2_init_symbol)
+ );
+ assert_eq!(relocation.addend(), 0);
+}