[MC,AArch64] Suppress local symbol to STT_SECTION conversion for GOT relocations

[MaskRay]

Summary

Assemblers change certain relocations referencing a local symbol to
reference the section symbol instead. This conversion is disabled for
many conditions (shouldRelocateWithSymbol), e.g. TLS symbol, for most
targets (including AArch32, x86, PowerPC, and RISC-V) GOT-generating
relocations.

However, AArch64 encodes the GOT-generating intent in MCValue::RefKind
instead of MCSymbolRef::Kind (see commit
0999cbd0b9ed8aa893cce10d681dec6d54b200ad (2014)), therefore not affected
by the code case MCSymbolRefExpr::VK_GOT:. As GNU ld and ld.lld
create GOT entries based on the symbol, ignoring addend, the two ldr
instructions will share the same GOT entry, which is not expected:

ldr     x1, [x1, :got_lo12:x]  // converted to .data+0
ldr     x1, [x1, :got_lo12:y]  // converted to .data+4

.data
// .globl x, y  would suppress STT_SECTION conversion
x:
.zero 4
y:
.long 42

This patch changes AArch64 to suppress local symbol to STT_SECTION
conversion for GOT relocations, matching most other targets. x and y
will use different GOT entries, which IMO is the most sensable behavior.

With this change, the ABI decision on https://github.com/ARM-software/abi-aa/issues/217
will only affect relocations explicitly referencing STT_SECTION symbols, e.g.

ldr     x1, [x1, :got_lo12:(.data+0)]
ldr     x1, [x1, :got_lo12:(.data+4)]
// I consider this unreasonable uses

IMO all reasonable use cases are unaffected.

Link: https://github.com/llvm/llvm-project/issues/63418
GNU assembler PR: https://sourceware.org/bugzilla/show_bug.cgi?id=30788

[MaskRay]

Note:

Having both MCValue and MCSymbol parameters in

bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
                             unsigned Type) const override;

is unfortunate but unavoidable due to .weakref handling.

