[lld-macho][nfc] Define BIND_* enums as uint8_t to avoid casting

lld/MachO/SyntheticSections.cpp

 } // namespace
 
 // Rebase opcodes allow us to describe a contiguous sequence of rebase location
 // using a single DO_REBASE opcode. To take advantage of it, we delay emitting
 // `DO_REBASE` until we have reached the end of a contiguous sequence.
 static void encodeDoRebase(Rebase &rebase, raw_svector_ostream &os) {
   assert(rebase.consecutiveCount != 0);
   if (rebase.consecutiveCount <= REBASE_IMMEDIATE_MASK) {
-    os << static_cast<uint8_t>(REBASE_OPCODE_DO_REBASE_IMM_TIMES |
-                               rebase.consecutiveCount);
+    os << (REBASE_OPCODE_DO_REBASE_IMM_TIMES | rebase.consecutiveCount);
   } else {
-    os << static_cast<uint8_t>(REBASE_OPCODE_DO_REBASE_ULEB_TIMES);
+    os << REBASE_OPCODE_DO_REBASE_ULEB_TIMES;
     encodeULEB128(rebase.consecutiveCount, os);
   }
   rebase.consecutiveCount = 0;
 }
 
 static void encodeRebase(const OutputSection *osec, uint64_t outSecOff,
                          Rebase &lastRebase, raw_svector_ostream &os) {
   OutputSegment *seg = osec->parent;
   uint64_t offset = osec->getSegmentOffset() + outSecOff;
   if (lastRebase.segment != seg || lastRebase.offset != offset) {
     if (lastRebase.consecutiveCount != 0)
       encodeDoRebase(lastRebase, os);
 
     if (lastRebase.segment != seg) {
-      os << static_cast<uint8_t>(REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
-                                 seg->index);
+      os << (REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | seg->index);
       encodeULEB128(offset, os);
       lastRebase.segment = seg;
       lastRebase.offset = offset;
     } else {
       assert(lastRebase.offset != offset);
-      os << static_cast<uint8_t>(REBASE_OPCODE_ADD_ADDR_ULEB);
+      os << REBASE_OPCODE_ADD_ADDR_ULEB;
       encodeULEB128(offset - lastRebase.offset, os);
       lastRebase.offset = offset;
     }
   }
   ++lastRebase.consecutiveCount;
   // DO_REBASE causes dyld to both perform the binding and increment the offset
   lastRebase.offset += target->wordSize;
 }
 
 void RebaseSection::finalizeContents() {
   if (locations.empty())
     return;
 
   raw_svector_ostream os{contents};
   Rebase lastRebase;
 
-  os << static_cast<uint8_t>(REBASE_OPCODE_SET_TYPE_IMM | REBASE_TYPE_POINTER);
+  os << (REBASE_OPCODE_SET_TYPE_IMM | REBASE_TYPE_POINTER);
 
   llvm::sort(locations, [](const Location &a, const Location &b) {
     return a.isec->getVA(a.offset) < b.isec->getVA(b.offset);
   });
   for (const Location &loc : locations)
     encodeRebase(loc.isec->parent, loc.isec->getOffset(loc.offset), lastRebase,
                  os);
   if (lastRebase.consecutiveCount != 0)
     encodeDoRebase(lastRebase, os);
 
-  os << static_cast<uint8_t>(REBASE_OPCODE_DONE);
+  os << REBASE_OPCODE_DONE;
 }
 
 void RebaseSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 NonLazyPointerSectionBase::NonLazyPointerSectionBase(const char *segname,
                                                      const char *name)

 // we only need to encode the differences between bindings. Hence the use of
 // lastBinding.
 static void encodeBinding(const OutputSection *osec, uint64_t outSecOff,
                           int64_t addend, Binding &lastBinding,
                           raw_svector_ostream &os) {
   OutputSegment *seg = osec->parent;
   uint64_t offset = osec->getSegmentOffset() + outSecOff;
   if (lastBinding.segment != seg) {
-    os << static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
-                               seg->index);
+    os << (BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | seg->index);
     encodeULEB128(offset, os);
     lastBinding.segment = seg;
     lastBinding.offset = offset;
   } else if (lastBinding.offset != offset) {
-    os << static_cast<uint8_t>(BIND_OPCODE_ADD_ADDR_ULEB);
+    os << BIND_OPCODE_ADD_ADDR_ULEB;
     encodeULEB128(offset - lastBinding.offset, os);
     lastBinding.offset = offset;
   }
 
   if (lastBinding.addend != addend) {
-    os << static_cast<uint8_t>(BIND_OPCODE_SET_ADDEND_SLEB);
+    os << BIND_OPCODE_SET_ADDEND_SLEB;
     encodeSLEB128(addend, os);
     lastBinding.addend = addend;
   }
 
