--- documentID: "9234e6bbacb2f0d3db307e70152f1335b633e161a06198ed452a3a25cb9454b3" docname: "formats/macho/cpp" title: "Mach-O C++ API - LIEF Documentation" description: "Mach-O C++ API reference documentation for LIEF, including APIs and examples for parsing, inspecting, modifying, and writing executable formats." canonical: "https://lief.re/doc/latest/formats/macho/cpp.html" markdownURL: "https://lief.re/doc/latest/formats/macho/cpp.md" documentationVersion: "2.0.0" documentationChannel: "latest" language: "en" contentHash: "5c75e9781c7028c0a49dca1f1b95183e23f6e33e8f28483b7dc941bd8bf50ac9" --- # [C++]() ## [Parser]() ### [` Parser `]() class Parser : public LIEF::[Parser]( "LIEF::Parser") The main interface to parse a Mach-O binary. This class is used to parse both Fat & non-Fat binary. Non-fat binaries are considered as a **fat** with only one architecture. This is why [MachO::Parser::parse]() outputs a [FatBinary]() object. Public Functions #### [` operator= `]() [Parser]( "LIEF::MachO::Parser") &operator=(const [Parser]( "LIEF::MachO::Parser") &copy) = delete #### [` Parser `]() Parser(const [Parser]( "LIEF::MachO::Parser::Parser") &copy) = delete #### [` ~Parser `]() ~Parser() Public Static Functions #### [` parse `]() static std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> parse(std::string\_view filename, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Parse a Mach-O file from the path provided by the `filename` parameter. The `conf` parameter can be used to tweak the configuration of the parser **Parameters:** - **filename** – **[in]** Path to the Mach-O file - **conf** – **[in]** [Parser]() configuration (Default: [ParserConfig::deep]()) #### [` PathTparse `]() template<class PathT, enable\_if\_path\_t<[PathT]( "LIEF::MachO::Parser::parse::PathT")> = 0> static inline std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> parse(const [PathT]( "LIEF::MachO::Parser::parse::PathT") &filename, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Same as [parse(std::string\_view, const ParserConfig&)]() but the file is given as a `std::filesystem::path`. #### [` parse `]() static std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> parse(const std::vector<uint8\_t> &data, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Parse a Mach-O file from the raw content provided by the `data` parameter. The `conf` parameter can be used to tweak the configuration of the parser **Parameters:** - **data** – **[in]** Mach-O file as a vector of bytes - **conf** – **[in]** [Parser]() configuration (Default: [ParserConfig::deep]()) #### [` parse `]() static std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> parse(std::unique\_ptr<[BinaryStream]( "LIEF::BinaryStream")> stream, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Parse a Mach-O binary from the provided [BinaryStream](). #### [` parse_from_memory `]() static std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> parse\_from\_memory(uintptr\_t address, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Parse the Mach-O binary from the address given in the first parameter. #### [` parse_from_memory `]() static std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> parse\_from\_memory(uintptr\_t address, size\_t size, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Parse the Mach-O binary from the address given in the first parameter and the size given in the second parameter. #### [` parse_from_dump `]() static std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> parse\_from\_dump(std::string\_view filepath, uint64\_t addr, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Parse a Mach-O binary from a memory dump located on disk. A dump is a raw capture of the process memory that was mapped starting at the virtual address `addr`. This is typically used to parse a Mach-O image that has been dumped from memory (e.g. from a debugger or a runtime hook). **Parameters:** - **filepath** – **[in]** Path to the file that contains the memory dump - **addr** – **[in]** Virtual address at which the dump was mapped - **conf** – **[in]** Optional configuration for the parser #### [` PathTparse_from_dump `]() template<class PathT, enable\_if\_path\_t<[PathT]( "LIEF::MachO::Parser::parse_from_dump::PathT")> = 0> static inline std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> parse\_from\_dump(const [PathT]( "LIEF::MachO::Parser::parse_from_dump::PathT") &filepath, uint64\_t addr, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Same as [parse\_from\_dump(std::string\_view, uint64\_t, const ParserConfig&)]() but the dump file is given as a `std::filesystem::path`. #### [` parse_from_dump `]() static std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> parse\_from\_dump([BinaryStream]( "LIEF::BinaryStream") &stream, uint64\_t addr, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Same as [parse\_from\_dump(std::string\_view, uint64\_t, const ParserConfig&)]() but the dump is wrapped in the given **non-owned** stream. #### [` parse_from_dump `]() static std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> parse\_from\_dump(std::unique\_ptr<[BinaryStream]( "LIEF::BinaryStream")> stream, uint64\_t addr, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Same as [parse\_from\_dump(std::string\_view, uint64\_t, const ParserConfig&)]() but the dump is wrapped in the given **owned** stream. ### [` BinaryParser `]() class BinaryParser : public LIEF::[Parser]( "LIEF::Parser") Class used to parse a **single** binary (i.e. non-FAT). > **See also** > > [MachO::Parser]() > **Warning** > > This class should not be used directly. Public Functions #### [` operator= `]() [BinaryParser]( "LIEF::MachO::BinaryParser") &operator=(const [BinaryParser]( "LIEF::MachO::BinaryParser") &copy) = delete #### [` BinaryParser `]() BinaryParser(const [BinaryParser]( "LIEF::MachO::BinaryParser::BinaryParser") &copy) = delete #### [` ~BinaryParser `]() ~BinaryParser() Public Static Functions #### [` parse `]() static std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")> parse(std::string\_view file) #### [` parse `]() static std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")> parse(std::string\_view file, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf) #### [` PathTparse `]() template<class PathT, enable\_if\_path\_t<[PathT]( "LIEF::MachO::BinaryParser::parse::PathT")> = 0> static inline std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")> parse(const [PathT]( "LIEF::MachO::BinaryParser::parse::PathT") &file, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) Same as [parse(std::string\_view, const ParserConfig&)]() but the file is given as a `std::filesystem::path`. #### [` parse `]() static std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")> parse(const std::vector<uint8\_t> &data, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) #### [` parse `]() static std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")> parse(const std::vector<uint8\_t> &data, uint64\_t fat\_offset, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf = [ParserConfig]( "LIEF::MachO::ParserConfig")::[deep]( "LIEF::MachO::ParserConfig::deep")()) #### [` parse `]() static std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")> parse(std::unique\_ptr<[BinaryStream]( "LIEF::BinaryStream")> stream, uint64\_t fat\_offset, const [ParserConfig]( "LIEF::MachO::ParserConfig") &conf) Friends **friend class MachO::Parser** ### [` ParserConfig `]() struct ParserConfig This structure is used to tweak the MachO [Parser]() ([MachO::Parser]()). Public Functions #### [` full_dyldinfo `]() [ParserConfig]( "LIEF::MachO::ParserConfig") &full\_dyldinfo(bool flag) If `flag` is set to `true`, Exports, Bindings and Rebases opcodes are parsed. > **Warning** > > Enabling this flag can slow down the parsing Public Members #### [` parse_dyld_exports `]() bool parse\_dyld\_exports = true Parse the Dyld export trie. #### [` parse_dyld_bindings `]() bool parse\_dyld\_bindings = true Parse the Dyld binding opcodes. #### [` parse_dyld_rebases `]() bool parse\_dyld\_rebases = true Parse the Dyld rebase opcodes. #### [` parse_overlay `]() bool parse\_overlay = true Whether the overlay data should be parsed. #### [` fix_from_memory `]() bool fix\_from\_memory = false When parsing Mach-O from memory, this option can be used to *undo* relocations and symbols bindings. When activated, this option requires parse\_dyld\_bindings and parse\_dyld\_rebases to be enabled. #### [` from_dyld_shared_cache `]() bool from\_dyld\_shared\_cache = false Whether the binary is coming/extracted from Dyld shared cache. Public Static Functions #### [` deep `]() static [ParserConfig]( "LIEF::MachO::ParserConfig") deep() Return a parser configuration such as all the objects supported by LIEF are parsed. #### [` quick `]() static [ParserConfig]( "LIEF::MachO::ParserConfig") quick() Return a configuration to parse the most important MachO structures. --- ## [FatBinary]() ### [` FatBinary `]() class FatBinary Class which represents a Mach-O (fat) binary This object is also used for representing Mach-O binaries that are **NOT FAT**. Public Types #### [` binaries_t `]() using binaries\_t = std::vector<std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")>> Internal container used to store [Binary]() objects within a Fat Mach-O. #### [` it_binaries `]() using it\_binaries = [ref\_iterator]( "LIEF::ref_iterator")<[binaries\_t]( "LIEF::MachO::FatBinary::binaries_t")&, [Binary]( "LIEF::MachO::Binary")\*> Iterator that outputs [Binary]()&. #### [` it_const_binaries `]() using it\_const\_binaries = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [binaries\_t]( "LIEF::MachO::FatBinary::binaries_t")&, [Binary]( "LIEF::MachO::Binary")\*> Iterator that outputs const [Binary]()&. Public Functions #### [` FatBinary `]() FatBinary(const [FatBinary]( "LIEF::MachO::FatBinary::FatBinary")&) = delete #### [` operator= `]() [FatBinary]( "LIEF::MachO::FatBinary") &operator=(const [FatBinary]( "LIEF::MachO::FatBinary")&) = delete #### [` ~FatBinary `]() virtual ~FatBinary() #### [` size `]() inline size\_t size() const Number of [MachO::Binary]() wrapped by this object. #### [` empty `]() inline bool empty() const Checks whether this object contains [MachO::Binary](). #### [` begin `]() inline [it\_binaries]( "LIEF::MachO::FatBinary::it_binaries") begin() #### [` begin `]() inline [it\_const\_binaries]( "LIEF::MachO::FatBinary::it_const_binaries") begin() const #### [` end `]() inline [it\_binaries]( "LIEF::MachO::FatBinary::it_binaries") end() #### [` end `]() inline [it\_const\_binaries]( "LIEF::MachO::FatBinary::it_const_binaries") end() const #### [` release_all_binaries `]() inline void release\_all\_binaries() #### [` pop_back `]() std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")> pop\_back() Get a pointer to the last [MachO::Binary]() object present in this Fat [Binary](). It returns a nullptr if no binaries are present. #### [` at `]() inline [Binary]( "LIEF::MachO::Binary") \*at(size\_t index) Get a pointer to the [MachO::Binary]() specified by the `index`. It returns a nullptr if the binary does not exist at the given index. #### [` at `]() inline const [Binary]( "LIEF::MachO::Binary") \*at(size\_t index) const #### [` back `]() inline [Binary]( "LIEF::MachO::Binary") \*back() #### [` back `]() inline const [Binary]( "LIEF::MachO::Binary") \*back() const #### [` front `]() inline [Binary]( "LIEF::MachO::Binary") \*front() #### [` front `]() inline const [Binary]( "LIEF::MachO::Binary") \*front() const #### [` operator[] `]() inline [Binary]( "LIEF::MachO::Binary") \*operator[](size\_t index) #### [` operator[] `]() inline const [Binary]( "LIEF::MachO::Binary") \*operator[](size\_t index) const #### [` take `]() std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")> take(size\_t index) Extract a [MachO::Binary]() object. Gives ownership to the caller, and remove it from this [FatBinary]() object. > **Warning** > > This invalidates any previously held iterator! #### [` take `]() std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")> take([Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") cpu) Take the underlying [MachO::Binary]() that matches the given architecture If no binary with the architecture can be found, return a nullptr. #### [` write `]() void write(const std::string &filename) Reconstruct the Fat binary object and write it in `filename`. **Parameters:** **filename** – Path to write the reconstructed binary #### [` raw `]() std::vector<uint8\_t> raw() Reconstruct the Fat binary object and return its content as bytes. #### [` get `]() inline [Binary]( "LIEF::MachO::Binary") \*get([Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") cpu) #### [` get `]() const [Binary]( "LIEF::MachO::Binary") \*get([Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") cpu) const Gets a pointer to the [MachO::Binary]() that matches the given architecture. #### [` operator[] `]() inline [Binary]( "LIEF::MachO::Binary") \*operator[]([Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") cpu) #### [` operator[] `]() inline const [Binary]( "LIEF::MachO::Binary") \*operator[]([Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") cpu) const Public Static Functions #### [` create `]() static std::unique\_ptr<[FatBinary]( "LIEF::MachO::FatBinary")> create([binaries\_t]( "LIEF::MachO::FatBinary::binaries_t") binaries) Create a [FatBinary]() object from the provided list of [Binary]() objects. The binaries **must** target different architectures (i.e. unique CPU type and subtype). If a duplicate architecture is detected, this function returns a nullptr. Friends **friend class LIEF::Parser** #### [` operator<< `]() friend std::ostream &operator<<(std::ostream &os, const [FatBinary]( "LIEF::MachO::FatBinary") &fatbinary) --- ## [Binary]() ### [` Binary `]() class Binary : public LIEF::[Binary]( "LIEF::Binary") Class which represents a MachO binary. Public Types #### [` commands_t `]() using commands\_t = std::vector<std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")>> Internal container for storing Mach-O [LoadCommand](). #### [` it_commands `]() using it\_commands = [ref\_iterator]( "LIEF::ref_iterator")<[commands\_t]( "LIEF::MachO::Binary::commands_t")&, [LoadCommand]( "LIEF::MachO::LoadCommand")\*> Iterator that outputs [LoadCommand]()&. #### [` it_const_commands `]() using it\_const\_commands = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [commands\_t]( "LIEF::MachO::Binary::commands_t")&, [LoadCommand]( "LIEF::MachO::LoadCommand")\*> Iterator that outputs const [LoadCommand]()&. #### [` symbols_t `]() using symbols\_t = std::vector<std::unique\_ptr<[Symbol]( "LIEF::MachO::Symbol")>> Internal container for storing Mach-O [Symbol](). #### [` it_symbols `]() using it\_symbols = [ref\_iterator]( "LIEF::ref_iterator")<[symbols\_t]( "LIEF::MachO::Binary::symbols_t")&, [Symbol]( "LIEF::MachO::Symbol")\*> Iterator that outputs [Symbol]()&. #### [` it_const_symbols `]() using it\_const\_symbols = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [symbols\_t]( "LIEF::MachO::Binary::symbols_t")&, const [Symbol]( "LIEF::MachO::Symbol")\*> Iterator that outputs const [Symbol]()&. #### [` it_exported_symbols `]() using it\_exported\_symbols = [filter\_iterator]( "LIEF::filter_iterator")<[symbols\_t]( "LIEF::MachO::Binary::symbols_t")&, [Symbol]( "LIEF::MachO::Symbol")\*> Iterator that outputs exported [Symbol]()&. #### [` it_const_exported_symbols `]() using it\_const\_exported\_symbols = [const\_filter\_iterator]( "LIEF::const_filter_iterator")<const [symbols\_t]( "LIEF::MachO::Binary::symbols_t")&, const [Symbol]( "LIEF::MachO::Symbol")\*> Iterator that outputs exported const [Symbol]()&. #### [` it_imported_symbols `]() using it\_imported\_symbols = [filter\_iterator]( "LIEF::filter_iterator")<[symbols\_t]( "LIEF::MachO::Binary::symbols_t")&, [Symbol]( "LIEF::MachO::Symbol")\*> Iterator that outputs imported [Symbol]()&. #### [` it_const_imported_symbols `]() using it\_const\_imported\_symbols = [const\_filter\_iterator]( "LIEF::const_filter_iterator")<const [symbols\_t]( "LIEF::MachO::Binary::symbols_t")&, const [Symbol]( "LIEF::MachO::Symbol")\*> Iterator that outputs imported const [Symbol]()&. #### [` sections_cache_t `]() using sections\_cache\_t = std::vector<[Section]( "LIEF::MachO::Section")\*> Internal container for caching Mach-O [Section](). #### [` it_sections `]() using it\_sections = [ref\_iterator]( "LIEF::ref_iterator")<[sections\_cache\_t]( "LIEF::MachO::Binary::sections_cache_t")&> Iterator that outputs [Section]()&. #### [` it_const_sections `]() using it\_const\_sections = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [sections\_cache\_t]( "LIEF::MachO::Binary::sections_cache_t")&> Iterator that outputs const [Section]()&. #### [` segments_cache_t `]() using segments\_cache\_t = std::vector<[SegmentCommand]( "LIEF::MachO::SegmentCommand")\*> Internal container for storing Mach-O [SegmentCommand](). #### [` it_segments `]() using it\_segments = [ref\_iterator]( "LIEF::ref_iterator")<[segments\_cache\_t]( "LIEF::MachO::Binary::segments_cache_t")&> Iterator that outputs [SegmentCommand]()&. #### [` it_const_segments `]() using it\_const\_segments = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [segments\_cache\_t]( "LIEF::MachO::Binary::segments_cache_t")&> Iterator that outputs const [SegmentCommand]()&. #### [` libraries_cache_t `]() using libraries\_cache\_t = std::vector<[DylibCommand]( "LIEF::MachO::DylibCommand")\*> Internal container for storing Mach-O [DylibCommand](). #### [` it_libraries `]() using it\_libraries = [ref\_iterator]( "LIEF::ref_iterator")<[libraries\_cache\_t]( "LIEF::MachO::Binary::libraries_cache_t")&> Iterator that outputs [DylibCommand]()&. #### [` it_const_libraries `]() using it\_const\_libraries = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [libraries\_cache\_t]( "LIEF::MachO::Binary::libraries_cache_t")&> Iterator that outputs const [DylibCommand]()&. #### [` lazy_load_dylib_info_cache_t `]() using lazy\_load\_dylib\_info\_cache\_t = std::vector<[LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo")\*> Internal container for storing Mach-O [LazyLoadDylibInfo](). #### [` it_lazy_load_dylib_info `]() using it\_lazy\_load\_dylib\_info = [ref\_iterator]( "LIEF::ref_iterator")<[lazy\_load\_dylib\_info\_cache\_t]( "LIEF::MachO::Binary::lazy_load_dylib_info_cache_t")&> Iterator that outputs [LazyLoadDylibInfo]()&. #### [` it_const_lazy_load_dylib_info `]() using it\_const\_lazy\_load\_dylib\_info = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [lazy\_load\_dylib\_info\_cache\_t]( "LIEF::MachO::Binary::lazy_load_dylib_info_cache_t")&> Iterator that outputs const [LazyLoadDylibInfo]()&. #### [` fileset_binaries_t `]() using fileset\_binaries\_t = std::vector<std::unique\_ptr<[Binary]( "LIEF::MachO::Binary")>> Internal container for storing Mach-O Fileset [Binary](). #### [` it_fileset_binaries `]() using it\_fileset\_binaries = [ref\_iterator]( "LIEF::ref_iterator")<[fileset\_binaries\_t]( "LIEF::MachO::Binary::fileset_binaries_t")&, [Binary]( "LIEF::MachO::Binary")\*> Iterator that outputs [Binary]()&. #### [` it_const_fileset_binaries `]() using it\_const\_fileset\_binaries = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [fileset\_binaries\_t]( "LIEF::MachO::Binary::fileset_binaries_t")&, [Binary]( "LIEF::MachO::Binary")\*> Iterator that outputs const [Binary]()&. #### [` relocations_t `]() using relocations\_t = std::set<[Relocation]( "LIEF::MachO::Relocation")\*, [KeyCmp]( "LIEF::MachO::Binary::KeyCmp")> Internal container that store all the relocations found in a Mach-O. The relocations are actually owned by [Section]() & [SegmentCommand]() and these references are used for convenience. #### [` it_relocations `]() using it\_relocations = [ref\_iterator]( "LIEF::ref_iterator")<[relocations\_t]( "LIEF::MachO::Binary::relocations_t")&, [Relocation]( "LIEF::MachO::Relocation")\*> Iterator which outputs [Relocation]()&. #### [` it_const_relocations `]() using it\_const\_relocations = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [relocations\_t]( "LIEF::MachO::Binary::relocations_t")&, const [Relocation]( "LIEF::MachO::Relocation")\*> Iterator which outputs const [Relocation]()&. #### [` it_rpaths `]() using it\_rpaths = [filter\_iterator]( "LIEF::filter_iterator")<[commands\_t]( "LIEF::MachO::Binary::commands_t")&, [RPathCommand]( "LIEF::MachO::RPathCommand")\*> Iterator which outputs [RPathCommand]()&. #### [` it_const_rpaths `]() using it\_const\_rpaths = [const\_filter\_iterator]( "LIEF::const_filter_iterator")<const [commands\_t]( "LIEF::MachO::Binary::commands_t")&, const [RPathCommand]( "LIEF::MachO::RPathCommand")\*> Iterator which outputs const [RPathCommand]()&. #### [` it_sub_clients `]() using it\_sub\_clients = [filter\_iterator]( "LIEF::filter_iterator")<[commands\_t]( "LIEF::MachO::Binary::commands_t")&, [SubClient]( "LIEF::MachO::SubClient")\*> Iterator which outputs [SubClient]()&. #### [` it_const_sub_clients `]() using it\_const\_sub\_clients = [const\_filter\_iterator]( "LIEF::const_filter_iterator")<const [commands\_t]( "LIEF::MachO::Binary::commands_t")&, const [SubClient]( "LIEF::MachO::SubClient")\*> Iterator which outputs const [SubClient]()&. #### [` it_bindings `]() using it\_bindings = [iterator\_range]( "LIEF::iterator_range")<BindingInfoIterator> #### [` stub_iterator `]() using stub\_iterator = [iterator\_range]( "LIEF::iterator_range")<[Stub]( "LIEF::MachO::Stub")::[Iterator]( "LIEF::MachO::Stub::Iterator")> Iterator type for [Symbol]()’s stub. #### [` it_notes `]() using it\_notes = [filter\_iterator]( "LIEF::filter_iterator")<[commands\_t]( "LIEF::MachO::Binary::commands_t")&, [NoteCommand]( "LIEF::MachO::NoteCommand")\*> Iterator which outputs [NoteCommand]()&. #### [` it_const_notes `]() using it\_const\_notes = [const\_filter\_iterator]( "LIEF::const_filter_iterator")<const [commands\_t]( "LIEF::MachO::Binary::commands_t")&, const [NoteCommand]( "LIEF::MachO::NoteCommand")\*> Iterator which outputs const [NoteCommand]()&. Public Functions #### [` Binary `]() Binary(const [Binary]( "LIEF::MachO::Binary::Binary")&) = delete #### [` operator= `]() [Binary]( "LIEF::MachO::Binary") &operator=(const [Binary]( "LIEF::MachO::Binary")&) = delete #### [` header `]() inline [Header]( "LIEF::MachO::Header") &header() Return a reference to the [MachO::Header](). #### [` header `]() inline const [Header]( "LIEF::MachO::Header") &header() const #### [` commands `]() inline [it\_commands]( "LIEF::MachO::Binary::it_commands") commands() Return an iterator over the MachO [LoadCommand]() present in the binary. #### [` commands `]() inline [it\_const\_commands]( "LIEF::MachO::Binary::it_const_commands") commands() const #### [` filesets `]() inline [it\_fileset\_binaries]( "LIEF::MachO::Binary::it_fileset_binaries") filesets() Return an iterator over the [MachO::Binary]() associated with the [LoadCommand::TYPE::FILESET\_ENTRY]() commands. #### [` filesets `]() inline [it\_const\_fileset\_binaries]( "LIEF::MachO::Binary::it_const_fileset_binaries") filesets() const #### [` symbols `]() inline [it\_symbols]( "LIEF::MachO::Binary::it_symbols") symbols() Return binary’s [symbols]() . #### [` symbols `]() inline [it\_const\_symbols]( "LIEF::MachO::Binary::it_const_symbols") symbols() const #### [` has_symbol `]() inline bool has\_symbol(const std::string &name) const Check if a symbol with the given name exists. #### [` get_symbol `]() const [Symbol]( "LIEF::MachO::Symbol") \*get\_symbol(const std::string &name) const Return [Symbol]() from the given name. If the symbol does not exist, it returns a null pointer. #### [` get_symbol `]() inline [Symbol]( "LIEF::MachO::Symbol") \*get\_symbol(const std::string &name) #### [` exported_symbols `]() inline [it\_exported\_symbols]( "LIEF::MachO::Binary::it_exported_symbols") exported\_symbols() Return binary’s exported symbols (iterator over [LIEF::MachO::Symbol]()). #### [` exported_symbols `]() inline [it\_const\_exported\_symbols]( "LIEF::MachO::Binary::it_const_exported_symbols") exported\_symbols() const #### [` imported_symbols `]() inline [it\_imported\_symbols]( "LIEF::MachO::Binary::it_imported_symbols") imported\_symbols() Return binary’s imported symbols (iterator over [LIEF::MachO::Symbol]()). #### [` imported_symbols `]() inline [it\_const\_imported\_symbols]( "LIEF::MachO::Binary::it_const_imported_symbols") imported\_symbols() const #### [` libraries `]() inline [it\_libraries]( "LIEF::MachO::Binary::it_libraries") libraries() Return binary imported libraries ([MachO::DylibCommand]()). #### [` libraries `]() inline [it\_const\_libraries]( "LIEF::MachO::Binary::it_const_libraries") libraries() const #### [` lazy_load_dylib_infos `]() inline [it\_lazy\_load\_dylib\_info]( "LIEF::MachO::Binary::it_lazy_load_dylib_info") lazy\_load\_dylib\_infos() Return an iterator over the binary’s [LazyLoadDylibInfo]() commands (`LC_LAZY_LOAD_DYLIB_INFO`). #### [` lazy_load_dylib_infos `]() inline [it\_const\_lazy\_load\_dylib\_info]( "LIEF::MachO::Binary::it_const_lazy_load_dylib_info") lazy\_load\_dylib\_infos() const #### [` segments `]() inline [it\_segments]( "LIEF::MachO::Binary::it_segments") segments() Return an iterator over the [SegmentCommand](). #### [` segments `]() inline [it\_const\_segments]( "LIEF::MachO::Binary::it_const_segments") segments() const #### [` sections `]() inline [it\_sections]( "LIEF::MachO::Binary::it_sections") sections() Return an iterator over the [MachO::Section](). #### [` sections `]() inline [it\_const\_sections]( "LIEF::MachO::Binary::it_const_sections") sections() const #### [` relocations `]() inline [it\_relocations]( "LIEF::MachO::Binary::it_relocations") relocations() Return an iterator over the [MachO::Relocation](). #### [` relocations `]() [it\_const\_relocations]( "LIEF::MachO::Binary::it_const_relocations") relocations() const #### [` write `]() void write(const std::string &filename) Reconstruct the binary object and write the result in the given `filename`. **Parameters:** **filename** – Path to write the reconstructed binary #### [` write `]() void write(const std::string &filename, [Builder]( "LIEF::MachO::Builder")::[config\_t]( "LIEF::MachO::Builder::config_t") config) Reconstruct the binary object and write the result in the given `filename`. The second `config` parameter is used to tweak the building process **Parameters:** - **filename** – Path to write the reconstructed binary - **config** – [Builder]() configuration #### [` write `]() void write(std::ostream &os) Reconstruct the binary object and write the result in the given `os` stream. **Parameters:** **os** – Output stream to write the reconstructed binary #### [` write `]() void write(std::ostream &os, [Builder]( "LIEF::MachO::Builder")::[config\_t]( "LIEF::MachO::Builder::config_t") config) Reconstruct the binary object and write the result in the given `os` stream for the given configuration. **Parameters:** - **os** – Output stream to write the reconstructed binary - **config** – [Builder]() configuration #### [` raw `]() std::vector<uint8\_t> raw() Reconstruct the binary object and return its content as bytes. #### [` has `]() bool has([LoadCommand]( "LIEF::MachO::LoadCommand")::[TYPE]( "LIEF::MachO::LoadCommand::TYPE") type) const Check if the current binary has the given [MachO::LoadCommand::TYPE](). #### [` get `]() const [LoadCommand]( "LIEF::MachO::LoadCommand") \*get([LoadCommand]( "LIEF::MachO::LoadCommand")::[TYPE]( "LIEF::MachO::LoadCommand::TYPE") type) const Return the [LoadCommand]() associated with the given [LoadCommand::TYPE]() or a nullptr if the command can’t be found. #### [` get `]() inline [LoadCommand]( "LIEF::MachO::LoadCommand") \*get([LoadCommand]( "LIEF::MachO::LoadCommand")::[TYPE]( "LIEF::MachO::LoadCommand::TYPE") type) #### [` add `]() [LoadCommand]( "LIEF::MachO::LoadCommand") \*add(std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> command) #### [` add `]() inline [LoadCommand]( "LIEF::MachO::LoadCommand") \*add(const [LoadCommand]( "LIEF::MachO::LoadCommand") &command) Insert a new [LoadCommand](). #### [` add `]() [LoadCommand]( "LIEF::MachO::LoadCommand") \*add(const [LoadCommand]( "LIEF::MachO::LoadCommand") &command, size\_t index) Insert a new [LoadCommand]() at the specified `index`. #### [` add `]() [LoadCommand]( "LIEF::MachO::LoadCommand") \*add(const [DylibCommand]( "LIEF::MachO::DylibCommand") &library) Insert the given [DylibCommand](). #### [` add `]() [LoadCommand]( "LIEF::MachO::LoadCommand") \*add(const [SegmentCommand]( "LIEF::MachO::SegmentCommand") &segment) Add a new LC\_SEGMENT command from the given [SegmentCommand](). #### [` add_library `]() [LoadCommand]( "LIEF::MachO::LoadCommand") \*add\_library(const std::string &name) Insert a new shared library through a `LC_LOAD_DYLIB` command. #### [` add_section `]() [Section]( "LIEF::MachO::Section") \*add\_section(const [Section]( "LIEF::MachO::Section") &section) Add a new [MachO::Section]() in the \_\_TEXT segment. #### [` find_library `]() const [DylibCommand]( "LIEF::MachO::DylibCommand") \*find\_library(const std::string &name) const Try to find the library with the given library name. This function tries to match the fullpath of the [DylibCommand]() or the library name suffix. #### [` find_library `]() inline [DylibCommand]( "LIEF::MachO::DylibCommand") \*find\_library(const std::string &name) #### [` add_section `]() [Section]( "LIEF::MachO::Section") \*add\_section(const [SegmentCommand]( "LIEF::MachO::SegmentCommand") &segment, const [Section]( "LIEF::MachO::Section") &section) Add a section in the given [MachO::SegmentCommand](). > **Warning** > > This method may corrupt the file if the segment is not the first one nor the last one #### [` remove_section `]() virtual void remove\_section(const std::string &name, bool clear = false) override Remove the section with the name provided in the first parameter. **Parameters:** - **name** – Name of the [MachO::Section]() to remove - **clear** – If `true` clear the content of the section before removing #### [` remove_section `]() void remove\_section(const std::string &segname, const std::string &secname, bool clear = false) Remove the section from the segment with the name given in the first parameter and with the section’s name provided in the second parameter. **Parameters:** - **segname** – Name of the MachO::Segment - **secname** – Name of the [MachO::Section]() to remove - **clear** – If `true` clear the content of the section before removing #### [` remove `]() bool remove(const [LoadCommand]( "LIEF::MachO::LoadCommand") &command) Remove the given [LoadCommand](). #### [` remove `]() bool remove([LoadCommand]( "LIEF::MachO::LoadCommand")::[TYPE]( "LIEF::MachO::LoadCommand::TYPE") type) Remove **all** [LoadCommand]() with the given type ([MachO::LoadCommand::TYPE]()). #### [` remove_command `]() bool remove\_command(size\_t index) Remove the Load Command at the provided `index`. #### [` remove_signature `]() bool remove\_signature() Remove the LC\_SIGNATURE command. #### [` extend `]() bool extend(const [LoadCommand]( "LIEF::MachO::LoadCommand") &command, uint64\_t size) Extend the **size** of the given [LoadCommand](). #### [` extend_segment `]() bool extend\_segment(const [SegmentCommand]( "LIEF::MachO::SegmentCommand") &segment, size\_t size) Extend the **content** of the given [SegmentCommand](). #### [` extend_section `]() bool extend\_section([Section]( "LIEF::MachO::Section") &section, size\_t size) Extend the **content** of the given [Section](). > **Note** > > This method may extend the section more than `size` preventing creation a gap between the current section and the next one. This may happen trying to satisfy alignment requirement of sections. > **Note** > > This method works only with sections that belong to the first segment. #### [` disable_pie `]() bool disable\_pie() Remove the `PIE` flag. #### [` imagebase `]() virtual uint64\_t imagebase() const override Return the binary’s imagebase. `0` if not relevant. #### [` virtual_size `]() inline virtual uint64\_t virtual\_size() const override Size of the binary in memory when mapped by the loader (`dyld`). #### [` loader `]() std::string\_view loader() const Return the binary’s loader (e.g. `/usr/lib/dyld`) or an empty string if the binary does not use a loader/linker. #### [` has_section `]() inline bool has\_section(const std::string &name) const Check if a section with the given name exists. #### [` get_section `]() inline [Section]( "LIEF::MachO::Section") \*get\_section(const std::string &name) Return the section from the given name or a nullptr if the section can’t be found. #### [` get_section `]() const [Section]( "LIEF::MachO::Section") \*get\_section(const std::string &name) const Return the section from the given name or a nullptr if the section can’t be found. #### [` get_section `]() inline [Section]( "LIEF::MachO::Section") \*get\_section(const std::string &segname, const std::string &secname) Return the section from the segment with the name given in the first parameter and with the section’s name provided in the second parameter. If the section cannot be found, it returns a nullptr. #### [` get_section `]() const [Section]( "LIEF::MachO::Section") \*get\_section(const std::string &segname, const std::string &secname) const #### [` has_segment `]() inline bool has\_segment(const std::string &name) const Check if a segment with the given name exists. #### [` get_segment `]() const [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*get\_segment(const std::string &name) const Return the segment from the given name. #### [` get_segment `]() inline [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*get\_segment(const std::string &name) Return the segment from the given name. #### [` remove_symbol `]() bool remove\_symbol(const std::string &name) Remove the symbol with the given name. #### [` remove `]() bool remove(const [Symbol]( "LIEF::MachO::Symbol") &sym) Remove the given symbol. #### [` can_remove `]() bool can\_remove(const [Symbol]( "LIEF::MachO::Symbol") &sym) const Check if the given symbol can be safely removed. #### [` can_remove_symbol `]() bool can\_remove\_symbol(const std::string &name) const Check if the [MachO::Symbol]() with the given name can be safely removed. #### [` unexport `]() bool unexport(const std::string &name) Remove the given [MachO::Symbol]() with the given name from the export table. #### [` unexport `]() bool unexport(const [Symbol]( "LIEF::MachO::Symbol") &sym) Remove the given symbol from the export table. #### [` section_from_offset `]() inline [Section]( "LIEF::MachO::Section") \*section\_from\_offset(uint64\_t offset) Return the [MachO::Section]() that encompasses the provided offset. If a section can’t be found, it returns a null pointer (`nullptr`). #### [` section_from_offset `]() const [Section]( "LIEF::MachO::Section") \*section\_from\_offset(uint64\_t offset) const #### [` section_from_virtual_address `]() inline [Section]( "LIEF::MachO::Section") \*section\_from\_virtual\_address(uint64\_t virtual\_address) Return the [MachO::Section]() that encompasses the provided virtual address. If a section can’t be found, it returns a null pointer (`nullptr`). #### [` section_from_virtual_address `]() const [Section]( "LIEF::MachO::Section") \*section\_from\_virtual\_address(uint64\_t virtual\_address) const #### [` virtual_address_to_offset `]() [result]( "LIEF::result")<uint64\_t> virtual\_address\_to\_offset(uint64\_t virtual\_address) const Convert a virtual address to an offset in the file. #### [` offset_to_virtual_address `]() virtual [result]( "LIEF::result")<uint64\_t> offset\_to\_virtual\_address(uint64\_t offset, uint64\_t slide = 0) const override Convert the given offset into a virtual address. **Parameters:** - **offset** – **[in]** The offset to convert. - **slide** – **[in]** If not 0, it will replace the default base address (if any) #### [` segment_from_offset `]() inline [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*segment\_from\_offset(uint64\_t offset) Return the binary’s [SegmentCommand]() that encompasses the provided offset. If a [SegmentCommand]() can’t be found it returns a null pointer (`nullptr`). #### [` segment_from_offset `]() const [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*segment\_from\_offset(uint64\_t offset) const #### [` segment_index `]() size\_t segment\_index(const [SegmentCommand]( "LIEF::MachO::SegmentCommand") &segment) const Return the index of the given [SegmentCommand](). #### [` fat_offset `]() inline uint64\_t fat\_offset() const Return binary’s *fat offset*. `0` if not relevant. #### [` segment_from_virtual_address `]() inline [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*segment\_from\_virtual\_address(uint64\_t virtual\_address) Return the binary’s [SegmentCommand]() which encompasses the given virtual address or a nullptr if not found. #### [` segment_from_virtual_address `]() const [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*segment\_from\_virtual\_address(uint64\_t virtual\_address) const #### [` va_ranges `]() [range\_t]( "LIEF::MachO::Binary::range_t") va\_ranges() const Return the range of virtual addresses. #### [` off_ranges `]() [range\_t]( "LIEF::MachO::Binary::range_t") off\_ranges() const Return the range of offsets. #### [` tlv_initial_content_range `]() [range\_t]( "LIEF::MachO::Binary::range_t") tlv\_initial\_content\_range() const Return the TLV initial content range. #### [` is_valid_addr `]() inline bool is\_valid\_addr(uint64\_t address) const Check if the given address is encompassed in the binary’s virtual addresses range. #### [` accept `]() virtual void accept(LIEF::Visitor &visitor) const override Method so that the `visitor` can visit us. #### [` print `]() virtual std::ostream &print(std::ostream &os) const override #### [` patch_address `]() virtual void patch\_address(uint64\_t address, const std::vector<uint8\_t> &patch\_value, LIEF::[Binary]( "LIEF::Binary")::[VA\_TYPES]( "LIEF::Binary::VA_TYPES") addr\_type = LIEF::[Binary]( "LIEF::Binary")::[VA\_TYPES]( "LIEF::Binary::VA_TYPES")::[AUTO]( "LIEF::Binary::VA_TYPES::AUTO")) override Patch the content at virtual address `address` with `patch_value`. **Parameters:** - **address** – **[in]** Address to patch - **patch\_value** – **[in]** Patch to apply - **addr\_type** – **[in]** Specify if the address should be used as an absolute virtual address or an RVA #### [` patch_address `]() virtual void patch\_address(uint64\_t address, uint64\_t patch\_value, size\_t size = sizeof(uint64\_t), LIEF::[Binary]( "LIEF::Binary")::[VA\_TYPES]( "LIEF::Binary::VA_TYPES") addr\_type = LIEF::[Binary]( "LIEF::Binary")::[VA\_TYPES]( "LIEF::Binary::VA_TYPES")::[AUTO]( "LIEF::Binary::VA_TYPES::AUTO")) override Patch the address with the given value. **Parameters:** - **address** – **[in]** Address to patch - **patch\_value** – **[in]** Patch to apply - **size** – **[in]** Size of the value in **bytes** (1, 2, … 8) - **addr\_type** – **[in]** Specify if the address should be used as an absolute virtual address or an RVA #### [` get_content_from_virtual_address `]() virtual span<const uint8\_t> get\_content\_from\_virtual\_address(uint64\_t virtual\_address, uint64\_t size, [Binary]( "LIEF::MachO::Binary")::VA\_TYPES addr\_type = [Binary]( "LIEF::MachO::Binary")::VA\_TYPES::AUTO) const override Return the content located at virtual address. #### [` entrypoint `]() virtual uint64\_t entrypoint() const override The binary entrypoint. #### [` is_pie `]() inline virtual bool is\_pie() const override Check if the binary is position independent. #### [` has_nx `]() inline virtual bool has\_nx() const override Check if the binary uses `NX` protection. #### [` has_nx_stack `]() inline bool has\_nx\_stack() const Return True if the **stack** is flagged as non-executable. False otherwise. #### [` has_nx_heap `]() inline bool has\_nx\_heap() const Return True if the **heap** is flagged as non-executable. False otherwise. #### [` has_entrypoint `]() inline bool has\_entrypoint() const `true` if the binary has an entrypoint. Basically for libraries it will return `false` #### [` has_uuid `]() inline bool has\_uuid() const `true` if the binary has a [MachO::UUIDCommand]() command. #### [` uuid `]() [UUIDCommand]( "LIEF::MachO::UUIDCommand") \*uuid() Return the [MachO::UUIDCommand]() if present, a nullptr otherwise. #### [` uuid `]() const [UUIDCommand]( "LIEF::MachO::UUIDCommand") \*uuid() const #### [` has_main_command `]() inline bool has\_main\_command() const `true` if the binary has a [MachO::MainCommand]() command. #### [` main_command `]() [MainCommand]( "LIEF::MachO::MainCommand") \*main\_command() Return the [MachO::MainCommand]() if present, a nullptr otherwise. #### [` main_command `]() const [MainCommand]( "LIEF::MachO::MainCommand") \*main\_command() const #### [` has_dylinker `]() inline bool has\_dylinker() const `true` if the binary has a [MachO::DylinkerCommand](). #### [` dylinker `]() [DylinkerCommand]( "LIEF::MachO::DylinkerCommand") \*dylinker() Return the [MachO::DylinkerCommand]() if present, a nullptr otherwise. #### [` dylinker `]() const [DylinkerCommand]( "LIEF::MachO::DylinkerCommand") \*dylinker() const #### [` has_dyld_info `]() inline bool has\_dyld\_info() const `true` if the binary has a [MachO::DyldInfo]() command. #### [` dyld_info `]() [DyldInfo]( "LIEF::MachO::DyldInfo") \*dyld\_info() Return the MachO::Dyld command if present, a nullptr otherwise. #### [` dyld_info `]() const [DyldInfo]( "LIEF::MachO::DyldInfo") \*dyld\_info() const #### [` has_function_starts `]() inline bool has\_function\_starts() const `true` if the binary has a [MachO::FunctionStarts]() command. #### [` function_starts `]() [FunctionStarts]( "LIEF::MachO::FunctionStarts") \*function\_starts() Return the [MachO::FunctionStarts]() command if present, a nullptr otherwise. #### [` function_starts `]() const [FunctionStarts]( "LIEF::MachO::FunctionStarts") \*function\_starts() const #### [` has_source_version `]() inline bool has\_source\_version() const `true` if the binary has a [MachO::SourceVersion]() command. #### [` source_version `]() [SourceVersion]( "LIEF::MachO::SourceVersion") \*source\_version() Return the [MachO::SourceVersion]() command if present, a nullptr otherwise. #### [` source_version `]() const [SourceVersion]( "LIEF::MachO::SourceVersion") \*source\_version() const #### [` has_version_min `]() inline bool has\_version\_min() const `true` if the binary has a [MachO::VersionMin]() command. #### [` version_min `]() [VersionMin]( "LIEF::MachO::VersionMin") \*version\_min() Return the [MachO::VersionMin]() command if present, a nullptr otherwise. #### [` version_min `]() const [VersionMin]( "LIEF::MachO::VersionMin") \*version\_min() const #### [` has_thread_command `]() inline bool has\_thread\_command() const `true` if the binary has a [MachO::ThreadCommand]() command. #### [` thread_command `]() [ThreadCommand]( "LIEF::MachO::ThreadCommand") \*thread\_command() Return the [MachO::ThreadCommand]() command if present, a nullptr otherwise. #### [` thread_command `]() const [ThreadCommand]( "LIEF::MachO::ThreadCommand") \*thread\_command() const #### [` has_routine_command `]() inline bool has\_routine\_command() const `true` if the binary has a [MachO::Routine]() command. #### [` routine_command `]() [Routine]( "LIEF::MachO::Routine") \*routine\_command() Return the [MachO::Routine]() command if present, a nullptr otherwise. #### [` routine_command `]() const [Routine]( "LIEF::MachO::Routine") \*routine\_command() const #### [` has_rpath `]() inline bool has\_rpath() const `true` if the binary has a [MachO::RPathCommand]() command. #### [` rpath `]() [RPathCommand]( "LIEF::MachO::RPathCommand") \*rpath() Return the [MachO::RPathCommand]() command if present, a nullptr otherwise. #### [` rpath `]() const [RPathCommand]( "LIEF::MachO::RPathCommand") \*rpath() const #### [` rpaths `]() [it\_rpaths]( "LIEF::MachO::Binary::it_rpaths") rpaths() Iterator over **all** the [MachO::RPathCommand]() commands. #### [` rpaths `]() [it\_const\_rpaths]( "LIEF::MachO::Binary::it_const_rpaths") rpaths() const #### [` has_symbol_command `]() inline bool has\_symbol\_command() const `true` if the binary has a [MachO::SymbolCommand]() command. #### [` symbol_command `]() [SymbolCommand]( "LIEF::MachO::SymbolCommand") \*symbol\_command() Return the [MachO::SymbolCommand]() if present, a nullptr otherwise. #### [` symbol_command `]() const [SymbolCommand]( "LIEF::MachO::SymbolCommand") \*symbol\_command() const #### [` has_dynamic_symbol_command `]() inline bool has\_dynamic\_symbol\_command() const `true` if the binary has a [MachO::DynamicSymbolCommand]() command. #### [` dynamic_symbol_command `]() [DynamicSymbolCommand]( "LIEF::MachO::DynamicSymbolCommand") \*dynamic\_symbol\_command() Return the [MachO::SymbolCommand]() if present, a nullptr otherwise. #### [` dynamic_symbol_command `]() const [DynamicSymbolCommand]( "LIEF::MachO::DynamicSymbolCommand") \*dynamic\_symbol\_command() const #### [` has_code_signature `]() inline bool has\_code\_signature() const `true` if the binary is signed with `LC_CODE_SIGNATURE` command #### [` code_signature `]() inline [CodeSignature]( "LIEF::MachO::CodeSignature") \*code\_signature() Return the [MachO::CodeSignature]() if present, a nullptr otherwise. #### [` code_signature `]() const [CodeSignature]( "LIEF::MachO::CodeSignature") \*code\_signature() const #### [` has_code_signature_dir `]() inline bool has\_code\_signature\_dir() const `true` if the binary is signed with the command `DYLIB_CODE_SIGN_DRS` #### [` code_signature_dir `]() inline [CodeSignatureDir]( "LIEF::MachO::CodeSignatureDir") \*code\_signature\_dir() Return the [MachO::CodeSignatureDir]() if present, a nullptr otherwise. #### [` code_signature_dir `]() const [CodeSignatureDir]( "LIEF::MachO::CodeSignatureDir") \*code\_signature\_dir() const #### [` has_data_in_code `]() inline bool has\_data\_in\_code() const `true` if the binary has a [MachO::DataInCode]() command. #### [` data_in_code `]() [DataInCode]( "LIEF::MachO::DataInCode") \*data\_in\_code() Return the [MachO::DataInCode]() if present, a nullptr otherwise. #### [` data_in_code `]() const [DataInCode]( "LIEF::MachO::DataInCode") \*data\_in\_code() const #### [` has_segment_split_info `]() inline bool has\_segment\_split\_info() const `true` if the binary has segment split info. #### [` segment_split_info `]() [SegmentSplitInfo]( "LIEF::MachO::SegmentSplitInfo") \*segment\_split\_info() Return the [MachO::SegmentSplitInfo]() if present, a nullptr otherwise. #### [` segment_split_info `]() const [SegmentSplitInfo]( "LIEF::MachO::SegmentSplitInfo") \*segment\_split\_info() const #### [` has_sub_framework `]() inline bool has\_sub\_framework() const `true` if the binary has a sub framework command. #### [` has_encryption_info `]() inline bool has\_encryption\_info() const `true` if the binary has Encryption Info. #### [` encryption_info `]() [EncryptionInfo]( "LIEF::MachO::EncryptionInfo") \*encryption\_info() Return the [MachO::EncryptionInfo]() if present, a nullptr otherwise. #### [` encryption_info `]() const [EncryptionInfo]( "LIEF::MachO::EncryptionInfo") \*encryption\_info() const #### [` sub_framework `]() [SubFramework]( "LIEF::MachO::SubFramework") \*sub\_framework() Return the [MachO::SubFramework]() if present, a nullptr otherwise. #### [` sub_framework `]() const [SubFramework]( "LIEF::MachO::SubFramework") \*sub\_framework() const #### [` subclients `]() [it\_sub\_clients]( "LIEF::MachO::Binary::it_sub_clients") subclients() Iterator over **all** the [MachO::SubClient]() commands. #### [` subclients `]() [it\_const\_sub\_clients]( "LIEF::MachO::Binary::it_const_sub_clients") subclients() const #### [` has_subclients `]() bool has\_subclients() const #### [` has_dyld_environment `]() inline bool has\_dyld\_environment() const `true` if the binary has Dyld environment variables. #### [` dyld_environment `]() [DyldEnvironment]( "LIEF::MachO::DyldEnvironment") \*dyld\_environment() Return the [MachO::DyldEnvironment]() if present, a nullptr otherwise. #### [` dyld_environment `]() const [DyldEnvironment]( "LIEF::MachO::DyldEnvironment") \*dyld\_environment() const #### [` has_build_version `]() inline bool has\_build\_version() const `true` if the binary has the [BuildVersion]() command. #### [` build_version `]() [BuildVersion]( "LIEF::MachO::BuildVersion") \*build\_version() Return the [MachO::BuildVersion]() if present, a nullptr otherwise. #### [` build_version `]() const [BuildVersion]( "LIEF::MachO::BuildVersion") \*build\_version() const #### [` platform `]() inline [BuildVersion]( "LIEF::MachO::BuildVersion")::[PLATFORMS]( "LIEF::MachO::BuildVersion::PLATFORMS") platform() const Return the platform for which this Mach-O has been compiled for. #### [` is_ios `]() inline bool is\_ios() const True if this binary targets iOS. #### [` is_macos `]() inline bool is\_macos() const True if this binary targets macOS. #### [` has_dyld_chained_fixups `]() inline bool has\_dyld\_chained\_fixups() const `true` if the binary has the command LC\_DYLD\_CHAINED\_FIXUPS. #### [` dyld_chained_fixups `]() [DyldChainedFixups]( "LIEF::MachO::DyldChainedFixups") \*dyld\_chained\_fixups() Return the [MachO::DyldChainedFixups]() if present, a nullptr otherwise. #### [` dyld_chained_fixups `]() const [DyldChainedFixups]( "LIEF::MachO::DyldChainedFixups") \*dyld\_chained\_fixups() const #### [` has_dyld_exports_trie `]() inline bool has\_dyld\_exports\_trie() const `true` if the binary has the command LC\_DYLD\_EXPORTS\_TRIE. #### [` dyld_exports_trie `]() [DyldExportsTrie]( "LIEF::MachO::DyldExportsTrie") \*dyld\_exports\_trie() Return the [MachO::DyldExportsTrie]() if present, a nullptr otherwise. #### [` dyld_exports_trie `]() const [DyldExportsTrie]( "LIEF::MachO::DyldExportsTrie") \*dyld\_exports\_trie() const #### [` has_two_level_hints `]() inline bool has\_two\_level\_hints() const `true` if the binary has the command LC\_TWO\_LEVEL\_HINTS. #### [` two_level_hints `]() inline [TwoLevelHints]( "LIEF::MachO::TwoLevelHints") \*two\_level\_hints() Return the [MachO::TwoLevelHints]() if present, a nullptr otherwise. #### [` two_level_hints `]() const [TwoLevelHints]( "LIEF::MachO::TwoLevelHints") \*two\_level\_hints() const #### [` has_linker_opt_hint `]() inline bool has\_linker\_opt\_hint() const `true` if the binary has the command LC\_LINKER\_OPTIMIZATION\_HINT. #### [` linker_opt_hint `]() inline [LinkerOptHint]( "LIEF::MachO::LinkerOptHint") \*linker\_opt\_hint() Return the [MachO::LinkerOptHint]() if present, a nullptr otherwise. #### [` linker_opt_hint `]() const [LinkerOptHint]( "LIEF::MachO::LinkerOptHint") \*linker\_opt\_hint() const #### [` add_exported_function `]() [ExportInfo]( "LIEF::MachO::ExportInfo") \*add\_exported\_function(uint64\_t address, const std::string &name) Add a symbol in the export trie of the current binary. #### [` add_local_symbol `]() [Symbol]( "LIEF::MachO::Symbol") \*add\_local\_symbol(uint64\_t address, const std::string &name) Add a symbol in LC\_SYMTAB command of the current binary. #### [` objc_metadata `]() std::unique\_ptr<objc::[Metadata]( "LIEF::objc::Metadata")> objc\_metadata() const Return Objective-C metadata if present. #### [` symbol_stubs `]() [stub\_iterator]( "LIEF::MachO::Binary::stub_iterator") symbol\_stubs() const Return an iterator over the symbol stubs. These stubs are involved when calling an **imported** function and are similar to the ELF’s plt/got mechanism. There are located in sections like: `__stubs,__auth_stubs,__symbol_stub,__picsymbolstub4` #### [` has_atom_info `]() inline bool has\_atom\_info() const `true` if the binary has the command LC\_ATOM\_INFO. #### [` atom_info `]() inline AtomInfo \*atom\_info() Return the MachO::AtomInfo if present, a nullptr otherwise. #### [` atom_info `]() const AtomInfo \*atom\_info() const #### [` notes `]() [it\_notes]( "LIEF::MachO::Binary::it_notes") notes() Iterator over the different `LC_NOTE` commands. #### [` notes `]() [it\_const\_notes]( "LIEF::MachO::Binary::it_const_notes") notes() const #### [` has_notes `]() inline bool has\_notes() const True if the binary contains `LC_NOTE` command(s). #### [` has_function_variants `]() inline bool has\_function\_variants() const `true` if the binary has the command `LC_FUNCTION_VARIANTS`. #### [` function_variants `]() inline [FunctionVariants]( "LIEF::MachO::FunctionVariants") \*function\_variants() Return the [FunctionVariants]() if present, a nullptr otherwise. #### [` function_variants `]() const [FunctionVariants]( "LIEF::MachO::FunctionVariants") \*function\_variants() const #### [` has_function_variant_fixups `]() inline bool has\_function\_variant\_fixups() const `true` if the binary has the command `LC_FUNCTION_VARIANT_FIXUPS`. #### [` function_variant_fixups `]() inline [FunctionVariantFixups]( "LIEF::MachO::FunctionVariantFixups") \*function\_variant\_fixups() Return the [FunctionVariantFixups]() if present, a nullptr otherwise. #### [` function_variant_fixups `]() const [FunctionVariantFixups]( "LIEF::MachO::FunctionVariantFixups") \*function\_variant\_fixups() const #### [` Thas_command `]() template<class T> bool has\_command() const #### [` Tcommand `]() template<class T> [T]( "LIEF::MachO::Binary::command::T") \*command() #### [` Tcommand `]() template<class T> const [T]( "LIEF::MachO::Binary::command::T") \*command() const #### [` Tcount_commands `]() template<class T> size\_t count\_commands() const #### [` CMDFuncfor_commands `]() template<class CMD, class Func> [Binary]( "LIEF::MachO::Binary") &for\_commands([Func]( "LIEF::MachO::Binary::for_commands::Func") f) #### [` operator[] `]() inline [LoadCommand]( "LIEF::MachO::LoadCommand") \*operator[]([LoadCommand]( "LIEF::MachO::LoadCommand")::[TYPE]( "LIEF::MachO::LoadCommand::TYPE") type) #### [` operator[] `]() inline const [LoadCommand]( "LIEF::MachO::LoadCommand") \*operator[]([LoadCommand]( "LIEF::MachO::LoadCommand")::[TYPE]( "LIEF::MachO::LoadCommand::TYPE") type) const #### [` ctor_functions `]() virtual LIEF::[Binary]( "LIEF::Binary")::[functions\_t]( "LIEF::Binary::functions_t") ctor\_functions() const override Return the list of the MachO’s constructors. #### [` functions `]() LIEF::[Binary]( "LIEF::Binary")::[functions\_t]( "LIEF::Binary::functions_t") functions() const Return all the functions found in this MachO. #### [` unwind_functions `]() LIEF::[Binary]( "LIEF::Binary")::[functions\_t]( "LIEF::Binary::functions_t") unwind\_functions() const Return the functions found in the `__unwind_info` section. #### [` has_filesets `]() inline bool has\_filesets() const `true` if the binary has a [LoadCommand::TYPE::FILESET\_ENTRY]() command #### [` fileset_name `]() inline std::string\_view fileset\_name() const Name associated with the `LC_FILESET_ENTRY` for this MachO. For instance: `com.apple.kec.corecrypto`. #### [` fileset_addr `]() inline uint64\_t fileset\_addr() const Original address associated with the `LC_FILESET_ENTRY` for this MachO. #### [` add `]() [Symbol]( "LIEF::MachO::Symbol") &add(const [Symbol]( "LIEF::MachO::Symbol") &symbol) Add a symbol to this binary. #### [` ~Binary `]() ~Binary() override #### [` shift `]() [ok\_error\_t]( "LIEF::ok_error_t") shift(size\_t value) Shift the content located right after the Load commands table. This operation can be used to add a new command. #### [` shift_linkedit `]() [ok\_error\_t]( "LIEF::ok_error_t") shift\_linkedit(size\_t width) Shift the position on the \_\_LINKEDIT data by `width`. #### [` memory_base_address `]() inline uint64\_t memory\_base\_address() const If this Mach-O binary has been parsed from memory, it returns the in-memory base address of this binary. Otherwise, it returns 0 #### [` support_arm64_ptr_auth `]() inline bool support\_arm64\_ptr\_auth() const Check if the binary is supporting ARM64 pointer authentication (arm64e). #### [` bindings `]() [it\_bindings]( "LIEF::MachO::Binary::it_bindings") bindings() const Return an iterator over the binding info which can come from either [DyldInfo]() or [DyldChainedFixups]() commands. #### [` get_function_address `]() virtual [result]( "LIEF::result")<uint64\_t> get\_function\_address(const std::string &name) const override Try to get the address for the function’s name given in parameter. #### [` overlay `]() inline span<const uint8\_t> overlay() const #### [` sort_segments `]() void sort\_segments() #### [` refresh_seg_offset `]() void refresh\_seg\_offset() Public Static Functions #### [` is_exported `]() static bool is\_exported(const [Symbol]( "LIEF::MachO::Symbol") &symbol) Check if the given symbol is exported. #### [` is_imported `]() static bool is\_imported(const [Symbol]( "LIEF::MachO::Symbol") &symbol) Check if the given symbol is an imported one. #### [` classof `]() static inline bool classof(const LIEF::[Binary]( "LIEF::Binary") \*bin) #### [` can_cache_segment `]() static bool can\_cache\_segment(const [SegmentCommand]( "LIEF::MachO::SegmentCommand") &segment) Check if the given segment can go in the offset\_seg\_ cache. #### [` range_t `]() struct range\_t Public Functions ##### [` size `]() inline uint64\_t size() const ##### [` empty `]() inline bool empty() const Public Members ##### [` start `]() uint64\_t start = 0 ##### [` end `]() uint64\_t end = 0 #### [` KeyCmp `]() struct KeyCmp Public Functions ##### [` operator() `]() bool operator()(const [Relocation]( "LIEF::MachO::Relocation") \*lhs, const [Relocation]( "LIEF::MachO::Relocation") \*rhs) const --- ## [Header]() ### [` Header `]() class Header : public LIEF::Object Class that represents the Mach-O header. Public Types #### [` FILE_TYPE `]() enum class FILE\_TYPE : uint32\_t *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` OBJECT `]() enumerator OBJECT = 0x1u ##### [` EXECUTE `]() enumerator EXECUTE = 0x2u ##### [` FVMLIB `]() enumerator FVMLIB = 0x3u ##### [` CORE `]() enumerator CORE = 0x4u ##### [` PRELOAD `]() enumerator PRELOAD = 0x5u ##### [` DYLIB `]() enumerator DYLIB = 0x6u ##### [` DYLINKER `]() enumerator DYLINKER = 0x7u ##### [` BUNDLE `]() enumerator BUNDLE = 0x8u ##### [` DYLIB_STUB `]() enumerator DYLIB\_STUB = 0x9u ##### [` DSYM `]() enumerator DSYM = 0xAu ##### [` KEXT_BUNDLE `]() enumerator KEXT\_BUNDLE = 0xBu ##### [` FILESET `]() enumerator FILESET = 0xCu ##### [` GPU_EXECUTE `]() enumerator GPU\_EXECUTE = 0xDu ##### [` GPU_DYLIB `]() enumerator GPU\_DYLIB = 0xEu #### [` FLAGS `]() enum class FLAGS : uint32\_t *Values:* ##### [` NOUNDEFS `]() enumerator NOUNDEFS = 0x00000001u ##### [` INCRLINK `]() enumerator INCRLINK = 0x00000002u ##### [` DYLDLINK `]() enumerator DYLDLINK = 0x00000004u ##### [` BINDATLOAD `]() enumerator BINDATLOAD = 0x00000008u ##### [` PREBOUND `]() enumerator PREBOUND = 0x00000010u ##### [` SPLIT_SEGS `]() enumerator SPLIT\_SEGS = 0x00000020u ##### [` LAZY_INIT `]() enumerator LAZY\_INIT = 0x00000040u ##### [` TWOLEVEL `]() enumerator TWOLEVEL = 0x00000080u ##### [` FORCE_FLAT `]() enumerator FORCE\_FLAT = 0x00000100u ##### [` NOMULTIDEFS `]() enumerator NOMULTIDEFS = 0x00000200u ##### [` NOFIXPREBINDING `]() enumerator NOFIXPREBINDING = 0x00000400u ##### [` PREBINDABLE `]() enumerator PREBINDABLE = 0x00000800u ##### [` ALLMODSBOUND `]() enumerator ALLMODSBOUND = 0x00001000u ##### [` SUBSECTIONS_VIA_SYMBOLS `]() enumerator SUBSECTIONS\_VIA\_SYMBOLS = 0x00002000u ##### [` CANONICAL `]() enumerator CANONICAL = 0x00004000u ##### [` WEAK_DEFINES `]() enumerator WEAK\_DEFINES = 0x00008000u ##### [` BINDS_TO_WEAK `]() enumerator BINDS\_TO\_WEAK = 0x00010000u ##### [` ALLOW_STACK_EXECUTION `]() enumerator ALLOW\_STACK\_EXECUTION = 0x00020000u ##### [` ROOT_SAFE `]() enumerator ROOT\_SAFE = 0x00040000u ##### [` SETUID_SAFE `]() enumerator SETUID\_SAFE = 0x00080000u ##### [` NO_REEXPORTED_DYLIBS `]() enumerator NO\_REEXPORTED\_DYLIBS = 0x00100000u ##### [` PIE `]() enumerator PIE = 0x00200000u ##### [` DEAD_STRIPPABLE_DYLIB `]() enumerator DEAD\_STRIPPABLE\_DYLIB = 0x00400000u ##### [` HAS_TLV_DESCRIPTORS `]() enumerator HAS\_TLV\_DESCRIPTORS = 0x00800000u ##### [` NO_HEAP_EXECUTION `]() enumerator NO\_HEAP\_EXECUTION = 0x01000000u ##### [` APP_EXTENSION_SAFE `]() enumerator APP\_EXTENSION\_SAFE = 0x02000000u ##### [` NLIST_OUTOFSYNC_WITH_DYLDINFO `]() enumerator NLIST\_OUTOFSYNC\_WITH\_DYLDINFO = 0x04000000u ##### [` SIM_SUPPORT `]() enumerator SIM\_SUPPORT = 0x08000000u ##### [` IMPLICIT_PAGEZERO `]() enumerator IMPLICIT\_PAGEZERO = 0x10000000u ##### [` DYLIB_IN_CACHE `]() enumerator DYLIB\_IN\_CACHE = 0x80000000u #### [` CPU_TYPE `]() enum class CPU\_TYPE : int32\_t *Values:* ##### [` ANY `]() enumerator ANY = -1 ##### [` X86 `]() enumerator X86 = 7 ##### [` X86_64 `]() enumerator X86\_64 = 7 | [ABI64]( "LIEF::MachO::Header::ABI64") ##### [` MIPS `]() enumerator MIPS = 8 ##### [` MC98000 `]() enumerator MC98000 = 10 ##### [` HPPA `]() enumerator HPPA = 11 ##### [` ARM `]() enumerator ARM = 12 ##### [` ARM64 `]() enumerator ARM64 = 12 | [ABI64]( "LIEF::MachO::Header::ABI64") ##### [` MC88000 `]() enumerator MC88000 = 13 ##### [` SPARC `]() enumerator SPARC = 14 ##### [` I860 `]() enumerator I860 = 15 ##### [` ALPHA `]() enumerator ALPHA = 16 ##### [` POWERPC `]() enumerator POWERPC = 18 ##### [` POWERPC64 `]() enumerator POWERPC64 = 18 | [ABI64]( "LIEF::MachO::Header::ABI64") ##### [` APPLE_GPU `]() enumerator APPLE\_GPU = 19 | [ABI64]( "LIEF::MachO::Header::ABI64") ##### [` AMD_GPU `]() enumerator AMD\_GPU = 20 | [ABI64]( "LIEF::MachO::Header::ABI64") ##### [` INTEL_GPU `]() enumerator INTEL\_GPU = 21 | [ABI64]( "LIEF::MachO::Header::ABI64") ##### [` AIR64 `]() enumerator AIR64 = 23 | [ABI64]( "LIEF::MachO::Header::ABI64") Public Functions #### [` Header `]() Header() = default #### [` operator= `]() [Header]( "LIEF::MachO::Header") &operator=(const [Header]( "LIEF::MachO::Header") &copy) = default #### [` Header `]() Header(const [Header]( "LIEF::MachO::Header::Header") &copy) = default #### [` ~Header `]() ~Header() override = default #### [` magic `]() inline [MACHO\_TYPES]( "LIEF::MachO::MACHO_TYPES") magic() const The Mach-O magic bytes. These bytes determine whether it is a 32 bits Mach-O, a 64 bits Mach-O files etc. #### [` cpu_type `]() inline [CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") cpu\_type() const The CPU architecture targeted by this binary. #### [` cpu_subtype `]() inline uint32\_t cpu\_subtype() const Return the CPU subtype supported by the Mach-O binary. For ARM architectures, this value could represent the minimum version for which the Mach-O binary has been compiled for. #### [` file_type `]() inline [FILE\_TYPE]( "LIEF::MachO::Header::FILE_TYPE") file\_type() const Return the type of the Mach-O file (executable, object, shared library, …). #### [` flags_list `]() std::vector<[FLAGS]( "LIEF::MachO::Header::FLAGS")> flags\_list() const Return the [FLAGS]() as a list. #### [` has `]() bool has([FLAGS]( "LIEF::MachO::Header::FLAGS") flag) const Check if the given HEADER\_FLAGS is present in the header’s flags. #### [` nb_cmds `]() inline uint32\_t nb\_cmds() const Number of [LoadCommand]() present in the Mach-O binary. #### [` sizeof_cmds `]() inline uint32\_t sizeof\_cmds() const The size of **all** the [LoadCommand](). #### [` flags `]() inline uint32\_t flags() const [Header]() flags (cf. HEADER\_FLAGS). > **See also** > > [flags\_list]() #### [` reserved `]() inline uint32\_t reserved() const According to the official documentation, a reserved value. #### [` add `]() void add([FLAGS]( "LIEF::MachO::Header::FLAGS") flag) #### [` magic `]() inline void magic([MACHO\_TYPES]( "LIEF::MachO::MACHO_TYPES") magic) #### [` cpu_type `]() inline void cpu\_type([CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") type) #### [` cpu_subtype `]() inline void cpu\_subtype(uint32\_t cpusubtype) #### [` file_type `]() inline void file\_type([FILE\_TYPE]( "LIEF::MachO::Header::FILE_TYPE") filetype) #### [` nb_cmds `]() inline void nb\_cmds(uint32\_t ncmds) #### [` sizeof_cmds `]() inline void sizeof\_cmds(uint32\_t sizeofcmds) #### [` flags `]() inline void flags(uint32\_t flags) #### [` is_32bit `]() inline bool is\_32bit() const True if the binary is 32-bit. #### [` is_64bit `]() inline bool is\_64bit() const True if the binary is 64-bit. #### [` remove `]() void remove([FLAGS]( "LIEF::MachO::Header::FLAGS") flag) #### [` reserved `]() inline void reserved(uint32\_t reserved) #### [` operator+= `]() inline [Header]( "LIEF::MachO::Header") &operator+=([FLAGS]( "LIEF::MachO::Header::FLAGS") c) #### [` operator-= `]() inline [Header]( "LIEF::MachO::Header") &operator-=([FLAGS]( "LIEF::MachO::Header::FLAGS") c) #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Attributes #### [` ABI64 `]() static int ABI64 = 0x01000000 #### [` SUBTYPE_MASK `]() static uint32\_t SUBTYPE\_MASK = 0xff000000 #### [` SUBTYPE_LIB64 `]() static uint32\_t SUBTYPE\_LIB64 = 0x80000000 #### [` CPU_SUBTYPE_ARM64_ARM64E `]() static auto CPU\_SUBTYPE\_ARM64\_ARM64E = 2 Friends #### [` operator<< `]() friend std::ostream &operator<<(std::ostream &os, const [Header]( "LIEF::MachO::Header") &hdr) --- ## [Builder]() ### [` Builder `]() class Builder Class used to rebuild a Mach-O file. Public Functions #### [` Builder `]() Builder() = delete #### [` ~Builder `]() ~Builder() Public Static Functions #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([Binary]( "LIEF::MachO::Binary") &binary, const std::string &filename) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([Binary]( "LIEF::MachO::Binary") &binary, const std::string &filename, [config\_t]( "LIEF::MachO::Builder::config_t") config) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([Binary]( "LIEF::MachO::Binary") &binary, std::vector<uint8\_t> &out) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([Binary]( "LIEF::MachO::Binary") &binary, std::vector<uint8\_t> &out, [config\_t]( "LIEF::MachO::Builder::config_t") config) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([Binary]( "LIEF::MachO::Binary") &binary, std::ostream &out) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([Binary]( "LIEF::MachO::Binary") &binary, std::ostream &out, [config\_t]( "LIEF::MachO::Builder::config_t") config) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([FatBinary]( "LIEF::MachO::FatBinary") &fat, const std::string &filename) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([FatBinary]( "LIEF::MachO::FatBinary") &fat, const std::string &filename, [config\_t]( "LIEF::MachO::Builder::config_t") config) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([FatBinary]( "LIEF::MachO::FatBinary") &fat, std::vector<uint8\_t> &out) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([FatBinary]( "LIEF::MachO::FatBinary") &fat, std::vector<uint8\_t> &out, [config\_t]( "LIEF::MachO::Builder::config_t") config) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([FatBinary]( "LIEF::MachO::FatBinary") &fat, std::ostream &out) #### [` write `]() static [ok\_error\_t]( "LIEF::ok_error_t") write([FatBinary]( "LIEF::MachO::FatBinary") &fat, std::ostream &out, [config\_t]( "LIEF::MachO::Builder::config_t") config) #### [` config_t `]() struct config\_t Options to tweak the building process. Public Members ##### [` linkedit `]() bool linkedit = true --- ## [DylibCommand]() ### [` DylibCommand `]() class DylibCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class which represents a library dependency. Public Types #### [` version_t `]() using version\_t = std::array<uint16\_t, 3> Public Functions #### [` DylibCommand `]() DylibCommand() = default #### [` DylibCommand `]() DylibCommand(const details::dylib\_command &cmd) #### [` operator= `]() [DylibCommand]( "LIEF::MachO::DylibCommand") &operator=(const [DylibCommand]( "LIEF::MachO::DylibCommand") &copy) = default #### [` DylibCommand `]() DylibCommand(const [DylibCommand]( "LIEF::MachO::DylibCommand::DylibCommand") &copy) = default #### [` ~DylibCommand `]() ~DylibCommand() override = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` name `]() inline std::string\_view name() const Library name. #### [` name_offset `]() inline uint32\_t name\_offset() const Original string offset of the name. #### [` timestamp `]() inline uint32\_t timestamp() const Date and Time when the shared library was built. #### [` current_version `]() inline [version\_t]( "LIEF::MachO::DylibCommand::version_t") current\_version() const Current version of the shared library. #### [` compatibility_version `]() inline [version\_t]( "LIEF::MachO::DylibCommand::version_t") compatibility\_version() const Compatibility version of the shared library. #### [` name `]() inline void name(std::string name) #### [` timestamp `]() inline void timestamp(uint32\_t timestamp) #### [` current_version `]() inline void current\_version([version\_t]( "LIEF::MachO::DylibCommand::version_t") version) #### [` compatibility_version `]() inline void compatibility\_version([version\_t]( "LIEF::MachO::DylibCommand::version_t") version) #### [` print `]() virtual std::ostream &print(std::ostream &os) const override #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` int2version `]() static inline [version\_t]( "LIEF::MachO::DylibCommand::version_t") int2version(uint32\_t version) Helper to convert an integer into a version array. #### [` version2int `]() static inline uint32\_t version2int([version\_t]( "LIEF::MachO::DylibCommand::version_t") version) Helper to convert a version array into an integer. #### [` weak_dylib `]() static [DylibCommand]( "LIEF::MachO::DylibCommand") weak\_dylib(const std::string &name, uint32\_t timestamp = 0, uint32\_t current\_version = 0, uint32\_t compat\_version = 0) Factory function to generate a LC\_LOAD\_WEAK\_DYLIB library. #### [` id_dylib `]() static [DylibCommand]( "LIEF::MachO::DylibCommand") id\_dylib(const std::string &name, uint32\_t timestamp = 0, uint32\_t current\_version = 0, uint32\_t compat\_version = 0) Factory function to generate a LC\_ID\_DYLIB library. #### [` load_dylib `]() static [DylibCommand]( "LIEF::MachO::DylibCommand") load\_dylib(const std::string &name, uint32\_t timestamp = 2, uint32\_t current\_version = 0, uint32\_t compat\_version = 0) Factory function to generate a LC\_LOAD\_DYLIB library. #### [` reexport_dylib `]() static [DylibCommand]( "LIEF::MachO::DylibCommand") reexport\_dylib(const std::string &name, uint32\_t timestamp = 0, uint32\_t current\_version = 0, uint32\_t compat\_version = 0) Factory function to generate a LC\_REEXPORT\_DYLIB library. #### [` load_upward_dylib `]() static [DylibCommand]( "LIEF::MachO::DylibCommand") load\_upward\_dylib(const std::string &name, uint32\_t timestamp = 0, uint32\_t current\_version = 0, uint32\_t compat\_version = 0) Factory function to generate a LC\_LOAD\_UPWARD\_DYLIB library. #### [` lazy_load_dylib `]() static [DylibCommand]( "LIEF::MachO::DylibCommand") lazy\_load\_dylib(const std::string &name, uint32\_t timestamp = 0, uint32\_t current\_version = 0, uint32\_t compat\_version = 0) Factory function to generate a LC\_LAZY\_LOAD\_DYLIB library. #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [DylinkerCommand]() ### [` DylinkerCommand `]() class DylinkerCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the Mach-O linker, also named loader. Most of the time, [DylinkerCommand::name()]() should return `/usr/lib/dyld`. Public Functions #### [` DylinkerCommand `]() DylinkerCommand() = default #### [` DylinkerCommand `]() DylinkerCommand(const details::dylinker\_command &cmd) #### [` DylinkerCommand `]() DylinkerCommand(std::string name) #### [` operator= `]() [DylinkerCommand]( "LIEF::MachO::DylinkerCommand") &operator=(const [DylinkerCommand]( "LIEF::MachO::DylinkerCommand") &copy) = default #### [` DylinkerCommand `]() DylinkerCommand(const [DylinkerCommand]( "LIEF::MachO::DylinkerCommand::DylinkerCommand") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~DylinkerCommand `]() ~DylinkerCommand() override = default #### [` print `]() virtual std::ostream &print(std::ostream &os) const override #### [` name `]() inline std::string\_view name() const Path to the linker (or loader). #### [` name `]() inline void name(std::string name) #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [DynamicSymbolCommand]() ### [` DynamicSymbolCommand `]() class DynamicSymbolCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the LC\_DYSYMTAB command. This command completes the LC\_SYMTAB ([SymbolCommand]()) to provide a better granularity over the symbols layout. Public Types #### [` indirect_symbols_t `]() using indirect\_symbols\_t = std::vector<[Symbol]( "LIEF::MachO::Symbol")\*> Container for the indirect symbols references (owned by [MachO::Binary]()). #### [` it_indirect_symbols `]() using it\_indirect\_symbols = [ref\_iterator]( "LIEF::ref_iterator")<[indirect\_symbols\_t]( "LIEF::MachO::DynamicSymbolCommand::indirect_symbols_t")&> Iterator for the indirect symbols referenced by this command. #### [` it_const_indirect_symbols `]() using it\_const\_indirect\_symbols = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [indirect\_symbols\_t]( "LIEF::MachO::DynamicSymbolCommand::indirect_symbols_t")&> Public Functions #### [` DynamicSymbolCommand `]() DynamicSymbolCommand() #### [` DynamicSymbolCommand `]() DynamicSymbolCommand(const details::dysymtab\_command &cmd) #### [` operator= `]() [DynamicSymbolCommand]( "LIEF::MachO::DynamicSymbolCommand") &operator=(const [DynamicSymbolCommand]( "LIEF::MachO::DynamicSymbolCommand") &copy) = default #### [` DynamicSymbolCommand `]() DynamicSymbolCommand(const [DynamicSymbolCommand]( "LIEF::MachO::DynamicSymbolCommand::DynamicSymbolCommand") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~DynamicSymbolCommand `]() ~DynamicSymbolCommand() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override #### [` idx_local_symbol `]() inline uint32\_t idx\_local\_symbol() const Index of the first symbol in the group of local symbols. #### [` nb_local_symbols `]() inline uint32\_t nb\_local\_symbols() const Number of symbols in the group of local symbols. #### [` idx_external_define_symbol `]() inline uint32\_t idx\_external\_define\_symbol() const Index of the first symbol in the group of defined external symbols. #### [` nb_external_define_symbols `]() inline uint32\_t nb\_external\_define\_symbols() const Number of symbols in the group of defined external symbols. #### [` idx_undefined_symbol `]() inline uint32\_t idx\_undefined\_symbol() const Index of the first symbol in the group of undefined external symbols. #### [` nb_undefined_symbols `]() inline uint32\_t nb\_undefined\_symbols() const Number of symbols in the group of undefined external symbols. #### [` toc_offset `]() inline uint32\_t toc\_offset() const Byte offset from the start of the file to the table of contents data. Table of content is used by legacy Mach-O loader and this field should be set to 0 #### [` nb_toc `]() inline uint32\_t nb\_toc() const Number of entries in the table of contents. Should be set to 0 on recent Mach-O #### [` module_table_offset `]() inline uint32\_t module\_table\_offset() const Byte offset from the start of the file to the module table data. This field seems unused by recent Mach-O loader and should be set to 0 #### [` nb_module_table `]() inline uint32\_t nb\_module\_table() const Number of entries in the module table. This field seems unused by recent Mach-O loader and should be set to 0 #### [` external_reference_symbol_offset `]() inline uint32\_t external\_reference\_symbol\_offset() const Byte offset from the start of the file to the external reference table data. This field seems unused by recent Mach-O loader and should be set to 0 #### [` nb_external_reference_symbols `]() inline uint32\_t nb\_external\_reference\_symbols() const Number of entries in the external reference table. This field seems unused by recent Mach-O loader and should be set to 0 #### [` indirect_symbol_offset `]() inline uint32\_t indirect\_symbol\_offset() const Byte offset from the start of the file to the indirect symbol table data. Indirect symbol table is used by the loader to speed-up symbol resolution during the *lazy binding* process References: - dyld-519.2.1/src/ImageLoaderMachOCompressed.cpp - dyld-519.2.1/src/ImageLoaderMachOClassic.cpp #### [` nb_indirect_symbols `]() inline uint32\_t nb\_indirect\_symbols() const Number of entries in the indirect symbol table. > **See also** > > [indirect\_symbol\_offset]() #### [` external_relocation_offset `]() inline uint32\_t external\_relocation\_offset() const Byte offset from the start of the file to the external relocation table data. This field seems unused by recent Mach-O loader and should be set to 0 #### [` nb_external_relocations `]() inline uint32\_t nb\_external\_relocations() const Number of entries in the external relocation table. This field seems unused by recent Mach-O loader and should be set to 0 #### [` local_relocation_offset `]() inline uint32\_t local\_relocation\_offset() const Byte offset from the start of the file to the local relocation table data. This field seems unused by recent Mach-O loader and should be set to 0 #### [` nb_local_relocations `]() inline uint32\_t nb\_local\_relocations() const Number of entries in the local relocation table. This field seems unused by recent Mach-O loader and should be set to 0 #### [` idx_local_symbol `]() inline void idx\_local\_symbol(uint32\_t value) #### [` nb_local_symbols `]() inline void nb\_local\_symbols(uint32\_t value) #### [` idx_external_define_symbol `]() inline void idx\_external\_define\_symbol(uint32\_t value) #### [` nb_external_define_symbols `]() inline void nb\_external\_define\_symbols(uint32\_t value) #### [` idx_undefined_symbol `]() inline void idx\_undefined\_symbol(uint32\_t value) #### [` nb_undefined_symbols `]() inline void nb\_undefined\_symbols(uint32\_t value) #### [` toc_offset `]() inline void toc\_offset(uint32\_t value) #### [` nb_toc `]() inline void nb\_toc(uint32\_t value) #### [` module_table_offset `]() inline void module\_table\_offset(uint32\_t value) #### [` nb_module_table `]() inline void nb\_module\_table(uint32\_t value) #### [` external_reference_symbol_offset `]() inline void external\_reference\_symbol\_offset(uint32\_t value) #### [` nb_external_reference_symbols `]() inline void nb\_external\_reference\_symbols(uint32\_t value) #### [` indirect_symbol_offset `]() inline void indirect\_symbol\_offset(uint32\_t value) #### [` nb_indirect_symbols `]() inline void nb\_indirect\_symbols(uint32\_t value) #### [` external_relocation_offset `]() inline void external\_relocation\_offset(uint32\_t value) #### [` nb_external_relocations `]() inline void nb\_external\_relocations(uint32\_t value) #### [` local_relocation_offset `]() inline void local\_relocation\_offset(uint32\_t value) #### [` nb_local_relocations `]() inline void nb\_local\_relocations(uint32\_t value) #### [` indirect_symbols `]() inline [it\_indirect\_symbols]( "LIEF::MachO::DynamicSymbolCommand::it_indirect_symbols") indirect\_symbols() Iterator over the indirect symbols indexed by this command. #### [` indirect_symbols `]() inline [it\_const\_indirect\_symbols]( "LIEF::MachO::DynamicSymbolCommand::it_const_indirect_symbols") indirect\_symbols() const Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [LoadCommand]() ### [` LoadCommand `]() class LoadCommand : public LIEF::Object Base class for the Mach-O load commands. Subclassed by LIEF::MachO::AtomInfo, [LIEF::MachO::BuildVersion](), [LIEF::MachO::CodeSignature](), [LIEF::MachO::CodeSignatureDir](), [LIEF::MachO::DataInCode](), [LIEF::MachO::DyldChainedFixups](), [LIEF::MachO::DyldEnvironment](), [LIEF::MachO::DyldExportsTrie](), [LIEF::MachO::DyldInfo](), [LIEF::MachO::DylibCommand](), [LIEF::MachO::DylinkerCommand](), [LIEF::MachO::DynamicSymbolCommand](), [LIEF::MachO::EncryptionInfo](), [LIEF::MachO::FilesetCommand](), [LIEF::MachO::FunctionStarts](), [LIEF::MachO::FunctionVariantFixups](), [LIEF::MachO::FunctionVariants](), [LIEF::MachO::LazyLoadDylibInfo](), [LIEF::MachO::LinkerOptHint](), [LIEF::MachO::MainCommand](), [LIEF::MachO::NoteCommand](), [LIEF::MachO::RPathCommand](), [LIEF::MachO::Routine](), [LIEF::MachO::SegmentCommand](), [LIEF::MachO::SegmentSplitInfo](), [LIEF::MachO::SourceVersion](), [LIEF::MachO::SubClient](), [LIEF::MachO::SubFramework](), [LIEF::MachO::SymbolCommand](), [LIEF::MachO::ThreadCommand](), [LIEF::MachO::TwoLevelHints](), [LIEF::MachO::UUIDCommand](), [LIEF::MachO::UnknownCommand](), [LIEF::MachO::VersionMin]() Public Types #### [` TYPE `]() enum class TYPE : uint64\_t *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` SEGMENT `]() enumerator SEGMENT = 0x00000001u ##### [` SYMTAB `]() enumerator SYMTAB = 0x00000002u ##### [` SYMSEG `]() enumerator SYMSEG = 0x00000003u ##### [` THREAD `]() enumerator THREAD = 0x00000004u ##### [` UNIXTHREAD `]() enumerator UNIXTHREAD = 0x00000005u ##### [` LOADFVMLIB `]() enumerator LOADFVMLIB = 0x00000006u ##### [` IDFVMLIB `]() enumerator IDFVMLIB = 0x00000007u ##### [` IDENT `]() enumerator IDENT = 0x00000008u ##### [` FVMFILE `]() enumerator FVMFILE = 0x00000009u ##### [` PREPAGE `]() enumerator PREPAGE = 0x0000000Au ##### [` DYSYMTAB `]() enumerator DYSYMTAB = 0x0000000Bu ##### [` LOAD_DYLIB `]() enumerator LOAD\_DYLIB = 0x0000000Cu ##### [` ID_DYLIB `]() enumerator ID\_DYLIB = 0x0000000Du ##### [` LOAD_DYLINKER `]() enumerator LOAD\_DYLINKER = 0x0000000Eu ##### [` ID_DYLINKER `]() enumerator ID\_DYLINKER = 0x0000000Fu ##### [` PREBOUND_DYLIB `]() enumerator PREBOUND\_DYLIB = 0x00000010u ##### [` ROUTINES `]() enumerator ROUTINES = 0x00000011u ##### [` SUB_FRAMEWORK `]() enumerator SUB\_FRAMEWORK = 0x00000012u ##### [` SUB_UMBRELLA `]() enumerator SUB\_UMBRELLA = 0x00000013u ##### [` SUB_CLIENT `]() enumerator SUB\_CLIENT = 0x00000014u ##### [` SUB_LIBRARY `]() enumerator SUB\_LIBRARY = 0x00000015u ##### [` TWOLEVEL_HINTS `]() enumerator TWOLEVEL\_HINTS = 0x00000016u ##### [` PREBIND_CKSUM `]() enumerator PREBIND\_CKSUM = 0x00000017u ##### [` LOAD_WEAK_DYLIB `]() enumerator LOAD\_WEAK\_DYLIB = 0x80000018u ##### [` SEGMENT_64 `]() enumerator SEGMENT\_64 = 0x00000019u ##### [` ROUTINES_64 `]() enumerator ROUTINES\_64 = 0x0000001Au ##### [` UUID `]() enumerator UUID = 0x0000001Bu ##### [` RPATH `]() enumerator RPATH = 0x8000001Cu ##### [` CODE_SIGNATURE `]() enumerator CODE\_SIGNATURE = 0x0000001Du ##### [` SEGMENT_SPLIT_INFO `]() enumerator SEGMENT\_SPLIT\_INFO = 0x0000001Eu ##### [` REEXPORT_DYLIB `]() enumerator REEXPORT\_DYLIB = 0x8000001Fu ##### [` LAZY_LOAD_DYLIB `]() enumerator LAZY\_LOAD\_DYLIB = 0x00000020u ##### [` ENCRYPTION_INFO `]() enumerator ENCRYPTION\_INFO = 0x00000021u ##### [` DYLD_INFO `]() enumerator DYLD\_INFO = 0x00000022u ##### [` DYLD_INFO_ONLY `]() enumerator DYLD\_INFO\_ONLY = 0x80000022u ##### [` LOAD_UPWARD_DYLIB `]() enumerator LOAD\_UPWARD\_DYLIB = 0x80000023u ##### [` VERSION_MIN_MACOSX `]() enumerator VERSION\_MIN\_MACOSX = 0x00000024u ##### [` VERSION_MIN_IPHONEOS `]() enumerator VERSION\_MIN\_IPHONEOS = 0x00000025u ##### [` FUNCTION_STARTS `]() enumerator FUNCTION\_STARTS = 0x00000026u ##### [` DYLD_ENVIRONMENT `]() enumerator DYLD\_ENVIRONMENT = 0x00000027u ##### [` MAIN `]() enumerator MAIN = 0x80000028u ##### [` DATA_IN_CODE `]() enumerator DATA\_IN\_CODE = 0x00000029u ##### [` SOURCE_VERSION `]() enumerator SOURCE\_VERSION = 0x0000002Au ##### [` DYLIB_CODE_SIGN_DRS `]() enumerator DYLIB\_CODE\_SIGN\_DRS = 0x0000002Bu ##### [` ENCRYPTION_INFO_64 `]() enumerator ENCRYPTION\_INFO\_64 = 0x0000002Cu ##### [` LINKER_OPTION `]() enumerator LINKER\_OPTION = 0x0000002Du ##### [` LINKER_OPTIMIZATION_HINT `]() enumerator LINKER\_OPTIMIZATION\_HINT = 0x0000002Eu ##### [` VERSION_MIN_TVOS `]() enumerator VERSION\_MIN\_TVOS = 0x0000002Fu ##### [` VERSION_MIN_WATCHOS `]() enumerator VERSION\_MIN\_WATCHOS = 0x00000030u ##### [` NOTE `]() enumerator NOTE = 0x00000031u ##### [` BUILD_VERSION `]() enumerator BUILD\_VERSION = 0x00000032u ##### [` DYLD_EXPORTS_TRIE `]() enumerator DYLD\_EXPORTS\_TRIE = 0x80000033u ##### [` DYLD_CHAINED_FIXUPS `]() enumerator DYLD\_CHAINED\_FIXUPS = 0x80000034u ##### [` FILESET_ENTRY `]() enumerator FILESET\_ENTRY = 0x80000035u ##### [` ATOM_INFO `]() enumerator ATOM\_INFO = 0x00000036u ##### [` FUNCTION_VARIANTS `]() enumerator FUNCTION\_VARIANTS = 0x00000037u ##### [` FUNCTION_VARIANT_FIXUPS `]() enumerator FUNCTION\_VARIANT\_FIXUPS = 0x00000038u ##### [` TARGET_TRIPLE `]() enumerator TARGET\_TRIPLE = 0x00000039u ##### [` LAZY_LOAD_DYLIB_INFO `]() enumerator LAZY\_LOAD\_DYLIB\_INFO = 0x0000003Au ##### [` LIEF_UNKNOWN `]() enumerator LIEF\_UNKNOWN = 0xffee0001u #### [` raw_t `]() using raw\_t = std::vector<uint8\_t> Public Functions #### [` LoadCommand `]() LoadCommand() = default #### [` LoadCommand `]() LoadCommand(const details::load\_command &command) #### [` LoadCommand `]() inline LoadCommand([LoadCommand]( "LIEF::MachO::LoadCommand::LoadCommand")::TYPE type, uint32\_t size) #### [` operator= `]() [LoadCommand]( "LIEF::MachO::LoadCommand") &operator=(const [LoadCommand]( "LIEF::MachO::LoadCommand") &copy) = default #### [` LoadCommand `]() LoadCommand(const [LoadCommand]( "LIEF::MachO::LoadCommand::LoadCommand") &copy) = default #### [` swap `]() void swap([LoadCommand]( "LIEF::MachO::LoadCommand") &other) noexcept #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const #### [` ~LoadCommand `]() ~LoadCommand() override = default #### [` command `]() inline [LoadCommand]( "LIEF::MachO::LoadCommand")::[TYPE]( "LIEF::MachO::LoadCommand::TYPE") command() const Command type. #### [` size `]() inline uint32\_t size() const Size of the command (should be greater than `sizeof(load_command)`). #### [` data `]() inline span<const uint8\_t> data() const Raw command. #### [` command_offset `]() inline uint64\_t command\_offset() const Offset of the command within the *Load Command Table*. #### [` data `]() inline void data([raw\_t]( "LIEF::MachO::LoadCommand::raw_t") data) #### [` command `]() inline void command([LoadCommand]( "LIEF::MachO::LoadCommand")::[TYPE]( "LIEF::MachO::LoadCommand::TYPE") command) #### [` size `]() inline void size(uint32\_t size) #### [` command_offset `]() inline void command\_offset(uint64\_t offset) #### [` print `]() virtual std::ostream &print(std::ostream &os) const #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` Tcast `]() template<class T> inline const [T]( "LIEF::MachO::LoadCommand::cast::T") \*cast() const #### [` Tcast `]() template<class T> inline [T]( "LIEF::MachO::LoadCommand::cast::T") \*cast() Public Static Functions #### [` is_linkedit_data `]() static bool is\_linkedit\_data(const [LoadCommand]( "LIEF::MachO::LoadCommand") &cmd) Friends #### [` operator<< `]() inline friend std::ostream &operator<<(std::ostream &os, const [LoadCommand]( "LIEF::MachO::LoadCommand") &cmd) --- ## [MainCommand]() ### [` MainCommand `]() class MainCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the LC\_MAIN command. This kind of command can be used to determine the entrypoint of an executable. Public Functions #### [` MainCommand `]() MainCommand() = default #### [` MainCommand `]() MainCommand(const details::entry\_point\_command &cmd) #### [` MainCommand `]() MainCommand(uint64\_t entrypoint, uint64\_t stacksize) #### [` operator= `]() [MainCommand]( "LIEF::MachO::MainCommand") &operator=(const [MainCommand]( "LIEF::MachO::MainCommand") &copy) = default #### [` MainCommand `]() MainCommand(const [MainCommand]( "LIEF::MachO::MainCommand::MainCommand") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~MainCommand `]() ~MainCommand() override = default #### [` entrypoint `]() inline uint64\_t entrypoint() const Offset of the *main* function relative to the `__TEXT` segment. #### [` stack_size `]() inline uint64\_t stack\_size() const The initial stack size. #### [` entrypoint `]() inline void entrypoint(uint64\_t entrypoint) #### [` stack_size `]() inline void stack\_size(uint64\_t stacksize) #### [` print `]() virtual std::ostream &print(std::ostream &os) const override #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [NoteCommand]() ### [` NoteCommand `]() class NoteCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the `LC_NOTE` command. This command is used to include arbitrary notes or metadata within a binary. Public Functions #### [` NoteCommand `]() NoteCommand() = default #### [` NoteCommand `]() NoteCommand(const details::note\_command &cmd) #### [` operator= `]() [NoteCommand]( "LIEF::MachO::NoteCommand") &operator=(const [NoteCommand]( "LIEF::MachO::NoteCommand") &copy) = default #### [` NoteCommand `]() NoteCommand(const [NoteCommand]( "LIEF::MachO::NoteCommand::NoteCommand") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` note_offset `]() inline uint64\_t note\_offset() const Offset of the data associated with this note. #### [` note_size `]() inline uint64\_t note\_size() const Size of the data referenced by the note\_offset. #### [` owner `]() inline span<const char> owner() const Owner of the note (e.g. `AIR_METALLIB`). #### [` owner `]() inline span<char> owner() #### [` owner_str `]() inline std::string owner\_str() const Owner as a zero-terminated string. #### [` note_offset `]() inline void note\_offset(uint64\_t offset) #### [` note_size `]() inline void note\_size(uint64\_t size) #### [` ~NoteCommand `]() ~NoteCommand() override = default #### [` print `]() virtual std::ostream &print(std::ostream &os) const override #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Section]() ### [` Section `]() class Section : public LIEF::[Section]( "LIEF::Section") Class that represents a Mach-O section. Subclassed by [LIEF::MachO::ThreadLocalVariables]() Public Types #### [` TYPE `]() enum class TYPE : uint64\_t *Values:* ##### [` REGULAR `]() enumerator REGULAR = 0x00u Regular section. ##### [` ZEROFILL `]() enumerator ZEROFILL = 0x01u Zero fill on demand section. ##### [` CSTRING_LITERALS `]() enumerator CSTRING\_LITERALS = 0x02u [Section]() with literal C strings. ##### [` IS_4BYTE_LITERALS `]() enumerator IS\_4BYTE\_LITERALS = 0x03u [Section]() with 4 byte literals. ##### [` IS_8BYTE_LITERALS `]() enumerator IS\_8BYTE\_LITERALS = 0x04u [Section]() with 8 byte literals. ##### [` LITERAL_POINTERS `]() enumerator LITERAL\_POINTERS = 0x05u [Section]() with pointers to literals. ##### [` NON_LAZY_SYMBOL_POINTERS `]() enumerator NON\_LAZY\_SYMBOL\_POINTERS = 0x06u [Section]() with non-lazy symbol pointers. ##### [` LAZY_SYMBOL_POINTERS `]() enumerator LAZY\_SYMBOL\_POINTERS = 0x07u [Section]() with lazy symbol pointers. ##### [` SYMBOL_STUBS `]() enumerator SYMBOL\_STUBS = 0x08u [Section]() with symbol stubs, byte size of stub in the Reserved2 field. ##### [` MOD_INIT_FUNC_POINTERS `]() enumerator MOD\_INIT\_FUNC\_POINTERS = 0x09u [Section]() with only function pointers for initialization. ##### [` MOD_TERM_FUNC_POINTERS `]() enumerator MOD\_TERM\_FUNC\_POINTERS = 0x0au [Section]() with only function pointers for termination. ##### [` COALESCED `]() enumerator COALESCED = 0x0bu [Section]() contains symbols that are to be coalesced. ##### [` GB_ZEROFILL `]() enumerator GB\_ZEROFILL = 0x0cu Zero fill on demand section (that can be larger than 4 gigabytes). ##### [` INTERPOSING `]() enumerator INTERPOSING = 0x0du [Section]() with only pairs of function pointers for interposing. ##### [` IS_16BYTE_LITERALS `]() enumerator IS\_16BYTE\_LITERALS = 0x0eu [Section]() with only 16 byte literals. ##### [` DTRACE_DOF `]() enumerator DTRACE\_DOF = 0x0fu [Section]() contains DTrace Object Format. ##### [` LAZY_DYLIB_SYMBOL_POINTERS `]() enumerator LAZY\_DYLIB\_SYMBOL\_POINTERS = 0x10u [Section]() with lazy symbol pointers to lazy loaded dylibs. ##### [` THREAD_LOCAL_REGULAR `]() enumerator THREAD\_LOCAL\_REGULAR = 0x11u Thread local data section. ##### [` THREAD_LOCAL_ZEROFILL `]() enumerator THREAD\_LOCAL\_ZEROFILL = 0x12u Thread local zerofill section. ##### [` THREAD_LOCAL_VARIABLES `]() enumerator THREAD\_LOCAL\_VARIABLES = 0x13u [Section]() with thread local variable structure data. ##### [` THREAD_LOCAL_VARIABLE_POINTERS `]() enumerator THREAD\_LOCAL\_VARIABLE\_POINTERS = 0x14u [Section]() with pointers to thread local structures. ##### [` THREAD_LOCAL_INIT_FUNCTION_POINTERS `]() enumerator THREAD\_LOCAL\_INIT\_FUNCTION\_POINTERS = 0x15u [Section]() with thread local variable initialization pointers to functions. ##### [` INIT_FUNC_OFFSETS `]() enumerator INIT\_FUNC\_OFFSETS = 0x16u [Section]() with 32-bit offsets to initializer functions. #### [` FLAGS `]() enum class FLAGS : uint64\_t *Values:* ##### [` PURE_INSTRUCTIONS `]() enumerator PURE\_INSTRUCTIONS = 0x80000000u [Section]() contains only true machine instructions. ##### [` NO_TOC `]() enumerator NO\_TOC = 0x40000000u [Section]() contains coalesced symbols that are not to be in a ranlib table of contents. ##### [` STRIP_STATIC_SYMS `]() enumerator STRIP\_STATIC\_SYMS = 0x20000000u Okay to strip static symbols in this section in files with the MY\_DYLDLINK flag. ##### [` NO_DEAD_STRIP `]() enumerator NO\_DEAD\_STRIP = 0x10000000u No dead stripping. ##### [` LIVE_SUPPORT `]() enumerator LIVE\_SUPPORT = 0x08000000u Blocks are live if they reference live blocks. ##### [` SELF_MODIFYING_CODE `]() enumerator SELF\_MODIFYING\_CODE = 0x04000000u Used with i386 code stubs written on by dyld. ##### [` DEBUG_INFO `]() enumerator DEBUG\_INFO = 0x02000000u A debug section. ##### [` SOME_INSTRUCTIONS `]() enumerator SOME\_INSTRUCTIONS = 0x00000400u [Section]() contains some machine instructions. ##### [` EXT_RELOC `]() enumerator EXT\_RELOC = 0x00000200u [Section]() has external relocation entries. ##### [` LOC_RELOC `]() enumerator LOC\_RELOC = 0x00000100u [Section]() has local relocation entries. #### [` content_t `]() using content\_t = std::vector<uint8\_t> #### [` relocations_t `]() using relocations\_t = std::vector<std::unique\_ptr<[Relocation]( "LIEF::MachO::Relocation")>> Internal container for storing Mach-O [Relocation](). #### [` it_relocations `]() using it\_relocations = [ref\_iterator]( "LIEF::ref_iterator")<[relocations\_t]( "LIEF::MachO::Section::relocations_t")&, [Relocation]( "LIEF::MachO::Relocation")\*> Iterator which outputs [Relocation]()&. #### [` it_const_relocations `]() using it\_const\_relocations = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [relocations\_t]( "LIEF::MachO::Section::relocations_t")&, const [Relocation]( "LIEF::MachO::Relocation")\*> Iterator which outputs const [Relocation]()&. Public Functions #### [` Section `]() Section(const details::section\_32 &sec) #### [` Section `]() Section(const details::section\_64 &sec) #### [` Section `]() Section([Section]( "LIEF::MachO::Section::Section")&&) #### [` operator= `]() [Section]( "LIEF::MachO::Section") &operator=([Section]( "LIEF::MachO::Section")&&) #### [` ~Section `]() ~Section() override #### [` clone `]() inline virtual std::unique\_ptr<[Section]( "LIEF::MachO::Section")> clone() const #### [` content `]() virtual span<const uint8\_t> content() const override [Section]()’s content. #### [` content `]() inline span<uint8\_t> content() #### [` content `]() virtual void content(const [content\_t]( "LIEF::MachO::Section::content_t") &data) override Update the content of the section. #### [` segment_name `]() std::string\_view segment\_name() const Return the name of the segment linked to this section. #### [` address `]() inline uint64\_t address() const Virtual base address of the section. #### [` alignment `]() inline uint32\_t alignment() const [Section]() alignment as a power of 2. #### [` relocation_offset `]() inline uint32\_t relocation\_offset() const Offset of the relocation table. This value should be 0 for executable and libraries as the relocations are managed by the [DyldInfo::rebase](). On the other hand, for object files (`.o`) this value should not be 0 > **See also** > > [numberof\_relocations]() > **See also** > > [relocations]() #### [` numberof_relocations `]() inline uint32\_t numberof\_relocations() const Number of relocations associated with this section. #### [` flags `]() inline [FLAGS]( "LIEF::MachO::Section::FLAGS") flags() const [Section]()’s flags masked with SECTION\_FLAGS\_MASK (see: [Section::FLAGS]()). > **See also** > > [flags]() #### [` type `]() inline [TYPE]( "LIEF::MachO::Section::TYPE") type() const Type of the section. This value can help to determine the purpose of the section (e.g. [TYPE::INTERPOSING]()). #### [` reserved1 `]() inline uint32\_t reserved1() const According to the official `loader.h` file, this value is reserved for *offset* or *index*. #### [` reserved2 `]() inline uint32\_t reserved2() const According to the official `loader.h` file, this value is reserved for *count* or *sizeof*. #### [` reserved3 `]() inline uint32\_t reserved3() const This value is only present for 64 bits Mach-O files. In that case, the value is *reserved*. #### [` flags_list `]() std::vector<[FLAGS]( "LIEF::MachO::Section::FLAGS")> flags\_list() const Return the [Section::flags]() as a list of [Section::FLAGS](). > **See also** > > [flags]() #### [` raw_flags `]() inline uint32\_t raw\_flags() const [Section]() flags without applying the SECTION\_FLAGS\_MASK mask. #### [` has_segment `]() inline bool has\_segment() const Check if this section is correctly linked with a [MachO::SegmentCommand](). #### [` segment `]() inline [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*segment() The segment associated with this section or a nullptr if not present. #### [` segment `]() inline const [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*segment() const #### [` stream `]() std::unique\_ptr<[SpanStream]( "LIEF::SpanStream")> stream() const Return a stream over the content of this section. #### [` clear `]() inline void clear(uint8\_t v) Clear the content of this section by filling its values with the byte provided in parameter. #### [` relocations `]() inline [it\_relocations]( "LIEF::MachO::Section::it_relocations") relocations() Return an iterator over the [MachO::Relocation]() associated with this section. This iterator is likely to be empty for executables and libraries while it should not be for object files (`.o`) #### [` relocations `]() inline [it\_const\_relocations]( "LIEF::MachO::Section::it_const_relocations") relocations() const #### [` segment_name `]() void segment\_name(const std::string &name) #### [` address `]() inline void address(uint64\_t address) #### [` alignment `]() inline void alignment(uint32\_t align) #### [` relocation_offset `]() inline void relocation\_offset(uint32\_t offset) #### [` numberof_relocations `]() inline void numberof\_relocations(uint32\_t nb\_reloc) #### [` flags `]() inline void flags(uint32\_t flags) #### [` flags `]() void flags(std::vector<[FLAGS]( "LIEF::MachO::Section::FLAGS")> flags) #### [` type `]() inline void type([TYPE]( "LIEF::MachO::Section::TYPE") type) #### [` reserved1 `]() inline void reserved1(uint32\_t reserved1) #### [` reserved2 `]() inline void reserved2(uint32\_t reserved2) #### [` reserved3 `]() inline void reserved3(uint32\_t reserved3) #### [` has `]() bool has([FLAGS]( "LIEF::MachO::Section::FLAGS") flag) const Check if the section has the given [Section::FLAGS]() flag. #### [` add `]() void add([FLAGS]( "LIEF::MachO::Section::FLAGS") flag) Append a [Section::FLAGS]() to the current section. #### [` remove `]() void remove([FLAGS]( "LIEF::MachO::Section::FLAGS") flag) Remove a [Section::FLAGS]() to the current section. #### [` operator+= `]() inline [Section]( "LIEF::MachO::Section") &operator+=([FLAGS]( "LIEF::MachO::Section::FLAGS") flag) #### [` operator-= `]() inline [Section]( "LIEF::MachO::Section") &operator-=([FLAGS]( "LIEF::MachO::Section::FLAGS") flag) #### [` Tcast `]() template<class T> inline const [T]( "LIEF::MachO::Section::cast::T") \*cast() const #### [` Tcast `]() template<class T> inline [T]( "LIEF::MachO::Section::cast::T") \*cast() #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` create `]() static std::unique\_ptr<[Section]( "LIEF::MachO::Section")> create(const details::section\_32 &sec) #### [` create `]() static std::unique\_ptr<[Section]( "LIEF::MachO::Section")> create(const details::section\_64 &sec) #### [` create `]() static std::unique\_ptr<[Section]( "LIEF::MachO::Section")> create(std::string name, const [content\_t]( "LIEF::MachO::Section::content_t") &content, [TYPE]( "LIEF::MachO::Section::TYPE") type = [TYPE]( "LIEF::MachO::Section::TYPE")::[REGULAR]( "LIEF::MachO::Section::TYPE::REGULAR")) #### [` create `]() static inline std::unique\_ptr<[Section]( "LIEF::MachO::Section")> create(std::string name, [TYPE]( "LIEF::MachO::Section::TYPE") type = [TYPE]( "LIEF::MachO::Section::TYPE")::[REGULAR]( "LIEF::MachO::Section::TYPE::REGULAR")) Public Static Attributes #### [` FLAGS_MASK `]() static auto FLAGS\_MASK = uint32\_t(0xffffff00u) #### [` TYPE_MASK `]() static auto TYPE\_MASK = uint32\_t(0xff) Friends #### [` operator<< `]() friend std::ostream &operator<<(std::ostream &os, const [Section]( "LIEF::MachO::Section") &section) --- ## [ThreadLocalVariables]() ### [` ThreadLocalVariables `]() class ThreadLocalVariables : public LIEF::MachO::[Section]( "LIEF::MachO::Section") This class represents a MachO section with type [Section::TYPE::THREAD\_LOCAL\_VARIABLES]() (`S_THREAD_LOCAL_VARIABLES`). Such a section contains an array of thread-local variable descriptors ([Thunk]()) that the dynamic linker (dyld) uses to lazily initialize thread-local storage (TLS) on first access. Each descriptor holds a pointer to the initializer function, a TLS key, and the offset of the variable in the TLS block. Public Types #### [` thunks_it `]() using thunks\_it = [iterator\_range]( "LIEF::iterator_range")<[Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator")> Public Functions #### [` ThreadLocalVariables `]() ThreadLocalVariables() #### [` ThreadLocalVariables `]() ThreadLocalVariables(const [ThreadLocalVariables]( "LIEF::MachO::ThreadLocalVariables::ThreadLocalVariables")&) = default #### [` ThreadLocalVariables `]() ThreadLocalVariables([ThreadLocalVariables]( "LIEF::MachO::ThreadLocalVariables::ThreadLocalVariables")&&) noexcept = default #### [` operator= `]() [ThreadLocalVariables]( "LIEF::MachO::ThreadLocalVariables") &operator=(const [ThreadLocalVariables]( "LIEF::MachO::ThreadLocalVariables")&) = default #### [` operator= `]() [ThreadLocalVariables]( "LIEF::MachO::ThreadLocalVariables") &operator=([ThreadLocalVariables]( "LIEF::MachO::ThreadLocalVariables")&&) noexcept = default #### [` clone `]() inline virtual std::unique\_ptr<[Section]( "LIEF::MachO::ThreadLocalVariables::Section")> clone() const override #### [` thunks `]() inline [thunks\_it]( "LIEF::MachO::ThreadLocalVariables::thunks_it") thunks() const Return an iterator range over the [Thunk]() descriptors stored in this section. #### [` nb_thunks `]() size\_t nb\_thunks() const Number of [Thunk]() descriptors in this section. #### [` get `]() std::optional<[Thunk]( "LIEF::MachO::ThreadLocalVariables::Thunk")> get(size\_t idx) const Access the [Thunk]() at the given `idx`, or return an empty optional if the index is out of range. #### [` set `]() void set(size\_t idx, const [Thunk]( "LIEF::MachO::ThreadLocalVariables::Thunk") &thunk) Change the [Thunk]() at the given `idx`. #### [` operator[] `]() inline std::optional<[Thunk]( "LIEF::MachO::ThreadLocalVariables::Thunk")> operator[](size\_t idx) const Access the [Thunk]() at the given `idx`. #### [` ~ThreadLocalVariables `]() ~ThreadLocalVariables() override = default #### [` Section `]() Section(const details::section\_32 &sec) #### [` Section `]() Section(const details::section\_64 &sec) #### [` Section `]() Section([Section]( "LIEF::MachO::ThreadLocalVariables::Section")&&) Public Static Functions #### [` classof `]() static inline bool classof(const [Section]( "LIEF::MachO::ThreadLocalVariables::Section") \*section) Friends **friend class Section** #### [` Thunk `]() struct Thunk Descriptor for a single thread-local variable. The layout mirrors the `tlv_descriptor` structure defined in `` (see also `libdyld/ThreadLocalVariables.h` in dyld). Public Functions ##### [` to_string `]() std::string to\_string() const Public Members ##### [` func `]() uint64\_t func = 0 Address of the initializer function (`tlv_thunk`). ##### [` key `]() uint64\_t key = 0 `pthread_key_t` key used by the runtime ##### [` offset `]() uint64\_t offset = 0 Offset of the variable in the TLS block. Friends ##### [` operator<< `]() inline friend std::ostream &operator<<(std::ostream &os, const [Thunk]( "LIEF::MachO::ThreadLocalVariables::Thunk") &thunk) #### [` Iterator `]() class Iterator : public LIEF::iterator\_facade\_base<[Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator"), std::random\_access\_iterator\_tag, const [Thunk]( "LIEF::MachO::ThreadLocalVariables::Thunk")> Random-access iterator that materializes [Thunk]() values on the fly from the raw section content. Public Functions ##### [` Iterator `]() Iterator() = default ##### [` Iterator `]() inline Iterator(const [ThreadLocalVariables]( "LIEF::MachO::ThreadLocalVariables") &parent, size\_t pos) ##### [` Iterator `]() Iterator(const [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator::Iterator")&) = default ##### [` operator= `]() [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator") &operator=(const [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator")&) = default ##### [` Iterator `]() Iterator([Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator::Iterator")&&) noexcept = default ##### [` operator= `]() [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator") &operator=([Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator")&&) noexcept = default ##### [` ~Iterator `]() ~Iterator() = default ##### [` operator< `]() inline bool operator<(const [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator") &rhs) const ##### [` operator- `]() inline std::ptrdiff\_t operator-(const [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator") &R) const ##### [` operator+= `]() inline [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator") &operator+=(std::ptrdiff\_t n) ##### [` operator-= `]() inline [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator") &operator-=(std::ptrdiff\_t n) ##### [` operator* `]() inline [Thunk]( "LIEF::MachO::ThreadLocalVariables::Thunk") operator\*() const Friends ##### [` operator== `]() inline friend bool operator==(const [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator") &LHS, const [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator") &RHS) ##### [` operator!= `]() inline friend bool operator!=(const [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator") &LHS, const [Iterator]( "LIEF::MachO::ThreadLocalVariables::Iterator") &RHS) --- ## [SegmentCommand]() ### [` SegmentCommand `]() class SegmentCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class which represents a [LoadCommand::TYPE::SEGMENT]() / [LoadCommand::TYPE::SEGMENT\_64]() command. Subclassed by LIEF::MachO::LinkEdit Public Types #### [` FLAGS `]() enum class FLAGS : uint64\_t *Values:* ##### [` HIGHVM `]() enumerator HIGHVM = 0x1u The file contents for this segment are for the high part of the virtual memory space; the low part is zero filled (for stacks in core files). ##### [` FVMLIB `]() enumerator FVMLIB = 0x2u This segment is the VM that is allocated by a fixed VM library, for overlap checking in the link editor. ##### [` NORELOC `]() enumerator NORELOC = 0x4u This segment has nothing that was relocated in it and nothing relocated to it. It may be safely replaced without relocation. ##### [` PROTECTED_VERSION_1 `]() enumerator PROTECTED\_VERSION\_1 = 0x8u ##### [` READ_ONLY `]() enumerator READ\_ONLY = 0x10u #### [` VM_PROTECTIONS `]() enum class VM\_PROTECTIONS Values for segment\_command.initprot. From <mach/vm\_prot.h>. *Values:* ##### [` READ `]() enumerator READ = 0x1 Reading data within the segment is allowed. ##### [` WRITE `]() enumerator WRITE = 0x2 Writing data within the segment is allowed. ##### [` EXECUTE `]() enumerator EXECUTE = 0x4 Executing data within the segment is allowed. #### [` content_t `]() using content\_t = std::vector<uint8\_t> #### [` sections_t `]() using sections\_t = std::vector<std::unique\_ptr<[Section]( "LIEF::MachO::Section")>> Internal container for storing Mach-O [Section](). #### [` it_sections `]() using it\_sections = [ref\_iterator]( "LIEF::ref_iterator")<[sections\_t]( "LIEF::MachO::SegmentCommand::sections_t")&, [Section]( "LIEF::MachO::Section")\*> Iterator which outputs [Section]()&. #### [` it_const_sections `]() using it\_const\_sections = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [sections\_t]( "LIEF::MachO::SegmentCommand::sections_t")&, const [Section]( "LIEF::MachO::Section")\*> Iterator which outputs const [Section]()&. #### [` relocations_t `]() using relocations\_t = std::vector<std::unique\_ptr<[Relocation]( "LIEF::MachO::Relocation")>> Internal container for storing Mach-O [Relocation](). #### [` it_relocations `]() using it\_relocations = [ref\_iterator]( "LIEF::ref_iterator")<[relocations\_t]( "LIEF::MachO::SegmentCommand::relocations_t")&, [Relocation]( "LIEF::MachO::Relocation")\*> Iterator which outputs [Relocation]()&. #### [` it_const_relocations `]() using it\_const\_relocations = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [relocations\_t]( "LIEF::MachO::SegmentCommand::relocations_t")&, const [Relocation]( "LIEF::MachO::Relocation")\*> Iterator which outputs const [Relocation]()&. Public Functions #### [` SegmentCommand `]() SegmentCommand() #### [` SegmentCommand `]() SegmentCommand(const details::segment\_command\_32 &cmd) #### [` SegmentCommand `]() SegmentCommand(const details::segment\_command\_64 &cmd) #### [` operator= `]() [SegmentCommand]( "LIEF::MachO::SegmentCommand") &operator=([SegmentCommand]( "LIEF::MachO::SegmentCommand") other) #### [` SegmentCommand `]() SegmentCommand(const [SegmentCommand]( "LIEF::MachO::SegmentCommand::SegmentCommand") &copy) #### [` SegmentCommand `]() SegmentCommand(std::string name, [content\_t]( "LIEF::MachO::SegmentCommand::content_t") content) #### [` SegmentCommand `]() SegmentCommand(std::string name) #### [` swap `]() void swap([SegmentCommand]( "LIEF::MachO::SegmentCommand") &other) noexcept #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~SegmentCommand `]() ~SegmentCommand() override #### [` name `]() inline std::string\_view name() const Name of the segment (e.g. `__TEXT`). #### [` virtual_address `]() inline uint64\_t virtual\_address() const Absolute virtual base address of the segment. #### [` virtual_size `]() inline uint64\_t virtual\_size() const Virtual size of the segment. #### [` file_size `]() inline uint64\_t file\_size() const Size of this segment in the binary file. #### [` file_offset `]() inline uint64\_t file\_offset() const Offset of the data of this segment in the file. #### [` max_protection `]() inline uint32\_t max\_protection() const The maximum of protections for this segment (cf. [VM\_PROTECTIONS]()). #### [` init_protection `]() inline uint32\_t init\_protection() const The initial protections of this segment (cf. [VM\_PROTECTIONS]()). #### [` numberof_sections `]() inline uint32\_t numberof\_sections() const The number of sections associated with this segment. #### [` flags `]() inline uint32\_t flags() const Flags associated with this segment (cf. [SegmentCommand::FLAGS]()). #### [` sections `]() inline [it\_sections]( "LIEF::MachO::SegmentCommand::it_sections") sections() Return an iterator over the [MachO::Section]() linked to this segment. #### [` sections `]() inline [it\_const\_sections]( "LIEF::MachO::SegmentCommand::it_const_sections") sections() const #### [` relocations `]() inline [it\_relocations]( "LIEF::MachO::SegmentCommand::it_relocations") relocations() Return an iterator over the [MachO::Relocation]() linked to this segment. For Mach-O executable or library this iterator should be empty as the relocations are managed by the Dyld::rebase\_opcodes. On the other hand, for object files (`.o`) this iterator should not be empty #### [` relocations `]() inline [it\_const\_relocations]( "LIEF::MachO::SegmentCommand::it_const_relocations") relocations() const #### [` get_section `]() const [Section]( "LIEF::MachO::Section") \*get\_section(const std::string &name) const Get the section with the given name. #### [` get_section `]() [Section]( "LIEF::MachO::Section") \*get\_section(const std::string &name) #### [` content `]() inline span<const uint8\_t> content() const The raw content of this segment. #### [` content `]() inline span<uint8\_t> content() #### [` stream `]() std::unique\_ptr<[SpanStream]( "LIEF::SpanStream")> stream() const Return a stream over the content of this segment. #### [` index `]() inline int8\_t index() const The original index of this segment or -1 if not defined. #### [` name `]() inline void name(std::string name) #### [` virtual_address `]() inline void virtual\_address(uint64\_t virtual\_address) #### [` virtual_size `]() inline void virtual\_size(uint64\_t virtual\_size) #### [` file_offset `]() inline void file\_offset(uint64\_t file\_offset) #### [` file_size `]() inline void file\_size(uint64\_t file\_size) #### [` max_protection `]() inline void max\_protection(uint32\_t max\_protection) #### [` init_protection `]() inline void init\_protection(uint32\_t init\_protection) #### [` numberof_sections `]() inline void numberof\_sections(uint32\_t nb\_section) #### [` flags `]() inline void flags(uint32\_t flags) #### [` content `]() void content([content\_t]( "LIEF::MachO::SegmentCommand::content_t") data) #### [` add_section `]() [Section]( "LIEF::MachO::Section") &add\_section(const [Section]( "LIEF::MachO::Section") &section) Add a new section in this segment. #### [` remove_all_sections `]() void remove\_all\_sections() Remove all the sections linked to this segment. #### [` has `]() bool has(const [Section]( "LIEF::MachO::Section") &section) const Check if the current segment embeds the given section. #### [` has_section `]() bool has\_section(const std::string &section\_name) const Check if the current segment embeds the given section name. #### [` is `]() inline bool is([VM\_PROTECTIONS]( "LIEF::MachO::SegmentCommand::VM_PROTECTIONS") prot) const #### [` print `]() virtual std::ostream &print(std::ostream &os) const override #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Symbol]() ### [` Symbol `]() class Symbol : public LIEF::[Symbol]( "LIEF::Symbol") Class that represents a [Symbol]() in a Mach-O file. A Mach-O symbol can come from: 1. The symbols command (LC\_SYMTAB / [SymbolCommand]()) 2. The Dyld Export trie 3. The Dyld [Symbol]() bindings Public Types #### [` CATEGORY `]() enum class CATEGORY : uint32\_t Category of the symbol when the symbol comes from the `LC_SYMTAB` command. The category is defined according to the `LC_DYSYMTAB` ([DynamicSymbolCommand]()) command. *Values:* ##### [` NONE `]() enumerator NONE = 0 ##### [` LOCAL `]() enumerator LOCAL ##### [` EXTERNAL `]() enumerator EXTERNAL ##### [` UNDEFINED `]() enumerator UNDEFINED ##### [` INDIRECT_ABS `]() enumerator INDIRECT\_ABS ##### [` INDIRECT_LOCAL `]() enumerator INDIRECT\_LOCAL ##### [` INDIRECT_ABS_LOCAL `]() enumerator INDIRECT\_ABS\_LOCAL #### [` ORIGIN `]() enum class ORIGIN : uint32\_t *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` DYLD_EXPORT `]() enumerator DYLD\_EXPORT = 1 ##### [` DYLD_BIND `]() enumerator DYLD\_BIND = 2 The symbol comes from the binding opcodes. ##### [` SYMTAB `]() enumerator SYMTAB = 3 The symbol comes from the LC\_SYMTAB command. #### [` TYPE `]() enum class TYPE : uint32\_t *Values:* ##### [` UNDEFINED `]() enumerator UNDEFINED = 0x0u The symbol is undefined. It is referenced in a different module. ##### [` ABSOLUTE_SYM `]() enumerator ABSOLUTE\_SYM = 0x2u The symbol is absolute. The linker doesn’t update its value. ##### [` SECTION `]() enumerator SECTION = 0xeu The symbol is defined in the section number given in nlist\_base.n\_sect. ##### [` PREBOUND `]() enumerator PREBOUND = 0xcu The symbol is undefined and the image is using a prebound value for the symbol. Set the n\_sect field to NO\_SECT. ##### [` INDIRECT `]() enumerator INDIRECT = 0xau The symbol is defined to be the same as another symbol. The n\_value field is an index into the string table specifying the name of the other symbol. When that symbol is linked, both this and the other symbol point to the same defined type and value. Public Functions #### [` Symbol `]() Symbol() = default #### [` Symbol `]() Symbol(const details::nlist\_32 &cmd) #### [` Symbol `]() Symbol(const details::nlist\_64 &cmd) #### [` Symbol `]() inline Symbol(uint8\_t n\_type, uint8\_t n\_sect, uint8\_t n\_desc, uint64\_t value) #### [` operator= `]() [Symbol]( "LIEF::MachO::Symbol") &operator=([Symbol]( "LIEF::MachO::Symbol") other) #### [` Symbol `]() Symbol(const [Symbol]( "LIEF::MachO::Symbol::Symbol") &other) #### [` swap `]() void swap([Symbol]( "LIEF::MachO::Symbol") &other) noexcept #### [` ~Symbol `]() ~Symbol() override = default #### [` library_ordinal `]() inline int library\_ordinal() const #### [` raw_type `]() inline uint8\_t raw\_type() const Raw value of `nlist_xx.n_type`. #### [` type `]() inline [TYPE]( "LIEF::MachO::Symbol::TYPE") type() const Type as defined by `nlist_xx.n_type & N_TYPE`. #### [` numberof_sections `]() inline uint8\_t numberof\_sections() const It returns the number of sections in which this symbol can be found. If the symbol can’t be found in any section, it returns 0 (NO\_SECT). #### [` description `]() inline uint16\_t description() const Return information about the symbol (SYMBOL\_DESCRIPTIONS). #### [` has_export_info `]() inline bool has\_export\_info() const True if the symbol is associated with an [ExportInfo]() This value is set when the symbol comes from the Dyld Export trie. #### [` export_info `]() inline const [ExportInfo]( "LIEF::MachO::ExportInfo") \*export\_info() const Return the [ExportInfo]() associated with this symbol (or nullptr if not present). > **See also** > > [has\_export\_info]() #### [` export_info `]() inline [ExportInfo]( "LIEF::MachO::ExportInfo") \*export\_info() #### [` has_binding_info `]() inline bool has\_binding\_info() const True if the symbol is associated with a BindingInfo This value is set when the symbol comes from the Dyld symbol bindings. #### [` binding_info `]() inline const BindingInfo \*binding\_info() const Return the BindingInfo associated with this symbol (or nullptr if not present). > **See also** > > [has\_binding\_info]() #### [` binding_info `]() inline BindingInfo \*binding\_info() #### [` demangled_name `]() std::string demangled\_name() const Try to demangle the symbol or return an empty string if it is not possible. #### [` is_external `]() inline bool is\_external() const True if the symbol is defined as an external symbol. #### [` library `]() inline const [DylibCommand]( "LIEF::MachO::DylibCommand") \*library() const Return the library in which the symbol is defined. It returns a null pointer if the library can’t be resolved. #### [` library `]() inline [DylibCommand]( "LIEF::MachO::DylibCommand") \*library() #### [` origin `]() inline [ORIGIN]( "LIEF::MachO::Symbol::ORIGIN") origin() const Return the origin of the symbol: from LC\_SYMTAB command or from the Dyld information. #### [` category `]() inline [CATEGORY]( "LIEF::MachO::Symbol::CATEGORY") category() const Category of the symbol according to the `LC_DYSYMTAB` command. #### [` raw_type `]() inline void raw\_type(uint8\_t type) #### [` numberof_sections `]() inline void numberof\_sections(uint8\_t nbsections) #### [` description `]() inline void description(uint16\_t desc) #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` is_valid_index_ordinal `]() static inline bool is\_valid\_index\_ordinal(int idx) #### [` indirect_abs `]() static const [Symbol]( "LIEF::MachO::Symbol") &indirect\_abs() #### [` indirect_local `]() static const [Symbol]( "LIEF::MachO::Symbol") &indirect\_local() #### [` indirect_abs_local `]() static const [Symbol]( "LIEF::MachO::Symbol") &indirect\_abs\_local() Public Static Attributes #### [` SELF_LIBRARY_ORD `]() static int SELF\_LIBRARY\_ORD = 0x0 #### [` MAIN_EXECUTABLE_ORD `]() static int MAIN\_EXECUTABLE\_ORD = 0xff #### [` DYNAMIC_LOOKUP_ORD `]() static int DYNAMIC\_LOOKUP\_ORD = 0xfe #### [` TYPE_MASK `]() static uint32\_t TYPE\_MASK = 0x0e Same as N\_TYPE. Friends #### [` operator<< `]() friend std::ostream &operator<<(std::ostream &os, const [Symbol]( "LIEF::MachO::Symbol") &symbol) --- ## [SymbolCommand]() ### [` SymbolCommand `]() class SymbolCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the LC\_SYMTAB command. Public Functions #### [` SymbolCommand `]() SymbolCommand() = default #### [` SymbolCommand `]() SymbolCommand(const details::symtab\_command &command) #### [` operator= `]() [SymbolCommand]( "LIEF::MachO::SymbolCommand") &operator=(const [SymbolCommand]( "LIEF::MachO::SymbolCommand") &copy) = default #### [` SymbolCommand `]() SymbolCommand(const [SymbolCommand]( "LIEF::MachO::SymbolCommand::SymbolCommand") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~SymbolCommand `]() ~SymbolCommand() override = default #### [` symbol_offset `]() inline uint32\_t symbol\_offset() const Offset from the start of the file to the n\_list associated with the command. #### [` numberof_symbols `]() inline uint32\_t numberof\_symbols() const Number of symbols registered. #### [` strings_offset `]() inline uint32\_t strings\_offset() const Offset from the start of the file to the string table. #### [` strings_size `]() inline uint32\_t strings\_size() const Size of the string table. #### [` symbol_offset `]() inline void symbol\_offset(uint32\_t offset) #### [` numberof_symbols `]() inline void numberof\_symbols(uint32\_t nb) #### [` strings_offset `]() inline void strings\_offset(uint32\_t offset) #### [` strings_size `]() inline void strings\_size(uint32\_t size) #### [` symbol_table `]() inline span<const uint8\_t> symbol\_table() const #### [` symbol_table `]() inline span<uint8\_t> symbol\_table() #### [` string_table `]() inline span<const uint8\_t> string\_table() const #### [` string_table `]() inline span<uint8\_t> string\_table() #### [` original_str_size `]() inline uint32\_t original\_str\_size() const #### [` original_nb_symbols `]() inline uint32\_t original\_nb\_symbols() const #### [` print `]() virtual std::ostream &print(std::ostream &os) const override #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [UUIDCommand]() ### [` UUIDCommand `]() class UUIDCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the UUID command. Public Functions #### [` UUIDCommand `]() UUIDCommand() = default #### [` UUIDCommand `]() UUIDCommand(const details::uuid\_command &cmd) #### [` operator= `]() [UUIDCommand]( "LIEF::MachO::UUIDCommand") &operator=(const [UUIDCommand]( "LIEF::MachO::UUIDCommand") &copy) = default #### [` UUIDCommand `]() UUIDCommand(const [UUIDCommand]( "LIEF::MachO::UUIDCommand::UUIDCommand") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~UUIDCommand `]() ~UUIDCommand() override = default #### [` uuid `]() inline const uuid\_t &uuid() const The UUID as a 16-bytes array. #### [` uuid `]() inline void uuid(const uuid\_t &uuid) #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Dyld Info]() ### [` DyldInfo `]() class DyldInfo : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the LC\_DYLD\_INFO and LC\_DYLD\_INFO\_ONLY commands. Public Types #### [` BINDING_ENCODING_VERSION `]() enum class BINDING\_ENCODING\_VERSION *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` V1 `]() enumerator V1 ##### [` V2 `]() enumerator V2 #### [` REBASE_TYPE `]() enum class REBASE\_TYPE : uint64\_t *Values:* ##### [` POINTER `]() enumerator POINTER = 1u ##### [` TEXT_ABSOLUTE32 `]() enumerator TEXT\_ABSOLUTE32 = 2u ##### [` TEXT_PCREL32 `]() enumerator TEXT\_PCREL32 = 3u ##### [` THREADED `]() enumerator THREADED = 102u #### [` REBASE_OPCODES `]() enum class REBASE\_OPCODES : uint8\_t *Values:* ##### [` DONE `]() enumerator DONE = 0x00u It’s finished. ##### [` SET_TYPE_IMM `]() enumerator SET\_TYPE\_IMM = 0x10u Set type to immediate (lower 4-bits). Used for ordinal numbers from 0-15. ##### [` SET_SEGMENT_AND_OFFSET_ULEB `]() enumerator SET\_SEGMENT\_AND\_OFFSET\_ULEB = 0x20u Set segment’s index to immediate (lower 4-bits) and segment’s offset to following ULEB128 encoding. ##### [` ADD_ADDR_ULEB `]() enumerator ADD\_ADDR\_ULEB = 0x30u Add segment’s offset with the following ULEB128 encoding. ##### [` ADD_ADDR_IMM_SCALED `]() enumerator ADD\_ADDR\_IMM\_SCALED = 0x40u Add segment’s offset with immediate scaling. ##### [` DO_REBASE_IMM_TIMES `]() enumerator DO\_REBASE\_IMM\_TIMES = 0x50u Rebase in the range of `[segment's offset; segment's offset + immediate * sizeof(ptr)]`. ##### [` DO_REBASE_ULEB_TIMES `]() enumerator DO\_REBASE\_ULEB\_TIMES = 0x60u Same as REBASE\_OPCODE\_DO\_REBASE\_IMM\_TIMES but *immediate* is replaced with ULEB128 value. ##### [` DO_REBASE_ADD_ADDR_ULEB `]() enumerator DO\_REBASE\_ADD\_ADDR\_ULEB = 0x70u Rebase and increment segment’s offset with following ULEB128 encoding + pointer’s size. ##### [` DO_REBASE_ULEB_TIMES_SKIPPING_ULEB `]() enumerator DO\_REBASE\_ULEB\_TIMES\_SKIPPING\_ULEB = 0x80u Rebase and skip several bytes. #### [` BIND_OPCODES `]() enum class BIND\_OPCODES : uint8\_t Opcodes used by Dyld info to bind symbols. *Values:* ##### [` DONE `]() enumerator DONE = 0x00u It’s finished. ##### [` SET_DYLIB_ORDINAL_IMM `]() enumerator SET\_DYLIB\_ORDINAL\_IMM = 0x10u Set ordinal to immediate (lower 4-bits). Used for ordinal numbers from 0-15. ##### [` SET_DYLIB_ORDINAL_ULEB `]() enumerator SET\_DYLIB\_ORDINAL\_ULEB = 0x20u Set ordinal to following ULEB128 encoding. Used for ordinal numbers from 16+. ##### [` SET_DYLIB_SPECIAL_IMM `]() enumerator SET\_DYLIB\_SPECIAL\_IMM = 0x30u Set ordinal, with 0 or negative number as immediate. The value is sign extended. ##### [` SET_SYMBOL_TRAILING_FLAGS_IMM `]() enumerator SET\_SYMBOL\_TRAILING\_FLAGS\_IMM = 0x40u Set the following symbol (NULL-terminated char\*). ##### [` SET_TYPE_IMM `]() enumerator SET\_TYPE\_IMM = 0x50u Set the type to immediate (lower 4-bits). See BIND\_TYPES. ##### [` SET_ADDEND_SLEB `]() enumerator SET\_ADDEND\_SLEB = 0x60u Set the addend field to the following SLEB128 encoding. ##### [` SET_SEGMENT_AND_OFFSET_ULEB `]() enumerator SET\_SEGMENT\_AND\_OFFSET\_ULEB = 0x70u Set Segment to immediate value, and address to the following SLEB128 encoding. ##### [` ADD_ADDR_ULEB `]() enumerator ADD\_ADDR\_ULEB = 0x80u Set the address field to the following SLEB128 encoding. ##### [` DO_BIND `]() enumerator DO\_BIND = 0x90u Perform binding of current table row. ##### [` DO_BIND_ADD_ADDR_ULEB `]() enumerator DO\_BIND\_ADD\_ADDR\_ULEB = 0xA0u Perform binding, also add following ULEB128 as address. ##### [` DO_BIND_ADD_ADDR_IMM_SCALED `]() enumerator DO\_BIND\_ADD\_ADDR\_IMM\_SCALED = 0xB0u Perform binding, also add immediate (lower 4-bits) using scaling. ##### [` DO_BIND_ULEB_TIMES_SKIPPING_ULEB `]() enumerator DO\_BIND\_ULEB\_TIMES\_SKIPPING\_ULEB = 0xC0u Perform binding for several symbols (as following ULEB128), and skip several bytes. ##### [` THREADED `]() enumerator THREADED = 0xD0u ##### [` THREADED_APPLY `]() enumerator THREADED\_APPLY = 0xD0u | 0x01u ##### [` THREADED_SET_BIND_ORDINAL_TABLE_SIZE_ULEB `]() enumerator THREADED\_SET\_BIND\_ORDINAL\_TABLE\_SIZE\_ULEB = 0xD0u | 0x00u #### [` BIND_SUBOPCODE_THREADED `]() enum class BIND\_SUBOPCODE\_THREADED : uint8\_t *Values:* ##### [` SET_BIND_ORDINAL_TABLE_SIZE_ULEB `]() enumerator SET\_BIND\_ORDINAL\_TABLE\_SIZE\_ULEB = 0x00u ##### [` APPLY `]() enumerator APPLY = 0x01u #### [` BIND_SYMBOL_FLAGS `]() enum BIND\_SYMBOL\_FLAGS *Values:* ##### [` WEAK_IMPORT `]() enumerator WEAK\_IMPORT = 0x1u ##### [` NON_WEAK_DEFINITION `]() enumerator NON\_WEAK\_DEFINITION = 0x8u #### [` info_t `]() using info\_t = std::pair<uint32\_t, uint32\_t> Tuple of `offset` and `size`. #### [` binding_info_t `]() using binding\_info\_t = std::vector<std::unique\_ptr<[DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo")>> Internal container for storing [DyldBindingInfo](). #### [` it_binding_info `]() using it\_binding\_info = [ref\_iterator]( "LIEF::ref_iterator")<[binding\_info\_t]( "LIEF::MachO::DyldInfo::binding_info_t")&, [DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo")\*> Iterator which outputs [DyldBindingInfo]()&. #### [` it_const_binding_info `]() using it\_const\_binding\_info = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [binding\_info\_t]( "LIEF::MachO::DyldInfo::binding_info_t")&, [DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo")\*> Iterator which outputs const [DyldBindingInfo]()&. #### [` export_info_t `]() using export\_info\_t = std::vector<std::unique\_ptr<[ExportInfo]( "LIEF::MachO::ExportInfo")>> Internal container for storing [ExportInfo](). #### [` it_export_info `]() using it\_export\_info = [ref\_iterator]( "LIEF::ref_iterator")<[export\_info\_t]( "LIEF::MachO::DyldInfo::export_info_t")&, [ExportInfo]( "LIEF::MachO::ExportInfo")\*> Iterator which outputs const [ExportInfo]()&. #### [` it_const_export_info `]() using it\_const\_export\_info = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [export\_info\_t]( "LIEF::MachO::DyldInfo::export_info_t")&, [ExportInfo]( "LIEF::MachO::ExportInfo")\*> Iterator which outputs const [ExportInfo]()&. Public Functions #### [` DyldInfo `]() DyldInfo() #### [` DyldInfo `]() DyldInfo(const details::dyld\_info\_command &dyld\_info\_cmd) #### [` operator= `]() [DyldInfo]( "LIEF::MachO::DyldInfo") &operator=([DyldInfo]( "LIEF::MachO::DyldInfo") other) #### [` DyldInfo `]() DyldInfo(const [DyldInfo]( "LIEF::MachO::DyldInfo::DyldInfo") &copy) #### [` swap `]() void swap([DyldInfo]( "LIEF::MachO::DyldInfo") &other) noexcept #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~DyldInfo `]() ~DyldInfo() override #### [` rebase `]() inline const [info\_t]( "LIEF::MachO::DyldInfo::info_t") &rebase() const *Rebase* information 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 for which 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 nth offset for m times” can be encoded in a few bytes. > **See also** > > `/usr/include/mach-o/loader.h` #### [` rebase_opcodes `]() inline span<const uint8\_t> rebase\_opcodes() const Return Rebase’s opcodes as raw data. #### [` rebase_opcodes `]() inline span<uint8\_t> rebase\_opcodes() #### [` rebase_opcodes `]() void rebase\_opcodes(buffer\_t raw) Set new opcodes. #### [` show_rebases_opcodes `]() std::string show\_rebases\_opcodes() const Return the rebase opcodes in a human-readable way. #### [` bind `]() inline const [info\_t]( "LIEF::MachO::DyldInfo::info_t") &bind() const *Bind* information Dyld binds an image during the loading process, if the image requires any pointers to be initialized to symbols in other images. The rebase information is a stream of byte sized opcodes for which 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 initialized to the same value can be encoded in a few bytes. > **See also** > > `/usr/include/mach-o/loader.h` #### [` bind_opcodes `]() inline span<const uint8\_t> bind\_opcodes() const Return Binding’s opcodes as raw data. #### [` bind_opcodes `]() inline span<uint8\_t> bind\_opcodes() #### [` bind_opcodes `]() void bind\_opcodes(buffer\_t raw) Set new opcodes. #### [` show_bind_opcodes `]() std::string show\_bind\_opcodes() const Return the bind opcodes in a human-readable way. #### [` weak_bind `]() inline const [info\_t]( "LIEF::MachO::DyldInfo::info_t") &weak\_bind() const *Weak Bind* information 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 enables 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. > **See also** > > `/usr/include/mach-o/loader.h` #### [` weak_bind_opcodes `]() inline span<const uint8\_t> weak\_bind\_opcodes() const Return **Weak** Binding’s opcodes as raw data. #### [` weak_bind_opcodes `]() inline span<uint8\_t> weak\_bind\_opcodes() #### [` weak_bind_opcodes `]() void weak\_bind\_opcodes(buffer\_t raw) Set new opcodes. #### [` show_weak_bind_opcodes `]() std::string show\_weak\_bind\_opcodes() const Return the bind opcodes in a human-readable way. #### [` lazy_bind `]() inline const [info\_t]( "LIEF::MachO::DyldInfo::info_t") &lazy\_bind() const *Lazy Bind* information Some uses of external symbols do not need to be bound immediately. Instead, they can be lazily bound on first use. The lazy\_bind area 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. > **See also** > > `/usr/include/mach-o/loader.h` #### [` lazy_bind_opcodes `]() inline span<const uint8\_t> lazy\_bind\_opcodes() const Return **Lazy** Binding’s opcodes as raw data. #### [` lazy_bind_opcodes `]() inline span<uint8\_t> lazy\_bind\_opcodes() #### [` lazy_bind_opcodes `]() void lazy\_bind\_opcodes(buffer\_t raw) Set new opcodes. #### [` show_lazy_bind_opcodes `]() std::string show\_lazy\_bind\_opcodes() const Return the lazy opcodes in a human-readable way. #### [` bindings `]() inline [it\_binding\_info]( "LIEF::MachO::DyldInfo::it_binding_info") bindings() Iterator over BindingInfo entries. #### [` bindings `]() inline [it\_const\_binding\_info]( "LIEF::MachO::DyldInfo::it_const_binding_info") bindings() const #### [` export_info `]() inline const [info\_t]( "LIEF::MachO::DyldInfo::info_t") &export\_info() const *Export* information 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 byte that is the length of the exported symbol information for the string so far. If there is no exported symbol, the byte is zero. If there is exported info, it follows the length byte. The exported info normally consists of a flags and offset both encoded in uleb128. The offset is location of the content named by the symbol. It is the offset from the mach\_header for the image. After the initial byte and 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 cstring of the addition chars in the symbol, followed by a uleb128 offset for the node that edge points to. > **See also** > > `/usr/include/mach-o/loader.h` #### [` exports `]() inline [it\_export\_info]( "LIEF::MachO::DyldInfo::it_export_info") exports() Iterator over [ExportInfo]() entries. #### [` exports `]() inline [it\_const\_export\_info]( "LIEF::MachO::DyldInfo::it_const_export_info") exports() const #### [` export_trie `]() inline span<const uint8\_t> export\_trie() const Return Export’s trie as raw data. #### [` export_trie `]() inline span<uint8\_t> export\_trie() #### [` export_trie `]() void export\_trie(buffer\_t raw) Set new trie. #### [` show_export_trie `]() std::string show\_export\_trie() const Return the export trie in a human-readable way. #### [` rebase `]() inline void rebase(const [info\_t]( "LIEF::MachO::DyldInfo::info_t") &info) #### [` bind `]() inline void bind(const [info\_t]( "LIEF::MachO::DyldInfo::info_t") &info) #### [` weak_bind `]() inline void weak\_bind(const [info\_t]( "LIEF::MachO::DyldInfo::info_t") &info) #### [` lazy_bind `]() inline void lazy\_bind(const [info\_t]( "LIEF::MachO::DyldInfo::info_t") &info) #### [` export_info `]() inline void export\_info(const [info\_t]( "LIEF::MachO::DyldInfo::info_t") &info) #### [` set_rebase_offset `]() inline void set\_rebase\_offset(uint32\_t offset) #### [` set_rebase_size `]() inline void set\_rebase\_size(uint32\_t size) #### [` set_bind_offset `]() inline void set\_bind\_offset(uint32\_t offset) #### [` set_bind_size `]() inline void set\_bind\_size(uint32\_t size) #### [` set_weak_bind_offset `]() inline void set\_weak\_bind\_offset(uint32\_t offset) #### [` set_weak_bind_size `]() inline void set\_weak\_bind\_size(uint32\_t size) #### [` set_lazy_bind_offset `]() inline void set\_lazy\_bind\_offset(uint32\_t offset) #### [` set_lazy_bind_size `]() inline void set\_lazy\_bind\_size(uint32\_t size) #### [` set_export_offset `]() inline void set\_export\_offset(uint32\_t offset) #### [` set_export_size `]() inline void set\_export\_size(uint32\_t size) #### [` add `]() [ExportInfo]( "LIEF::MachO::ExportInfo") \*add(std::unique\_ptr<[ExportInfo]( "LIEF::MachO::ExportInfo")> info) #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) Public Static Attributes #### [` OPCODE_MASK `]() static auto OPCODE\_MASK = uint32\_t(0xF0) #### [` IMMEDIATE_MASK `]() static auto IMMEDIATE\_MASK = uint32\_t(0x0F) --- ## [Function starts]() ### [` FunctionStarts `]() class FunctionStarts : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class which represents the LC\_FUNCTION\_STARTS command. This command is an array of ULEB128 encoded values Public Functions #### [` FunctionStarts `]() FunctionStarts() = default #### [` FunctionStarts `]() FunctionStarts(const details::linkedit\_data\_command &cmd) #### [` operator= `]() [FunctionStarts]( "LIEF::MachO::FunctionStarts") &operator=(const [FunctionStarts]( "LIEF::MachO::FunctionStarts") &copy) = default #### [` FunctionStarts `]() FunctionStarts(const [FunctionStarts]( "LIEF::MachO::FunctionStarts::FunctionStarts") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` data_offset `]() inline uint32\_t data\_offset() const Offset in the `__LINKEDIT` [SegmentCommand]() where *start functions* are located. #### [` data_size `]() inline uint32\_t data\_size() const Size of the functions list in the binary. #### [` functions `]() inline const std::vector<uint64\_t> &functions() const Addresses of every function entry point in the executable. This allows functions to exist for which there are no entries in the symbol table. > **Warning** > > The address is relative to the `__TEXT` segment #### [` functions `]() inline std::vector<uint64\_t> &functions() #### [` add_function `]() inline void add\_function(uint64\_t address) Add a new function. #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` functions `]() inline void functions(std::vector<uint64\_t> funcs) #### [` content `]() inline span<const uint8\_t> content() const #### [` content `]() inline span<uint8\_t> content() #### [` ~FunctionStarts `]() ~FunctionStarts() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Function Variants]() ### [` FunctionVariants `]() class FunctionVariants : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class representing the `LC_FUNCTION_VARIANTS` load command. Introduced publicly in `dyld-1284.13` (April 2025), this command supports **function multiversioning**, the ability to associate multiple implementations of the same function, each optimized for a specific platform, architecture, or runtime context. At runtime, the system dispatches the most appropriate variant based on hardware capabilities or execution environment. For example: ```cpp FUNCTION_VARIANT_TABLE(my_function, { (void*)my_function$Rosetta, "rosetta" }, // Rosetta translation { (void*)my_function$Haswell, "haswell" }, // Haswell-optimized { (void*)my_function$Base, "default" } // Default fallback ); ``` Public Types #### [` runtime_table_t `]() using runtime\_table\_t = std::vector<[RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable")> #### [` it_runtime_table `]() using it\_runtime\_table = [ref\_iterator]( "LIEF::ref_iterator")<[runtime\_table\_t]( "LIEF::MachO::FunctionVariants::runtime_table_t")&> Iterator that outputs [RuntimeTable]()&. #### [` it_const_runtime_table `]() using it\_const\_runtime\_table = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [runtime\_table\_t]( "LIEF::MachO::FunctionVariants::runtime_table_t")&> Iterator that outputs const [RuntimeTable]()&. Public Functions #### [` FunctionVariants `]() FunctionVariants() = default #### [` FunctionVariants `]() FunctionVariants(const details::linkedit\_data\_command &cmd) #### [` operator= `]() [FunctionVariants]( "LIEF::MachO::FunctionVariants") &operator=(const [FunctionVariants]( "LIEF::MachO::FunctionVariants") &copy) = default #### [` FunctionVariants `]() FunctionVariants(const [FunctionVariants]( "LIEF::MachO::FunctionVariants::FunctionVariants") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` data_offset `]() inline uint32\_t data\_offset() const Offset in the `__LINKEDIT` [SegmentCommand]() where the payload starts. #### [` data_size `]() inline uint32\_t data\_size() const Size of the payload. #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` content `]() inline span<const uint8\_t> content() const Return the data slice in the `__LINKEDIT` segment referenced by data\_offset and data\_size;. #### [` content `]() inline span<uint8\_t> content() #### [` runtime_table `]() inline [it\_runtime\_table]( "LIEF::MachO::FunctionVariants::it_runtime_table") runtime\_table() Iterator over the different [RuntimeTable]() entries located in the content of this `__LINKEDIT` command. #### [` runtime_table `]() inline [it\_const\_runtime\_table]( "LIEF::MachO::FunctionVariants::it_const_runtime_table") runtime\_table() const #### [` add `]() inline [RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable") &add([RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable") table) Append a new [RuntimeTable]() and return a reference to the inserted table. #### [` ~FunctionVariants `]() ~FunctionVariants() override = default #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) #### [` parse_payload `]() static std::vector<[RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable")> parse\_payload([SpanStream]( "LIEF::SpanStream") &stream) #### [` parse_entry `]() static [result]( "LIEF::result")<[RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable")> parse\_entry([BinaryStream]( "LIEF::BinaryStream") &stream, uint64\_t max\_entries) #### [` RuntimeTableEntry `]() class RuntimeTableEntry This class exposes information about a given implementation. Public Types ##### [` FLAGS `]() enum class FLAGS : uint32\_t Flags describing the target platform, environment, or architecture for a given function implementation. These are encoded as a `uint32_t`, where high bits determine the namespace (`KIND`), and the lower bits encode the specific capability. *Values:* ###### [` UNKNOWN `]() enumerator UNKNOWN = 0 ###### [` ARM64_DEFAULT `]() enumerator ARM64\_DEFAULT = (0 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_FLAGM `]() enumerator ARM64\_FLAGM = (1 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_FLAGM2 `]() enumerator ARM64\_FLAGM2 = (2 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_FHM `]() enumerator ARM64\_FHM = (3 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_DOTPROD `]() enumerator ARM64\_DOTPROD = (4 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SHA3 `]() enumerator ARM64\_SHA3 = (5 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_RDM `]() enumerator ARM64\_RDM = (6 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_LSE `]() enumerator ARM64\_LSE = (7 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SHA256 `]() enumerator ARM64\_SHA256 = (8 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SHA512 `]() enumerator ARM64\_SHA512 = (9 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SHA1 `]() enumerator ARM64\_SHA1 = (10 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_AES `]() enumerator ARM64\_AES = (11 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_PMULL `]() enumerator ARM64\_PMULL = (12 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SPECRES `]() enumerator ARM64\_SPECRES = (13 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SB `]() enumerator ARM64\_SB = (14 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_FRINTTS `]() enumerator ARM64\_FRINTTS = (15 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_LRCPC `]() enumerator ARM64\_LRCPC = (16 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_LRCPC2 `]() enumerator ARM64\_LRCPC2 = (17 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_FCMA `]() enumerator ARM64\_FCMA = (18 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_JSCVT `]() enumerator ARM64\_JSCVT = (19 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_PAUTH `]() enumerator ARM64\_PAUTH = (20 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_PAUTH2 `]() enumerator ARM64\_PAUTH2 = (21 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_FPAC `]() enumerator ARM64\_FPAC = (22 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_DPB `]() enumerator ARM64\_DPB = (23 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_DPB2 `]() enumerator ARM64\_DPB2 = (24 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_BF16 `]() enumerator ARM64\_BF16 = (25 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_I8MM `]() enumerator ARM64\_I8MM = (26 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_WFXT `]() enumerator ARM64\_WFXT = (27 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_RPRES `]() enumerator ARM64\_RPRES = (28 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_ECV `]() enumerator ARM64\_ECV = (29 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_AFP `]() enumerator ARM64\_AFP = (30 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_LSE2 `]() enumerator ARM64\_LSE2 = (31 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_CSV2 `]() enumerator ARM64\_CSV2 = (32 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_CVS3 `]() enumerator ARM64\_CVS3 = (33 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_DIT `]() enumerator ARM64\_DIT = (34 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_FP16 `]() enumerator ARM64\_FP16 = (35 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SSBS `]() enumerator ARM64\_SSBS = (36 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_BTI `]() enumerator ARM64\_BTI = (37 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SME `]() enumerator ARM64\_SME = (44 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SME2 `]() enumerator ARM64\_SME2 = (45 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SMEF64F64 `]() enumerator ARM64\_SMEF64F64 = (46 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SMEI16I64 `]() enumerator ARM64\_SMEI16I64 = (47 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SMEF32F32 `]() enumerator ARM64\_SMEF32F32 = (48 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SMEBI32I32 `]() enumerator ARM64\_SMEBI32I32 = (49 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SMEB16F32 `]() enumerator ARM64\_SMEB16F32 = (50 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SMEF16F32 `]() enumerator ARM64\_SMEF16F32 = (51 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SMEI8I32 `]() enumerator ARM64\_SMEI8I32 = (52 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_SMEI16I32 `]() enumerator ARM64\_SMEI16I32 = (53 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_ADVSIMD `]() enumerator ARM64\_ADVSIMD = (54 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_ADVSIMDHPFP `]() enumerator ARM64\_ADVSIMDHPFP = (55 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` ARM64_CRC32 `]() enumerator ARM64\_CRC32 = (56 | [F\_ARM64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_ARM64")) ###### [` X86_64_DEFAULT `]() enumerator X86\_64\_DEFAULT = (0 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_SSE41 `]() enumerator X86\_64\_SSE41 = (1 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_FMA `]() enumerator X86\_64\_FMA = (2 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_AVX `]() enumerator X86\_64\_AVX = (3 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_AVX2 `]() enumerator X86\_64\_AVX2 = (4 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_AVX512F `]() enumerator X86\_64\_AVX512F = (5 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_AVX512BW `]() enumerator X86\_64\_AVX512BW = (6 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_BMI1 `]() enumerator X86\_64\_BMI1 = (7 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_ROSETTA `]() enumerator X86\_64\_ROSETTA = (8 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_HASWELL `]() enumerator X86\_64\_HASWELL = (9 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_IVYBRIDGE `]() enumerator X86\_64\_IVYBRIDGE = (10 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` X86_64_NEHALEM `]() enumerator X86\_64\_NEHALEM = (11 | [F\_X86\_64]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_X86_64")) ###### [` SYSTEM_WIDE_DEFAULT `]() enumerator SYSTEM\_WIDE\_DEFAULT = (0 | [F\_SYSTEM\_WIDE]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_SYSTEM_WIDE")) ###### [` SYSTEM_WIDE_INTERNAL_INSTALL `]() enumerator SYSTEM\_WIDE\_INTERNAL\_INSTALL = (1 | [F\_SYSTEM\_WIDE]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_SYSTEM_WIDE")) ###### [` SYSTEM_WIDE_CUSTOMER_INSTALL `]() enumerator SYSTEM\_WIDE\_CUSTOMER\_INSTALL = (2 | [F\_SYSTEM\_WIDE]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_SYSTEM_WIDE")) ###### [` SYSTEM_WIDE_LOCKDOWN `]() enumerator SYSTEM\_WIDE\_LOCKDOWN = (3 | [F\_SYSTEM\_WIDE]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_SYSTEM_WIDE")) ###### [` PER_PROCESS_DEFAULT `]() enumerator PER\_PROCESS\_DEFAULT = (0 | [F\_PER\_PROCESS]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_PER_PROCESS")) ###### [` PER_PROCESS_TRANSLATED `]() enumerator PER\_PROCESS\_TRANSLATED = (1 | [F\_PER\_PROCESS]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_PER_PROCESS")) ###### [` PER_PROCESS_MTE_ENABLED `]() enumerator PER\_PROCESS\_MTE\_ENABLED = (2 | [F\_PER\_PROCESS]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_PER_PROCESS")) ###### [` PER_PROCESS_NO_OVERREAD `]() enumerator PER\_PROCESS\_NO\_OVERREAD = (3 | [F\_PER\_PROCESS]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_PER_PROCESS")) Public Functions ##### [` RuntimeTableEntry `]() RuntimeTableEntry() = default ##### [` RuntimeTableEntry `]() RuntimeTableEntry(const details::runtime\_table\_entry\_t &entry) ##### [` RuntimeTableEntry `]() RuntimeTableEntry(const [RuntimeTableEntry]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::RuntimeTableEntry")&) = default ##### [` operator= `]() [RuntimeTableEntry]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry") &operator=(const [RuntimeTableEntry]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry")&) = default ##### [` RuntimeTableEntry `]() RuntimeTableEntry([RuntimeTableEntry]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::RuntimeTableEntry")&&) noexcept = default ##### [` operator= `]() [RuntimeTableEntry]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry") &operator=([RuntimeTableEntry]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry")&&) noexcept = default ##### [` ~RuntimeTableEntry `]() ~RuntimeTableEntry() = default ##### [` impl `]() inline uint32\_t impl() const The relative address of the implementation or an index if [another\_table()]() is set. ##### [` impl `]() inline void impl(uint32\_t value) Set the relative address of the implementation (or the index of the target entry when [another\_table()]() is set). > **Note** > > The value is stored on 31 bits, so the most significant bit is silently dropped. ##### [` another_table `]() inline bool another\_table() const Indicates whether [impl()]() refers to an entry in another runtime table, rather than a direct function implementation address. ##### [` another_table `]() inline void another\_table(bool value) Set whether [impl()]() refers to an entry in another runtime table. ##### [` flag_bit_nums `]() inline span<const uint8\_t> flag\_bit\_nums() const The `flagBitNums` value as a slice of bytes. ##### [` flags `]() inline const std::vector<[FLAGS]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::FLAGS")> &flags() const Return the **interpreted** [flag\_bit\_nums()](). ##### [` to_string `]() std::string to\_string() const Public Static Functions ##### [` get_raw `]() static inline uint8\_t get\_raw([FLAGS]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::FLAGS") f) Public Static Attributes ##### [` MAX_IMPL `]() static uint32\_t MAX\_IMPL = (uint32\_t(1) << 31) - 1 The implementation address/index is encoded on 31 bits. ##### [` F_BIT `]() static uint32\_t F\_BIT = 20 ##### [` F_MASK `]() static uint32\_t F\_MASK = (uint32\_t(1) << [F\_BIT]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_BIT")) - 1 ##### [` F_PER_PROCESS `]() static uint32\_t F\_PER\_PROCESS = uint32\_t(1) << [F\_BIT]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_BIT") ##### [` F_SYSTEM_WIDE `]() static uint32\_t F\_SYSTEM\_WIDE = uint32\_t(2) << [F\_BIT]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_BIT") ##### [` F_ARM64 `]() static uint32\_t F\_ARM64 = uint32\_t(3) << [F\_BIT]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_BIT") ##### [` F_X86_64 `]() static uint32\_t F\_X86\_64 = uint32\_t(4) << [F\_BIT]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry::F_BIT") Friends ##### [` operator<< `]() inline friend std::ostream &operator<<(std::ostream &os, const [RuntimeTableEntry]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry") &entry) #### [` RuntimeTable `]() class RuntimeTable Represents a runtime table of function variants sharing a common namespace (referred to internally as `FunctionVariantsRuntimeTable` in `dyld`). Each table holds multiple [RuntimeTableEntry]() instances that map to function implementations optimized for a given [KIND](). Public Types ##### [` KIND `]() enum class KIND : uint32\_t Enumeration describing the namespace or category of a function variant. Each [FunctionVariants::RuntimeTable]() is associated with one [KIND](), which indicates the domain or context under which its variant entries should be considered valid or applicable. These categories map to the runtime dispatch logic used by `dyld` when selecting the optimal function variant. *Values:* ###### [` UNKNOWN `]() enumerator UNKNOWN = 0 Fallback/default kind when the category is not recognized. ###### [` PER_PROCESS `]() enumerator PER\_PROCESS = 1 Variants that apply on a per-process basis. ###### [` SYSTEM_WIDE `]() enumerator SYSTEM\_WIDE = 2 Variants that are selected based on system-wide capabilities or configurations. ###### [` ARM64 `]() enumerator ARM64 = 3 Variants optimized for the ARM64 architecture. ###### [` X86_64 `]() enumerator X86\_64 = 4 Variants optimized for the x86-64 architecture. ##### [` entries_t `]() using entries\_t = std::vector<[RuntimeTableEntry]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry")> ##### [` it_entries `]() using it\_entries = [ref\_iterator]( "LIEF::ref_iterator")<[entries\_t]( "LIEF::MachO::FunctionVariants::RuntimeTable::entries_t")&> Iterator that outputs [RuntimeTableEntry]()&. ##### [` it_const_entries `]() using it\_const\_entries = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [entries\_t]( "LIEF::MachO::FunctionVariants::RuntimeTable::entries_t")&> Iterator that outputs const [RuntimeTableEntry]()&. Public Functions ##### [` RuntimeTable `]() RuntimeTable() = default ##### [` RuntimeTable `]() inline RuntimeTable([KIND]( "LIEF::MachO::FunctionVariants::RuntimeTable::KIND") kind, uint32\_t offset) ##### [` RuntimeTable `]() RuntimeTable(const [RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable::RuntimeTable")&) = default ##### [` operator= `]() [RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable") &operator=(const [RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable")&) = default ##### [` RuntimeTable `]() RuntimeTable([RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable::RuntimeTable")&&) noexcept = default ##### [` operator= `]() [RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable") &operator=([RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable")&&) noexcept = default ##### [` ~RuntimeTable `]() ~RuntimeTable() = default ##### [` kind `]() inline [KIND]( "LIEF::MachO::FunctionVariants::RuntimeTable::KIND") kind() const Kind of this runtime table. ##### [` offset `]() inline uint32\_t offset() const Original offset in the payload. ##### [` entries `]() inline [it\_entries]( "LIEF::MachO::FunctionVariants::RuntimeTable::it_entries") entries() Iterator over the different [RuntimeTableEntry]() entries. ##### [` entries `]() inline [it\_const\_entries]( "LIEF::MachO::FunctionVariants::RuntimeTable::it_const_entries") entries() const ##### [` add `]() inline void add([RuntimeTableEntry]( "LIEF::MachO::FunctionVariants::RuntimeTableEntry") entry) ##### [` to_string `]() std::string to\_string() const Friends ##### [` operator<< `]() inline friend std::ostream &operator<<(std::ostream &os, const [RuntimeTable]( "LIEF::MachO::FunctionVariants::RuntimeTable") &table) --- ## [Function Variant Fixups]() ### [` FunctionVariantFixups `]() class FunctionVariantFixups : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class which represents the `LC_FUNCTION_VARIANT_FIXUPS` command. This command contains the relocations that must be applied to the GOT-like slots associated with a [FunctionVariants]() table. At runtime, `dyld` resolves each slot to the best implementation and (re-)signs it according to the pointer-authentication information. Public Types #### [` fixups_t `]() using fixups\_t = std::vector<[Fixup]( "LIEF::MachO::FunctionVariantFixups::Fixup")> #### [` it_fixups `]() using it\_fixups = [ref\_iterator]( "LIEF::ref_iterator")<[fixups\_t]( "LIEF::MachO::FunctionVariantFixups::fixups_t")&> Iterator that outputs [Fixup]()&. #### [` it_const_fixups `]() using it\_const\_fixups = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [fixups\_t]( "LIEF::MachO::FunctionVariantFixups::fixups_t")&> Iterator that outputs const [Fixup]()&. Public Functions #### [` FunctionVariantFixups `]() FunctionVariantFixups() = default #### [` FunctionVariantFixups `]() FunctionVariantFixups([FunctionVariantFixups]( "LIEF::MachO::FunctionVariantFixups::FunctionVariantFixups")&&) noexcept = default #### [` operator= `]() [FunctionVariantFixups]( "LIEF::MachO::FunctionVariantFixups") &operator=([FunctionVariantFixups]( "LIEF::MachO::FunctionVariantFixups")&&) noexcept = default #### [` FunctionVariantFixups `]() FunctionVariantFixups(const details::linkedit\_data\_command &cmd) #### [` operator= `]() [FunctionVariantFixups]( "LIEF::MachO::FunctionVariantFixups") &operator=(const [FunctionVariantFixups]( "LIEF::MachO::FunctionVariantFixups") &copy) = default #### [` FunctionVariantFixups `]() FunctionVariantFixups(const [FunctionVariantFixups]( "LIEF::MachO::FunctionVariantFixups::FunctionVariantFixups") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` data_offset `]() inline uint32\_t data\_offset() const Offset in the `__LINKEDIT` [SegmentCommand]() where the payload starts. #### [` data_size `]() inline uint32\_t data\_size() const Size of the payload. #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` content `]() inline span<const uint8\_t> content() const Return the data slice in the `__LINKEDIT` segment referenced by data\_offset and data\_size. #### [` content `]() inline span<uint8\_t> content() #### [` fixups `]() inline [it\_fixups]( "LIEF::MachO::FunctionVariantFixups::it_fixups") fixups() Iterator over the different [Fixup]() entries. #### [` fixups `]() inline [it\_const\_fixups]( "LIEF::MachO::FunctionVariantFixups::it_const_fixups") fixups() const #### [` add `]() inline [FunctionVariantFixups]( "LIEF::MachO::FunctionVariantFixups") &add([Fixup]( "LIEF::MachO::FunctionVariantFixups::Fixup") fixup) Append a new [Fixup](). #### [` ~FunctionVariantFixups `]() ~FunctionVariantFixups() override = default #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) #### [` parse_payload `]() static std::vector<[Fixup]( "LIEF::MachO::FunctionVariantFixups::Fixup")> parse\_payload([SpanStream]( "LIEF::SpanStream") &stream) #### [` Fixup `]() class Fixup A single relocation associated with a function-variant. It mirrors the `FunctionVariantFixups::InternalFixup` structure used by `dyld` and describes a slot that must be fixed up to point to the variant referenced by [variant\_index()](). Public Functions ##### [` Fixup `]() Fixup() = default ##### [` Fixup `]() inline Fixup(uint32\_t seg\_offset, uint32\_t seg\_index, uint32\_t variant\_index, bool pac\_auth, bool pac\_address, uint8\_t pac\_key, uint16\_t pac\_diversity) ##### [` Fixup `]() Fixup(const details::function\_variant\_fixup\_t &raw) ##### [` Fixup `]() Fixup(const [Fixup]( "LIEF::MachO::FunctionVariantFixups::Fixup::Fixup")&) = default ##### [` operator= `]() [Fixup]( "LIEF::MachO::FunctionVariantFixups::Fixup") &operator=(const [Fixup]( "LIEF::MachO::FunctionVariantFixups::Fixup")&) = default ##### [` Fixup `]() Fixup([Fixup]( "LIEF::MachO::FunctionVariantFixups::Fixup::Fixup")&&) noexcept = default ##### [` operator= `]() [Fixup]( "LIEF::MachO::FunctionVariantFixups::Fixup") &operator=([Fixup]( "LIEF::MachO::FunctionVariantFixups::Fixup")&&) noexcept = default ##### [` ~Fixup `]() ~Fixup() = default ##### [` seg_offset `]() inline uint32\_t seg\_offset() const Offset of the slot to fix up, relative to the segment designated by [seg\_index()](). ##### [` seg_index `]() inline uint32\_t seg\_index() const Index of the segment that owns the slot to fix up. ##### [` variant_index `]() inline uint32\_t variant\_index() const Index of the [FunctionVariants]() runtime table used to resolve the slot. ##### [` pac_auth `]() inline bool pac\_auth() const Whether the slot is signed with pointer authentication (arm64e). ##### [` pac_address `]() inline bool pac\_address() const Whether the pointer-authentication signature mixes the storage address (address diversity). ##### [` pac_key `]() inline uint8\_t pac\_key() const Pointer-authentication key used to sign the slot. ##### [` pac_diversity `]() inline uint16\_t pac\_diversity() const Pointer-authentication diversity (discriminator) of the slot. ##### [` segment `]() inline [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*segment() [SegmentCommand]() referenced by [seg\_index()]() if it could be resolved. ##### [` segment `]() inline const [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*segment() const ##### [` seg_offset `]() inline void seg\_offset(uint32\_t value) ##### [` seg_index `]() inline void seg\_index(uint32\_t value) ##### [` variant_index `]() inline void variant\_index(uint32\_t value) ##### [` pac_auth `]() inline void pac\_auth(bool value) ##### [` pac_address `]() inline void pac\_address(bool value) ##### [` pac_key `]() inline void pac\_key(uint8\_t value) ##### [` pac_diversity `]() inline void pac\_diversity(uint16\_t value) ##### [` segment `]() inline void segment([SegmentCommand]( "LIEF::MachO::SegmentCommand") &seg) ##### [` to_string `]() std::string to\_string() const Friends ##### [` operator<< `]() inline friend std::ostream &operator<<(std::ostream &os, const [Fixup]( "LIEF::MachO::FunctionVariantFixups::Fixup") &fixup) --- ## [Lazy Load Dylib Info]() ### [` LazyLoadDylibInfo `]() class LazyLoadDylibInfo : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class representing the `LC_LAZY_LOAD_DYLIB_INFO` load command. This command describes how to **lazily load a dylib**: instead of binding the library and its symbols at launch time, `dyld` keeps the information required to resolve the dylib on the first use of one of its symbols. Public Types #### [` fixups_t `]() using fixups\_t = std::vector<[Fixup]( "LIEF::MachO::LazyLoadDylibInfo::Fixup")> #### [` it_fixups `]() using it\_fixups = [ref\_iterator]( "LIEF::ref_iterator")<[fixups\_t]( "LIEF::MachO::LazyLoadDylibInfo::fixups_t")&> Iterator that outputs [Fixup]()&. #### [` it_const_fixups `]() using it\_const\_fixups = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [fixups\_t]( "LIEF::MachO::LazyLoadDylibInfo::fixups_t")&> Iterator that outputs const [Fixup]()&. Public Functions #### [` LazyLoadDylibInfo `]() LazyLoadDylibInfo() #### [` LazyLoadDylibInfo `]() LazyLoadDylibInfo(const details::linkedit\_data\_command &cmd) #### [` operator= `]() [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &operator=(const [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &copy) = default #### [` LazyLoadDylibInfo `]() LazyLoadDylibInfo(const [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo::LazyLoadDylibInfo") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` data_offset `]() inline uint32\_t data\_offset() const Offset in the `__LINKEDIT` segment where the payload starts. #### [` data_size `]() inline uint32\_t data\_size() const Size of the payload. #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` content `]() inline span<const uint8\_t> content() const Return the data slice in the `__LINKEDIT` segment referenced by data\_offset and data\_size. #### [` content `]() inline span<uint8\_t> content() #### [` load_path `]() inline std::string\_view load\_path() const Load path of the dylib to bind lazily. #### [` load_path `]() inline [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &load\_path(std::string value) Change the load path of the dylib to bind lazily. #### [` flag_image_offset `]() inline uint32\_t flag\_image\_offset() const Image offset of the global flag that is set once the dylib has been loaded by dyld. #### [` flag_image_offset `]() inline [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &flag\_image\_offset(uint32\_t value) #### [` flags `]() inline uint16\_t flags() const Raw flags associated with this command. #### [` flags `]() inline [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &flags(uint16\_t value) #### [` may_be_missing `]() inline bool may\_be\_missing() const Whether the dylib is allowed to be missing at runtime (i.e. “weak linked”). #### [` may_be_missing `]() inline [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &may\_be\_missing(bool value) Set or clear the “may be missing” (weak linked) bit of [flags()](). #### [` pointer_format `]() inline uint16\_t pointer\_format() const Chained-fixups pointer format used by the binding chain (e.g. `DYLD_CHAINED_PTR_ARM64E_USERLAND`). #### [` pointer_format `]() inline [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &pointer\_format(uint16\_t value) #### [` chain_start_image_offset `]() inline uint32\_t chain\_start\_image\_offset() const Image offset of the fixup chain start used to bind the dylib’s symbols. #### [` chain_start_image_offset `]() inline [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &chain\_start\_image\_offset(uint32\_t value) #### [` symbols `]() inline const std::vector<std::string> &symbols() const List of the symbol names to bind lazily for this dylib. #### [` symbols `]() inline [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &symbols(std::vector<std::string> value) Replace the list of the symbol names to bind lazily for this dylib. #### [` add_symbol `]() inline [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &add\_symbol(std::string value) Append a symbol name to the list of symbols to bind lazily. #### [` clear_symbols `]() inline [LazyLoadDylibInfo]( "LIEF::MachO::LazyLoadDylibInfo") &clear\_symbols() Remove all the symbol names to bind lazily. #### [` fixups `]() inline [it\_fixups]( "LIEF::MachO::LazyLoadDylibInfo::it_fixups") fixups() Iterator over the lazy-binding [Fixup]() entries. #### [` fixups `]() inline [it\_const\_fixups]( "LIEF::MachO::LazyLoadDylibInfo::it_const_fixups") fixups() const #### [` ~LazyLoadDylibInfo `]() ~LazyLoadDylibInfo() override = default #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) Public Static Attributes #### [` MAYBE_MISSING_FLAG `]() static auto MAYBE\_MISSING\_FLAG = 1 #### [` Fixup `]() class Fixup A single lazy-binding fixup decoded from the chain referenced by chain\_start\_image\_offset and decoded according to pointer\_format. Public Functions ##### [` Fixup `]() Fixup() = default ##### [` Fixup `]() inline Fixup(uint64\_t address, uint32\_t ordinal, std::string symbol, bool is\_auth) ##### [` Fixup `]() Fixup(const [Fixup]( "LIEF::MachO::LazyLoadDylibInfo::Fixup::Fixup")&) = default ##### [` operator= `]() [Fixup]( "LIEF::MachO::LazyLoadDylibInfo::Fixup") &operator=(const [Fixup]( "LIEF::MachO::LazyLoadDylibInfo::Fixup")&) = default ##### [` Fixup `]() Fixup([Fixup]( "LIEF::MachO::LazyLoadDylibInfo::Fixup::Fixup")&&) noexcept = default ##### [` operator= `]() [Fixup]( "LIEF::MachO::LazyLoadDylibInfo::Fixup") &operator=([Fixup]( "LIEF::MachO::LazyLoadDylibInfo::Fixup")&&) noexcept = default ##### [` ~Fixup `]() ~Fixup() = default ##### [` address `]() inline uint64\_t address() const Virtual address of the slot bound by this fixup. ##### [` address `]() inline void address(uint64\_t value) ##### [` ordinal `]() inline uint32\_t ordinal() const Index of the bound symbol in the symbols table of [LazyLoadDylibInfo](). ##### [` symbol `]() inline std::string\_view symbol() const Name of the bound symbol, resolved from [ordinal()]() (empty if the ordinal is out of the [symbols()]() range). ##### [` is_auth `]() inline bool is\_auth() const Whether the bound pointer is authenticated (`arm64e` PAC). ##### [` to_string `]() std::string to\_string() const Friends ##### [` operator<< `]() inline friend std::ostream &operator<<(std::ostream &os, const [Fixup]( "LIEF::MachO::LazyLoadDylibInfo::Fixup") &fixup) --- ## [Source Version]() ### [` SourceVersion `]() class SourceVersion : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the MachO [LoadCommand::TYPE::SOURCE\_VERSION]() This command is used to provide the *version* of the sources used to build the binary. Public Types #### [` version_t `]() using version\_t = std::array<uint32\_t, 5> Version is an array of **5** integers. Public Functions #### [` SourceVersion `]() SourceVersion() = default #### [` SourceVersion `]() SourceVersion(const details::source\_version\_command &version\_cmd) #### [` operator= `]() [SourceVersion]( "LIEF::MachO::SourceVersion") &operator=(const [SourceVersion]( "LIEF::MachO::SourceVersion") &copy) = default #### [` SourceVersion `]() SourceVersion(const [SourceVersion]( "LIEF::MachO::SourceVersion::SourceVersion") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~SourceVersion `]() ~SourceVersion() override = default #### [` version `]() inline const [version\_t]( "LIEF::MachO::SourceVersion::version_t") &version() const Return the version as an array. #### [` version `]() inline void version(const [version\_t]( "LIEF::MachO::SourceVersion::version_t") &version) #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Version Min]() ### [` VersionMin `]() class VersionMin : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that wraps the LC\_VERSION\_MIN\_MACOSX, LC\_VERSION\_MIN\_IPHONEOS, … commands. Public Types #### [` version_t `]() using version\_t = std::array<uint32\_t, 3> Version is an array of **3** integers. Public Functions #### [` VersionMin `]() VersionMin() = default #### [` VersionMin `]() VersionMin(const details::version\_min\_command &version\_cmd) #### [` operator= `]() [VersionMin]( "LIEF::MachO::VersionMin") &operator=(const [VersionMin]( "LIEF::MachO::VersionMin") &copy) = default #### [` VersionMin `]() VersionMin(const [VersionMin]( "LIEF::MachO::VersionMin::VersionMin") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~VersionMin `]() ~VersionMin() override = default #### [` version `]() inline const [version\_t]( "LIEF::MachO::VersionMin::version_t") &version() const Return the version as an array. #### [` version `]() inline void version(const [version\_t]( "LIEF::MachO::VersionMin::version_t") &version) #### [` sdk `]() inline const [version\_t]( "LIEF::MachO::VersionMin::version_t") &sdk() const Return the sdk version as an array. #### [` sdk `]() inline void sdk(const [version\_t]( "LIEF::MachO::VersionMin::version_t") &sdk) #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Routine]() ### [` Routine `]() class Routine : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the `LC_ROUTINE/LC_ROUTINE64` commands. According to the Mach-O `loader.h` documentation: > 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. Public Functions #### [` Routine `]() Routine() = default #### [` TRoutine `]() template<class T> Routine(const [T]( "LIEF::MachO::Routine::Routine::T") &cmd) #### [` operator= `]() [Routine]( "LIEF::MachO::Routine") &operator=(const [Routine]( "LIEF::MachO::Routine") &copy) = default #### [` Routine `]() Routine(const [Routine]( "LIEF::MachO::Routine::Routine") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` init_address `]() inline uint64\_t init\_address() const address of initialization routine #### [` init_address `]() inline void init\_address(uint64\_t addr) #### [` init_module `]() inline uint64\_t init\_module() const Index into the module table that the init routine is defined in. #### [` init_module `]() inline void init\_module(uint64\_t mod) #### [` reserved1 `]() inline uint64\_t reserved1() const #### [` reserved1 `]() inline void reserved1(uint64\_t value) #### [` reserved2 `]() inline uint64\_t reserved2() const #### [` reserved2 `]() inline void reserved2(uint64\_t value) #### [` reserved3 `]() inline uint64\_t reserved3() const #### [` reserved3 `]() inline void reserved3(uint64\_t value) #### [` reserved4 `]() inline uint64\_t reserved4() const #### [` reserved4 `]() inline void reserved4(uint64\_t value) #### [` reserved5 `]() inline uint64\_t reserved5() const #### [` reserved5 `]() inline void reserved5(uint64\_t value) #### [` reserved6 `]() inline uint64\_t reserved6() const #### [` reserved6 `]() inline void reserved6(uint64\_t value) #### [` ~Routine `]() ~Routine() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Relocation]() ### [` Relocation `]() class Relocation : public LIEF::[Relocation]( "LIEF::Relocation") Class that represents a Mach-O relocation. > **See also** > > - [MachO::RelocationObject]() > - [MachO::RelocationDyld]() > - [MachO::RelocationFixup]() Subclassed by [LIEF::MachO::RelocationDyld](), [LIEF::MachO::RelocationFixup](), [LIEF::MachO::RelocationObject]() Public Types #### [` ORIGIN `]() enum class ORIGIN *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` DYLDINFO `]() enumerator DYLDINFO = 1 ##### [` RELOC_TABLE `]() enumerator RELOC\_TABLE = 2 ##### [` CHAINED_FIXUPS `]() enumerator CHAINED\_FIXUPS = 3 Public Functions #### [` Relocation `]() Relocation() = default #### [` Relocation `]() Relocation(uint64\_t address, uint8\_t type) #### [` operator= `]() [Relocation]( "LIEF::MachO::Relocation") &operator=(const [Relocation]( "LIEF::MachO::Relocation") &other) #### [` Relocation `]() Relocation(const [Relocation]( "LIEF::MachO::Relocation::Relocation") &other) #### [` swap `]() void swap([Relocation]( "LIEF::MachO::Relocation") &other) noexcept #### [` ~Relocation `]() ~Relocation() override = default #### [` clone `]() virtual std::unique\_ptr<[Relocation]( "LIEF::MachO::Relocation")> clone() const = 0 #### [` is_pc_relative `]() virtual bool is\_pc\_relative() const = 0 Indicates whether the item containing the address to be relocated is part of a CPU instruction that uses PC-relative addressing. For addresses contained in PC-relative instructions, the CPU adds the address of the instruction to the address contained in the instruction. #### [` type `]() inline virtual uint8\_t type() const Type of the relocation according to the [Relocation::architecture]() and/or the [Relocation::origin](). See: - [MachO::X86\_RELOCATION]() - [MachO::X86\_64\_RELOCATION]() - [MachO::PPC\_RELOCATION]() - [MachO::ARM\_RELOCATION]() - [MachO::ARM64\_RELOCATION]() - MachO::REBASE\_TYPES #### [` architecture `]() inline [Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") architecture() const Architecture targeted by this relocation. #### [` origin `]() virtual [ORIGIN]( "LIEF::MachO::Relocation::ORIGIN") origin() const = 0 Origin of the relocation. #### [` has_symbol `]() inline bool has\_symbol() const `true` if the relocation has a symbol associated with #### [` symbol `]() inline [Symbol]( "LIEF::MachO::Symbol") \*symbol() [Symbol]() associated with the relocation, if any, otherwise a nullptr. #### [` symbol `]() inline const [Symbol]( "LIEF::MachO::Symbol") \*symbol() const #### [` has_section `]() inline bool has\_section() const `true` if the relocation has a section associated with #### [` section `]() inline [Section]( "LIEF::MachO::Section") \*section() [Section]() associated with the relocation, if any, otherwise a nullptr. #### [` section `]() inline const [Section]( "LIEF::MachO::Section") \*section() const #### [` has_segment `]() inline bool has\_segment() const `true` if the relocation has a [SegmentCommand]() associated with #### [` segment `]() inline [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*segment() [SegmentCommand]() associated with the relocation, if any, otherwise a nullptr. #### [` segment `]() inline const [SegmentCommand]( "LIEF::MachO::SegmentCommand") \*segment() const #### [` Tcast `]() template<class T> inline const [T]( "LIEF::MachO::Relocation::cast::T") \*cast() const #### [` Tcast `]() template<class T> inline [T]( "LIEF::MachO::Relocation::cast::T") \*cast() #### [` pc_relative `]() virtual void pc\_relative(bool val) = 0 #### [` type `]() virtual void type(uint8\_t type) #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const #### [` address `]() inline virtual uint64\_t address() const [Relocation]()’s address. #### [` address `]() inline virtual void address(uint64\_t address) #### [` size `]() inline virtual size\_t size() const [Relocation]() size in **bits**. #### [` size `]() inline virtual void size(size\_t size) Public Static Attributes #### [` R_SCATTERED `]() static auto R\_SCATTERED = uint32\_t(0x80000000) #### [` R_ABS `]() static auto R\_ABS = uint32\_t(0) Friends #### [` operator<< `]() friend std::ostream &operator<<(std::ostream &os, const [Relocation]( "LIEF::MachO::Relocation") &relocation) --- ## [Relocation Object]() ### [` RelocationObject `]() class RelocationObject : public LIEF::MachO::[Relocation]( "LIEF::MachO::Relocation") Class that represents a relocation present in the MachO object file (`.o`). Usually, this kind of relocation is found in the [MachO::Section](). > **See also** > > [RelocationDyld]() Public Functions #### [` RelocationObject `]() RelocationObject() = default #### [` RelocationObject `]() RelocationObject(const details::relocation\_info &relocinfo) #### [` RelocationObject `]() RelocationObject(const details::scattered\_relocation\_info &scattered\_relocinfo) #### [` operator= `]() [RelocationObject]( "LIEF::MachO::RelocationObject") &operator=(const [RelocationObject]( "LIEF::MachO::RelocationObject") &other) = default #### [` RelocationObject `]() RelocationObject(const [RelocationObject]( "LIEF::MachO::RelocationObject::RelocationObject") &other) = default #### [` swap `]() void swap([RelocationObject]( "LIEF::MachO::RelocationObject") &other) noexcept #### [` ~RelocationObject `]() ~RelocationObject() override = default #### [` clone `]() inline virtual std::unique\_ptr<[Relocation]( "LIEF::MachO::RelocationObject::Relocation")> clone() const override #### [` is_pc_relative `]() inline virtual bool is\_pc\_relative() const override Whether the relocation is PC relative. #### [` size `]() virtual size\_t size() const override Size of the relocation. #### [` address `]() virtual uint64\_t address() const override Address where the relocation is applied This address is relative to the start of the section where the relocation takes place. #### [` is_scattered `]() inline bool is\_scattered() const `true` if the relocation is a scattered one #### [` value `]() int32\_t value() const For **scattered** relocations: The address of the relocatable expression for the item in the file that needs to be updated if the address is changed. For relocatable expressions with the difference of two section addresses, the address from which to subtract (in mathematical terms, the minuend) is contained in the first relocation entry and the address to subtract (the subtrahend) is contained in the second relocation entry. #### [` origin `]() inline virtual ORIGIN origin() const override Origin of the relocation. For this object it should be [Relocation::ORIGIN::RELOC\_TABLE]()). #### [` pc_relative `]() inline virtual void pc\_relative(bool val) override #### [` size `]() virtual void size(size\_t size) override #### [` value `]() void value(int32\_t value) #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() inline virtual std::ostream &print(std::ostream &os) const override #### [` Relocation `]() Relocation() = default #### [` Relocation `]() Relocation(uint64\_t address, uint8\_t type) #### [` Relocation `]() Relocation(const [Relocation]( "LIEF::MachO::RelocationObject::Relocation") &other) Public Static Functions #### [` classof `]() static inline bool classof(const [Relocation]( "LIEF::MachO::RelocationObject::Relocation") &r) --- ## [Relocation Dyld]() ### [` RelocationDyld `]() class RelocationDyld : public LIEF::MachO::[Relocation]( "LIEF::MachO::Relocation") Class that represents a relocation found in the [DyldInfo]() structure. While this class does not have an associated structure in the Mach-O format specification, it provides a convenient interface for the Dyld::rebase Public Functions #### [` RelocationDyld `]() RelocationDyld() = default #### [` operator= `]() [RelocationDyld]( "LIEF::MachO::RelocationDyld") &operator=(const [RelocationDyld]( "LIEF::MachO::RelocationDyld")&) = default #### [` RelocationDyld `]() RelocationDyld(const [RelocationDyld]( "LIEF::MachO::RelocationDyld::RelocationDyld")&) = default #### [` ~RelocationDyld `]() ~RelocationDyld() override = default #### [` clone `]() inline virtual std::unique\_ptr<[Relocation]( "LIEF::MachO::RelocationDyld::Relocation")> clone() const override #### [` is_pc_relative `]() virtual bool is\_pc\_relative() const override Indicates whether the item containing the address to be relocated is part of a CPU instruction that uses PC-relative addressing. For addresses contained in PC-relative instructions, the CPU adds the address of the instruction to the address contained in the instruction. #### [` origin `]() inline virtual ORIGIN origin() const override Origin of the relocation. For this concrete object, it should be [Relocation::ORIGIN::DYLDINFO](). #### [` pc_relative `]() virtual void pc\_relative(bool val) override #### [` operator< `]() bool operator<(const [RelocationDyld]( "LIEF::MachO::RelocationDyld") &rhs) const #### [` operator>= `]() inline bool operator>=(const [RelocationDyld]( "LIEF::MachO::RelocationDyld") &rhs) const #### [` operator> `]() bool operator>(const [RelocationDyld]( "LIEF::MachO::RelocationDyld") &rhs) const #### [` operator<= `]() inline bool operator<=(const [RelocationDyld]( "LIEF::MachO::RelocationDyld") &rhs) const #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() inline virtual std::ostream &print(std::ostream &os) const override #### [` Relocation `]() Relocation() = default #### [` Relocation `]() Relocation(uint64\_t address, uint8\_t type) #### [` Relocation `]() Relocation(const [Relocation]( "LIEF::MachO::RelocationDyld::Relocation") &other) #### [` operator< `]() inline virtual bool operator<(const [Relocation]( "LIEF::MachO::RelocationDyld::Relocation") &rhs) const Comparison based on the [Relocation]()’s **address**. #### [` operator<= `]() inline virtual bool operator<=(const [Relocation]( "LIEF::MachO::RelocationDyld::Relocation") &rhs) const Comparison based on the [Relocation]()’s **address**. #### [` operator> `]() inline virtual bool operator>(const [Relocation]( "LIEF::MachO::RelocationDyld::Relocation") &rhs) const Comparison based on the [Relocation]()’s **address**. #### [` operator>= `]() inline virtual bool operator>=(const [Relocation]( "LIEF::MachO::RelocationDyld::Relocation") &rhs) const Comparison based on the [Relocation]()’s **address**. Public Static Functions #### [` classof `]() static inline bool classof(const [Relocation]( "LIEF::MachO::RelocationDyld::Relocation") &r) --- ## [Relocation Fixup]() ### [` RelocationFixup `]() class RelocationFixup : public LIEF::MachO::[Relocation]( "LIEF::MachO::Relocation") Class that represents a rebase relocation found in the `LC_DYLD_CHAINED_FIXUPS` command. This class extends [LIEF::Relocation]() in which [LIEF::Relocation::address]() is set to the absolute virtual address where the relocation must take place (e.g. `0x10000d270`). On the other hand, [RelocationFixup::target]() contains the value that should be set at [LIEF::Relocation::address]() if the imagebase is [LIEF::Binary::imagebase]() (e.g. `0x1000073a8`). If the Mach-O loader chooses another base address (like 0x7ff100000), it must set `0x10000d270` to `0x7ff1073a8`. Public Functions #### [` RelocationFixup `]() RelocationFixup() = delete #### [` RelocationFixup `]() RelocationFixup([DYLD\_CHAINED\_PTR\_FORMAT]( "LIEF::MachO::DYLD_CHAINED_PTR_FORMAT") fmt, uint64\_t imagebase) #### [` operator= `]() [RelocationFixup]( "LIEF::MachO::RelocationFixup") &operator=(const [RelocationFixup]( "LIEF::MachO::RelocationFixup")&) #### [` RelocationFixup `]() RelocationFixup(const [RelocationFixup]( "LIEF::MachO::RelocationFixup::RelocationFixup")&) #### [` operator= `]() [RelocationFixup]( "LIEF::MachO::RelocationFixup") &operator=([RelocationFixup]( "LIEF::MachO::RelocationFixup")&&) noexcept = default #### [` RelocationFixup `]() RelocationFixup([RelocationFixup]( "LIEF::MachO::RelocationFixup::RelocationFixup")&&) noexcept = default #### [` ~RelocationFixup `]() ~RelocationFixup() override #### [` clone `]() inline virtual std::unique\_ptr<[Relocation]( "LIEF::MachO::Relocation")> clone() const override #### [` is_pc_relative `]() inline virtual bool is\_pc\_relative() const override Not relevant for this kind of relocation. #### [` origin `]() inline virtual ORIGIN origin() const override Origin of the relocation. For this concrete object, it should be [Relocation::ORIGIN::CHAINED\_FIXUPS](). #### [` ptr_format `]() inline [DYLD\_CHAINED\_PTR\_FORMAT]( "LIEF::MachO::DYLD_CHAINED_PTR_FORMAT") ptr\_format() const #### [` target `]() uint64\_t target() const The value that should be set at the address pointed by [LIEF::Relocation::address]() if the imagebase chosen by the loader is [LIEF::Binary::imagebase](). Otherwise: [target()]() - [LIEF::Binary::imagebase()]() + new\_imagebase. #### [` target `]() void target(uint64\_t target) #### [` pc_relative `]() inline virtual void pc\_relative(bool) override Not relevant for this kind of relocation. #### [` offset `]() inline uint32\_t offset() const #### [` offset `]() inline void offset(uint32\_t offset) #### [` address `]() inline virtual uint64\_t address() const override The address of this relocation is bound to its offset. #### [` address `]() inline virtual void address(uint64\_t address) override Changing the address means changing the offset. #### [` next `]() uint32\_t next() const Return the (unscaled) next offset in the chain. #### [` next `]() void next(uint32\_t value) Change next offset of the current element. #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [Relocation]( "LIEF::MachO::Relocation") &r) --- ## [Dyld Binding Info]() ### [` DyldBindingInfo `]() class DyldBindingInfo : public LIEF::MachO::BindingInfo This class represents a symbol binding operation associated with the LC\_DYLD\_INFO bytecode. It does not represent a structure that exists in the Mach-O format specifications but it provides a *view* on an entry of the Dyld binding opcodes. > **See also** > > BindingInfo Public Types #### [` CLASS `]() enum class CLASS : uint64\_t *Values:* ##### [` WEAK `]() enumerator WEAK = 1u ##### [` LAZY `]() enumerator LAZY = 2u ##### [` STANDARD `]() enumerator STANDARD = 3u ##### [` THREADED `]() enumerator THREADED = 100u #### [` TYPE `]() enum class TYPE : uint64\_t *Values:* ##### [` POINTER `]() enumerator POINTER = 1u ##### [` TEXT_ABSOLUTE32 `]() enumerator TEXT\_ABSOLUTE32 = 2u ##### [` TEXT_PCREL32 `]() enumerator TEXT\_PCREL32 = 3u Public Functions #### [` DyldBindingInfo `]() DyldBindingInfo() = default #### [` DyldBindingInfo `]() DyldBindingInfo([CLASS]( "LIEF::MachO::DyldBindingInfo::CLASS") cls, [TYPE]( "LIEF::MachO::DyldBindingInfo::TYPE") type, uint64\_t address, int64\_t addend = 0, int32\_t oridnal = 0, bool is\_weak = false, bool is\_non\_weak\_definition = false, uint64\_t offset = 0) #### [` operator= `]() [DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo") &operator=(const [DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo") &other) = default #### [` DyldBindingInfo `]() DyldBindingInfo(const [DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo::DyldBindingInfo") &other) = default #### [` operator= `]() [DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo") &operator=([DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo")&&) noexcept = default #### [` DyldBindingInfo `]() DyldBindingInfo([DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo::DyldBindingInfo")&&) noexcept = default #### [` swap `]() void swap([DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo") &other) noexcept #### [` binding_class `]() inline [CLASS]( "LIEF::MachO::DyldBindingInfo::CLASS") binding\_class() const Class of the binding (weak, lazy, …). #### [` binding_class `]() inline void binding\_class([CLASS]( "LIEF::MachO::DyldBindingInfo::CLASS") bind\_class) #### [` binding_type `]() inline [TYPE]( "LIEF::MachO::DyldBindingInfo::TYPE") binding\_type() const Type of the binding. Most of the time it’s [TYPE::POINTER](). #### [` binding_type `]() inline void binding\_type([TYPE]( "LIEF::MachO::DyldBindingInfo::TYPE") type) #### [` is_non_weak_definition `]() inline bool is\_non\_weak\_definition() const #### [` set_non_weak_definition `]() inline void set\_non\_weak\_definition(bool val) #### [` original_offset `]() inline uint64\_t original\_offset() const Original relative offset of the binding opcodes. #### [` type `]() inline virtual BindingInfo::TYPES type() const override The type of the binding. This type provides the origin of the binding (LC\_DYLD\_INFO or LC\_DYLD\_CHAINED\_FIXUPS). #### [` ~DyldBindingInfo `]() ~DyldBindingInfo() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` classof `]() static inline bool classof(const BindingInfo \*info) Friends #### [` operator<< `]() inline friend std::ostream &operator<<(std::ostream &os, const [DyldBindingInfo]( "LIEF::MachO::DyldBindingInfo") &info) --- ## [Chained Binding Info]() ### [` ChainedBindingInfo `]() class ChainedBindingInfo : public LIEF::MachO::BindingInfo This class represents a symbol binding operation associated with the LC\_DYLD\_CHAINED\_FIXUPS command. This class does not represent a structure that exists in the Mach-O format specifications but it provides a *view* on an entry. > **See also** > > BindingInfo Public Functions #### [` ChainedBindingInfo `]() ChainedBindingInfo() = delete #### [` ChainedBindingInfo `]() explicit ChainedBindingInfo([DYLD\_CHAINED\_FORMAT]( "LIEF::MachO::DYLD_CHAINED_FORMAT") fmt, bool is\_weak) #### [` operator= `]() [ChainedBindingInfo]( "LIEF::MachO::ChainedBindingInfo") &operator=(const [ChainedBindingInfo]( "LIEF::MachO::ChainedBindingInfo") &other) #### [` ChainedBindingInfo `]() ChainedBindingInfo(const [ChainedBindingInfo]( "LIEF::MachO::ChainedBindingInfo::ChainedBindingInfo") &other) #### [` ChainedBindingInfo `]() ChainedBindingInfo([ChainedBindingInfo]( "LIEF::MachO::ChainedBindingInfo::ChainedBindingInfo")&&) noexcept #### [` operator= `]() [ChainedBindingInfo]( "LIEF::MachO::ChainedBindingInfo") &operator=([ChainedBindingInfo]( "LIEF::MachO::ChainedBindingInfo")&&) noexcept #### [` format `]() inline [DYLD\_CHAINED\_FORMAT]( "LIEF::MachO::DYLD_CHAINED_FORMAT") format() const Format of the imports. #### [` ptr_format `]() inline [DYLD\_CHAINED\_PTR\_FORMAT]( "LIEF::MachO::DYLD_CHAINED_PTR_FORMAT") ptr\_format() const Format of the pointer. #### [` offset `]() inline uint32\_t offset() const Original offset in the chain of this binding. #### [` offset `]() inline void offset(uint32\_t offset) #### [` address `]() inline virtual uint64\_t address() const override Address of the binding. #### [` address `]() inline virtual void address(uint64\_t address) override #### [` sign_extended_addend `]() uint64\_t sign\_extended\_addend() const #### [` type `]() inline virtual TYPES type() const override The type of the binding. This type provides the origin of the binding (LC\_DYLD\_INFO or LC\_DYLD\_CHAINED\_FIXUPS). #### [` ~ChainedBindingInfo `]() ~ChainedBindingInfo() override #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` classof `]() static inline bool classof(const BindingInfo \*info) Friends #### [` operator<< `]() inline friend std::ostream &operator<<(std::ostream &os, const [ChainedBindingInfo]( "LIEF::MachO::ChainedBindingInfo") &info) --- ## [Export Info]() ### [` ExportInfo `]() class ExportInfo : public LIEF::Object Class that provides an interface over the Dyld export info. This class does not represent a structure that exists in the Mach-O format specification but provides a *view* on an entry of the Dyld export trie. Public Types #### [` KIND `]() enum class KIND : uint64\_t *Values:* ##### [` REGULAR `]() enumerator REGULAR = 0x00u ##### [` THREAD_LOCAL_KIND `]() enumerator THREAD\_LOCAL\_KIND = 0x01u ##### [` ABSOLUTE_KIND `]() enumerator ABSOLUTE\_KIND = 0x02u #### [` FLAGS `]() enum class FLAGS : uint64\_t *Values:* ##### [` WEAK_DEFINITION `]() enumerator WEAK\_DEFINITION = 0x04u ##### [` REEXPORT `]() enumerator REEXPORT = 0x08u ##### [` STUB_AND_RESOLVER `]() enumerator STUB\_AND\_RESOLVER = 0x10u ##### [` STATIC_RESOLVER `]() enumerator STATIC\_RESOLVER = 0x20u #### [` flag_list_t `]() using flag\_list\_t = std::vector<[FLAGS]( "LIEF::MachO::ExportInfo::FLAGS")> Public Functions #### [` ExportInfo `]() ExportInfo() = default #### [` ExportInfo `]() inline ExportInfo(uint64\_t address, uint64\_t flags, uint64\_t offset = 0) #### [` operator= `]() [ExportInfo]( "LIEF::MachO::ExportInfo") &operator=([ExportInfo]( "LIEF::MachO::ExportInfo") copy) #### [` ExportInfo `]() ExportInfo(const [ExportInfo]( "LIEF::MachO::ExportInfo::ExportInfo") &copy) #### [` swap `]() void swap([ExportInfo]( "LIEF::MachO::ExportInfo") &other) noexcept #### [` node_offset `]() inline uint64\_t node\_offset() const Original offset in the export Trie. #### [` flags `]() inline uint64\_t flags() const Some information ([ExportInfo::FLAGS]()) about the export. (like weak export, reexport, …). #### [` flags `]() inline void flags(uint64\_t flags) #### [` flags_list `]() [flag\_list\_t]( "LIEF::MachO::ExportInfo::flag_list_t") flags\_list() const The export [flags()]() as a list. #### [` has `]() bool has([FLAGS]( "LIEF::MachO::ExportInfo::FLAGS") flag) const Check if the current entry contains the provided [ExportInfo::FLAGS](). #### [` kind `]() inline [KIND]( "LIEF::MachO::ExportInfo::KIND") kind() const The export’s kind (regular, thread local, absolute, …). #### [` other `]() inline uint64\_t other() const #### [` address `]() inline uint64\_t address() const The address of the export. #### [` address `]() inline void address(uint64\_t addr) #### [` has_symbol `]() inline bool has\_symbol() const Check if a symbol is associated with this export. #### [` symbol `]() inline const [Symbol]( "LIEF::MachO::Symbol") \*symbol() const [MachO::Symbol]() associated with this export or a nullptr if no symbol. #### [` symbol `]() inline [Symbol]( "LIEF::MachO::Symbol") \*symbol() #### [` alias `]() inline [Symbol]( "LIEF::MachO::Symbol") \*alias() If the export is a [ExportInfo::FLAGS::REEXPORT](), this returns the (optional) [MachO::Symbol](). #### [` alias `]() inline const [Symbol]( "LIEF::MachO::Symbol") \*alias() const #### [` alias_library `]() inline [DylibCommand]( "LIEF::MachO::DylibCommand") \*alias\_library() If the export is a [ExportInfo::FLAGS::REEXPORT](), this returns the (optional) library ([MachO::DylibCommand]()). #### [` alias_library `]() inline const [DylibCommand]( "LIEF::MachO::DylibCommand") \*alias\_library() const #### [` ~ExportInfo `]() ~ExportInfo() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override Friends #### [` operator<< `]() friend std::ostream &operator<<(std::ostream &os, const [ExportInfo]( "LIEF::MachO::ExportInfo") &export\_info) --- ## [Thread Command]() ### [` ThreadCommand `]() class ThreadCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the LC\_THREAD / LC\_UNIXTHREAD commands and that can be used to get the binary entrypoint when the LC\_MAIN ([MainCommand]()) is not present. Generally speaking, this command aims at defining the original state of the main thread which includes the registers’ values Public Functions #### [` ThreadCommand `]() ThreadCommand() = default #### [` ThreadCommand `]() ThreadCommand(const details::thread\_command &cmd, [Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") arch = [Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE")::[ANY]( "LIEF::MachO::Header::CPU_TYPE::ANY")) #### [` ThreadCommand `]() ThreadCommand(uint32\_t flavor, uint32\_t count, [Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") arch = [Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE")::[ANY]( "LIEF::MachO::Header::CPU_TYPE::ANY")) #### [` operator= `]() [ThreadCommand]( "LIEF::MachO::ThreadCommand") &operator=(const [ThreadCommand]( "LIEF::MachO::ThreadCommand") &copy) = default #### [` ThreadCommand `]() ThreadCommand(const [ThreadCommand]( "LIEF::MachO::ThreadCommand::ThreadCommand") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~ThreadCommand `]() ~ThreadCommand() override = default #### [` flavor `]() inline uint32\_t flavor() const Integer that defines a special *flavor* for the thread. The meaning of this value depends on the [architecture()](). The list of the values can be found in the XNU kernel files: - xnu/osfmk/mach/arm/thread\_status.h for the ARM/AArch64 architectures - xnu/osfmk/mach/i386/thread\_status.h for the x86/x86-64 architectures #### [` count `]() inline uint32\_t count() const Size of the thread state data with 32-bits alignment. This value should match [state()]().[size()]() #### [` architecture `]() inline [Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") architecture() const The CPU architecture that is targeted by this [ThreadCommand](). #### [` state `]() inline span<const uint8\_t> state() const The actual thread state as a vector of bytes. Depending on the [architecture()](), these data can be cast into x86\_thread\_state\_t, x86\_thread\_state64\_t, … #### [` state `]() inline span<uint8\_t> state() #### [` pc `]() uint64\_t pc() const Return the initial Program Counter regardless of the underlying architecture. This value, when non null, can be used to determine the binary’s entrypoint. Underneath, it works by looking for the PC register value in the [state()]() data #### [` state `]() inline void state(std::vector<uint8\_t> state) #### [` flavor `]() inline void flavor(uint32\_t flavor) #### [` count `]() inline void count(uint32\_t count) #### [` architecture `]() inline void architecture([Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") arch) #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [RPath Command]() ### [` RPathCommand `]() class RPathCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the `LC_RPATH` command. This command is used to add path for searching libraries associated with the `@rpath` prefix. Public Functions #### [` RPathCommand `]() RPathCommand() = default #### [` RPathCommand `]() RPathCommand(std::string path) #### [` RPathCommand `]() RPathCommand(const details::rpath\_command &rpathCmd) #### [` operator= `]() [RPathCommand]( "LIEF::MachO::RPathCommand") &operator=(const [RPathCommand]( "LIEF::MachO::RPathCommand") &copy) = default #### [` RPathCommand `]() RPathCommand(const [RPathCommand]( "LIEF::MachO::RPathCommand::RPathCommand") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~RPathCommand `]() ~RPathCommand() override = default #### [` path `]() inline std::string\_view path() const The rpath value as a string. #### [` path_offset `]() inline uint32\_t path\_offset() const Original string offset of the path. #### [` path `]() inline void path(std::string path) #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` create `]() static inline std::unique\_ptr<[RPathCommand]( "LIEF::MachO::RPathCommand")> create(std::string path) Create a new RPath command for the provided `path`. #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Code Signature]() ### [` CodeSignature `]() class CodeSignature : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Public Functions #### [` CodeSignature `]() CodeSignature() = default #### [` CodeSignature `]() CodeSignature(const details::linkedit\_data\_command &cmd) #### [` operator= `]() [CodeSignature]( "LIEF::MachO::CodeSignature") &operator=(const [CodeSignature]( "LIEF::MachO::CodeSignature") &copy) = default #### [` CodeSignature `]() CodeSignature(const [CodeSignature]( "LIEF::MachO::CodeSignature::CodeSignature") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` data_offset `]() inline uint32\_t data\_offset() const Offset in the binary where the signature starts. #### [` data_size `]() inline uint32\_t data\_size() const Size of the raw signature. #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` content `]() inline span<uint8\_t> content() #### [` content `]() inline span<const uint8\_t> content() const #### [` ~CodeSignature `]() ~CodeSignature() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Data In Code]() ### [` DataInCode `]() class DataInCode : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Interface of the LC\_DATA\_IN\_CODE command This command is used to list slices of code sections that contain data. The *slices* information are stored as an array of [DataCodeEntry](). > **See also** > > [DataCodeEntry]() Public Types #### [` entries_t `]() using entries\_t = std::vector<[DataCodeEntry]( "LIEF::MachO::DataCodeEntry")> #### [` it_const_entries `]() using it\_const\_entries = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [entries\_t]( "LIEF::MachO::DataInCode::entries_t")&> #### [` it_entries `]() using it\_entries = [ref\_iterator]( "LIEF::ref_iterator")<[entries\_t]( "LIEF::MachO::DataInCode::entries_t")&> Public Functions #### [` DataInCode `]() DataInCode() = default #### [` DataInCode `]() DataInCode(const details::linkedit\_data\_command &cmd) #### [` operator= `]() [DataInCode]( "LIEF::MachO::DataInCode") &operator=(const [DataInCode]( "LIEF::MachO::DataInCode")&) = default #### [` DataInCode `]() DataInCode(const [DataInCode]( "LIEF::MachO::DataInCode::DataInCode")&) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` data_offset `]() inline uint32\_t data\_offset() const Start of the array of the [DataCodeEntry]() entries. #### [` data_size `]() inline uint32\_t data\_size() const Size of the raw array (`size = sizeof(DataCodeEntry) * nb_elements`). #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` add `]() inline [DataInCode]( "LIEF::MachO::DataInCode") &add([DataCodeEntry]( "LIEF::MachO::DataCodeEntry") entry) Add a new entry. #### [` entries `]() inline [it\_const\_entries]( "LIEF::MachO::DataInCode::it_const_entries") entries() const Iterator over the [DataCodeEntry](). #### [` entries `]() inline [it\_entries]( "LIEF::MachO::DataInCode::it_entries") entries() #### [` content `]() inline span<uint8\_t> content() #### [` content `]() inline span<const uint8\_t> content() const #### [` ~DataInCode `]() ~DataInCode() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Data Code Entry]() ### [` DataCodeEntry `]() class DataCodeEntry : public LIEF::Object Interface over an entry in the [DataInCode]() command. Public Types #### [` TYPES `]() enum class TYPES *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` DATA `]() enumerator DATA = 1 ##### [` JUMP_TABLE_8 `]() enumerator JUMP\_TABLE\_8 = 2 ##### [` JUMP_TABLE_16 `]() enumerator JUMP\_TABLE\_16 = 3 ##### [` JUMP_TABLE_32 `]() enumerator JUMP\_TABLE\_32 = 4 ##### [` ABS_JUMP_TABLE_32 `]() enumerator ABS\_JUMP\_TABLE\_32 = 5 Public Functions #### [` DataCodeEntry `]() DataCodeEntry() = default #### [` DataCodeEntry `]() inline DataCodeEntry(uint32\_t off, uint16\_t length, [TYPES]( "LIEF::MachO::DataCodeEntry::TYPES") type) #### [` DataCodeEntry `]() DataCodeEntry(const details::data\_in\_code\_entry &entry) #### [` operator= `]() [DataCodeEntry]( "LIEF::MachO::DataCodeEntry") &operator=(const [DataCodeEntry]( "LIEF::MachO::DataCodeEntry")&) = default #### [` DataCodeEntry `]() DataCodeEntry(const [DataCodeEntry]( "LIEF::MachO::DataCodeEntry::DataCodeEntry")&) = default #### [` offset `]() inline uint32\_t offset() const Offset of the data. #### [` length `]() inline uint16\_t length() const Length of the data. #### [` type `]() inline [TYPES]( "LIEF::MachO::DataCodeEntry::TYPES") type() const #### [` offset `]() inline void offset(uint32\_t off) #### [` length `]() inline void length(uint16\_t length) #### [` type `]() inline void type([TYPES]( "LIEF::MachO::DataCodeEntry::TYPES") type) #### [` ~DataCodeEntry `]() ~DataCodeEntry() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override Friends #### [` operator<< `]() friend std::ostream &operator<<(std::ostream &os, const [DataCodeEntry]( "LIEF::MachO::DataCodeEntry") &entry) --- ## [Segment Split Info]() ### [` SegmentSplitInfo `]() class SegmentSplitInfo : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the [LoadCommand::TYPE::SEGMENT\_SPLIT\_INFO]() command. Public Functions #### [` SegmentSplitInfo `]() SegmentSplitInfo() = default #### [` SegmentSplitInfo `]() SegmentSplitInfo(const details::linkedit\_data\_command &cmd) #### [` operator= `]() [SegmentSplitInfo]( "LIEF::MachO::SegmentSplitInfo") &operator=(const [SegmentSplitInfo]( "LIEF::MachO::SegmentSplitInfo") &copy) = default #### [` SegmentSplitInfo `]() SegmentSplitInfo(const [SegmentSplitInfo]( "LIEF::MachO::SegmentSplitInfo::SegmentSplitInfo") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` data_offset `]() inline uint32\_t data\_offset() const #### [` data_size `]() inline uint32\_t data\_size() const #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` content `]() inline span<uint8\_t> content() #### [` content `]() inline span<const uint8\_t> content() const #### [` ~SegmentSplitInfo `]() ~SegmentSplitInfo() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Sub-Framework]() ### [` SubFramework `]() class SubFramework : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the [SubFramework]() command. According to the Mach-O `loader.h` documentation: > 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. Public Functions #### [` SubFramework `]() SubFramework() = default #### [` SubFramework `]() SubFramework(const details::sub\_framework\_command &cmd) #### [` operator= `]() [SubFramework]( "LIEF::MachO::SubFramework") &operator=(const [SubFramework]( "LIEF::MachO::SubFramework") &copy) = default #### [` SubFramework `]() SubFramework(const [SubFramework]( "LIEF::MachO::SubFramework::SubFramework") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` umbrella `]() inline std::string\_view umbrella() const Name of the umbrella framework. #### [` umbrella `]() inline void umbrella(std::string u) #### [` ~SubFramework `]() ~SubFramework() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Sub-Client]() ### [` SubClient `]() class SubClient : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the [SubClient]() command. According to the Mach-O `loader.h` documentation: > 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”. Public Functions #### [` SubClient `]() SubClient() = default #### [` SubClient `]() SubClient(const details::sub\_client\_command &cmd) #### [` operator= `]() [SubClient]( "LIEF::MachO::SubClient") &operator=(const [SubClient]( "LIEF::MachO::SubClient") &copy) = default #### [` SubClient `]() SubClient(const [SubClient]( "LIEF::MachO::SubClient::SubClient") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` client `]() inline std::string\_view client() const Name of the client. #### [` client `]() inline void client(std::string u) #### [` ~SubClient `]() ~SubClient() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Dyld Environment]() ### [` DyldEnvironment `]() class DyldEnvironment : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents a `LC_DYLD_ENVIRONMENT` command which is used by the Mach-O linker/loader to initialize an environment variable. Public Functions #### [` DyldEnvironment `]() DyldEnvironment() = default #### [` DyldEnvironment `]() DyldEnvironment(const details::dylinker\_command &cmd) #### [` operator= `]() [DyldEnvironment]( "LIEF::MachO::DyldEnvironment") &operator=(const [DyldEnvironment]( "LIEF::MachO::DyldEnvironment") &copy) = default #### [` DyldEnvironment `]() DyldEnvironment(const [DyldEnvironment]( "LIEF::MachO::DyldEnvironment::DyldEnvironment") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~DyldEnvironment `]() ~DyldEnvironment() override = default #### [` print `]() virtual std::ostream &print(std::ostream &os) const override #### [` value `]() inline std::string\_view value() const The actual environment variable. #### [` value `]() inline void value(std::string value) #### [` accept `]() virtual void accept(Visitor &visitor) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Encryption Info]() ### [` EncryptionInfo `]() class EncryptionInfo : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the LC\_ENCRYPTION\_INFO / LC\_ENCRYPTION\_INFO\_64 commands. The encryption info is usually present in Mach-O executables that target iOS to encrypt some sections of the binary Public Functions #### [` EncryptionInfo `]() EncryptionInfo() = default #### [` EncryptionInfo `]() EncryptionInfo(const details::encryption\_info\_command &cmd) #### [` operator= `]() [EncryptionInfo]( "LIEF::MachO::EncryptionInfo") &operator=(const [EncryptionInfo]( "LIEF::MachO::EncryptionInfo") &copy) = default #### [` EncryptionInfo `]() EncryptionInfo(const [EncryptionInfo]( "LIEF::MachO::EncryptionInfo::EncryptionInfo") &copy) = default #### [` ~EncryptionInfo `]() ~EncryptionInfo() override = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` crypt_offset `]() inline uint32\_t crypt\_offset() const The beginning of the encrypted area. #### [` crypt_size `]() inline uint32\_t crypt\_size() const The size of the encrypted area. #### [` crypt_id `]() inline uint32\_t crypt\_id() const The encryption system. 0 means not encrypted. #### [` crypt_offset `]() inline void crypt\_offset(uint32\_t offset) #### [` crypt_size `]() inline void crypt\_size(uint32\_t size) #### [` crypt_id `]() inline void crypt\_id(uint32\_t id) #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Build Version]() ### [` BuildVersion `]() class BuildVersion : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Public Types #### [` PLATFORMS `]() enum class PLATFORMS : uint32\_t *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` MACOS `]() enumerator MACOS = 1 ##### [` IOS `]() enumerator IOS = 2 ##### [` TVOS `]() enumerator TVOS = 3 ##### [` WATCHOS `]() enumerator WATCHOS = 4 ##### [` BRIDGEOS `]() enumerator BRIDGEOS = 5 ##### [` MAC_CATALYST `]() enumerator MAC\_CATALYST = 6 ##### [` IOS_SIMULATOR `]() enumerator IOS\_SIMULATOR = 7 ##### [` TVOS_SIMULATOR `]() enumerator TVOS\_SIMULATOR = 8 ##### [` WATCHOS_SIMULATOR `]() enumerator WATCHOS\_SIMULATOR = 9 ##### [` DRIVERKIT `]() enumerator DRIVERKIT = 10 ##### [` VISIONOS `]() enumerator VISIONOS = 11 ##### [` VISIONOS_SIMULATOR `]() enumerator VISIONOS\_SIMULATOR = 12 ##### [` FIRMWARE `]() enumerator FIRMWARE = 13 ##### [` SEPOS `]() enumerator SEPOS = 14 ##### [` MACOS_EXCLAVE_CORE `]() enumerator MACOS\_EXCLAVE\_CORE = 15 ##### [` MACOS_EXCLAVE_KIT `]() enumerator MACOS\_EXCLAVE\_KIT = 16 ##### [` IOS_EXCLAVE_CORE `]() enumerator IOS\_EXCLAVE\_CORE = 17 ##### [` IOS_EXCLAVE_KIT `]() enumerator IOS\_EXCLAVE\_KIT = 18 ##### [` TVOS_EXCLAVE_CORE `]() enumerator TVOS\_EXCLAVE\_CORE = 19 ##### [` TVOS_EXCLAVE_KIT `]() enumerator TVOS\_EXCLAVE\_KIT = 20 ##### [` WATCHOS_EXCLAVE_CORE `]() enumerator WATCHOS\_EXCLAVE\_CORE = 21 ##### [` WATCHOS_EXCLAVE_KIT `]() enumerator WATCHOS\_EXCLAVE\_KIT = 22 ##### [` VISIONOS_EXCLAVE_CORE `]() enumerator VISIONOS\_EXCLAVE\_CORE = 23 ##### [` VISIONOS_EXCLAVE_KIT `]() enumerator VISIONOS\_EXCLAVE\_KIT = 24 ##### [` ANY `]() enumerator ANY = 0xFFFFFFFF #### [` version_t `]() using version\_t = std::array<uint32\_t, 3> Version is an array of **3** integers. #### [` tools_list_t `]() using tools\_list\_t = std::vector<[BuildToolVersion]( "LIEF::MachO::BuildToolVersion")> Public Functions #### [` BuildVersion `]() BuildVersion() = default #### [` BuildVersion `]() BuildVersion(const details::build\_version\_command &version\_cmd) #### [` BuildVersion `]() BuildVersion(const [PLATFORMS]( "LIEF::MachO::BuildVersion::PLATFORMS") platform, const [version\_t]( "LIEF::MachO::BuildVersion::version_t") &minos, const [version\_t]( "LIEF::MachO::BuildVersion::version_t") &sdk, const [tools\_list\_t]( "LIEF::MachO::BuildVersion::tools_list_t") &tools) #### [` operator= `]() [BuildVersion]( "LIEF::MachO::BuildVersion") &operator=(const [BuildVersion]( "LIEF::MachO::BuildVersion") &copy) = default #### [` BuildVersion `]() BuildVersion(const [BuildVersion]( "LIEF::MachO::BuildVersion::BuildVersion") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` minos `]() inline [version\_t]( "LIEF::MachO::BuildVersion::version_t") minos() const #### [` minos `]() inline void minos([version\_t]( "LIEF::MachO::BuildVersion::version_t") version) #### [` sdk `]() inline [version\_t]( "LIEF::MachO::BuildVersion::version_t") sdk() const #### [` sdk `]() inline void sdk([version\_t]( "LIEF::MachO::BuildVersion::version_t") version) #### [` platform `]() inline [PLATFORMS]( "LIEF::MachO::BuildVersion::PLATFORMS") platform() const #### [` platform `]() inline void platform([PLATFORMS]( "LIEF::MachO::BuildVersion::PLATFORMS") plat) #### [` tools `]() inline const [tools\_list\_t]( "LIEF::MachO::BuildVersion::tools_list_t") &tools() const #### [` ~BuildVersion `]() ~BuildVersion() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Build Tool Version]() ### [` BuildToolVersion `]() class BuildToolVersion : public LIEF::Object Class that represents a tool’s version that was involved in the build of the binary. Public Types #### [` TOOLS `]() enum class TOOLS *Values:* ##### [` UNKNOWN `]() enumerator UNKNOWN = 0 ##### [` CLANG `]() enumerator CLANG = 1 ##### [` SWIFT `]() enumerator SWIFT = 2 ##### [` LD `]() enumerator LD = 3 ##### [` LLD `]() enumerator LLD = 4 ##### [` METAL `]() enumerator METAL = 1024 ##### [` AIRLLD `]() enumerator AIRLLD = 1025 ##### [` AIRNT `]() enumerator AIRNT = 1026 ##### [` AIRNT_PLUGIN `]() enumerator AIRNT\_PLUGIN = 1027 ##### [` AIRPACK `]() enumerator AIRPACK = 1028 ##### [` GPUARCHIVER `]() enumerator GPUARCHIVER = 1031 ##### [` METAL_FRAMEWORK `]() enumerator METAL\_FRAMEWORK = 1032 #### [` version_t `]() using version\_t = std::array<uint32\_t, 3> A version is an array of **3** integers. Public Functions #### [` BuildToolVersion `]() BuildToolVersion() = default #### [` BuildToolVersion `]() BuildToolVersion(const details::build\_tool\_version &tool) #### [` tool `]() inline [TOOLS]( "LIEF::MachO::BuildToolVersion::TOOLS") tool() const The tools used. #### [` version `]() inline [version\_t]( "LIEF::MachO::BuildToolVersion::version_t") version() const Version associated with the tool. #### [` ~BuildToolVersion `]() ~BuildToolVersion() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override Friends #### [` operator<< `]() friend std::ostream &operator<<(std::ostream &os, const [BuildToolVersion]( "LIEF::MachO::BuildToolVersion") &tool) --- ## [Fileset Command]() ### [` FilesetCommand `]() class FilesetCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class associated with the LC\_FILESET\_ENTRY commands. Public Types #### [` content_t `]() using content\_t = std::vector<uint8\_t> Public Functions #### [` FilesetCommand `]() FilesetCommand() = default #### [` FilesetCommand `]() FilesetCommand(const details::fileset\_entry\_command &command) #### [` FilesetCommand `]() inline FilesetCommand(std::string name) #### [` operator= `]() [FilesetCommand]( "LIEF::MachO::FilesetCommand") &operator=([FilesetCommand]( "LIEF::MachO::FilesetCommand") copy) #### [` FilesetCommand `]() FilesetCommand(const [FilesetCommand]( "LIEF::MachO::FilesetCommand::FilesetCommand") &copy) #### [` swap `]() void swap([FilesetCommand]( "LIEF::MachO::FilesetCommand") &other) noexcept #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~FilesetCommand `]() ~FilesetCommand() override = default #### [` name `]() inline std::string\_view name() const Name of the underlying MachO binary (e.g. `com.apple.security.quarantine`). #### [` virtual_address `]() inline uint64\_t virtual\_address() const Memory address where the MachO file should be mapped. #### [` file_offset `]() inline uint64\_t file\_offset() const Original offset in the kernel cache. #### [` binary `]() inline const [Binary]( "LIEF::MachO::Binary") \*binary() const Return a pointer on the [LIEF::MachO::Binary]() associated with this entry. #### [` binary `]() inline [Binary]( "LIEF::MachO::Binary") \*binary() #### [` name `]() inline void name(std::string name) #### [` virtual_address `]() inline void virtual\_address(uint64\_t virtual\_address) #### [` file_offset `]() inline void file\_offset(uint64\_t file\_offset) #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) Friends **friend class BinaryParser** --- ## [DyldChainedFixups Command]() ### [` DyldChainedFixups `]() class DyldChainedFixups : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the LC\_DYLD\_CHAINED\_FIXUPS command. This command aims at providing rebase and binding information like the [DyldInfo]()’s bytecode. Compared to the [DyldInfo]() bytecode, these chained fixups are taking less space. Public Types #### [` chained_starts_in_segments_t `]() using chained\_starts\_in\_segments\_t = std::vector<[chained\_starts\_in\_segment]( "LIEF::MachO::DyldChainedFixups::chained_starts_in_segment")> Internal container for storing [chained\_starts\_in\_segment](). #### [` it_chained_starts_in_segments_t `]() using it\_chained\_starts\_in\_segments\_t = [ref\_iterator]( "LIEF::ref_iterator")<[chained\_starts\_in\_segments\_t]( "LIEF::MachO::DyldChainedFixups::chained_starts_in_segments_t")&> Iterator that outputs [chained\_starts\_in\_segment]()&. #### [` it_const_chained_starts_in_segments_t `]() using it\_const\_chained\_starts\_in\_segments\_t = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [chained\_starts\_in\_segments\_t]( "LIEF::MachO::DyldChainedFixups::chained_starts_in_segments_t")&> Iterator that outputs const [chained\_starts\_in\_segment]()&. #### [` binding_info_t `]() using binding\_info\_t = std::vector<std::unique\_ptr<[ChainedBindingInfo]( "LIEF::MachO::ChainedBindingInfo")>> Internal container for storing [DyldBindingInfo](). #### [` it_binding_info `]() using it\_binding\_info = [ref\_iterator]( "LIEF::ref_iterator")<[binding\_info\_t]( "LIEF::MachO::DyldChainedFixups::binding_info_t")&, [ChainedBindingInfo]( "LIEF::MachO::ChainedBindingInfo")\*> Iterator which outputs [DyldBindingInfo]()&. #### [` it_const_binding_info `]() using it\_const\_binding\_info = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [binding\_info\_t]( "LIEF::MachO::DyldChainedFixups::binding_info_t")&, [ChainedBindingInfo]( "LIEF::MachO::ChainedBindingInfo")\*> Iterator which outputs const [DyldBindingInfo]()&. Public Functions #### [` DyldChainedFixups `]() DyldChainedFixups() #### [` DyldChainedFixups `]() DyldChainedFixups(const details::linkedit\_data\_command &cmd) #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~DyldChainedFixups `]() ~DyldChainedFixups() override #### [` data_offset `]() inline uint32\_t data\_offset() const Offset of the LC\_DYLD\_CHAINED\_FIXUPS chained payload. This offset should point in the \_\_LINKEDIT segment. #### [` data_size `]() inline uint32\_t data\_size() const Size of the LC\_DYLD\_CHAINED\_FIXUPS payload. #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` payload `]() inline span<const uint8\_t> payload() const Return the raw content of the command. #### [` bindings `]() inline [it\_binding\_info]( "LIEF::MachO::DyldChainedFixups::it_binding_info") bindings() Iterator over the bindings ([ChainedBindingInfo]()) associated with this command. #### [` bindings `]() inline [it\_const\_binding\_info]( "LIEF::MachO::DyldChainedFixups::it_const_binding_info") bindings() const Iterator over the bindings ([ChainedBindingInfo]()) associated with this command. #### [` chained_starts_in_segments `]() inline [it\_chained\_starts\_in\_segments\_t]( "LIEF::MachO::DyldChainedFixups::it_chained_starts_in_segments_t") chained\_starts\_in\_segments() Iterator over the chained fixup metadata. #### [` chained_starts_in_segments `]() inline [it\_const\_chained\_starts\_in\_segments\_t]( "LIEF::MachO::DyldChainedFixups::it_const_chained_starts_in_segments_t") chained\_starts\_in\_segments() const #### [` fixups_version `]() inline uint32\_t fixups\_version() const Chained fixups version. The loader (dyld v852.2) checks that this value is set to 0. #### [` fixups_version `]() inline void fixups\_version(uint32\_t version) #### [` starts_offset `]() inline uint32\_t starts\_offset() const offset of dyld\_chained\_starts\_in\_image in chain\_data #### [` starts_offset `]() inline void starts\_offset(uint32\_t offset) #### [` imports_offset `]() inline uint32\_t imports\_offset() const Offset of imports table in chain data. #### [` imports_offset `]() inline void imports\_offset(uint32\_t offset) #### [` symbols_offset `]() inline uint32\_t symbols\_offset() const Offset of symbol strings in chain data. #### [` symbols_offset `]() inline void symbols\_offset(uint32\_t offset) #### [` imports_count `]() inline uint32\_t imports\_count() const Number of imported symbol names. #### [` imports_count `]() inline void imports\_count(uint32\_t cnt) #### [` symbols_format `]() inline uint32\_t symbols\_format() const The compression algorithm (if any) used to store the symbols 0 means uncompressed while 1 means zlib compressed. As far of the version v852.2 of dyld loader, it only supports **uncompressed** format #### [` symbols_format `]() inline void symbols\_format(uint32\_t fmt) #### [` imports_format `]() inline [DYLD\_CHAINED\_FORMAT]( "LIEF::MachO::DYLD_CHAINED_FORMAT") imports\_format() const The format of the imports ([ChainedBindingInfo]()). #### [` imports_format `]() inline void imports\_format([DYLD\_CHAINED\_FORMAT]( "LIEF::MachO::DYLD_CHAINED_FORMAT") fmt) #### [` add `]() inline [chained\_starts\_in\_segment]( "LIEF::MachO::DyldChainedFixups::chained_starts_in_segment") &add([chained\_starts\_in\_segment]( "LIEF::MachO::DyldChainedFixups::chained_starts_in_segment") start\_info) #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) #### [` chained_starts_in_segment `]() struct chained\_starts\_in\_segment Structure that mirrors the raw dyld\_chained\_starts\_in\_segment which aims at providing information about the chained rebase/bind fixups. The relocations provided by this structure can be accessed through [SegmentCommand::relocations]() Public Functions ##### [` page_count `]() inline size\_t page\_count() const How many pages are in the page\_start array. Public Members ##### [` offset `]() uint32\_t offset = 0 Original offset of the structure, relative to [DyldChainedFixups::starts\_offset](). ##### [` size `]() uint32\_t size = 0 sizeof(size) + sizeof(page\_size) + … + sizeof(pointer\_format) ##### [` page_size `]() uint16\_t page\_size = 0 Likely 0x1000 for x86/x86\_64 architectures and 0x4000 for ARM64 architecture. ##### [` segment_offset `]() uint64\_t segment\_offset = 0 Offset of the segment’s data from the beginning of the file (it should match [SegmentCommand::file\_offset]()). ##### [` max_valid_pointer `]() uint32\_t max\_valid\_pointer = 0 for 32-bit OS, any value beyond this is not a pointer ##### [` pointer_format `]() [DYLD\_CHAINED\_PTR\_FORMAT]( "LIEF::MachO::DYLD_CHAINED_PTR_FORMAT") pointer\_format = [DYLD\_CHAINED\_PTR\_FORMAT]( "LIEF::MachO::DYLD_CHAINED_PTR_FORMAT")::[NONE]( "LIEF::MachO::DYLD_CHAINED_PTR_FORMAT::NONE") How pointers are encoded. ##### [` page_start `]() std::vector<uint16\_t> page\_start Offset in the [SegmentCommand]() of the first element of the chain. ##### [` chain_starts `]() std::vector<uint16\_t> chain\_starts Currently not supported. ##### [` segment `]() [SegmentCommand]( "LIEF::MachO::SegmentCommand") &segment Segment in which the rebase/bind fixups take place. Public Static Functions ##### [` create_empty_chained `]() static inline [chained\_starts\_in\_segment]( "LIEF::MachO::DyldChainedFixups::chained_starts_in_segment") create\_empty\_chained([SegmentCommand]( "LIEF::MachO::SegmentCommand") &segment) Friends ##### [` operator<< `]() friend std::ostream &operator<<(std::ostream &os, const [chained\_starts\_in\_segment]( "LIEF::MachO::DyldChainedFixups::chained_starts_in_segment") &info) --- ## [DyldExportsTrie Command]() ### [` DyldExportsTrie `]() class DyldExportsTrie : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class that represents the LC\_DYLD\_EXPORTS\_TRIE command. In recent Mach-O binaries, this command replaces the [DyldInfo]() export trie buffer Public Types #### [` export_info_t `]() using export\_info\_t = std::vector<std::unique\_ptr<[ExportInfo]( "LIEF::MachO::ExportInfo")>> Internal container for storing [ExportInfo](). #### [` it_export_info `]() using it\_export\_info = [ref\_iterator]( "LIEF::ref_iterator")<[export\_info\_t]( "LIEF::MachO::DyldExportsTrie::export_info_t")&, [ExportInfo]( "LIEF::MachO::ExportInfo")\*> Iterator which outputs const [ExportInfo]()&. #### [` it_const_export_info `]() using it\_const\_export\_info = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [export\_info\_t]( "LIEF::MachO::DyldExportsTrie::export_info_t")&, [ExportInfo]( "LIEF::MachO::ExportInfo")\*> Iterator which outputs const [ExportInfo]()&. Public Functions #### [` DyldExportsTrie `]() DyldExportsTrie() #### [` DyldExportsTrie `]() DyldExportsTrie(const details::linkedit\_data\_command &cmd) #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` swap `]() void swap([DyldExportsTrie]( "LIEF::MachO::DyldExportsTrie") &other) noexcept #### [` ~DyldExportsTrie `]() ~DyldExportsTrie() override #### [` data_offset `]() inline uint32\_t data\_offset() const Offset of the LC\_DYLD\_EXPORTS\_TRIE. This offset should point in the \_\_LINKEDIT segment. #### [` data_size `]() inline uint32\_t data\_size() const Size of the LC\_DYLD\_EXPORTS\_TRIE payload. #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` content `]() inline span<const uint8\_t> content() const #### [` exports `]() inline [it\_export\_info]( "LIEF::MachO::DyldExportsTrie::it_export_info") exports() Iterator over the [ExportInfo]() entries. #### [` exports `]() inline [it\_const\_export\_info]( "LIEF::MachO::DyldExportsTrie::it_const_export_info") exports() const #### [` show_export_trie `]() std::string show\_export\_trie() const Print the exports trie in a human-readable way. #### [` add `]() [ExportInfo]( "LIEF::MachO::ExportInfo") \*add(std::unique\_ptr<[ExportInfo]( "LIEF::MachO::ExportInfo")> info) Add an entry in the current trie. See also: [LIEF::MachO::Binary::add\_exported\_function](). #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Code Signature Dir Command]() ### [` CodeSignatureDir `]() class CodeSignatureDir : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Public Functions #### [` CodeSignatureDir `]() CodeSignatureDir() = default #### [` CodeSignatureDir `]() CodeSignatureDir(const details::linkedit\_data\_command &cmd) #### [` operator= `]() [CodeSignatureDir]( "LIEF::MachO::CodeSignatureDir") &operator=(const [CodeSignatureDir]( "LIEF::MachO::CodeSignatureDir") &copy) = default #### [` CodeSignatureDir `]() CodeSignatureDir(const [CodeSignatureDir]( "LIEF::MachO::CodeSignatureDir::CodeSignatureDir") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` data_offset `]() inline uint32\_t data\_offset() const Offset in the binary where the signature starts. #### [` data_size `]() inline uint32\_t data\_size() const Size of the raw signature. #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` content `]() inline span<const uint8\_t> content() const #### [` content `]() inline span<uint8\_t> content() #### [` ~CodeSignatureDir `]() ~CodeSignatureDir() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Linker Optimization Hint Command]() ### [` LinkerOptHint `]() class LinkerOptHint : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class which represents the `LC_LINKER_OPTIMIZATION_HINT` command. Public Functions #### [` LinkerOptHint `]() LinkerOptHint() = default #### [` LinkerOptHint `]() LinkerOptHint(const details::linkedit\_data\_command &cmd) #### [` operator= `]() [LinkerOptHint]( "LIEF::MachO::LinkerOptHint") &operator=(const [LinkerOptHint]( "LIEF::MachO::LinkerOptHint") &copy) = default #### [` LinkerOptHint `]() LinkerOptHint(const [LinkerOptHint]( "LIEF::MachO::LinkerOptHint::LinkerOptHint") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` data_offset `]() inline uint32\_t data\_offset() const Offset in the binary where the *hint* starts. #### [` data_size `]() inline uint32\_t data\_size() const Size of the payload. #### [` data_offset `]() inline void data\_offset(uint32\_t offset) #### [` data_size `]() inline void data\_size(uint32\_t size) #### [` content `]() inline span<const uint8\_t> content() const #### [` content `]() inline span<uint8\_t> content() #### [` ~LinkerOptHint `]() ~LinkerOptHint() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Two Level Hints Command]() ### [` TwoLevelHints `]() class TwoLevelHints : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Class which represents the `LC_TWOLEVEL_HINTS` command. Public Types #### [` hints_list_t `]() using hints\_list\_t = std::vector<uint32\_t> #### [` it_hints_t `]() using it\_hints\_t = [ref\_iterator]( "LIEF::ref_iterator")<[hints\_list\_t]( "LIEF::MachO::TwoLevelHints::hints_list_t")&> #### [` it_const_hints_t `]() using it\_const\_hints\_t = [const\_ref\_iterator]( "LIEF::const_ref_iterator")<const [hints\_list\_t]( "LIEF::MachO::TwoLevelHints::hints_list_t")&> Public Functions #### [` TwoLevelHints `]() TwoLevelHints() = default #### [` TwoLevelHints `]() TwoLevelHints(const details::twolevel\_hints\_command &cmd) #### [` operator= `]() [TwoLevelHints]( "LIEF::MachO::TwoLevelHints") &operator=(const [TwoLevelHints]( "LIEF::MachO::TwoLevelHints") &copy) = default #### [` TwoLevelHints `]() TwoLevelHints(const [TwoLevelHints]( "LIEF::MachO::TwoLevelHints::TwoLevelHints") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` content `]() inline span<const uint8\_t> content() const Original payload of the command. #### [` content `]() inline span<uint8\_t> content() #### [` hints `]() inline [it\_hints\_t]( "LIEF::MachO::TwoLevelHints::it_hints_t") hints() Iterator over the hints (`uint32_t` integers). #### [` hints `]() inline [it\_const\_hints\_t]( "LIEF::MachO::TwoLevelHints::it_const_hints_t") hints() const #### [` offset `]() inline uint32\_t offset() const Original offset of the command. It should point in the `__LINKEDIT` segment. #### [` offset `]() inline void offset(uint32\_t offset) #### [` original_nb_hints `]() inline uint32\_t original\_nb\_hints() const #### [` ~TwoLevelHints `]() ~TwoLevelHints() override = default #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Unknown Command]() ### [` UnknownCommand `]() class UnknownCommand : public LIEF::MachO::[LoadCommand]( "LIEF::MachO::LoadCommand") Generic class when the command is not recognized by LIEF. Public Functions #### [` UnknownCommand `]() UnknownCommand() = delete #### [` UnknownCommand `]() inline UnknownCommand(const details::load\_command &command) #### [` operator= `]() [UnknownCommand]( "LIEF::MachO::UnknownCommand") &operator=(const [UnknownCommand]( "LIEF::MachO::UnknownCommand") &copy) = default #### [` UnknownCommand `]() UnknownCommand(const [UnknownCommand]( "LIEF::MachO::UnknownCommand::UnknownCommand") &copy) = default #### [` clone `]() inline virtual std::unique\_ptr<[LoadCommand]( "LIEF::MachO::LoadCommand")> clone() const override #### [` ~UnknownCommand `]() ~UnknownCommand() override = default #### [` original_command `]() inline uint64\_t original\_command() const The original `LC_` int that is not supported by LIEF. #### [` accept `]() virtual void accept(Visitor &visitor) const override #### [` print `]() virtual std::ostream &print(std::ostream &os) const override Public Static Functions #### [` classof `]() static inline bool classof(const [LoadCommand]( "LIEF::MachO::LoadCommand") \*cmd) --- ## [Stub]() ### [` Stub `]() class Stub This class represents a stub entry in sections like `__stubs,__auth_stubs`. It wraps assembly instructions which are used to access the *got* where the address of the symbol is resolved. Example: ```text 0000000236a3c1bc: ___memcpy_chk adrp x17, #0x241513aa8 add x17, x17, #0x241513aa8 ldr x16, [x17] braa x16, x17 ``` Public Functions #### [` Stub `]() Stub() = delete #### [` Stub `]() Stub(const [Stub]( "LIEF::MachO::Stub::Stub")&) = default #### [` operator= `]() [Stub]( "LIEF::MachO::Stub") &operator=(const [Stub]( "LIEF::MachO::Stub")&) = default #### [` Stub `]() Stub([Stub]( "LIEF::MachO::Stub::Stub")&&) noexcept = default #### [` operator= `]() [Stub]( "LIEF::MachO::Stub") &operator=([Stub]( "LIEF::MachO::Stub")&&) noexcept = default #### [` ~Stub `]() ~Stub() = default #### [` Stub `]() inline Stub([target\_info\_t]( "LIEF::MachO::Stub::target_info_t") target\_info, uint64\_t addr, std::vector<uint8\_t> raw) #### [` raw `]() inline span<const uint8\_t> raw() const The (raw) instructions of this entry as a slice of bytes. #### [` address `]() inline uint64\_t address() const The virtual address where the stub is located. #### [` target `]() [result]( "LIEF::result")<uint64\_t> target() const The address resolved by this stub. For instance, given this stub: ```text 0x3eec: adrp x16, #4096 0x3ef0: ldr x16, [x16, #24] 0x3ef4: br x16 ``` The function returns: `0x4018`. > **Warning** > > This function is only available with LIEF’s extended version Friends #### [` operator<< `]() friend std::ostream &operator<<(std::ostream &os, const [Stub]( "LIEF::MachO::Stub") &stub) #### [` target_info_t `]() struct target\_info\_t Public Members ##### [` arch `]() [Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE") arch = [Header]( "LIEF::MachO::Header")::[CPU\_TYPE]( "LIEF::MachO::Header::CPU_TYPE")::[ANY]( "LIEF::MachO::Header::CPU_TYPE::ANY") ##### [` subtype `]() uint32\_t subtype = 0 Friends ##### [` operator== `]() inline friend bool operator==([Stub]( "LIEF::MachO::Stub")::[target\_info\_t]( "LIEF::MachO::Stub::target_info_t") lhs, [Stub]( "LIEF::MachO::Stub")::[target\_info\_t]( "LIEF::MachO::Stub::target_info_t") rhs) #### [` Iterator `]() class Iterator : public LIEF::iterator\_facade\_base<[Iterator]( "LIEF::MachO::Stub::Iterator"), std::random\_access\_iterator\_tag, const [Stub]( "LIEF::MachO::Stub")> Public Functions ##### [` Iterator `]() Iterator() = default ##### [` Iterator `]() inline Iterator([target\_info\_t]( "LIEF::MachO::Stub::target_info_t") target\_info, std::vector<const [Section]( "LIEF::MachO::Section")\*> sections, size\_t pos) ##### [` Iterator `]() Iterator(const [Iterator]( "LIEF::MachO::Stub::Iterator::Iterator")&) = default ##### [` operator= `]() [Iterator]( "LIEF::MachO::Stub::Iterator") &operator=(const [Iterator]( "LIEF::MachO::Stub::Iterator")&) = default ##### [` Iterator `]() Iterator([Iterator]( "LIEF::MachO::Stub::Iterator::Iterator")&&) noexcept = default ##### [` operator= `]() [Iterator]( "LIEF::MachO::Stub::Iterator") &operator=([Iterator]( "LIEF::MachO::Stub::Iterator")&&) noexcept = default ##### [` ~Iterator `]() ~Iterator() = default ##### [` operator< `]() inline bool operator<(const [Iterator]( "LIEF::MachO::Stub::Iterator") &rhs) const ##### [` operator- `]() inline std::ptrdiff\_t operator-(const [Iterator]( "LIEF::MachO::Stub::Iterator") &R) const ##### [` operator+= `]() inline [Iterator]( "LIEF::MachO::Stub::Iterator") &operator+=(std::ptrdiff\_t n) ##### [` operator-= `]() inline [Iterator]( "LIEF::MachO::Stub::Iterator") &operator-=(std::ptrdiff\_t n) ##### [` operator* `]() [Stub]( "LIEF::MachO::Stub") operator\*() const Friends ##### [` operator== `]() inline friend bool operator==(const [Iterator]( "LIEF::MachO::Stub::Iterator") &LHS, const [Iterator]( "LIEF::MachO::Stub::Iterator") &RHS) ##### [` operator!= `]() inline friend bool operator!=(const [Iterator]( "LIEF::MachO::Stub::Iterator") &LHS, const [Iterator]( "LIEF::MachO::Stub::Iterator") &RHS) --- ## [Utilities]() ### [` LIEF::MachO::check_layout `]() bool LIEF::MachO::check\_layout(const [Binary]( "LIEF::MachO::Binary") &binary, std::string \*error = nullptr) Check the layout of the given Mach-O binary. It checks if it can be signed according to cctools-921/libstuff/checkout.c. ### [` LIEF::MachO::check_layout `]() bool LIEF::MachO::check\_layout(const [FatBinary]( "LIEF::MachO::FatBinary") &binary, std::string \*error = nullptr) Check the layout of the given FAT Mach-O by checking individually the layout of the binaries embedded in the FAT. ### [` LIEF::MachO::is_macho `]() bool LIEF::MachO::is\_macho(std::string\_view file) Check if the given file is a Mach-O binary. ### [` LIEF::MachO::is_macho `]() bool LIEF::MachO::is\_macho(const std::vector<uint8\_t> &raw) Check if the given raw data is a Mach-O binary. ### [` LIEF::MachO::is_fat `]() bool LIEF::MachO::is\_fat(std::string\_view file) Check if the given file is a FAT Mach-O. ### [` LIEF::MachO::is_64 `]() bool LIEF::MachO::is\_64(std::string\_view file) Check if the given Mach-O is 64-bits. --- ## [Enums]() ### [` LIEF::MachO::MACHO_TYPES `]() enum class LIEF::MachO::MACHO\_TYPES : uint32\_t *Values:* #### [` UNKNOWN `]() enumerator UNKNOWN = 0 #### [` MAGIC `]() enumerator MAGIC = 0xFEEDFACEu 32-bit big-endian magic #### [` CIGAM `]() enumerator CIGAM = 0xCEFAEDFEu 32-bit little-endian magic #### [` MAGIC_64 `]() enumerator MAGIC\_64 = 0xFEEDFACFu 64-bit big-endian magic #### [` CIGAM_64 `]() enumerator CIGAM\_64 = 0xCFFAEDFEu 64-bit little-endian magic #### [` MAGIC_FAT `]() enumerator MAGIC\_FAT = 0xCAFEBABEu big-endian fat magic #### [` CIGAM_FAT `]() enumerator CIGAM\_FAT = 0xBEBAFECAu little-endian fat magic #### [` NEURAL_MODEL `]() enumerator NEURAL\_MODEL = 0xbeeffaceu ### [` LIEF::MachO::X86_RELOCATION `]() enum class LIEF::MachO::X86\_RELOCATION *Values:* #### [` GENERIC_RELOC_VANILLA `]() enumerator GENERIC\_RELOC\_VANILLA = 0 A generic relocation entry for both addresses contained in data and addresses contained in CPU instructions. #### [` GENERIC_RELOC_PAIR `]() enumerator GENERIC\_RELOC\_PAIR = 1 The second relocation entry of a pair. #### [` GENERIC_RELOC_SECTDIFF `]() enumerator GENERIC\_RELOC\_SECTDIFF = 2 A relocation entry for an item that contains the difference of two section addresses. This is generally used for position-independent code generation. #### [` GENERIC_RELOC_PB_LA_PTR `]() enumerator GENERIC\_RELOC\_PB\_LA\_PTR = 3 contains the address from which to subtract; it must be followed by a [X86\_RELOCATION::GENERIC\_RELOC\_PAIR]() containing the address to subtract. #### [` GENERIC_RELOC_LOCAL_SECTDIFF `]() enumerator GENERIC\_RELOC\_LOCAL\_SECTDIFF = 4 Similar to [X86\_RELOCATION::GENERIC\_RELOC\_SECTDIFF]() except that this entry refers specifically to the address in this item. If the address is that of a globally visible coalesced symbol, this relocation entry does not change if the symbol is overridden. This is used to associate stack unwinding information with the object code this relocation entry describes. #### [` GENERIC_RELOC_TLV `]() enumerator GENERIC\_RELOC\_TLV = 5 A relocation entry for a prebound lazy pointer. This is always a scattered relocation entry. The MachO::Relocation::value field contains the non-prebound value of the lazy pointer. ### [` LIEF::MachO::X86_64_RELOCATION `]() enum class LIEF::MachO::X86\_64\_RELOCATION *Values:* #### [` X86_64_RELOC_UNSIGNED `]() enumerator X86\_64\_RELOC\_UNSIGNED = 0 A CALL/JMP instruction with 32-bit displacement. #### [` X86_64_RELOC_SIGNED `]() enumerator X86\_64\_RELOC\_SIGNED = 1 A MOVQ load of a GOT entry. #### [` X86_64_RELOC_BRANCH `]() enumerator X86\_64\_RELOC\_BRANCH = 2 Other GOT references. #### [` X86_64_RELOC_GOT_LOAD `]() enumerator X86\_64\_RELOC\_GOT\_LOAD = 3 Signed 32-bit displacement. #### [` X86_64_RELOC_GOT `]() enumerator X86\_64\_RELOC\_GOT = 4 Absolute address. #### [` X86_64_RELOC_SUBTRACTOR `]() enumerator X86\_64\_RELOC\_SUBTRACTOR = 5 Must be followed by a [X86\_64\_RELOCATION::X86\_64\_RELOC\_UNSIGNED]() relocation. #### [` X86_64_RELOC_SIGNED_1 `]() enumerator X86\_64\_RELOC\_SIGNED\_1 = 6 #### [` X86_64_RELOC_SIGNED_2 `]() enumerator X86\_64\_RELOC\_SIGNED\_2 = 7 #### [` X86_64_RELOC_SIGNED_4 `]() enumerator X86\_64\_RELOC\_SIGNED\_4 = 8 #### [` X86_64_RELOC_TLV `]() enumerator X86\_64\_RELOC\_TLV = 9 ### [` LIEF::MachO::PPC_RELOCATION `]() enum class LIEF::MachO::PPC\_RELOCATION *Values:* #### [` PPC_RELOC_VANILLA `]() enumerator PPC\_RELOC\_VANILLA = 0 #### [` PPC_RELOC_PAIR `]() enumerator PPC\_RELOC\_PAIR = 1 #### [` PPC_RELOC_BR14 `]() enumerator PPC\_RELOC\_BR14 = 2 #### [` PPC_RELOC_BR24 `]() enumerator PPC\_RELOC\_BR24 = 3 #### [` PPC_RELOC_HI16 `]() enumerator PPC\_RELOC\_HI16 = 4 #### [` PPC_RELOC_LO16 `]() enumerator PPC\_RELOC\_LO16 = 5 #### [` PPC_RELOC_HA16 `]() enumerator PPC\_RELOC\_HA16 = 6 #### [` PPC_RELOC_LO14 `]() enumerator PPC\_RELOC\_LO14 = 7 #### [` PPC_RELOC_SECTDIFF `]() enumerator PPC\_RELOC\_SECTDIFF = 8 #### [` PPC_RELOC_PB_LA_PTR `]() enumerator PPC\_RELOC\_PB\_LA\_PTR = 9 #### [` PPC_RELOC_HI16_SECTDIFF `]() enumerator PPC\_RELOC\_HI16\_SECTDIFF = 10 #### [` PPC_RELOC_LO16_SECTDIFF `]() enumerator PPC\_RELOC\_LO16\_SECTDIFF = 11 #### [` PPC_RELOC_HA16_SECTDIFF `]() enumerator PPC\_RELOC\_HA16\_SECTDIFF = 12 #### [` PPC_RELOC_JBSR `]() enumerator PPC\_RELOC\_JBSR = 13 #### [` PPC_RELOC_LO14_SECTDIFF `]() enumerator PPC\_RELOC\_LO14\_SECTDIFF = 14 #### [` PPC_RELOC_LOCAL_SECTDIFF `]() enumerator PPC\_RELOC\_LOCAL\_SECTDIFF = 15 ### [` LIEF::MachO::ARM_RELOCATION `]() enum class LIEF::MachO::ARM\_RELOCATION *Values:* #### [` ARM_RELOC_VANILLA `]() enumerator ARM\_RELOC\_VANILLA = 0 #### [` ARM_RELOC_PAIR `]() enumerator ARM\_RELOC\_PAIR = 1 #### [` ARM_RELOC_SECTDIFF `]() enumerator ARM\_RELOC\_SECTDIFF = 2 #### [` ARM_RELOC_LOCAL_SECTDIFF `]() enumerator ARM\_RELOC\_LOCAL\_SECTDIFF = 3 #### [` ARM_RELOC_PB_LA_PTR `]() enumerator ARM\_RELOC\_PB\_LA\_PTR = 4 #### [` ARM_RELOC_BR24 `]() enumerator ARM\_RELOC\_BR24 = 5 #### [` ARM_THUMB_RELOC_BR22 `]() enumerator ARM\_THUMB\_RELOC\_BR22 = 6 #### [` ARM_THUMB_32BIT_BRANCH `]() enumerator ARM\_THUMB\_32BIT\_BRANCH = 7 #### [` ARM_RELOC_HALF `]() enumerator ARM\_RELOC\_HALF = 8 #### [` ARM_RELOC_HALF_SECTDIFF `]() enumerator ARM\_RELOC\_HALF\_SECTDIFF = 9 ### [` LIEF::MachO::ARM64_RELOCATION `]() enum class LIEF::MachO::ARM64\_RELOCATION *Values:* #### [` ARM64_RELOC_UNSIGNED `]() enumerator ARM64\_RELOC\_UNSIGNED = 0 For pointers. #### [` ARM64_RELOC_SUBTRACTOR `]() enumerator ARM64\_RELOC\_SUBTRACTOR = 1 Must be followed by an [ARM64\_RELOCATION::ARM64\_RELOC\_UNSIGNED](). #### [` ARM64_RELOC_BRANCH26 `]() enumerator ARM64\_RELOC\_BRANCH26 = 2 A B/BL instruction with 26-bit displacement. #### [` ARM64_RELOC_PAGE21 `]() enumerator ARM64\_RELOC\_PAGE21 = 3 PC-rel distance to page of target. #### [` ARM64_RELOC_PAGEOFF12 `]() enumerator ARM64\_RELOC\_PAGEOFF12 = 4 Offset within page, scaled by [MachO::Relocation::size](). #### [` ARM64_RELOC_GOT_LOAD_PAGE21 `]() enumerator ARM64\_RELOC\_GOT\_LOAD\_PAGE21 = 5 PC-rel distance to page of GOT slot. #### [` ARM64_RELOC_GOT_LOAD_PAGEOFF12 `]() enumerator ARM64\_RELOC\_GOT\_LOAD\_PAGEOFF12 = 6 Offset within page of GOT slot, scaled by [MachO::Relocation::size](). #### [` ARM64_RELOC_POINTER_TO_GOT `]() enumerator ARM64\_RELOC\_POINTER\_TO\_GOT = 7 For pointers to GOT slots. #### [` ARM64_RELOC_TLVP_LOAD_PAGE21 `]() enumerator ARM64\_RELOC\_TLVP\_LOAD\_PAGE21 = 8 PC-rel distance to page of TLVP slot. #### [` ARM64_RELOC_TLVP_LOAD_PAGEOFF12 `]() enumerator ARM64\_RELOC\_TLVP\_LOAD\_PAGEOFF12 = 9 Offset within page of TLVP slot, scaled by [MachO::Relocation::size](). #### [` ARM64_RELOC_ADDEND `]() enumerator ARM64\_RELOC\_ADDEND = 10 Must be followed by [ARM64\_RELOCATION::ARM64\_RELOC\_PAGE21]() or [ARM64\_RELOCATION::ARM64\_RELOC\_PAGEOFF12](). ### [` LIEF::MachO::DYLD_CHAINED_FORMAT `]() enum class LIEF::MachO::DYLD\_CHAINED\_FORMAT *Values:* #### [` IMPORT `]() enumerator IMPORT = 1 Originally: DYLD\_CHAINED\_IMPORT. #### [` IMPORT_ADDEND `]() enumerator IMPORT\_ADDEND = 2 Originally: DYLD\_CHAINED\_IMPORT\_ADDEND. #### [` IMPORT_ADDEND64 `]() enumerator IMPORT\_ADDEND64 = 3 Originally: DYLD\_CHAINED\_IMPORT\_ADDEND64. ### [` LIEF::MachO::DYLD_CHAINED_PTR_FORMAT `]() enum class LIEF::MachO::DYLD\_CHAINED\_PTR\_FORMAT *Values:* #### [` NONE `]() enumerator NONE = 0 #### [` PTR_ARM64E `]() enumerator PTR\_ARM64E = 1 #### [` PTR_64 `]() enumerator PTR\_64 = 2 #### [` PTR_32 `]() enumerator PTR\_32 = 3 #### [` PTR_32_CACHE `]() enumerator PTR\_32\_CACHE = 4 #### [` PTR_32_FIRMWARE `]() enumerator PTR\_32\_FIRMWARE = 5 #### [` PTR_64_OFFSET `]() enumerator PTR\_64\_OFFSET = 6 #### [` PTR_ARM64E_OFFSET `]() enumerator PTR\_ARM64E\_OFFSET = 7 #### [` PTR_ARM64E_KERNEL `]() enumerator PTR\_ARM64E\_KERNEL = 7 #### [` PTR_64_KERNEL_CACHE `]() enumerator PTR\_64\_KERNEL\_CACHE = 8 #### [` PTR_ARM64E_USERLAND `]() enumerator PTR\_ARM64E\_USERLAND = 9 #### [` PTR_ARM64E_FIRMWARE `]() enumerator PTR\_ARM64E\_FIRMWARE = 10 #### [` PTR_X86_64_KERNEL_CACHE `]() enumerator PTR\_X86\_64\_KERNEL\_CACHE = 11 #### [` PTR_ARM64E_USERLAND24 `]() enumerator PTR\_ARM64E\_USERLAND24 = 12 #### [` PTR_ARM64E_SHARED_CACHE `]() enumerator PTR\_ARM64E\_SHARED\_CACHE = 13 #### [` PTR_ARM64E_SEGMENTED `]() enumerator PTR\_ARM64E\_SEGMENTED = 14