[lld-macho] Remove partially supported 32-bit ARM arch

[thevinster]

Summary

We never really supported 32-bit ARM arch entirely, and partial support was added for
very specific features. Regardless, it fails to even link the most basic applications that at
this point, it might be better to move this arch as unsupported. Given that Apple will be
moving towards arm64 long term, I don't see any reason for anyone to invest time in
supporting this either, and for those who still need it should use apple's ld64 linker.

Fixes #62691

[int3]

Thanks :D

[int3]

lld/test/MachO/weak-def-thumb-conflict.s

8

hmm, should we delete the logic around N_ARM_THUMB_DEF in InputFiles.cpp as well? maybe just add an assert that checks that the flag isn't set on any n_desc

[thevinster]

Remove thumb field. Assert N_ARM_THUMB_DEF flag not set.

[int3]

lld/MachO/ConcatOutputSection.cpp

343–344

could you run clang-format before landing? I think this can be reflowed

[barannikov88]

lld/MachO/ConcatOutputSection.cpp

343–344

FWIW From my experience, clang-format does not join lines with argument comments.
A workaround is to join them manually (possibly exceeding column limit), then reformat.

lld/MachO/Arch/ARM.cpp

-//===- ARM.cpp ------------------------------------------------------------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "InputFiles.h"
-#include "Symbols.h"
-#include "SyntheticSections.h"
-#include "Target.h"
-
-#include "lld/Common/ErrorHandler.h"
-#include "llvm/ADT/Bitfields.h"
-#include "llvm/BinaryFormat/MachO.h"
-#include "llvm/Support/Endian.h"
-
-using namespace llvm;
-using namespace llvm::MachO;
-using namespace llvm::support::endian;
-using namespace lld;
-using namespace lld::macho;
-
-namespace {
-
-struct ARM : TargetInfo {
-  ARM(uint32_t cpuSubtype);
-
-  int64_t getEmbeddedAddend(MemoryBufferRef, uint64_t offset,
-                            const relocation_info) const override;
-  void relocateOne(uint8_t *loc, const Reloc &, uint64_t va,
-                   uint64_t pc) const override;
-
-  void writeStub(uint8_t *buf, const Symbol &, uint64_t) const override;
-  void writeStubHelperHeader(uint8_t *buf) const override;
-  void writeStubHelperEntry(uint8_t *buf, const Symbol &,
-                            uint64_t entryAddr) const override;
-
-  void writeObjCMsgSendStub(uint8_t *buf, Symbol *sym, uint64_t stubsAddr,
-                            uint64_t stubOffset, uint64_t selrefsVA,
-                            uint64_t selectorIndex, uint64_t gotAddr,
-                            uint64_t msgSendIndex) const override;
-
-  void relaxGotLoad(uint8_t *loc, uint8_t type) const override;
-  uint64_t getPageSize() const override { return 4 * 1024; }
-
-  void handleDtraceReloc(const Symbol *sym, const Reloc &r,
-                         uint8_t *loc) const override;
-};
-} // namespace
-
-static constexpr std::array<RelocAttrs, 10> relocAttrsArray{{
-#define B(x) RelocAttrBits::x
-    {"VANILLA", /* FIXME populate this */ B(_0)},
-    {"PAIR", /* FIXME populate this */ B(_0)},
-    {"SECTDIFF", /* FIXME populate this */ B(_0)},
-    {"LOCAL_SECTDIFF", /* FIXME populate this */ B(_0)},
-    {"PB_LA_PTR", /* FIXME populate this */ B(_0)},
-    {"BR24", B(PCREL) | B(LOCAL) | B(EXTERN) | B(BRANCH) | B(BYTE4)},
-    {"BR22", B(PCREL) | B(LOCAL) | B(EXTERN) | B(BRANCH) | B(BYTE4)},
-    {"32BIT_BRANCH", /* FIXME populate this */ B(_0)},
-    {"HALF", /* FIXME populate this */ B(_0)},
-    {"HALF_SECTDIFF", /* FIXME populate this */ B(_0)},
-#undef B
-}};
-
-int64_t ARM::getEmbeddedAddend(MemoryBufferRef mb, uint64_t offset,
-                               relocation_info rel) const {
-  // FIXME: implement this
-  return 0;
-}
-
-template <int N> using BitfieldFlag = Bitfield::Element<bool, N, 1>;
-
-// ARM BL encoding:
-//
-// 30       28        24                                              0
-// +---------+---------+----------------------------------------------+
-// |  cond   | 1 0 1 1 |                  imm24                       |
-// +---------+---------+----------------------------------------------+
-//
-// `cond` here varies depending on whether we have bleq, blne, etc.
-// `imm24` encodes a 26-bit pcrel offset -- last 2 bits are zero as ARM
-// functions are 4-byte-aligned.
-//
-// ARM BLX encoding:
-//
-// 30       28        24                                              0
-// +---------+---------+----------------------------------------------+
-// | 1 1 1 1 | 1 0 1 H |                  imm24                       |
-// +---------+---------+----------------------------------------------+
-//
-// Since Thumb functions are 2-byte-aligned, we need one extra bit to encode
-// the offset -- that is the H bit.
-//
-// BLX is always unconditional, so while we can convert directly from BLX to BL,
-// we need to insert a shim if a BL's target is a Thumb function.
-//
-// Helper aliases for decoding BL / BLX:
-using Cond = Bitfield::Element<uint32_t, 28, 4>;
-using Imm24 = Bitfield::Element<int32_t, 0, 24>;
-
-void ARM::relocateOne(uint8_t *loc, const Reloc &r, uint64_t value,
-                      uint64_t pc) const {
-  switch (r.type) {
-  case ARM_RELOC_BR24: {
-    uint32_t base = read32le(loc);
-    bool isBlx = Bitfield::get<Cond>(base) == 0xf;
-    const Symbol *sym = r.referent.get<Symbol *>();
-    int32_t offset = value - (pc + 8);
-
-    if (auto *defined = dyn_cast<Defined>(sym)) {
-      if (!isBlx && defined->thumb) {
-        error("TODO: implement interworking shim");
-        return;
-      } else if (isBlx && !defined->thumb) {
-        Bitfield::set<Cond>(base, 0xe); // unconditional BL
-        Bitfield::set<BitfieldFlag<24>>(base, true);
-        isBlx = false;
-      }
-    } else {
-      error("TODO: Implement ARM_RELOC_BR24 for dylib symbols");
-      return;
-    }
-
-    if (isBlx) {
-      assert((0x1 & value) == 0);
-      Bitfield::set<Imm24>(base, offset >> 2);
-      Bitfield::set<BitfieldFlag<24>>(base, (offset >> 1) & 1); // H bit
-    } else {
-      assert((0x3 & value) == 0);
-      Bitfield::set<Imm24>(base, offset >> 2);
-    }
-    write32le(loc, base);
-    break;
-  }
-  default:
-    fatal("unhandled relocation type");
-  }
-}
-
-void ARM::writeStub(uint8_t *buf, const Symbol &sym, uint64_t) const {
-  fatal("TODO: implement this");
-}
-
-void ARM::writeStubHelperHeader(uint8_t *buf) const {
-  fatal("TODO: implement this");
-}
-
-void ARM::writeStubHelperEntry(uint8_t *buf, const Symbol &sym,
-                               uint64_t entryAddr) const {
-  fatal("TODO: implement this");
-}
-
-void ARM::writeObjCMsgSendStub(uint8_t *buf, Symbol *sym, uint64_t stubsAddr,
-                               uint64_t stubOffset, uint64_t selrefsVA,
-                               uint64_t selectorIndex, uint64_t gotAddr,
-                               uint64_t msgSendIndex) const {
-  fatal("TODO: implement this");
-}
-
-void ARM::relaxGotLoad(uint8_t *loc, uint8_t type) const {
-  fatal("TODO: implement this");
-}
-
-ARM::ARM(uint32_t cpuSubtype) : TargetInfo(ILP32()) {
-  cpuType = CPU_TYPE_ARM;
-  this->cpuSubtype = cpuSubtype;
-
-  stubSize = 0 /* FIXME */;
-  stubHelperHeaderSize = 0 /* FIXME */;
-  stubHelperEntrySize = 0 /* FIXME */;
-
-  relocAttrs = {relocAttrsArray.data(), relocAttrsArray.size()};
-}
-
-TargetInfo *macho::createARMTargetInfo(uint32_t cpuSubtype) {
-  static ARM t(cpuSubtype);
-  return &t;
-}
-
-void ARM::handleDtraceReloc(const Symbol *sym, const Reloc &r,
-                            uint8_t *loc) const {
-  if (config->outputType == MH_OBJECT)
-    return;
-
-  switch (r.type) {
-  case ARM_RELOC_BR24:
-    if (sym->getName().startswith("___dtrace_probe")) {
-      // change call site to a NOP
-      write32le(loc, 0xE1A00000);
-    } else if (sym->getName().startswith("___dtrace_isenabled")) {
-      // change call site to 'eor r0, r0, r0'
-      write32le(loc, 0xE0200000);
-    } else {
-      error("Unrecognized dtrace symbol prefix: " + toString(*sym));
-    }
-    break;
-  case ARM_THUMB_RELOC_BR22:
-    if (sym->getName().startswith("___dtrace_probe")) {
-      // change 32-bit blx call site to two thumb NOPs
-      write32le(loc, 0x46C046C0);
-    } else if (sym->getName().startswith("___dtrace_isenabled")) {
-      // change 32-bit blx call site to 'nop', 'eor r0, r0'
-      write32le(loc, 0x46C04040);
-    } else {
-      error("Unrecognized dtrace symbol prefix: " + toString(*sym));
-    }
-    break;
-  default:
-    llvm_unreachable("Unsupported dtrace relocation type for ARM");
-  }
-}