To not affect .weakref behavior (strange directive, see https://sourceware.org/pipermail/binutils/2020-June/111676.html) on Mips/PowerPC, we need the const MCSymbol &Sym parameter, even if in all the other cases Sym can be easily inferred from const MCValue &Val.

[MaskRay]

llvm/test/MC/AArch64/elf-reloc-got-local.s

1 ↗

(On Diff #552584)

Sorry, this file is unneeded as the tests are subsumed by arm64-elf-relocs.s. I'll remove this file in a new revision.

[peter.smith]

Thanks for the patch. I'm in favour of making the change as this does avoid an awkward corner case in the specification with no obvious drawbacks. A couple of suggestions for extra tests. I think there could be an alternative implementation that doesn't need an extra parameter although if it is possible it does have its own drawbacks.

I'll be out of office till next Tuesday, happy for others to approve in my absence.

llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp

467

In theory this won't catch VK_GOTTPREL which would get used by something like:

adrp    x8, :gottprel:foo
ldr     x8, [x8, :gottprel_lo12:foo]

Empirically it looks like TLS relocations to local symbols via GOT expressions does not use a section symbol

        .text
        .globl  f  
        .p2align        2
        .type   f,@function
f:
        adrp    x8, :gottprel:foo
        ldr     x8, [x8, :gottprel_lo12:foo]
        mrs     x9, TPIDR_EL0
        ldr     w0, [x9, x8]
        ret

        .local foo
        .type   foo,@object
        .section        .tbss,"awT",@nobits
        .p2align        2, 0x0
foo:
        .word   0
        .size   foo, 4

generates:

Relocation section '.rela.text' at offset 0x1c0 contains 2 entries:
    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
0000000000000000  000000040000021d R_AARCH64_TLSIE_ADR_GOTTPREL_PAGE21 0000000000000000 foo + 0
0000000000000004  000000040000021e R_AARCH64_TLSIE_LD64_GOTTPREL_LO12_NC 0000000000000000 foo + 0

Could be worth a test case to make sure it doesn't get broken in the future.

llvm/lib/Target/VE/MCTargetDesc/VEELFObjectWriter.cpp

148

Assuming AArch64 behaves the same way, an alternative implementation that wouldn't need the additional parameter could use the AArch64 equivalent relocation types.

For example

case ELF::R_AARCH64_LD64_GOT_LO12_NC:
...
return true;

This would be a bit tedious to construct (ILP32 as well) wouldn't be as future proof for further GOT expressions, and we couldn't easily test it in full due to not being able to generate the relocations.

llvm/test/MC/AArch64/arm64-elf-relocs.s

319

Can we add a test case for :gotpage_lo15: as well.

        .text
        ldr x24, [x23, #:gotpage_lo15:sym]

        .bss
        .local sym
sym:
        .space 8

Will (without this change) use the section symbol + offset too:

Relocation section '.rela.text' at offset 0xc0 contains 1 entries:
    Offset             Info             Type               Symbol's Value  Symbol's Name + Addend
0000000000000000  0000000300000139 R_AARCH64_LD64_GOTPAGE_LO15 0000000000000000 .bss + 0

There are a handful more got generating operators but these are not currently supported by LLVM only GCC
https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst#64assembler-language-addressing-mode-conventions (GOT operators)

[MaskRay]

llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp

467

TLS symbols are handled by if (Flags & ELF::SHF_TLS) and this patch is unrelated to it.

I've tried implementing lld in the past for STT_SECTION but later decided that it's not a good idea. I'll need to study GNU behavior more and rewrite that gold centric comment.

llvm/lib/Target/VE/MCTargetDesc/VEELFObjectWriter.cpp

148

Yes. VK_GOT is associated with many relocation types in AArch64ELFObjectWriter.cpp. Those and ILP32 make me think that we do need an extra parameter const MCValue &Val.

[MaskRay]

• Add test for ldr x2, [x2, :gotpage_lo15:local2]
• Precommit test 1271ba473e276977d2afb443d462d0a6766d8f95 for GOT TLS relocation: related to this patch but does not need this patch

[peter.smith]

Thanks for adding the additional tests. LGTM.

llvm/include/llvm/MC/MCELFObjectWriter.h

switch (OSType) {
       default:
         return ELF::ELFOSABI_NONE;
     }
   }
 
   virtual unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                                 const MCFixup &Fixup, bool IsPCRel) const = 0;
 
-  virtual bool needsRelocateWithSymbol(const MCSymbol &Sym,
+  virtual bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
                                        unsigned Type) const;
 
   virtual void sortRelocs(const MCAssembler &Asm,
                           std::vector<ELFRelocationEntry> &Relocs);
 
   virtual void addTargetSectionFlags(MCContext &Ctx, MCSectionELF &Sec);
 
   /// \name Accessors

llvm/lib/MC/ELFObjectWriter.cpp

class ELFObjectWriter : public MCObjectWriter {
   DenseMap<const MCSectionELF *, std::vector<ELFRelocationEntry>> Relocations;
 
   DenseMap<const MCSymbolELF *, const MCSymbolELF *> Renames;
 
   bool SeenGnuAbi = false;
 
   bool hasRelocationAddend() const;
 
-  bool shouldRelocateWithSymbol(const MCAssembler &Asm,
-                                const MCSymbolRefExpr *RefA,
+  bool shouldRelocateWithSymbol(const MCAssembler &Asm, const MCValue &Val,
                                 const MCSymbolELF *Sym, uint64_t C,
                                 unsigned Type) const;
 
 public:
   ELFObjectWriter(std::unique_ptr<MCELFObjectTargetWriter> MOTW)
       : TargetObjectWriter(std::move(MOTW)) {}
 
   void reset() override {
for (const MCSymbol *&Sym : AddrsigSyms) {
     Sym->setUsedInReloc();
   }
 }
 
 // It is always valid to create a relocation with a symbol. It is preferable
 // to use a relocation with a section if that is possible. Using the section
 // allows us to omit some local symbols from the symbol table.
 bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
-                                               const MCSymbolRefExpr *RefA,
+                                               const MCValue &Val,
                                                const MCSymbolELF *Sym,
                                                uint64_t C,
                                                unsigned Type) const {
+  const MCSymbolRefExpr *RefA = Val.getSymA();
   // A PCRel relocation to an absolute value has no symbol (or section). We
   // represent that with a relocation to a null section.
   if (!RefA)
     return false;
 
   MCSymbolRefExpr::VariantKind Kind = RefA->getKind();
   switch (Kind) {
   default:
bool ELFObjectWriter::shouldRelocateWithSymbol(const MCAssembler &Asm,
 
   // If the symbol is a thumb function the final relocation must set the lowest
   // bit. With a symbol that is done by just having the symbol have that bit
   // set, so we would lose the bit if we relocated with the section.
   // FIXME: We could use the section but add the bit to the relocation value.
   if (Asm.isThumbFunc(Sym))
     return true;
 
-  if (TargetObjectWriter->needsRelocateWithSymbol(*Sym, Type))
+  if (TargetObjectWriter->needsRelocateWithSymbol(Val, *Sym, Type))
     return true;
   return false;
 }
 
 void ELFObjectWriter::recordRelocation(MCAssembler &Asm,
                                        const MCAsmLayout &Layout,
                                        const MCFragment *Fragment,
                                        const MCFixup &Fixup, MCValue Target,
const MCSectionELF *SecA = (SymA && SymA->isInSection())
                                  : nullptr;
   if (!checkRelocation(Ctx, Fixup.getLoc(), &FixupSection, SecA))
     return;
 
   unsigned Type = TargetObjectWriter->getRelocType(Ctx, Target, Fixup, IsPCRel);
   const auto *Parent = cast<MCSectionELF>(Fragment->getParent());
   // Emiting relocation with sybmol for CG Profile to  help with --cg-profile.
   bool RelocateWithSymbol =
-      shouldRelocateWithSymbol(Asm, RefA, SymA, C, Type) ||
+      shouldRelocateWithSymbol(Asm, Target, SymA, C, Type) ||
       (Parent->getType() == ELF::SHT_LLVM_CALL_GRAPH_PROFILE);
   uint64_t Addend = 0;
 
   FixedValue = !RelocateWithSymbol && SymA && !SymA->isUndefined()
                    ? C + Layout.getSymbolOffset(*SymA)
                    : C;
   if (hasRelocationAddend()) {
     Addend = FixedValue;

llvm/lib/MC/MCELFObjectTargetWriter.cpp

 
 MCELFObjectTargetWriter::MCELFObjectTargetWriter(bool Is64Bit_, uint8_t OSABI_,
                                                  uint16_t EMachine_,
                                                  bool HasRelocationAddend_,
                                                  uint8_t ABIVersion_)
     : OSABI(OSABI_), ABIVersion(ABIVersion_), EMachine(EMachine_),
       HasRelocationAddend(HasRelocationAddend_), Is64Bit(Is64Bit_) {}
 
-bool MCELFObjectTargetWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
+bool MCELFObjectTargetWriter::needsRelocateWithSymbol(const MCValue &,
+                                                      const MCSymbol &,
                                                       unsigned Type) const {
   return false;
 }
 
 void
 MCELFObjectTargetWriter::sortRelocs(const MCAssembler &Asm,
                                     std::vector<ELFRelocationEntry> &Relocs) {
 }
 
 void MCELFObjectTargetWriter::addTargetSectionFlags(MCContext &Ctx,
                                                     MCSectionELF &Sec) {}

llvm/lib/Target/AArch64/MCTargetDesc/AArch64ELFObjectWriter.cpp

public:
 
   ~AArch64ELFObjectWriter() override = default;
 
   MCSectionELF *getMemtagRelocsSection(MCContext &Ctx) const override;
 
 protected:
   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                         const MCFixup &Fixup, bool IsPCRel) const override;
+  bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
+                               unsigned Type) const override;
   bool IsILP32;
 };
 
 } // end anonymous namespace
 
 AArch64ELFObjectWriter::AArch64ELFObjectWriter(uint8_t OSABI, bool IsILP32)
     : MCELFObjectTargetWriter(/*Is64Bit*/ !IsILP32, OSABI, ELF::EM_AARCH64,
                               /*HasRelocationAddend*/ true),
default:
       Ctx.reportError(Fixup.getLoc(), "Unknown ELF relocation type");
       return ELF::R_AARCH64_NONE;
     }
   }
 
   llvm_unreachable("Unimplemented fixup -> relocation");
 }
 
+bool AArch64ELFObjectWriter::needsRelocateWithSymbol(const MCValue &Val,
+                                                     const MCSymbol &,
+                                                     unsigned) const {
+  return (Val.getRefKind() & AArch64MCExpr::VK_GOT) == AArch64MCExpr::VK_GOT;
+}
+
 MCSectionELF *
 AArch64ELFObjectWriter::getMemtagRelocsSection(MCContext &Ctx) const {
   return Ctx.getELFSection(".memtag.globals.static",
                            ELF::SHT_AARCH64_MEMTAG_GLOBALS_STATIC, 0);
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 llvm::createAArch64ELFObjectWriter(uint8_t OSABI, bool IsILP32) {
   return std::make_unique<AArch64ELFObjectWriter>(OSABI, IsILP32);
 }

llvm/lib/Target/ARM/MCTargetDesc/ARMELFObjectWriter.cpp

namespace {
   public:
     ARMELFObjectWriter(uint8_t OSABI);
 
     ~ARMELFObjectWriter() override = default;
 
     unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                           const MCFixup &Fixup, bool IsPCRel) const override;
 
-    bool needsRelocateWithSymbol(const MCSymbol &Sym,
+    bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
                                  unsigned Type) const override;
 
     void addTargetSectionFlags(MCContext &Ctx, MCSectionELF &Sec) override;
   };
 
 } // end anonymous namespace
 
 ARMELFObjectWriter::ARMELFObjectWriter(uint8_t OSABI)
   : MCELFObjectTargetWriter(/*Is64Bit*/ false, OSABI,
                             ELF::EM_ARM,
                             /*HasRelocationAddend*/ false) {}
 