-  os << static_cast<uint8_t>(BIND_OPCODE_DO_BIND);
+  os << BIND_OPCODE_DO_BIND;
   // DO_BIND causes dyld to both perform the binding and increment the offset
   lastBinding.offset += target->wordSize;
 }
 
 // Non-weak bindings need to have their dylib ordinal encoded as well.
 static int16_t ordinalForDylibSymbol(const DylibSymbol &dysym) {
   if (config->namespaceKind == NamespaceKind::flat || dysym.isDynamicLookup())
     return static_cast<int16_t>(BIND_SPECIAL_DYLIB_FLAT_LOOKUP);
   assert(dysym.getFile()->isReferenced());
   return dysym.getFile()->ordinal;
 }
 
 static void encodeDylibOrdinal(int16_t ordinal, raw_svector_ostream &os) {
   if (ordinal <= 0) {
-    os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_SPECIAL_IMM |
-                               (ordinal & BIND_IMMEDIATE_MASK));
+    os << (BIND_OPCODE_SET_DYLIB_SPECIAL_IMM | (ordinal & BIND_IMMEDIATE_MASK));
   } else if (ordinal <= BIND_IMMEDIATE_MASK) {
-    os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | ordinal);
+    os << (BIND_OPCODE_SET_DYLIB_ORDINAL_IMM | ordinal);
   } else {
-    os << static_cast<uint8_t>(BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB);
+    os << BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB;
     encodeULEB128(ordinal, os);
   }
 }
 
 static void encodeWeakOverride(const Defined *defined,
                                raw_svector_ostream &os) {
-  os << static_cast<uint8_t>(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM |
-                             BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION)
+  os << (BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM |
      << defined->getName() << '\0';
 }
 
 // Organize the bindings so we can encoded them with fewer opcodes.
 //
 // First, all bindings for a given symbol should be grouped together.
 // BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM is the largest opcode (since it
 // has an associated symbol string), so we only want to emit it once per symbol.
for (auto &p : sortBindings(bindingsMap)) {
     std::vector<BindingEntry> &bindings = p.second;
     llvm::sort(bindings, [](const BindingEntry &a, const BindingEntry &b) {
       return a.target.getVA() < b.target.getVA();
     });
     uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
     if (sym->isWeakRef())
       flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;
     os << flags << sym->getName() << '\0'
-       << static_cast<uint8_t>(BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER);
+       << (BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER);
     int16_t ordinal = ordinalForDylibSymbol(*sym);
     if (ordinal != lastOrdinal) {
       encodeDylibOrdinal(ordinal, os);
       lastOrdinal = ordinal;
     }
     for (const BindingEntry &b : bindings)
       encodeBinding(b.target.isec->parent,
                     b.target.isec->getOffset(b.target.offset), b.addend,
                     lastBinding, os);
   }
   if (!bindingsMap.empty())
-    os << static_cast<uint8_t>(BIND_OPCODE_DONE);
+    os << BIND_OPCODE_DONE;
 }
 
 void BindingSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 WeakBindingSection::WeakBindingSection()
     : LinkEditSection(segment_names::linkEdit, section_names::weakBinding) {}
 
 void WeakBindingSection::finalizeContents() {
   raw_svector_ostream os{contents};
   Binding lastBinding;
 
   for (const Defined *defined : definitions)
     encodeWeakOverride(defined, os);
 
   for (auto &p : sortBindings(bindingsMap)) {
     const Symbol *sym = p.first;
     std::vector<BindingEntry> &bindings = p.second;
-    os << static_cast<uint8_t>(BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM)
-       << sym->getName() << '\0'
-       << static_cast<uint8_t>(BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER);
+    os << (BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM) << sym->getName() << '\0'
+       << (BIND_OPCODE_SET_TYPE_IMM | BIND_TYPE_POINTER);
     for (const BindingEntry &b : bindings)
       encodeBinding(b.target.isec->parent,
                     b.target.isec->getOffset(b.target.offset), b.addend,
                     lastBinding, os);
   }
   if (!bindingsMap.empty() || !definitions.empty())
-    os << static_cast<uint8_t>(BIND_OPCODE_DONE);
+    os << BIND_OPCODE_DONE;
 }
 
 void WeakBindingSection::writeTo(uint8_t *buf) const {
   memcpy(buf, contents.data(), contents.size());
 }
 
 StubsSection::StubsSection()
     : SyntheticSection(segment_names::text, section_names::stubs) {

 // interpreted all at once. Rather, dyld will start interpreting opcodes at a
 // given offset, typically only binding a single symbol before it finds a
 // BIND_OPCODE_DONE terminator. As such, unlike in the non-lazy-binding case,
 // we cannot encode just the differences between symbols; we have to emit the
 // complete bind information for each symbol.
 uint32_t LazyBindingSection::encode(const DylibSymbol &sym) {
   uint32_t opstreamOffset = contents.size();
   OutputSegment *dataSeg = in.lazyPointers->parent;
-  os << static_cast<uint8_t>(BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB |
-                             dataSeg->index);
+  os << (BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB | dataSeg->index);
   uint64_t offset = in.lazyPointers->addr - dataSeg->firstSection()->addr +
                     sym.stubsIndex * target->wordSize;
   encodeULEB128(offset, os);
   encodeDylibOrdinal(ordinalForDylibSymbol(sym), os);
 
   uint8_t flags = BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM;
   if (sym.isWeakRef())
     flags |= BIND_SYMBOL_FLAGS_WEAK_IMPORT;
 
-  os << flags << sym.getName() << '\0'
-     << static_cast<uint8_t>(BIND_OPCODE_DO_BIND)
-     << static_cast<uint8_t>(BIND_OPCODE_DONE);
+  os << flags << sym.getName() << '\0' << BIND_OPCODE_DO_BIND
+     << BIND_OPCODE_DONE;
   return opstreamOffset;
 }
 
 ExportSection::ExportSection()
     : LinkEditSection(segment_names::linkEdit, section_names::export_) {}
 
 void ExportSection::finalizeContents() {
   trieBuilder.setImageBase(in.header->addr);

llvm/include/llvm/BinaryFormat/MachO.h

enum DataRegionType {
   // Constants for the "kind" field in a data_in_code_entry structure
   DICE_KIND_DATA = 1u,
   DICE_KIND_JUMP_TABLE8 = 2u,
   DICE_KIND_JUMP_TABLE16 = 3u,
   DICE_KIND_JUMP_TABLE32 = 4u,
   DICE_KIND_ABS_JUMP_TABLE32 = 5u
 };
 
-enum RebaseType {
+enum RebaseType : uint8_t {
   REBASE_TYPE_POINTER = 1u,
   REBASE_TYPE_TEXT_ABSOLUTE32 = 2u,
   REBASE_TYPE_TEXT_PCREL32 = 3u
 };
 
 enum { REBASE_OPCODE_MASK = 0xF0u, REBASE_IMMEDIATE_MASK = 0x0Fu };
 
-enum RebaseOpcode {
+enum RebaseOpcode : uint8_t {
   REBASE_OPCODE_DONE = 0x00u,
   REBASE_OPCODE_SET_TYPE_IMM = 0x10u,
   REBASE_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x20u,
   REBASE_OPCODE_ADD_ADDR_ULEB = 0x30u,
   REBASE_OPCODE_ADD_ADDR_IMM_SCALED = 0x40u,
   REBASE_OPCODE_DO_REBASE_IMM_TIMES = 0x50u,
   REBASE_OPCODE_DO_REBASE_ULEB_TIMES = 0x60u,
   REBASE_OPCODE_DO_REBASE_ADD_ADDR_ULEB = 0x70u,
   REBASE_OPCODE_DO_REBASE_ULEB_TIMES_SKIPPING_ULEB = 0x80u
 };
 
-enum BindType {
+enum BindType : uint8_t {
   BIND_TYPE_POINTER = 1u,
   BIND_TYPE_TEXT_ABSOLUTE32 = 2u,
   BIND_TYPE_TEXT_PCREL32 = 3u
 };
 
 enum BindSpecialDylib {
   BIND_SPECIAL_DYLIB_SELF = 0,
   BIND_SPECIAL_DYLIB_MAIN_EXECUTABLE = -1,
   BIND_SPECIAL_DYLIB_FLAT_LOOKUP = -2
 };
 
-enum {
+enum : uint8_t {
   BIND_SYMBOL_FLAGS_WEAK_IMPORT = 0x1u,
   BIND_SYMBOL_FLAGS_NON_WEAK_DEFINITION = 0x8u,
 
   BIND_OPCODE_MASK = 0xF0u,
   BIND_IMMEDIATE_MASK = 0x0Fu
 };
 
-enum BindOpcode {
+enum BindOpcode : uint8_t {
   BIND_OPCODE_DONE = 0x00u,
   BIND_OPCODE_SET_DYLIB_ORDINAL_IMM = 0x10u,
   BIND_OPCODE_SET_DYLIB_ORDINAL_ULEB = 0x20u,
   BIND_OPCODE_SET_DYLIB_SPECIAL_IMM = 0x30u,
   BIND_OPCODE_SET_SYMBOL_TRAILING_FLAGS_IMM = 0x40u,
   BIND_OPCODE_SET_TYPE_IMM = 0x50u,
   BIND_OPCODE_SET_ADDEND_SLEB = 0x60u,
   BIND_OPCODE_SET_SEGMENT_AND_OFFSET_ULEB = 0x70u,