[ELF] Make .captable explicitly MIPS-specific

CHERI-RISC-V no longer uses it, and Morello never has downstream.

Author: jrtc27

lld/ELF/Arch/Cheri.cpp

@@ -583,14 +583,14 @@ void CheriCapRelocsSection::writeTo(uint8_t *buf) {
   invokeELFT(writeToImpl, buf);
 }
 
-CheriCapTableSection::CheriCapTableSection()
+MipsCheriCapTableSection::MipsCheriCapTableSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                        config->capabilitySize, ".captable") {
   assert(config->capabilitySize > 0);
   this->entsize = config->capabilitySize;
 }
 
-void CheriCapTableSection::writeTo(uint8_t* buf) {
+void MipsCheriCapTableSection::writeTo(uint8_t *buf) {
   // Capability part should be filled with all zeros and crt_init_globals fills
   // it in. For the TLS part, assignValuesAndAddCapTableSymbols adds any static
   // relocations needed, and should be procesed by relocateAlloc.
@@ -603,8 +603,8 @@ static Defined *findMatchingFunction(const InputSectionBase *isec,
   return isec->getEnclosingFunction(symOffset);
 }
 
-CheriCapTableSection::CaptableMap &
-CheriCapTableSection::getCaptableMapForFileAndOffset(
+MipsCheriCapTableSection::CaptableMap &
+MipsCheriCapTableSection::getCaptableMapForFileAndOffset(
     const InputSectionBase *isec, uint64_t offset) {
   if (LLVM_LIKELY(config->capTableScope == CapTableScopePolicy::All))
     return globalEntries;
@@ -626,17 +626,18 @@ CheriCapTableSection::getCaptableMapForFileAndOffset(
   return globalEntries;
 }
 
-void CheriCapTableSection::addEntry(Symbol &sym, RelExpr expr,
-                                    InputSectionBase *isec, uint64_t offset) {
+void MipsCheriCapTableSection::addEntry(Symbol &sym, RelExpr expr,
+                                        InputSectionBase *isec,
+                                        uint64_t offset) {
   // FIXME: can this be called from multiple threads?
   CapTableIndex idx;
   idx.needsSmallImm = false;
   idx.usedInCallExpr = false;
   idx.firstUse = SymbolAndOffset(isec, offset);
   assert(!idx.firstUse->symOrSec.isNull());
   switch (expr) {
-  case R_CHERI_CAPABILITY_TABLE_INDEX_SMALL_IMMEDIATE:
-  case R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE:
+  case R_MIPS_CHERI_CAPTAB_INDEX_SMALL_IMMEDIATE:
+  case R_MIPS_CHERI_CAPTAB_INDEX_CALL_SMALL_IMMEDIATE:
     idx.needsSmallImm = true;
     break;
   default:
@@ -648,8 +649,8 @@ void CheriCapTableSection::addEntry(Symbol &sym, RelExpr expr,
   // not used as a function pointer and therefore does not need a unique
   // address (plt stub) across all DSOs.
   switch (expr) {
-  case R_CHERI_CAPABILITY_TABLE_INDEX_CALL:
-  case R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE:
+  case R_MIPS_CHERI_CAPTAB_INDEX_CALL:
+  case R_MIPS_CHERI_CAPTAB_INDEX_CALL_SMALL_IMMEDIATE:
     if (!sym.isFunc() && !sym.isUndefWeak()) {
       CheriCapRelocLocation loc{isec, offset};
       std::string msg = "call relocation against non-function symbol " + verboseToString(&sym, 0) +
@@ -689,25 +690,25 @@ void CheriCapTableSection::addEntry(Symbol &sym, RelExpr expr,
   }
 }
 
-void CheriCapTableSection::addDynTlsEntry(Symbol &sym) {
+void MipsCheriCapTableSection::addDynTlsEntry(Symbol &sym) {
   dynTlsEntries.map.insert(std::make_pair(&sym, CapTableIndex()));
 }
 
-void CheriCapTableSection::addTlsIndex() {
+void MipsCheriCapTableSection::addTlsIndex() {
   dynTlsEntries.map.insert(std::make_pair(nullptr, CapTableIndex()));
 }
 
-void CheriCapTableSection::addTlsEntry(Symbol &sym) {
+void MipsCheriCapTableSection::addTlsEntry(Symbol &sym) {
   tlsEntries.map.insert(std::make_pair(&sym, CapTableIndex()));
 }
 
-uint32_t CheriCapTableSection::getIndex(const Symbol &sym,
-                                        const InputSectionBase *isec,
-                                        uint64_t offset) const {
+uint32_t MipsCheriCapTableSection::getIndex(const Symbol &sym,
+                                            const InputSectionBase *isec,
+                                            uint64_t offset) const {
   assert(valuesAssigned && "getIndex called before index assignment");
   const CaptableMap &entries =
-      const_cast<CheriCapTableSection *>(this)->getCaptableMapForFileAndOffset(
-          isec, offset);
+      const_cast<MipsCheriCapTableSection *>(this)
+          ->getCaptableMapForFileAndOffset(isec, offset);
   auto it = entries.map.find(const_cast<Symbol *>(&sym));
   assert(entries.firstIndex != std::numeric_limits<uint64_t>::max() &&
          "First index not set yet?");
@@ -719,31 +720,31 @@ uint32_t CheriCapTableSection::getIndex(const Symbol &sym,
   return *it->second.index - entries.firstIndex;
 }
 
-uint32_t CheriCapTableSection::getDynTlsOffset(const Symbol &sym) const {
+uint32_t MipsCheriCapTableSection::getDynTlsOffset(const Symbol &sym) const {
   assert(valuesAssigned && "getDynTlsOffset called before index assignment");
   auto it = dynTlsEntries.map.find(const_cast<Symbol *>(&sym));
   assert(it != dynTlsEntries.map.end());
   return *it->second.index * config->wordsize;
 }
 
-uint32_t CheriCapTableSection::getTlsIndexOffset() const {
+uint32_t MipsCheriCapTableSection::getTlsIndexOffset() const {
   assert(valuesAssigned && "getTlsIndexOffset called before index assignment");
   auto it = dynTlsEntries.map.find(nullptr);
   assert(it != dynTlsEntries.map.end());
   return *it->second.index * config->wordsize;
 }
 
-uint32_t CheriCapTableSection::getTlsOffset(const Symbol &sym) const {
+uint32_t MipsCheriCapTableSection::getTlsOffset(const Symbol &sym) const {
   assert(valuesAssigned && "getTlsOffset called before index assignment");
   auto it = tlsEntries.map.find(const_cast<Symbol *>(&sym));
   assert(it != tlsEntries.map.end());
   return *it->second.index * config->wordsize;
 }
 
 template <class ELFT>
-uint64_t CheriCapTableSection::assignIndices(uint64_t startIndex,
-                                             CaptableMap &entries,
-                                             const Twine &symContext) {
+uint64_t MipsCheriCapTableSection::assignIndices(uint64_t startIndex,
+                                                 CaptableMap &entries,
+                                                 const Twine &symContext) {
   // Usually StartIndex will be zero (one global captable) but if we are
   // compiling with per-file/per-function
   uint64_t smallEntryCount = 0;
@@ -846,7 +847,7 @@ uint64_t CheriCapTableSection::assignIndices(uint64_t startIndex,
     RelocationBaseSection *dynRelSec =
         it.second.usedInCallExpr ? in.relaPlt.get() : mainPart->relaDyn.get();
     addCapabilityRelocation<ELFT>(
-        targetSym, elfCapabilityReloc, in.cheriCapTable.get(), off,
+        targetSym, elfCapabilityReloc, in.mipsCheriCapTable.get(), off,
         R_CHERI_CAPABILITY, 0, it.second.usedInCallExpr,
         [&]() {
           return ("\n>>> referenced by " + refName + "\n>>> first used in " +
@@ -860,7 +861,7 @@ uint64_t CheriCapTableSection::assignIndices(uint64_t startIndex,
 }
 
 template <class ELFT>
-void CheriCapTableSection::assignValuesAndAddCapTableSymbols() {
+void MipsCheriCapTableSection::assignValuesAndAddCapTableSymbols() {
   // First assign the global indices (which will usually be the only ones)
   uint64_t assignedEntries = assignIndices<ELFT>(0, globalEntries, "");
   if (LLVM_UNLIKELY(config->capTableScope != CapTableScopePolicy::All)) {
@@ -948,22 +949,22 @@ void CheriCapTableSection::assignValuesAndAddCapTableSymbols() {
 }
 
 template void
-CheriCapTableSection::assignValuesAndAddCapTableSymbols<ELF32LE>();
+MipsCheriCapTableSection::assignValuesAndAddCapTableSymbols<ELF32LE>();
 template void
-CheriCapTableSection::assignValuesAndAddCapTableSymbols<ELF32BE>();
+MipsCheriCapTableSection::assignValuesAndAddCapTableSymbols<ELF32BE>();
 template void
-CheriCapTableSection::assignValuesAndAddCapTableSymbols<ELF64LE>();
+MipsCheriCapTableSection::assignValuesAndAddCapTableSymbols<ELF64LE>();
 template void
-CheriCapTableSection::assignValuesAndAddCapTableSymbols<ELF64BE>();
+MipsCheriCapTableSection::assignValuesAndAddCapTableSymbols<ELF64BE>();
 
-CheriCapTableMappingSection::CheriCapTableMappingSection()
+MipsCheriCapTableMappingSection::MipsCheriCapTableMappingSection()
     : SyntheticSection(SHF_ALLOC, SHT_PROGBITS, 8, ".captable_mapping") {
   assert(config->capabilitySize > 0);
   this->entsize = sizeof(CaptableMappingEntry);
   static_assert(sizeof(CaptableMappingEntry) == 24, "");
 }
 
-size_t CheriCapTableMappingSection::getSize() const {
+size_t MipsCheriCapTableMappingSection::getSize() const {
   assert(config->capTableScope != CapTableScopePolicy::All);
   if (!isNeeded())
     return 0;
@@ -980,9 +981,9 @@ size_t CheriCapTableMappingSection::getSize() const {
   return count * sizeof(CaptableMappingEntry);
 }
 
-void CheriCapTableMappingSection::writeTo(uint8_t *buf) {
+void MipsCheriCapTableMappingSection::writeTo(uint8_t *buf) {
   assert(config->capTableScope != CapTableScopePolicy::All);
-  if (!in.cheriCapTable)
+  if (!in.mipsCheriCapTable)
     return;
   if (!in.symTab) {
     error("Cannot write " + this->name + " without .symtab section!");
@@ -997,14 +998,14 @@ void CheriCapTableMappingSection::writeTo(uint8_t *buf) {
     Symbol* sym = ste.sym;
     if (!sym->isDefined() || !sym->isFunc())
       continue;
-    const CheriCapTableSection::CaptableMap *capTableMap = nullptr;
+    const MipsCheriCapTableSection::CaptableMap *capTableMap = nullptr;
     if (config->capTableScope == CapTableScopePolicy::Function) {
-      auto it = in.cheriCapTable->perFunctionEntries.find(sym);
-      if (it != in.cheriCapTable->perFunctionEntries.end())
+      auto it = in.mipsCheriCapTable->perFunctionEntries.find(sym);
+      if (it != in.mipsCheriCapTable->perFunctionEntries.end())
         capTableMap = &it->second;
     } else if (config->capTableScope == CapTableScopePolicy::File) {
-      auto it = in.cheriCapTable->perFileEntries.find(sym->file);
-      if (it != in.cheriCapTable->perFileEntries.end())
+      auto it = in.mipsCheriCapTable->perFileEntries.find(sym->file);
+      if (it != in.mipsCheriCapTable->perFileEntries.end())
         capTableMap = &it->second;
     } else {
       llvm_unreachable("Invalid mode!");

lld/ELF/Arch/Cheri.h

@@ -186,9 +186,9 @@ class CheriCapRelocsSection : public SyntheticSection {
 // +---------------------------------------+
 // TODO: TLS caps also need to be per file/function
 
-class CheriCapTableSection : public SyntheticSection {
+class MipsCheriCapTableSection : public SyntheticSection {
 public:
-  CheriCapTableSection();
+  MipsCheriCapTableSection();
   // InputFile and Offset is needed in order to implement per-file/per-function
   // tables
   void addEntry(Symbol &sym, RelExpr expr, InputSectionBase *isec,
@@ -266,7 +266,7 @@ class CheriCapTableSection : public SyntheticSection {
   CaptableMap dynTlsEntries;
   CaptableMap tlsEntries;
   bool valuesAssigned = false;
-  friend class CheriCapTableMappingSection;
+  friend class MipsCheriCapTableMappingSection;
 };
 
 // TODO: could shrink these to reduce size overhead but this is experimental
@@ -280,13 +280,13 @@ struct CaptableMappingEntry {
 
 // Map from symbol vaddr -> captable subset so that RTLD can setup the correct
 // trampolines to initialize $cgp to the correct subset
-class CheriCapTableMappingSection : public SyntheticSection {
+class MipsCheriCapTableMappingSection : public SyntheticSection {
 public:
-  CheriCapTableMappingSection();
+  MipsCheriCapTableMappingSection();
   bool isNeeded() const override {
     if (config->capTableScope == CapTableScopePolicy::All)
       return false;
-    return in.cheriCapTable && in.cheriCapTable->isNeeded();
+    return in.mipsCheriCapTable && in.mipsCheriCapTable->isNeeded();
   }
   void writeTo(uint8_t *buf) override;
   size_t getSize() const override;

lld/ELF/Arch/Mips.cpp

@@ -123,7 +123,7 @@ RelExpr MIPS<ELFT>::getRelExpr(RelType type, const Symbol &s,
   case R_MICROMIPS_GPREL7_S2:
     return R_MIPS_GOTREL;
   case R_MIPS_CHERI_CAPTABLEREL16:
-    return R_CHERI_CAPABILITY_TABLE_REL;
+    return R_MIPS_CHERI_CAPTAB_REL;
   case R_MIPS_26:
   case R_MICROMIPS_26_S1:
     return R_PLT;
@@ -212,16 +212,16 @@ RelExpr MIPS<ELFT>::getRelExpr(RelType type, const Symbol &s,
     return R_CHERI_CAPABILITY;
   case R_MIPS_CHERI_CAPTAB_LO16:
   case R_MIPS_CHERI_CAPTAB_HI16:
-    return R_CHERI_CAPABILITY_TABLE_INDEX;
+    return R_MIPS_CHERI_CAPTAB_INDEX;
   case R_MIPS_CHERI_CAPCALL_LO16:
   case R_MIPS_CHERI_CAPCALL_HI16:
-    return R_CHERI_CAPABILITY_TABLE_INDEX_CALL;
+    return R_MIPS_CHERI_CAPTAB_INDEX_CALL;
   case R_MIPS_CHERI_CAPTAB_CLC11:
   case R_MIPS_CHERI_CAPTAB20:
-    return R_CHERI_CAPABILITY_TABLE_INDEX_SMALL_IMMEDIATE;
+    return R_MIPS_CHERI_CAPTAB_INDEX_SMALL_IMMEDIATE;
   case R_MIPS_CHERI_CAPCALL_CLC11:
   case R_MIPS_CHERI_CAPCALL20:
-    return R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE;
+    return R_MIPS_CHERI_CAPTAB_INDEX_CALL_SMALL_IMMEDIATE;
   case R_MIPS_CHERI_CAPTAB_TLS_GD_LO16:
   case R_MIPS_CHERI_CAPTAB_TLS_GD_HI16:
     return R_MIPS_CHERI_CAPTAB_TLSGD;

lld/ELF/InputSection.cpp

@@ -863,28 +863,28 @@ uint64_t InputSectionBase::getRelocTargetVA(const InputFile *file, RelType type,
     return in.got->getTlsIndexVA() + a - p;
   case R_CHERI_CAPABILITY:
     llvm_unreachable("R_CHERI_CAPABILITY should not be handled here!");
-  case R_CHERI_CAPABILITY_TABLE_INDEX:
-  case R_CHERI_CAPABILITY_TABLE_INDEX_SMALL_IMMEDIATE:
-  case R_CHERI_CAPABILITY_TABLE_INDEX_CALL:
-  case R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE:
+  case R_MIPS_CHERI_CAPTAB_INDEX:
+  case R_MIPS_CHERI_CAPTAB_INDEX_SMALL_IMMEDIATE:
+  case R_MIPS_CHERI_CAPTAB_INDEX_CALL:
+  case R_MIPS_CHERI_CAPTAB_INDEX_CALL_SMALL_IMMEDIATE:
     assert(a == 0 && "capability table index relocs should not have addends");
-    return sym.getCapTableOffset(isec, offset);
-  case R_CHERI_CAPABILITY_TABLE_REL:
-    if (!ElfSym::cheriCapabilityTable) {
+    return sym.getMipsCheriCapTableOffset(isec, offset);
+  case R_MIPS_CHERI_CAPTAB_REL:
+    if (!ElfSym::mipsCheriCapabilityTable) {
       error("cannot compute difference between non-existent "
             "CheriCapabilityTable and symbol " + toString(sym));
       return sym.getVA(a);
     }
-    return sym.getVA(a) - ElfSym::cheriCapabilityTable->getVA();
+    return sym.getVA(a) - ElfSym::mipsCheriCapabilityTable->getVA();
   case R_MIPS_CHERI_CAPTAB_TLSGD:
     assert(a == 0 && "capability table index relocs should not have addends");
-    return in.cheriCapTable->getDynTlsOffset(sym);
+    return in.mipsCheriCapTable->getDynTlsOffset(sym);
   case R_MIPS_CHERI_CAPTAB_TLSLD:
     assert(a == 0 && "capability table index relocs should not have addends");
-    return in.cheriCapTable->getTlsIndexOffset();
+    return in.mipsCheriCapTable->getTlsIndexOffset();
   case R_MIPS_CHERI_CAPTAB_TPREL:
     assert(a == 0 && "capability table index relocs should not have addends");
-    return in.cheriCapTable->getTlsOffset(sym);
+    return in.mipsCheriCapTable->getTlsOffset(sym);
   default:
     llvm_unreachable("invalid expression");
   }

lld/ELF/Relocations.cpp

@@ -222,7 +222,7 @@ static bool isRelExpr(RelExpr expr) {
   return oneof<R_PC, R_GOTREL, R_GOTPLTREL, R_MIPS_GOTREL, R_PPC64_CALL,
                R_PPC64_RELAX_TOC, R_AARCH64_PAGE_PC, R_RELAX_GOT_PC,
                R_RISCV_PC_INDIRECT, R_PPC64_RELAX_GOT_PC, R_LOONGARCH_PAGE_PC,
-               R_CHERI_CAPABILITY_TABLE_REL>(expr);
+               R_MIPS_CHERI_CAPTAB_REL>(expr);
 }
 
 static RelExpr toPlt(RelExpr expr) {
@@ -976,11 +976,11 @@ bool RelocationScanner::isStaticLinkTimeConstant(RelExpr e, RelType type,
   // These expressions always compute a constant
   if (oneof<R_GOTPLT, R_GOT_OFF, R_RELAX_HINT, R_MIPS_GOT_LOCAL_PAGE,
             R_MIPS_GOTREL, R_MIPS_GOT_OFF, R_MIPS_GOT_OFF32, R_MIPS_GOT_GP_PC,
-            R_CHERI_CAPABILITY_TABLE_INDEX,
-            R_CHERI_CAPABILITY_TABLE_INDEX_SMALL_IMMEDIATE,
-            R_CHERI_CAPABILITY_TABLE_INDEX_CALL,
-            R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE,
-            R_CHERI_CAPABILITY_TABLE_REL,
+            R_MIPS_CHERI_CAPTAB_INDEX,
+            R_MIPS_CHERI_CAPTAB_INDEX_SMALL_IMMEDIATE,
+            R_MIPS_CHERI_CAPTAB_INDEX_CALL,
+            R_MIPS_CHERI_CAPTAB_INDEX_CALL_SMALL_IMMEDIATE,
+            R_MIPS_CHERI_CAPTAB_REL,
             R_AARCH64_GOT_PAGE_PC, R_GOT_PC, R_GOTONLY_PC, R_GOTPLTONLY_PC,
             R_PLT_PC, R_PLT_GOTPLT, R_PPC32_PLTREL, R_PPC64_CALL_PLT,
             R_PPC64_RELAX_TOC, R_RISCV_ADD, R_AARCH64_GOT_PAGE,
@@ -1087,12 +1087,12 @@ void RelocationScanner::processAux(RelExpr expr, RelType type, uint64_t offset,
     return;
   }
 
-  if (oneof<R_CHERI_CAPABILITY_TABLE_INDEX,
-            R_CHERI_CAPABILITY_TABLE_INDEX_SMALL_IMMEDIATE,
-            R_CHERI_CAPABILITY_TABLE_INDEX_CALL,
-            R_CHERI_CAPABILITY_TABLE_INDEX_CALL_SMALL_IMMEDIATE>(expr)) {
+  if (oneof<R_MIPS_CHERI_CAPTAB_INDEX,
+            R_MIPS_CHERI_CAPTAB_INDEX_SMALL_IMMEDIATE,
+            R_MIPS_CHERI_CAPTAB_INDEX_CALL,
+            R_MIPS_CHERI_CAPTAB_INDEX_CALL_SMALL_IMMEDIATE>(expr)) {
     std::lock_guard<std::mutex> lock(relocMutex);
-    in.cheriCapTable->addEntry(sym, expr, sec, offset);
+    in.mipsCheriCapTable->addEntry(sym, expr, sec, offset);
     // Write out the index into the instruction
     sec->relocations.push_back({expr, type, offset, addend, &sym});
     return;
@@ -1295,17 +1295,17 @@ static unsigned handleMipsTlsRelocation(RelType type, Symbol &sym,
     return 1;
   }
   if (expr == R_MIPS_CHERI_CAPTAB_TLSLD) {
-    in.cheriCapTable->addTlsIndex();
+    in.mipsCheriCapTable->addTlsIndex();
     c.relocations.push_back({expr, type, offset, addend, &sym});
     return 1;
   }
   if (expr == R_MIPS_CHERI_CAPTAB_TLSGD) {
-    in.cheriCapTable->addDynTlsEntry(sym);
+    in.mipsCheriCapTable->addDynTlsEntry(sym);
     c.relocations.push_back({expr, type, offset, addend, &sym});
     return 1;
   }
   if (expr == R_MIPS_CHERI_CAPTAB_TPREL) {
-    in.cheriCapTable->addTlsEntry(sym);
+    in.mipsCheriCapTable->addTlsEntry(sym);
     c.relocations.push_back({expr, type, offset, addend, &sym});
     return 1;
   }