[NFCI][ELF] Move undef weak capability code to align more with integer case

Burying it in addCapabilityRelocation isn't quite right, since we don't
actually want a dynamic relocation, which the name would suggest (like
addRelativeReloc). This will also help for Morello LLD, which has its
own addMorelloCapabilityRelocation that would otherwise need to
duplicate (a subset of) the code in question.

Author: jrtc27

lld/ELF/Arch/Cheri.cpp

@@ -766,15 +766,18 @@ uint64_t MipsCheriCapTableSection::assignIndices(uint64_t startIndex,
     RelocationBaseSection *dynRelSec = it.second.usedInCallExpr
                                            ? ctx.in.relaPlt.get()
                                            : ctx.mainPart->relaDyn.get();
-    addCapabilityRelocation<ELFT>(
-        ctx, targetSym, elfCapabilityReloc, this, off, R_CHERI_CAPABILITY, 0,
-        it.second.usedInCallExpr,
-        [&]() {
-          return ("\n>>> referenced by " + refName + "\n>>> first used in " +
-                  it.second.firstUse->verboseToString(ctx))
-              .str();
-        },
-        dynRelSec);
+    if (!targetSym->isPreemptible && targetSym->isUndefWeak())
+      addNullDerivedCapability(ctx, *targetSym, *this, off, 0);
+    else
+      addCapabilityRelocation<ELFT>(
+          ctx, targetSym, elfCapabilityReloc, this, off, R_CHERI_CAPABILITY, 0,
+          it.second.usedInCallExpr,
+          [&]() {
+            return ("\n>>> referenced by " + refName + "\n>>> first used in " +
+                    it.second.firstUse->verboseToString(ctx))
+                .str();
+          },
+          dynRelSec);
   }
   assert(assignedSmallIndexes + assignedLargeIndexes == entries.size());
   return assignedSmallIndexes + assignedLargeIndexes;
@@ -1030,26 +1033,10 @@ void addCapabilityRelocation(
     }
   }
 
-  // Non-preemptible undef weak symbols are link-time constants
-  if (sym && !sym->isPreemptible && sym->isUndefWeak()) {
-    if (ctx.arg.isLE) {
-      sec->addReloc({R_ABS, ctx.target->symbolicRel, offset, addend, sym});
-      sec->addReloc({R_ADDEND, ctx.target->symbolicRel,
-                     offset + ctx.arg.wordsize, 0, sym});
-    } else {
-      sec->addReloc({R_ADDEND, ctx.target->symbolicRel, offset, 0, sym});
-      sec->addReloc({R_ABS, ctx.target->symbolicRel, offset + ctx.arg.wordsize,
-                     addend, sym});
-    }
-    // Handle deprecated CHERI-256
-    if (ctx.target->getCapabilitySize() == ctx.arg.wordsize * 4) {
-      sec->addReloc({R_ADDEND, ctx.target->symbolicRel,
-                     offset + 2 * ctx.arg.wordsize, 0, sym});
-      sec->addReloc({R_ADDEND, ctx.target->symbolicRel,
-                     offset + 3 * ctx.arg.wordsize, 0, sym});
-    }
-    return;
-  }
+  // Non-preemptible undef weak symbols are link-time constants and should use
+  // addNullDerivedCapability
+  if (sym)
+    assert(sym->isPreemptible || !sym->isUndefWeak());
 
   // local cap relocs don't need a Elf relocation with a full symbol lookup:
   if (capRelocMode == CapRelocsMode::ElfReloc) {
@@ -1121,6 +1108,28 @@ void addCapabilityRelocation(
   }
 }
 
