Fix #define conflicts

romainthomas · romainthomas · commit 9260bae262e2 · 2025-06-07T11:50:27.000+02:00
diff --git a/api/python/lief/MachO/__init__.pyi b/api/python/lief/MachO/__init__.pyi
@@ -1532,9 +1532,9 @@ class Section(lief.Section):
 
         CSTRING_LITERALS = 2
 
-        S_4BYTE_LITERALS = 3
+        IS_4BYTE_LITERALS = 3
 
-        S_8BYTE_LITERALS = 4
+        IS_8BYTE_LITERALS = 4
 
         LITERAL_POINTERS = 5
 
@@ -1554,7 +1554,7 @@ class Section(lief.Section):
 
         INTERPOSING = 13
 
-        S_16BYTE_LITERALS = 14
+        IS_16BYTE_LITERALS = 14
 
         DTRACE_DOF = 15
 
@@ -2085,7 +2085,7 @@ class Symbol(lief.Symbol):
 
         DYLD_BIND = 2
 
-        LC_SYMTAB = 3
+        SYMTAB = 3
 
     class TYPE(enum.Enum):
         @staticmethod
diff --git a/api/python/src/MachO/objects/pySection.cpp b/api/python/src/MachO/objects/pySection.cpp
@@ -51,8 +51,8 @@ void create<Section>(nb::module_& m) {
     .value(PY_ENUM(Section::TYPE::REGULAR))
     .value(PY_ENUM(Section::TYPE::ZEROFILL))
     .value(PY_ENUM(Section::TYPE::CSTRING_LITERALS))
-    .value(PY_ENUM(Section::TYPE::S_4BYTE_LITERALS))
-    .value(PY_ENUM(Section::TYPE::S_8BYTE_LITERALS))
+    .value(PY_ENUM(Section::TYPE::IS_4BYTE_LITERALS))
+    .value(PY_ENUM(Section::TYPE::IS_8BYTE_LITERALS))
     .value(PY_ENUM(Section::TYPE::LITERAL_POINTERS))
     .value(PY_ENUM(Section::TYPE::NON_LAZY_SYMBOL_POINTERS))
     .value(PY_ENUM(Section::TYPE::LAZY_SYMBOL_POINTERS))
@@ -62,7 +62,7 @@ void create<Section>(nb::module_& m) {
     .value(PY_ENUM(Section::TYPE::COALESCED))
     .value(PY_ENUM(Section::TYPE::GB_ZEROFILL))
     .value(PY_ENUM(Section::TYPE::INTERPOSING))
-    .value(PY_ENUM(Section::TYPE::S_16BYTE_LITERALS))
+    .value(PY_ENUM(Section::TYPE::IS_16BYTE_LITERALS))
     .value(PY_ENUM(Section::TYPE::DTRACE_DOF))
     .value(PY_ENUM(Section::TYPE::LAZY_DYLIB_SYMBOL_POINTERS))
     .value(PY_ENUM(Section::TYPE::THREAD_LOCAL_REGULAR))
diff --git a/api/python/src/MachO/objects/pySymbol.cpp b/api/python/src/MachO/objects/pySymbol.cpp
@@ -57,7 +57,7 @@ void create<Symbol>(nb::module_& m) {
     .value("UNKNOWN",        Symbol::ORIGIN::UNKNOWN)
     .value("DYLD_EXPORT",    Symbol::ORIGIN::DYLD_EXPORT)
     .value("DYLD_BIND",      Symbol::ORIGIN::DYLD_BIND)
-    .value("LC_SYMTAB",      Symbol::ORIGIN::LC_SYMTAB)
+    .value("SYMTAB",         Symbol::ORIGIN::SYMTAB)
   ;
 
   enum_<Symbol::TYPE>(symbol, "TYPE")
diff --git a/doc/sphinx/changelog.rst b/doc/sphinx/changelog.rst
@@ -63,6 +63,18 @@
             - lief.MachO.FAT_CIGAM
             + lief.MachO.CIGAM_FAT
 
+            - lief.MachO.Symbol.ORIGIN.LC_SYMTAB
+            + lief.MachO.Symbol.ORIGIN.SYMTAB
+
+            - lief.MachO.Section.TYPE.S_4BYTE_LITERALS
+            + lief.MachO.Section.TYPE.IS_4BYTE_LITERALS
+
+            - lief.MachO.Section.TYPE.S_8BYTE_LITERALS
+            + lief.MachO.Section.TYPE.IS_8BYTE_LITERALS
+
+            - lief.MachO.Section.TYPE.S_16BYTE_LITERALS
+            + lief.MachO.Section.TYPE.IS_16BYTE_LITERALS
+
 
        .. tab:: :fa:`regular fa-file-code` C++
 
@@ -82,6 +94,18 @@
             + MACHO_TYPES::MAGIC_FAT
             + MACHO_TYPES::CIGAM_FAT
 
+            - Section::TYPE::S_16BYTE_LITERALS
+            + Section::TYPE::IS_16BYTE_LITERALS
+
+            - Section::TYPE::S_4BYTE_LITERALS
+            + Section::TYPE::IS_4BYTE_LITERALS
+
+            - Section::TYPE::S_8BYTE_LITERALS
+            + Section::TYPE::IS_8BYTE_LITERALS
+
+            - Symbol::ORIGIN::LC_SYMTAB
+            + Symbol::ORIGIN::SYMTAB
+
 :ELF:
 
   * LIEF inserted sections are not compatible with a ``strip`` after the
diff --git a/include/LIEF/MachO/Binary.hpp b/include/LIEF/MachO/Binary.hpp
@@ -952,7 +952,7 @@ class LIEF_API Binary : public LIEF::Binary  {
   /// Check if the binary is supporting ARM64 pointer authentication (arm64e)
   bool support_arm64_ptr_auth() const {
     return header().cpu_type() == Header::CPU_TYPE::ARM64 &&
-           (header().cpu_subtype() & ~Header::CPU_SUBTYPE_MASK) == Header::CPU_SUBTYPE_ARM64_ARM64E;
+           (header().cpu_subtype() & ~Header::SUBTYPE_MASK) == Header::CPU_SUBTYPE_ARM64_ARM64E;
   }
 
   /// Return an iterator over the binding info which can come from either
diff --git a/include/LIEF/MachO/Header.hpp b/include/LIEF/MachO/Header.hpp
@@ -108,8 +108,8 @@ class LIEF_API Header : public Object {
     POWERPC64 = 18 | ABI64,
   };
 
-  static constexpr uint32_t CPU_SUBTYPE_MASK = 0xff000000;
-  static constexpr uint32_t CPU_SUBTYPE_LIB64 = 0x80000000;
+  static constexpr uint32_t SUBTYPE_MASK = 0xff000000;
+  static constexpr uint32_t SUBTYPE_LIB64 = 0x80000000;
 
   static constexpr auto CPU_SUBTYPE_ARM64_ARM64E = 2;
 
diff --git a/include/LIEF/MachO/Section.hpp b/include/LIEF/MachO/Section.hpp
@@ -68,8 +68,8 @@ class LIEF_API Section : public LIEF::Section {
     REGULAR                             = 0x00u, ///< Regular section.
     ZEROFILL                            = 0x01u, ///< Zero fill on demand section.
     CSTRING_LITERALS                    = 0x02u, ///< Section with literal C strings.
-    S_4BYTE_LITERALS                    = 0x03u, ///< Section with 4 byte literals.
-    S_8BYTE_LITERALS                    = 0x04u, ///< Section with 8 byte literals.
+    IS_4BYTE_LITERALS                    = 0x03u, ///< Section with 4 byte literals.
+    IS_8BYTE_LITERALS                    = 0x04u, ///< Section with 8 byte literals.
     LITERAL_POINTERS                    = 0x05u, ///< Section with pointers to literals.
     NON_LAZY_SYMBOL_POINTERS            = 0x06u, ///< Section with non-lazy symbol pointers.
     LAZY_SYMBOL_POINTERS                = 0x07u, ///< Section with lazy symbol pointers.
@@ -79,7 +79,7 @@ class LIEF_API Section : public LIEF::Section {
     COALESCED                           = 0x0bu, ///< Section contains symbols that are to be coalesced.
     GB_ZEROFILL                         = 0x0cu, ///< Zero fill on demand section (that can be larger than 4 gigabytes).
     INTERPOSING                         = 0x0du, ///< Section with only pairs of function pointers for interposing.
-    S_16BYTE_LITERALS                   = 0x0eu, ///< Section with only 16 byte literals.
+    IS_16BYTE_LITERALS                   = 0x0eu, ///< Section with only 16 byte literals.
     DTRACE_DOF                          = 0x0fu, ///< Section contains DTrace Object Format.
     LAZY_DYLIB_SYMBOL_POINTERS          = 0x10u, ///< Section with lazy symbol pointers to lazy loaded dylibs.
     THREAD_LOCAL_REGULAR                = 0x11u, ///< Thread local data section.
diff --git a/include/LIEF/MachO/Symbol.hpp b/include/LIEF/MachO/Symbol.hpp
@@ -71,7 +71,7 @@ class LIEF_API Symbol : public LIEF::Symbol {
     UNKNOWN     = 0,
     DYLD_EXPORT = 1,
     DYLD_BIND   = 2, /// The symbol comes from the binding opcodes
-    LC_SYMTAB   = 3,
+    SYMTAB      = 3, /// The symbol comes from the LC_SYMTAB command
   };
 
   enum class TYPE : uint32_t{
@@ -94,7 +94,7 @@ class LIEF_API Symbol : public LIEF::Symbol {
     type_{n_type},
     numberof_sections_{n_sect},
     description_{n_desc},
-    origin_{ORIGIN::LC_SYMTAB}
+    origin_{ORIGIN::SYMTAB}
   {
     value_ = value;
   }
diff --git a/src/MachO/Binary.cpp b/src/MachO/Binary.cpp
@@ -2385,7 +2385,7 @@ Symbol* Binary::add_local_symbol(uint64_t address, const std::string& name) {
 
   auto sym = std::make_unique<Symbol>();
   sym->category_          = Symbol::CATEGORY::LOCAL;
-  sym->origin_            = Symbol::ORIGIN::LC_SYMTAB;
+  sym->origin_            = Symbol::ORIGIN::SYMTAB;
   sym->numberof_sections_ = 0;
   sym->description_       = static_cast<uint16_t>(/* N_NO_DEAD_STRIP */0x20);
 
diff --git a/src/MachO/BinaryParser.tcc b/src/MachO/BinaryParser.tcc
@@ -3569,7 +3569,7 @@ ok_error_t BinaryParser::post_process(DynamicSymbolCommand& cmd) {
   symtab.reserve(binary_->symbols_.size());
   size_t isym = 0;
   for (const std::unique_ptr<Symbol>& sym : binary_->symbols_) {
-    if (sym->origin() != Symbol::ORIGIN::LC_SYMTAB) {
+    if (sym->origin() != Symbol::ORIGIN::SYMTAB) {
       continue;
     }
 
diff --git a/src/MachO/Builder.tcc b/src/MachO/Builder.tcc
@@ -687,7 +687,7 @@ ok_error_t Builder::build(SymbolCommand& symbol_command) {
 
   /* 1. Fille the n_list table */ {
     for (Symbol& s : binary_->symbols()) {
-      if (s.origin() != Symbol::ORIGIN::LC_SYMTAB) {
+      if (s.origin() != Symbol::ORIGIN::SYMTAB) {
         continue;
       }
       all_syms.push_back(&s);
diff --git a/src/MachO/Section.cpp b/src/MachO/Section.cpp
@@ -283,8 +283,8 @@ const char* to_string(Section::TYPE e) {
     ENTRY(REGULAR),
     ENTRY(ZEROFILL),
     ENTRY(CSTRING_LITERALS),
-    ENTRY(S_4BYTE_LITERALS),
-    ENTRY(S_8BYTE_LITERALS),
+    ENTRY(IS_4BYTE_LITERALS),
+    ENTRY(IS_8BYTE_LITERALS),
     ENTRY(LITERAL_POINTERS),
     ENTRY(NON_LAZY_SYMBOL_POINTERS),
     ENTRY(LAZY_SYMBOL_POINTERS),
@@ -294,7 +294,7 @@ const char* to_string(Section::TYPE e) {
     ENTRY(COALESCED),
     ENTRY(GB_ZEROFILL),
     ENTRY(INTERPOSING),
-    ENTRY(S_16BYTE_LITERALS),
+    ENTRY(IS_16BYTE_LITERALS),
     ENTRY(DTRACE_DOF),
     ENTRY(LAZY_DYLIB_SYMBOL_POINTERS),
     ENTRY(THREAD_LOCAL_REGULAR),
diff --git a/src/MachO/Symbol.cpp b/src/MachO/Symbol.cpp
@@ -49,7 +49,7 @@ Symbol::Symbol(const details::nlist_32& cmd) :
   type_{cmd.n_type},
   numberof_sections_{cmd.n_sect},
   description_{static_cast<uint16_t>(cmd.n_desc)},
-  origin_{ORIGIN::LC_SYMTAB}
+  origin_{ORIGIN::SYMTAB}
 {
   value_ = cmd.n_value;
 }
@@ -58,7 +58,7 @@ Symbol::Symbol(const details::nlist_64& cmd) :
   type_{cmd.n_type},
   numberof_sections_{cmd.n_sect},
   description_{cmd.n_desc},
-  origin_{ORIGIN::LC_SYMTAB}
+  origin_{ORIGIN::SYMTAB}
 {
   value_ = cmd.n_value;
 }
@@ -133,7 +133,7 @@ const char* to_string(Symbol::ORIGIN e) {
     ENTRY(UNKNOWN),
     ENTRY(DYLD_EXPORT),
     ENTRY(DYLD_BIND),
-    ENTRY(LC_SYMTAB),
+    ENTRY(SYMTAB),
   };
   #undef ENTRY
 

Original file line number	Diff line number	Diff line change
`@@ -57,7 +57,7 @@ void create<Symbol>(nb::module_& m) {`
`57`	`57`	`.value("UNKNOWN", Symbol::ORIGIN::UNKNOWN)`
`58`	`58`	`.value("DYLD_EXPORT", Symbol::ORIGIN::DYLD_EXPORT)`
`59`	`59`	`.value("DYLD_BIND", Symbol::ORIGIN::DYLD_BIND)`
`60`		`- .value("LC_SYMTAB", Symbol::ORIGIN::LC_SYMTAB)`
	`60`	`+ .value("SYMTAB", Symbol::ORIGIN::SYMTAB)`
`61`	`61`	`;`
`62`	`62`
`63`	`63`	`enum_<Symbol::TYPE>(symbol, "TYPE")`
Original file line number	Diff line number	Diff line change
`@@ -952,7 +952,7 @@ class LIEF_API Binary : public LIEF::Binary {`
`952`	`952`	`/// Check if the binary is supporting ARM64 pointer authentication (arm64e)`
`953`	`953`	`bool support_arm64_ptr_auth() const {`
`954`	`954`	`return header().cpu_type() == Header::CPU_TYPE::ARM64 &&`
`955`		`- (header().cpu_subtype() & ~Header::CPU_SUBTYPE_MASK) == Header::CPU_SUBTYPE_ARM64_ARM64E;`
	`955`	`+ (header().cpu_subtype() & ~Header::SUBTYPE_MASK) == Header::CPU_SUBTYPE_ARM64_ARM64E;`
`956`	`956`	`}`
`957`	`957`
`958`	`958`	`/// Return an iterator over the binding info which can come from either`
Original file line number	Diff line number	Diff line change
`@@ -3569,7 +3569,7 @@ ok_error_t BinaryParser::post_process(DynamicSymbolCommand& cmd) {`
`3569`	`3569`	`symtab.reserve(binary_->symbols_.size());`
`3570`	`3570`	`size_t isym = 0;`
`3571`	`3571`	`for (const std::unique_ptr<Symbol>& sym : binary_->symbols_) {`
`3572`		`- if (sym->origin() != Symbol::ORIGIN::LC_SYMTAB) {`
	`3572`	`+ if (sym->origin() != Symbol::ORIGIN::SYMTAB) {`
`3573`	`3573`	`continue;`
`3574`	`3574`	`}`
`3575`	`3575`