-bool ARMELFObjectWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
+bool ARMELFObjectWriter::needsRelocateWithSymbol(const MCValue &,
+                                                 const MCSymbol &,
                                                  unsigned Type) const {
   // FIXME: This is extremely conservative. This really needs to use an
   // explicit list with a clear explanation for why each realocation needs to
   // point to the symbol, not to the section.
   switch (Type) {
   default:
     return true;
 

llvm/lib/Target/Lanai/MCTargetDesc/LanaiELFObjectWriter.cpp

 public:
   explicit LanaiELFObjectWriter(uint8_t OSABI);
 
   ~LanaiELFObjectWriter() override = default;
 
 protected:
   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                         const MCFixup &Fixup, bool IsPCRel) const override;
-  bool needsRelocateWithSymbol(const MCSymbol &SD,
+  bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
                                unsigned Type) const override;
 };
 
 } // end anonymous namespace
 
 LanaiELFObjectWriter::LanaiELFObjectWriter(uint8_t OSABI)
     : MCELFObjectTargetWriter(/*Is64Bit_=*/false, OSABI, ELF::EM_LANAI,
                               /*HasRelocationAddend_=*/true) {}
case Lanai::FIXUP_LANAI_NONE:
     break;
 
   default:
     llvm_unreachable("Invalid fixup kind!");
   }
   return Type;
 }
 
-bool LanaiELFObjectWriter::needsRelocateWithSymbol(const MCSymbol & /*SD*/,
+bool LanaiELFObjectWriter::needsRelocateWithSymbol(const MCValue &,
+                                                   const MCSymbol &,
                                                    unsigned Type) const {
   switch (Type) {
   case ELF::R_LANAI_21:
   case ELF::R_LANAI_21_F:
   case ELF::R_LANAI_25:
   case ELF::R_LANAI_32:
   case ELF::R_LANAI_HI16:
     return true;

llvm/lib/Target/Mips/MCTargetDesc/MipsELFObjectWriter.cpp

 class MipsELFObjectWriter : public MCELFObjectTargetWriter {
 public:
   MipsELFObjectWriter(uint8_t OSABI, bool HasRelocationAddend, bool Is64);
 
   ~MipsELFObjectWriter() override = default;
 
   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                         const MCFixup &Fixup, bool IsPCRel) const override;
-  bool needsRelocateWithSymbol(const MCSymbol &Sym,
+  bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
                                unsigned Type) const override;
   void sortRelocs(const MCAssembler &Asm,
                   std::vector<ELFRelocationEntry> &Relocs) override;
 };
 
 /// The possible results of the Predicate function used by find_best.
 enum FindBestPredicateResult {
   FindBest_NoMatch = 0,  ///< The current element is not a match.
void MipsELFObjectWriter::sortRelocs(const MCAssembler &Asm,
 
   // Overwrite the original vector with the sorted elements. The caller expects
   // them in reverse order.
   unsigned CopyTo = 0;
   for (const auto &R : reverse(Sorted))
     Relocs[CopyTo++] = R.R;
 }
 
-bool MipsELFObjectWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
+bool MipsELFObjectWriter::needsRelocateWithSymbol(const MCValue &Val,
+                                                  const MCSymbol &Sym,
                                                   unsigned Type) const {
   // If it's a compound relocation for N64 then we need the relocation if any
   // sub-relocation needs it.
   if (!isUInt<8>(Type))
-    return needsRelocateWithSymbol(Sym, Type & 0xff) ||
-           needsRelocateWithSymbol(Sym, (Type >> 8) & 0xff) ||
-           needsRelocateWithSymbol(Sym, (Type >> 16) & 0xff);
+    return needsRelocateWithSymbol(Val, Sym, Type & 0xff) ||
+           needsRelocateWithSymbol(Val, Sym, (Type >> 8) & 0xff) ||
+           needsRelocateWithSymbol(Val, Sym, (Type >> 16) & 0xff);
 
   switch (Type) {
   default:
     errs() << Type << "\n";
     llvm_unreachable("Unexpected relocation");
     return true;
 
   // This relocation doesn't affect the section data.

llvm/lib/Target/PowerPC/MCTargetDesc/PPCELFObjectWriter.cpp

namespace {
   class PPCELFObjectWriter : public MCELFObjectTargetWriter {
   public:
     PPCELFObjectWriter(bool Is64Bit, uint8_t OSABI);
 
   protected:
     unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                           const MCFixup &Fixup, bool IsPCRel) const override;
 
-    bool needsRelocateWithSymbol(const MCSymbol &Sym,
+    bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
                                  unsigned Type) const override;
   };
 }
 
 PPCELFObjectWriter::PPCELFObjectWriter(bool Is64Bit, uint8_t OSABI)
   : MCELFObjectTargetWriter(Is64Bit, OSABI,
                             Is64Bit ?  ELF::EM_PPC64 : ELF::EM_PPC,
                             /*HasRelocationAddend*/ true) {}
if (IsPCRel) {
     case FK_Data_2:
       Type = ELF::R_PPC_ADDR16;
       break;
     }
   }
   return Type;
 }
 
-bool PPCELFObjectWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
+bool PPCELFObjectWriter::needsRelocateWithSymbol(const MCValue &,
+                                                 const MCSymbol &Sym,
                                                  unsigned Type) const {
   switch (Type) {
     default:
       return false;
 
     case ELF::R_PPC_REL24:
     case ELF::R_PPC64_REL24_NOTOC:
       // If the target symbol has a local entry point, we must keep the

llvm/lib/Target/RISCV/MCTargetDesc/RISCVELFObjectWriter.cpp

 class RISCVELFObjectWriter : public MCELFObjectTargetWriter {
 public:
   RISCVELFObjectWriter(uint8_t OSABI, bool Is64Bit);
 
   ~RISCVELFObjectWriter() override;
 
   // Return true if the given relocation must be with a symbol rather than
   // section plus offset.
-  bool needsRelocateWithSymbol(const MCSymbol &Sym,
+  bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
                                unsigned Type) const override {
     // TODO: this is very conservative, update once RISC-V psABI requirements
     //       are clarified.
     return true;
   }
 
 protected:
   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,

llvm/lib/Target/Sparc/MCTargetDesc/SparcELFObjectWriter.cpp

SparcELFObjectWriter(bool Is64Bit, uint8_t OSABI)
                                 /*HasRelocationAddend*/ true) {}
 
     ~SparcELFObjectWriter() override = default;
 
   protected:
     unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                           const MCFixup &Fixup, bool IsPCRel) const override;
 
-    bool needsRelocateWithSymbol(const MCSymbol &Sym,
+    bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
                                  unsigned Type) const override;
-
   };
 }
 
 unsigned SparcELFObjectWriter::getRelocType(MCContext &Ctx,
                                             const MCValue &Target,
                                             const MCFixup &Fixup,
                                             bool IsPCRel) const {
   MCFixupKind Kind = Fixup.getKind();
unsigned SparcELFObjectWriter::getRelocType(MCContext &Ctx,
   case Sparc::fixup_sparc_gotdata_hix22: return ELF::R_SPARC_GOTDATA_HIX22;
   case Sparc::fixup_sparc_gotdata_lox10: return ELF::R_SPARC_GOTDATA_LOX10;
   case Sparc::fixup_sparc_gotdata_op:    return ELF::R_SPARC_GOTDATA_OP;
   }
 
   return ELF::R_SPARC_NONE;
 }
 
-bool SparcELFObjectWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
+bool SparcELFObjectWriter::needsRelocateWithSymbol(const MCValue &,
+                                                   const MCSymbol &,
                                                    unsigned Type) const {
   switch (Type) {
     default:
       return false;
 
     // All relocations that use a GOT need a symbol, not an offset, as
     // the offset of the symbol within the section is irrelevant to
     // where the GOT entry is. Don't need to list all the TLS entries,
     // as they're all marked as requiring a symbol anyways.

llvm/lib/Target/VE/MCTargetDesc/VEELFObjectWriter.cpp

VEELFObjectWriter(uint8_t OSABI)
                                 /* HasRelocationAddend */ true) {}
 
   ~VEELFObjectWriter() override = default;
 
 protected:
   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                         const MCFixup &Fixup, bool IsPCRel) const override;
 
-  bool needsRelocateWithSymbol(const MCSymbol &Sym,
+  bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
                                unsigned Type) const override;
 };
 } // namespace
 
 unsigned VEELFObjectWriter::getRelocType(MCContext &Ctx, const MCValue &Target,
                                          const MCFixup &Fixup,
                                          bool IsPCRel) const {
   if (const VEMCExpr *SExpr = dyn_cast<VEMCExpr>(Fixup.getValue())) {
case VE::fixup_ve_tpoff_hi32:
     return ELF::R_VE_TPOFF_HI32;
   case VE::fixup_ve_tpoff_lo32:
     return ELF::R_VE_TPOFF_LO32;
   }
 
   return ELF::R_VE_NONE;
 }
 