+void addNullDerivedCapability(Ctx &ctx, Symbol &sym, InputSectionBase &sec,
+                              uint64_t offset, int64_t addend) {
+  // Only non-preemptible undef weak symbols are link-time constants
+  assert(!sym.isPreemptible && sym.isUndefWeak());
+  if (ctx.arg.isLE) {
+    sec.addReloc({R_ABS, ctx.target->symbolicRel, offset, addend, &sym});
+    sec.addReloc({R_ADDEND, ctx.target->symbolicRel, offset + ctx.arg.wordsize,
+                  0, &sym});
+  } else {
+    sec.addReloc({R_ADDEND, ctx.target->symbolicRel, offset, 0, &sym});
+    sec.addReloc({R_ABS, ctx.target->symbolicRel, offset + ctx.arg.wordsize,
+                  addend, &sym});
+  }
+  // Handle deprecated CHERI-256
+  if (ctx.target->getCapabilitySize() == ctx.arg.wordsize * 4) {
+    sec.addReloc({R_ADDEND, ctx.target->symbolicRel,
+                  offset + 2 * ctx.arg.wordsize, 0, &sym});
+    sec.addReloc({R_ADDEND, ctx.target->symbolicRel,
+                  offset + 3 * ctx.arg.wordsize, 0, &sym});
+  }
+}
+
 }  // namespace elf
 }  // namespace lld
 

lld/ELF/Arch/Cheri.h

@@ -364,6 +364,9 @@ void addCapabilityRelocation(
     int64_t addend, bool isCallExpr,
     llvm::function_ref<std::string()> referencedBy,
     RelocationBaseSection *dynRelSec = nullptr);
+
+void addNullDerivedCapability(Ctx &ctx, Symbol &sym, InputSectionBase &sec,
+                              uint64_t offset, int64_t addend);
 } // namespace elf
 } // namespace lld
 

lld/ELF/Relocations.cpp

@@ -962,8 +962,11 @@ void elf::addGotEntry(Ctx &ctx, Symbol &sym) {
   }
 
   // Otherwise, the value is either a link-time constant or the load base
-  // plus a constant. For CHERI it always requires run-time initialisation.
-  if (ctx.arg.isCheriAbi) {
+  // plus a constant. For CHERI it always requires run-time initialisation,
+  // with the exception of undef weak symbols.
+  if (ctx.arg.isCheriAbi && sym.isUndefWeak())
+    addNullDerivedCapability(ctx, sym, *ctx.in.got, off, 0);
+  else if (ctx.arg.isCheriAbi) {
     invokeELFT(addCapabilityRelocation, ctx, &sym, *ctx.target->cheriCapRel,
                ctx.in.got.get(), off, R_CHERI_CAPABILITY, 0, false,
                [] { return ""; });
@@ -1057,9 +1060,10 @@ bool RelocationScanner::isStaticLinkTimeConstant(RelExpr e, RelType type,
   // Cheri capability relocations are never static link time constants since
   // even if we know the exact value of the capability we can't write it since
   // there is no way to store the tag bit
-  // TODO: for undef weak -> 0 (or other untagged values) it actually is okay
+  // The exception is for non-preemptible undef weak symbols, which are
+  // NULL-derived constants.
   if (e == R_CHERI_CAPABILITY)
-    return false;
+    return !sym.isPreemptible && sym.isUndefWeak();
 
   // These never do, except if the entire file is position dependent or if
   // only the low bits are used.
@@ -1211,8 +1215,23 @@ void RelocationScanner::processAux(RelExpr expr, RelType type, uint64_t offset,
   // If the relocation is known to be a link-time constant, we know no dynamic
   // relocation will be created, pass the control to relocateAlloc() or
   // relocateNonAlloc() to resolve it.
-  if (isStaticLinkTimeConstant(expr, type, sym, offset)) {
-    sec->addReloc({expr, type, offset, addend, &sym});
+  //
+  // The behavior of an undefined weak reference is implementation defined. For
+  // non-link-time constants, we resolve relocations statically (let
+  // relocate{,Non}Alloc() resolve them) for -no-pie and try producing dynamic
+  // relocations for -pie and -shared.
+  //
+  // The general expectation of -no-pie static linking is that there is no
+  // dynamic relocation (except IRELATIVE). Emitting dynamic relocations for
+  // -shared matches the spirit of its -z undefs default. -pie has freedom on
+  // choices, and we choose dynamic relocations to be consistent with the
+  // handling of GOT-generating relocations.
+  if (isStaticLinkTimeConstant(expr, type, sym, offset) ||
+      (!ctx.arg.isPic && sym.isUndefWeak())) {
+    if (expr == R_CHERI_CAPABILITY)
+      addNullDerivedCapability(ctx, sym, *sec, offset, addend);
+    else
+      sec->addReloc({expr, type, offset, addend, &sym});
     return;
   }