lld/MachO/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(MachOOptionsTableGen)
 
 include_directories(${LLVM_MAIN_SRC_DIR}/../libunwind/include)
 
 add_lld_library(lldMachO
-  Arch/ARM.cpp
   Arch/ARM64.cpp
   Arch/ARM64Common.cpp
   Arch/ARM64_32.cpp
   Arch/X86_64.cpp
   ConcatOutputSection.cpp
   Driver.cpp
   DriverUtils.cpp
   Dwarf.cpp

lld/MachO/ConcatOutputSection.cpp

for (Reloc &r : reverse(relocs)) {
       thunkInfo.isec->live = true;
 
       StringRef thunkName = saver().save(funcSym->getName() + ".thunk." +
                                          std::to_string(thunkInfo.sequence++));
       if (!isa<Defined>(funcSym) || cast<Defined>(funcSym)->isExternal()) {
         r.referent = thunkInfo.sym = symtab->addDefined(
             thunkName, /*file=*/nullptr, thunkInfo.isec, /*value=*/0, thunkSize,
             /*isWeakDef=*/false, /*isPrivateExtern=*/true,
-            /*isThumb=*/false, /*isReferencedDynamically=*/false,
-            /*noDeadStrip=*/false, /*isWeakDefCanBeHidden=*/false);
+            /*isReferencedDynamically=*/false, /*noDeadStrip=*/false,
+            /*isWeakDefCanBeHidden=*/false);
       } else {
         r.referent = thunkInfo.sym = make<Defined>(
             thunkName, /*file=*/nullptr, thunkInfo.isec, /*value=*/0, thunkSize,
             /*isWeakDef=*/false, /*isExternal=*/false, /*isPrivateExtern=*/true,
-            /*includeInSymtab=*/true, /*isThumb=*/false,
-            /*isReferencedDynamically=*/false, /*noDeadStrip=*/false,
-            /*isWeakDefCanBeHidden=*/false);
+            /*includeInSymtab=*/true, /*isReferencedDynamically=*/false,
+            /*noDeadStrip=*/false, /*isWeakDefCanBeHidden=*/false);
       }
       thunkInfo.sym->used = true;
       target->populateThunk(thunkInfo.isec, funcSym);
       finalizeOne(thunkInfo.isec);
       thunks.push_back(thunkInfo.isec);
       ++thunkCount;
     }
   }