-bool VEELFObjectWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
+bool VEELFObjectWriter::needsRelocateWithSymbol(const MCValue &,
+                                                const MCSymbol &,
                                                 unsigned Type) const {
   switch (Type) {
   default:
     return false;
 
   // All relocations that use a GOT need a symbol, not an offset, as
   // the offset of the symbol within the section is irrelevant to
   // where the GOT entry is. Don't need to list all the TLS entries,
   // as they're all marked as requiring a symbol anyways.
   case ELF::R_VE_GOT_HI32:
   case ELF::R_VE_GOT_LO32:
   case ELF::R_VE_GOTOFF_HI32:
   case ELF::R_VE_GOTOFF_LO32:
   case ELF::R_VE_TLS_GD_HI32:
   case ELF::R_VE_TLS_GD_LO32:
     return true;
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 llvm::createVEELFObjectWriter(uint8_t OSABI) {
   return std::make_unique<VEELFObjectWriter>(OSABI);
 }

llvm/lib/Target/Xtensa/MCTargetDesc/XtensaELFObjectWriter.cpp

 public:
   XtensaObjectWriter(uint8_t OSABI);
 
   virtual ~XtensaObjectWriter();
 
 protected:
   unsigned getRelocType(MCContext &Ctx, const MCValue &Target,
                         const MCFixup &Fixup, bool IsPCRel) const override;
-  bool needsRelocateWithSymbol(const MCSymbol &Sym,
+  bool needsRelocateWithSymbol(const MCValue &Val, const MCSymbol &Sym,
                                unsigned Type) const override;
 };
 } // namespace
 
 XtensaObjectWriter::XtensaObjectWriter(uint8_t OSABI)
     : MCELFObjectTargetWriter(false, OSABI, ELF::EM_XTENSA,
                               /*HasRelocationAddend=*/true) {}
 
unsigned XtensaObjectWriter::getRelocType(MCContext &Ctx, const MCValue &Target,
   }
 }
 
 std::unique_ptr<MCObjectTargetWriter>
 llvm::createXtensaObjectWriter(uint8_t OSABI, bool IsLittleEndian) {
   return std::make_unique<XtensaObjectWriter>(OSABI);
 }
 
-bool XtensaObjectWriter::needsRelocateWithSymbol(const MCSymbol &Sym,
+bool XtensaObjectWriter::needsRelocateWithSymbol(const MCValue &,
+                                                 const MCSymbol &,
                                                  unsigned Type) const {
   return false;
 }

llvm/test/MC/AArch64/arm64-elf-relocs.s

 // CHECK: add x3, x5, :lo12:imm
 
    ldr x24, #:got:sym
    ldr d22, :got:sym
 // CHECK: ldr x24, :got:sym
 // CHECK: ldr d22, :got:sym
 // CHECK-OBJ-LP64: R_AARCH64_GOT_LD_PREL19 sym
 // CHECK-OBJ-LP64: R_AARCH64_GOT_LD_PREL19 sym
+
+// GOT relocations referencing local symbols are not converted to reference
+// STT_SECTION symbols. https://github.com/llvm/llvm-project/issues/63418
+  ldr x0, [x0, :got_lo12:local0]
+  ldr x1, [x1, :got_lo12:local1]
+  ldr x2, [x2, :gotpage_lo15:local2]
+  adrp x3, :got:local3
+// CHECK:      ldr x0, [x0, :got_lo12:local0]
+// CHECK-NEXT: ldr x1, [x1, :got_lo12:local1]
+// CHECK-NEXT: ldr x2, [x2, :gotpage_lo15:local2]
+// CHECK-NEXT: adrp x3, :got:local3
+// CHECK-OBJ-LP64:      R_AARCH64_LD64_GOT_LO12_NC local0{{$}}
+// CHECK-OBJ-LP64-NEXT: R_AARCH64_LD64_GOT_LO12_NC local1{{$}}
+// CHECK-OBJ-LP64-NEXT: R_AARCH64_LD64_GOTPAGE_LO15 local2{{$}}
+// CHECK-OBJ-LP64-NEXT: R_AARCH64_ADR_GOT_PAGE local3{{$}}
+
+.data
+local0: .long 0
+local1: .long 0
+local2: .long 0
+local3: .long 0