lld/MachO/Driver.cpp

for (Symbol *sym : symtab->getSymbols()) {
     isec->parent = osec;
     inputSections.push_back(isec);
 
     // FIXME: CommonSymbol should store isReferencedDynamically, noDeadStrip
     // and pass them on here.
     replaceSymbol<Defined>(
         sym, sym->getName(), common->getFile(), isec, /*value=*/0, common->size,
         /*isWeakDef=*/false, /*isExternal=*/true, common->privateExtern,
-        /*includeInSymtab=*/true, /*isThumb=*/false,
-        /*isReferencedDynamically=*/false, /*noDeadStrip=*/false);
+        /*includeInSymtab=*/true, /*isReferencedDynamically=*/false,
+        /*noDeadStrip=*/false);
   }
 }
 
 static void initializeSectionRenameMap() {
   if (config->dataConst) {
     SmallVector<StringRef> v{section_names::got,
                              section_names::authGot,
                              section_names::authPtr,
static TargetInfo *createTargetInfo(InputArgList &args) {
   auto [cpuType, cpuSubtype] = getCPUTypeFromArchitecture(config->arch());
   switch (cpuType) {
   case CPU_TYPE_X86_64:
     return createX86_64TargetInfo();
   case CPU_TYPE_ARM64:
     return createARM64TargetInfo();
   case CPU_TYPE_ARM64_32:
     return createARM64_32TargetInfo();
-  case CPU_TYPE_ARM:
-    return createARMTargetInfo(cpuSubtype);
   default:
     error("missing or unsupported -arch " + archName);
     return nullptr;
   }
 }
 
 static UndefinedSymbolTreatment
 getUndefinedSymbolTreatment(const ArgList &args) {

lld/MachO/InputFiles.cpp

static macho::Symbol *createDefined(const NList &sym, StringRef name,
   // N_PEXT: llvm-mc does not emit these, but `ld -r` (wherein ld64 emits
   //         object files) may produce them. LLD does not yet support -r.
   //         These are translation-unit scoped, identical to the `0` case.
   // 0: Translation-unit scoped. These are not in the symbol table during
   //    link, and not in the export table of the output either.
   bool isWeakDefCanBeHidden =
       (sym.n_desc & (N_WEAK_DEF | N_WEAK_REF)) == (N_WEAK_DEF | N_WEAK_REF);
 
+  assert(!(sym.n_desc & N_ARM_THUMB_DEF) && "ARM32 arch is not supported");
+
   if (sym.n_type & N_EXT) {
     // -load_hidden makes us treat global symbols as linkage unit scoped.
     // Duplicates are reported but the symbol does not go in the export trie.
     bool isPrivateExtern = sym.n_type & N_PEXT || forceHidden;
 
     // lld's behavior for merging symbols is slightly different from ld64:
     // ld64 picks the winning symbol based on several criteria (see
     // pickBetweenRegularAtoms() in ld64's SymbolTable.cpp), while lld
if (sym.n_type & N_EXT) {
     // So we nullify the autohide flag when privateExtern is present
     // and promote the symbol to privateExtern when it is not already.
     if (isWeakDefCanBeHidden && isPrivateExtern)
       isWeakDefCanBeHidden = false;
     else if (isWeakDefCanBeHidden)
       isPrivateExtern = true;
     return symtab->addDefined(
         name, isec->getFile(), isec, value, size, sym.n_desc & N_WEAK_DEF,
-        isPrivateExtern, sym.n_desc & N_ARM_THUMB_DEF,
-        sym.n_desc & REFERENCED_DYNAMICALLY, sym.n_desc & N_NO_DEAD_STRIP,
-        isWeakDefCanBeHidden);
+        isPrivateExtern, sym.n_desc & REFERENCED_DYNAMICALLY,
+        sym.n_desc & N_NO_DEAD_STRIP, isWeakDefCanBeHidden);
   }
   bool includeInSymtab = !isPrivateLabel(name) && !isEhFrameSection(isec);
   return make<Defined>(
       name, isec->getFile(), isec, value, size, sym.n_desc & N_WEAK_DEF,
       /*isExternal=*/false, /*isPrivateExtern=*/false, includeInSymtab,
-      sym.n_desc & N_ARM_THUMB_DEF, sym.n_desc & REFERENCED_DYNAMICALLY,
-      sym.n_desc & N_NO_DEAD_STRIP);
+      sym.n_desc & REFERENCED_DYNAMICALLY, sym.n_desc & N_NO_DEAD_STRIP);
 }
 
 // Absolute symbols are defined symbols that do not have an associated
 // InputSection. They cannot be weak.
 template <class NList>
 static macho::Symbol *createAbsolute(const NList &sym, InputFile *file,
                                      StringRef name, bool forceHidden) {
+  assert(!(sym.n_desc & N_ARM_THUMB_DEF) && "ARM32 arch is not supported");
+
   if (sym.n_type & N_EXT) {
     bool isPrivateExtern = sym.n_type & N_PEXT || forceHidden;
-    return symtab->addDefined(
-        name, file, nullptr, sym.n_value, /*size=*/0,
-        /*isWeakDef=*/false, isPrivateExtern, sym.n_desc & N_ARM_THUMB_DEF,
-        /*isReferencedDynamically=*/false, sym.n_desc & N_NO_DEAD_STRIP,
+    return symtab->addDefined(name, file, nullptr, sym.n_value, /*size=*/0,
+                              /*isWeakDef=*/false, isPrivateExtern,
+                              /*isReferencedDynamically=*/false,
+                              sym.n_desc & N_NO_DEAD_STRIP,
                               /*isWeakDefCanBeHidden=*/false);
   }
   return make<Defined>(name, file, nullptr, sym.n_value, /*size=*/0,
                        /*isWeakDef=*/false,
                        /*isExternal=*/false, /*isPrivateExtern=*/false,
-                       /*includeInSymtab=*/true, sym.n_desc & N_ARM_THUMB_DEF,
+                       /*includeInSymtab=*/true,
                        /*isReferencedDynamically=*/false,
                        sym.n_desc & N_NO_DEAD_STRIP);
 }
 
 template <class NList>
 macho::Symbol *ObjFile::parseNonSectionSymbol(const NList &sym,
                                               const char *strtab) {
   StringRef name = StringRef(strtab + sym.n_strx);
for (const Subsection &subsec : ehFrameSection.subsections) {
 
     // Subtractor relocs require the subtrahend to be a symbol reloc. Ensure
     // that all EH frames have an associated symbol so that we can generate
     // subtractor relocs that reference them.
     if (isec->symbols.size() == 0)
       make<Defined>("EH_Frame", isec->getFile(), isec, /*value=*/0,
                     isec->getSize(), /*isWeakDef=*/false, /*isExternal=*/false,
                     /*isPrivateExtern=*/false, /*includeInSymtab=*/false,
-                    /*isThumb=*/false, /*isReferencedDynamically=*/false,
+                    /*isReferencedDynamically=*/false,
                     /*noDeadStrip=*/false);
     else if (isec->symbols[0]->value != 0)
       fatal("found symbol at unexpected offset in __eh_frame");
 
     EhReader reader(this, isec->data, subsec.offset);
     size_t dataOff = 0; // Offset from the start of the EH frame.
     reader.skipValidLength(&dataOff); // readLength() already validated this.
     // cieOffOff is the offset from the start of the EH frame to the cieOff
isPrivateExtern = isPrivateExtern || objSym.canBeOmittedFromSymbolTable() ||
                     file.forceHidden;
 
   if (objSym.isCommon())
     return symtab->addCommon(name, &file, objSym.getCommonSize(),
                              objSym.getCommonAlignment(), isPrivateExtern);
 
   return symtab->addDefined(name, &file, /*isec=*/nullptr, /*value=*/0,
                             /*size=*/0, objSym.isWeak(), isPrivateExtern,
-                            /*isThumb=*/false,
                             /*isReferencedDynamically=*/false,
                             /*noDeadStrip=*/false,
                             /*isWeakDefCanBeHidden=*/false);
 }
 
 BitcodeFile::BitcodeFile(MemoryBufferRef mb, StringRef archiveName,
                          uint64_t offsetInArchive, bool lazy, bool forceHidden)
     : InputFile(BitcodeKind, mb, lazy), forceHidden(forceHidden) {

lld/MachO/SymbolTable.h

  * replaceSymbol(), which does an in-place update of the Symbol via `placement
  * new`. Therefore, there is no need to update any relocations that hold
  * pointers the "old" Symbol -- they will automatically point to the new one.
  */
 class SymbolTable {
 public:
   Defined *addDefined(StringRef name, InputFile *, InputSection *,
                       uint64_t value, uint64_t size, bool isWeakDef,
-                      bool isPrivateExtern, bool isThumb,
-                      bool isReferencedDynamically, bool noDeadStrip,
-                      bool isWeakDefCanBeHidden);
+                      bool isPrivateExtern, bool isReferencedDynamically,
+                      bool noDeadStrip, bool isWeakDefCanBeHidden);
 
   Defined *aliasDefined(Defined *src, StringRef target, InputFile *newFile,
                         bool makePrivateExtern = false);
 
   Symbol *addUndefined(StringRef name, InputFile *, bool isWeakRef);
 
   Symbol *addCommon(StringRef name, InputFile *, uint64_t size, uint32_t align,
                     bool isPrivateExtern);

lld/MachO/SymbolTable.cpp

llvm::erase_if(fromIsec->symbols, [&](Symbol *s) {
     }
     return true;
   });
 }
 
 Defined *SymbolTable::addDefined(StringRef name, InputFile *file,
                                  InputSection *isec, uint64_t value,
                                  uint64_t size, bool isWeakDef,
-                                 bool isPrivateExtern, bool isThumb,
+                                 bool isPrivateExtern,
                                  bool isReferencedDynamically, bool noDeadStrip,
                                  bool isWeakDefCanBeHidden) {
   bool overridesWeakDef = false;
   auto [s, wasInserted] = insert(name, file);
 
   assert(!file || !isa<BitcodeFile>(file) || !isec);
 
   if (!wasInserted) {
Defined *SymbolTable::addDefined(StringRef name, InputFile *file,
 
   // With -flat_namespace, all extern symbols in dylibs are interposable.
   // FIXME: Add support for `-interposable` (PR53680).
   bool interposable = config->namespaceKind == NamespaceKind::flat &&
                       config->outputType != MachO::MH_EXECUTE &&
                       !isPrivateExtern;
   Defined *defined = replaceSymbol<Defined>(
       s, name, file, isec, value, size, isWeakDef, /*isExternal=*/true,
-      isPrivateExtern, /*includeInSymtab=*/true, isThumb,
-      isReferencedDynamically, noDeadStrip, overridesWeakDef,
-      isWeakDefCanBeHidden, interposable);
+      isPrivateExtern, /*includeInSymtab=*/true, isReferencedDynamically,
+      noDeadStrip, overridesWeakDef, isWeakDefCanBeHidden, interposable);
   return defined;
 }
 
 Defined *SymbolTable::aliasDefined(Defined *src, StringRef target,
                                    InputFile *newFile, bool makePrivateExtern) {
   bool isPrivateExtern = makePrivateExtern || src->privateExtern;
   return addDefined(target, newFile, src->isec, src->value, src->size,
-                    src->isWeakDef(), isPrivateExtern, src->thumb,
+                    src->isWeakDef(), isPrivateExtern,
                     src->referencedDynamically, src->noDeadStrip,
                     src->weakDefCanBeHidden);
 }
 
 Symbol *SymbolTable::addUndefined(StringRef name, InputFile *file,
                                   bool isWeakRef) {
   auto [s, wasInserted] = insert(name, file);
 
Symbol *SymbolTable::addLazyObject(StringRef name, InputFile &file) {
   return s;
 }
 
 Defined *SymbolTable::addSynthetic(StringRef name, InputSection *isec,
                                    uint64_t value, bool isPrivateExtern,
                                    bool includeInSymtab,
                                    bool referencedDynamically) {
   assert(!isec || !isec->getFile()); // See makeSyntheticInputSection().
-  Defined *s =
-      addDefined(name, /*file=*/nullptr, isec, value, /*size=*/0,
-                 /*isWeakDef=*/false, isPrivateExtern, /*isThumb=*/false,
+  Defined *s = addDefined(name, /*file=*/nullptr, isec, value, /*size=*/0,
+                          /*isWeakDef=*/false, isPrivateExtern,
                           referencedDynamically, /*noDeadStrip=*/false,
                           /*isWeakDefCanBeHidden=*/false);
   s->includeInSymtab = includeInSymtab;
   return s;
 }
 
 enum class Boundary {
   Start,
   End,
 };

lld/MachO/Symbols.h

public:
   // True if this symbol is used from a live section.
   bool used : 1;
 };
 
 class Defined : public Symbol {
 public:
   Defined(StringRefZ name, InputFile *file, InputSection *isec, uint64_t value,
           uint64_t size, bool isWeakDef, bool isExternal, bool isPrivateExtern,
-          bool includeInSymtab, bool isThumb, bool isReferencedDynamically,
-          bool noDeadStrip, bool canOverrideWeakDef = false,
-          bool isWeakDefCanBeHidden = false, bool interposable = false);
+          bool includeInSymtab, bool isReferencedDynamically, bool noDeadStrip,
+          bool canOverrideWeakDef = false, bool isWeakDefCanBeHidden = false,
+          bool interposable = false);
 
   bool isWeakDef() const override { return weakDef; }
   bool isExternalWeakDef() const {
     return isWeakDef() && isExternal() && !privateExtern;
   }
   bool isTlv() const override;
 
   bool isExternal() const { return external; }
public:
   // of the parent class, on platforms which support it.
   bool overridesWeakDef : 1;
   // Whether this symbol should appear in the output binary's export trie.
   bool privateExtern : 1;
   // Whether this symbol should appear in the output symbol table.
   bool includeInSymtab : 1;
   // Whether this symbol was folded into a different symbol during ICF.
   bool wasIdenticalCodeFolded : 1;
-  // Only relevant when compiling for Thumb-supporting arm32 archs.
-  bool thumb : 1;
   // Symbols marked referencedDynamically won't be removed from the output's
   // symbol table by tools like strip. In theory, this could be set on arbitrary
   // symbols in input object files. In practice, it's used solely for the
   // synthetic __mh_execute_header symbol.
   // This is information for the static linker, and it's also written to the
   // output file's symbol table for tools running later (such as `strip`).
   bool referencedDynamically : 1;
   // Set on symbols that should not be removed by dead code stripping.

lld/MachO/Symbols.cpp

 uint64_t Symbol::getLazyPtrVA() const {
   return in.lazyPointers->getVA(stubsIndex);
 }
 uint64_t Symbol::getGotVA() const { return in.got->getVA(gotIndex); }
 uint64_t Symbol::getTlvVA() const { return in.tlvPointers->getVA(gotIndex); }
 
 Defined::Defined(StringRefZ name, InputFile *file, InputSection *isec,
                  uint64_t value, uint64_t size, bool isWeakDef, bool isExternal,
-                 bool isPrivateExtern, bool includeInSymtab, bool isThumb,
+                 bool isPrivateExtern, bool includeInSymtab,
                  bool isReferencedDynamically, bool noDeadStrip,
                  bool canOverrideWeakDef, bool isWeakDefCanBeHidden,
                  bool interposable)
     : Symbol(DefinedKind, name, file), overridesWeakDef(canOverrideWeakDef),
       privateExtern(isPrivateExtern), includeInSymtab(includeInSymtab),
-      wasIdenticalCodeFolded(false), thumb(isThumb),
+      wasIdenticalCodeFolded(false),
       referencedDynamically(isReferencedDynamically), noDeadStrip(noDeadStrip),
       interposable(interposable), weakDefCanBeHidden(isWeakDefCanBeHidden),
       weakDef(isWeakDef), external(isExternal), isec(isec), value(value),
       size(size) {
   if (isec) {
     isec->symbols.push_back(this);
     // Maintain sorted order.
     for (auto it = isec->symbols.rbegin(), rend = isec->symbols.rend();

lld/MachO/SyntheticSections.cpp

void StubHelperSection::setUp() {
   inputSections.push_back(in.imageLoaderCache);
   // Since this isn't in the symbol table or in any input file, the noDeadStrip
   // argument doesn't matter.
   dyldPrivate =
       make<Defined>("__dyld_private", nullptr, in.imageLoaderCache, 0, 0,
                     /*isWeakDef=*/false,
                     /*isExternal=*/false, /*isPrivateExtern=*/false,
                     /*includeInSymtab=*/true,
-                    /*isThumb=*/false, /*isReferencedDynamically=*/false,
+                    /*isReferencedDynamically=*/false,
                     /*noDeadStrip=*/false);
   dyldPrivate->used = true;
 }
 
 ObjCStubsSection::ObjCStubsSection()
     : SyntheticSection(segment_names::text, section_names::objcStubs) {
   flags = S_ATTR_SOME_INSTRUCTIONS | S_ATTR_PURE_INSTRUCTIONS;
   align = target->objcStubsAlignment;
 }
 
 void ObjCStubsSection::addEntry(Symbol *sym) {
   assert(sym->getName().startswith(symbolPrefix) && "not an objc stub");
   StringRef methname = sym->getName().drop_front(symbolPrefix.size());
   offsets.push_back(
       in.objcMethnameSection->getStringOffset(methname).outSecOff);
   Defined *newSym = replaceSymbol<Defined>(
       sym, sym->getName(), nullptr, isec,
       /*value=*/symbols.size() * target->objcStubsFastSize,
       /*size=*/target->objcStubsFastSize,
       /*isWeakDef=*/false, /*isExternal=*/true, /*isPrivateExtern=*/true,
-      /*includeInSymtab=*/true, /*isThumb=*/false,
-      /*isReferencedDynamically=*/false, /*noDeadStrip=*/false);
+      /*includeInSymtab=*/true, /*isReferencedDynamically=*/false,
+      /*noDeadStrip=*/false);
   symbols.push_back(newSym);
 }
 
 void ObjCStubsSection::setUp() {
   Symbol *objcMsgSend = symtab->addUndefined("_objc_msgSend", /*file=*/nullptr,
                                              /*isWeakRef=*/false);
   objcMsgSend->used = true;
   in.got->addEntry(objcMsgSend);
void FunctionStartsSection::finalizeContents() {
   std::vector<uint64_t> addrs;
   for (const InputFile *file : inputFiles) {
     if (auto *objFile = dyn_cast<ObjFile>(file)) {
       for (const Symbol *sym : objFile->symbols) {
         if (const auto *defined = dyn_cast_or_null<Defined>(sym)) {
           if (!defined->isec || !isCodeSection(defined->isec) ||
               !defined->isLive())
             continue;
-          // TODO: Add support for thumbs, in that case
-          // the lowest bit of nextAddr needs to be set to 1.
           addrs.push_back(defined->getVA());
         }
       }
     }
   }
   llvm::sort(addrs);
   uint64_t addr = in.header->addr;
   for (uint64_t nextAddr : addrs) {
if (auto *defined = dyn_cast<Defined>(entry.sym)) {
         nList->n_sect = NO_SECT;
         nList->n_value = defined->value;
       } else {
         nList->n_type = scope | N_SECT;
         nList->n_sect = defined->isec->parent->index;
         // For the N_SECT symbol type, n_value is the address of the symbol
         nList->n_value = defined->getVA();
       }
-      nList->n_desc |= defined->thumb ? N_ARM_THUMB_DEF : 0;
       nList->n_desc |= defined->isExternalWeakDef() ? N_WEAK_DEF : 0;
       nList->n_desc |=
           defined->referencedDynamically ? REFERENCED_DYNAMICALLY : 0;
     } else if (auto *dysym = dyn_cast<DylibSymbol>(entry.sym)) {
       uint16_t n_desc = nList->n_desc;
       int16_t ordinal = ordinalForDylibSymbol(*dysym);
       if (ordinal == BIND_SPECIAL_DYLIB_FLAT_LOOKUP)
         SET_LIBRARY_ORDINAL(n_desc, DYNAMIC_LOOKUP_ORDINAL);

lld/MachO/Target.h

public:
   // good choice because it is (a) only 1 away from wrapping to 0, and (b) the
   // tombstone value for DenseMap<> and caused weird assertions for me.
   static constexpr uint64_t outOfRangeVA = 0xfull << 60;
 };
 
 TargetInfo *createX86_64TargetInfo();
 TargetInfo *createARM64TargetInfo();
 TargetInfo *createARM64_32TargetInfo();
-TargetInfo *createARMTargetInfo(uint32_t cpuSubtype);
 
 struct LP64 {
   using mach_header = llvm::MachO::mach_header_64;
   using nlist = structs::nlist_64;
   using segment_command = llvm::MachO::segment_command_64;
   using section = llvm::MachO::section_64;
   using encryption_info_command = llvm::MachO::encryption_info_command_64;
 

lld/MachO/UnwindInfoSection.cpp

if (auto *referentIsec = r.referent.dyn_cast<InputSection *>()) {
       Symbol *&s = personalityTable[{referentIsec, r.addend}];
       if (s == nullptr) {
         // This runs after dead stripping, so the noDeadStrip argument does not
         // matter.
         s = make<Defined>("<internal>", /*file=*/nullptr, referentIsec,
                           r.addend, /*size=*/0, /*isWeakDef=*/false,
                           /*isExternal=*/false, /*isPrivateExtern=*/false,
                           /*includeInSymtab=*/true,
-                          /*isThumb=*/false, /*isReferencedDynamically=*/false,
+                          /*isReferencedDynamically=*/false,
                           /*noDeadStrip=*/false);
         s->used = true;
         in.got->addEntry(s);
       }
       r.referent = s;
       r.addend = 0;
     }
   }

lld/test/MachO/arm-branch-relocs.s

-# REQUIRES: arm
-# RUN: llvm-mc -filetype=obj -triple=armv7-apple-watchos %s -o %t.o
-# RUN: %lld-watchos -dylib -arch armv7 -lSystem -o %t %t.o
-# RUN: llvm-objdump --macho -d %t | FileCheck %s
-
-# CHECK:      _arm:
-# CHECK-NEXT: blx _thumb_1
-# CHECK-NEXT: blx _thumb_2
-# CHECK-NEXT: bl  _arm
-# CHECK-NEXT: bl  _arm
-
-.globl _arm, _thumb_1, _thumb_2
-.syntax unified
-.thumb_func _thumb_1
-.thumb_func _thumb_2
-
-.p2align 2
-
-.code 16
-## These two thumb functions are exactly 2 bytes apart in order to test that we
-## set the H bit correctly in the BLX instruction.
-_thumb_1:
-  nop
-
-_thumb_2:
-  nop
-
-.code 32
-_arm:
-  blx _thumb_1
-  blx _thumb_2
-  bl _arm
-  blx _arm

lld/test/MachO/arm-dtrace.s

-# REQUIRES: arm
-# RUN: rm -rf %t; split-file %s %t
-
-# TODO: Replace %no-lsystem-lld with %lld
-
-# RUN: llvm-mc -filetype=obj -triple=armv4t-apple-darwin %t/armv4t-dtrace.s -o %t/armv4t-dtrace.o
-# RUN: %no-lsystem-lld -arch armv4t -o %t/armv4t-dtrace %t/armv4t-dtrace.o
-
-## If references of dtrace symbols are handled by lld, their relocation should be replaced with the following instructions
-# RUN: llvm-objdump --macho -D %t/armv4t-dtrace | FileCheck %s --check-prefix=CHECK-armv4t
-
-# CHECK-armv4t: 00 00 20 e0  eor     r0, r0, r0
-
-# CHECK-armv4t: 00 00 a0 e1  mov     r0, r0
-
-# RUN: llvm-mc -filetype=obj -triple=thumbv7-apple-darwin %t/armv7-dtrace.s -o %t/armv7-dtrace.o
-# RUN: %no-lsystem-lld -arch armv7 -o %t/armv7-dtrace %t/armv7-dtrace.o
-
-## If references of dtrace symbols are handled by lld, their relocation should be replaced with the following instructions
-# RUN: llvm-objdump --macho -D %t/armv7-dtrace | FileCheck %s --check-prefix=CHECK-armv7
-
-# CHECK-armv7:      40 40   eors    r0, r0
-# CHECK-armv7-NEXT: c0 46   mov     r8, r8
-
-# CHECK-armv7:      c0 46   mov     r8, r8
-# CHECK-armv7-NEXT: c0 46   mov     r8, r8
-
-;--- armv4t-dtrace.s
-  .globl  _main
-_main:
-  bl  ___dtrace_isenabled$Foo$added$v1
-  .reference  ___dtrace_typedefs$Foo$v2
-  bl  ___dtrace_probe$Foo$added$v1$696e74
-  .reference  ___dtrace_stability$Foo$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0
-
-.subsections_via_symbols
-
-;--- armv7-dtrace.s
-  .globl  _main
-  .thumb_func _main
-_main:
-  bl  ___dtrace_isenabled$Foo$added$v1
-  .reference  ___dtrace_typedefs$Foo$v2
-  bl  ___dtrace_probe$Foo$added$v1$696e74
-  .reference  ___dtrace_stability$Foo$v1$1_1_0_1_1_0_1_1_0_1_1_0_1_1_0
-
-.subsections_via_symbols

lld/test/MachO/header.s

-# REQUIRES: x86, aarch64, arm
+# REQUIRES: x86, aarch64
 # RUN: rm -rf %t && mkdir -p %t
 # RUN: llvm-mc -filetype=obj -triple=x86_64-apple-darwin %s -o %t/x86-64-test.o
 # RUN: llvm-mc -filetype=obj -triple=arm64-apple-darwin %s -o %t/arm64-test.o
 # RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos %s -o %t/arm64-32-test.o
 # RUN: llvm-mc -filetype=obj -triple=arm64_32-apple-watchos %s -o %t/arm64-32-test.o
-# RUN: llvm-mc -filetype=obj -triple=armv7-apple-watchos %s -o %t/arm-test.o
 
 # RUN: %lld -lSystem -arch x86_64 -o %t/x86-64-executable %t/x86-64-test.o
 # RUN: %lld -lSystem -arch arm64 -o %t/arm64-executable %t/arm64-test.o
 # RUN: %lld-watchos -lSystem -o %t/arm64-32-executable %t/arm64-32-test.o
-# RUN: %lld-watchos -lSystem -arch armv7 -o %t/arm-executable %t/arm-test.o
 
 # RUN: %lld -arch x86_64 -dylib -o %t/x86-64-dylib %t/x86-64-test.o
 
 ## NOTE: recent versions of ld64 don't emit LIB64 for x86-64-executable, maybe we should follow suit
 # RUN: llvm-objdump --macho --private-header %t/x86-64-executable | FileCheck %s --check-prefix=EXEC -DCPU=X86_64 -DSUBTYPE=ALL -DCAPS=LIB64
 # RUN: llvm-objdump --macho --private-header %t/arm64-executable | FileCheck %s --check-prefix=EXEC -DCPU=ARM64 -DSUBTYPE=ALL -DCAPS=0x00
 # RUN: llvm-objdump --macho --private-header %t/arm64-32-executable | FileCheck %s --check-prefix=EXEC -DCPU=ARM64_32 -DSUBTYPE=V8 -DCAPS=0x00
-# RUN: llvm-objdump --macho --private-header %t/arm-executable | FileCheck %s  --check-prefix=EXEC -DCPU=ARM -DSUBTYPE=V7 -DCAPS=0x00
 
 # RUN: llvm-objdump --macho --private-header %t/x86-64-dylib | FileCheck %s --check-prefix=DYLIB -DCPU=X86_64 -DSUBTYPE=ALL -DCAPS=0x00
 
 # EXEC:      magic               cputype  cpusubtype   caps     filetype {{.*}} flags
 # EXEC-NEXT: MH_MAGIC{{(_64)?}}  [[CPU]]  [[SUBTYPE]]  [[CAPS]] EXECUTE  {{.*}} NOUNDEFS DYLDLINK TWOLEVEL PIE{{$}}
 
 # DYLIB:      magic                  cputype  cpusubtype   caps      filetype {{.*}} flags
 # DYLIB-NEXT: MH_MAGIC_64{{(_64)?}}  [[CPU]]  [[SUBTYPE]]  [[CAPS]]  DYLIB    {{.*}} NOUNDEFS DYLDLINK TWOLEVEL NO_REEXPORTED_DYLIBS{{$}}
 
 .globl _main
 _main:

lld/test/MachO/weak-def-thumb-conflict.s

-# REQUIRES: arm
-# RUN: rm -rf %t; split-file %s %t
-# RUN: llvm-mc -filetype=obj -triple=armv7-apple-watchos %t/thumb-foo.s -o %t/thumb-foo.o
-# RUN: llvm-mc -filetype=obj -triple=armv7-apple-watchos %t/arm-foo.s -o %t/arm-foo.o
-# RUN: %lld-watchos -arch armv7 -dylib %t/arm-foo.o %t/thumb-foo.o -o %t/arm-foo
-# RUN: %lld-watchos -arch armv7 -dylib %t/thumb-foo.o %t/arm-foo.o -o %t/thumb-foo
-# RUN: llvm-nm -m %t/arm-foo | FileCheck %s --check-prefix=ARM
-# RUN: llvm-nm -m %t/thumb-foo | FileCheck %s --check-prefix=THUMB
-
-## Check that we preserve the .thumb_def flag if we pick the thumb definition of
-## _foo.
-# ARM:   (__TEXT,arm)   weak external         _foo
-# THUMB: (__TEXT,thumb) weak external [Thumb] _foo
-
-#--- thumb-foo.s
-.section __TEXT,thumb
-.globl _foo
-.weak_definition _foo
-.thumb_func _foo
-.p2align 2
-_foo:
-
-#--- arm-foo.s
-.section __TEXT,arm
-.globl _foo
-.weak_definition _foo
-.p2align 2
-_foo: