[COFF] [ARM64] Create symbols with regular intervals for relocations against temporary symbols

[mstorsjo]

Summary

For relocations against temporary symbols (that don't persist in
the object file), we normally adjust them to reference the start of
the section.

For adrp relocations, the immediate offset from the referenced
symbol is stored in the opcode as the 21 bit signed immediate; this
means that the symbol referenced must be within +/- 1 MB from the
referenced symbol.

Create label symbols with regular intervals (1 MB intervals). For
relocations against temporary symbols, pick the preceding added
offset symbol and make the relocation against that instead of
against the start of the section.

This should fix the root issue behind
https://bugs.llvm.org/show_bug.cgi?id=52378.

[rnk]

lgtm

Just nits

llvm/lib/MC/WinCOFFObjectWriter.cpp

155–156

These should both really have default member initializers (= false). Looking at the constructor, it's not at all clear how UseBigObj is initialized.

I thought this was part of CodingStandards, but I don't see it there. *shrug*

167

This looks like it should re-initialize UseBigObj, and maybe some other fields... I'm not sure what codepath exercises this reset method (maybe LTO, since it emits multiple objects in process?), but it seems buggy and beyond the scope of this patch.

[mstorsjo]

llvm/lib/MC/WinCOFFObjectWriter.cpp

155–156

I'll add a default initialization of the newly added variable here just for clarity, but I'm leaving the existing code as is for now.

llvm/lib/MC/WinCOFFObjectWriter.cpp

 
 using namespace llvm;
 using llvm::support::endian::write32le;
 
 #define DEBUG_TYPE "WinCOFFObjectWriter"
 
 namespace {
 
+constexpr int OffsetLabelIntervalBits = 20;
+
 using name = SmallString<COFF::NameSize>;
 
 enum AuxiliaryType {
   ATWeakExternal,
   ATFile,
   ATSectionDefinition
 };
 
public:
 
   std::string Name;
   int Number;
   MCSectionCOFF const *MCSection = nullptr;
   COFFSymbol *Symbol = nullptr;
   relocations Relocations;
 
   COFFSection(StringRef Name) : Name(std::string(Name)) {}
+
+  SmallVector<COFFSymbol *, 1> OffsetSymbols;
 };
 
 class WinCOFFObjectWriter : public MCObjectWriter {
 public:
   support::endian::Writer W;
 
   using symbols = std::vector<std::unique_ptr<COFFSymbol>>;
   using sections = std::vector<std::unique_ptr<COFFSection>>;
public:
   StringTableBuilder Strings{StringTableBuilder::WinCOFF};
 
   // Maps used during object file creation.
   section_map SectionMap;
   symbol_map SymbolMap;
 
   symbol_list WeakDefaults;
 
   bool UseBigObj;
+  bool UseOffsetLabels;
 
   bool EmitAddrsigSection = false;
   MCSectionCOFF *AddrsigSection;
   std::vector<const MCSymbol *> AddrsigSyms;
 
   MCSectionCOFF *CGProfileSection = nullptr;
 
   WinCOFFObjectWriter(std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW,
                       raw_pwrite_stream &OS);
 
   void reset() override {
     memset(&Header, 0, sizeof(Header));
     Header.Machine = TargetObjectWriter->getMachine();
     Sections.clear();
     Symbols.clear();
     Strings.clear();
     SectionMap.clear();
     SymbolMap.clear();
     MCObjectWriter::reset();
   }
 
   COFFSymbol *createSymbol(StringRef Name);
   COFFSymbol *GetOrCreateCOFFSymbol(const MCSymbol *Symbol);
   COFFSection *createSection(StringRef Name);
 
-  void defineSection(MCSectionCOFF const &Sec);
+  void defineSection(MCSectionCOFF const &Sec, const MCAsmLayout &Layout);
 
   COFFSymbol *getLinkedSymbol(const MCSymbol &Symbol);
   void DefineSymbol(const MCSymbol &Symbol, MCAssembler &Assembler,
                     const MCAsmLayout &Layout);
 
   void SetSymbolName(COFFSymbol &S);
   void SetSectionName(COFFSection &S);
 

 
 //------------------------------------------------------------------------------
 // WinCOFFObjectWriter class implementation
 
 WinCOFFObjectWriter::WinCOFFObjectWriter(
     std::unique_ptr<MCWinCOFFObjectTargetWriter> MOTW, raw_pwrite_stream &OS)
     : W(OS, support::little), TargetObjectWriter(std::move(MOTW)) {
   Header.Machine = TargetObjectWriter->getMachine();
+  // Some relocations on ARM64 (the 21 bit ADRP relocations) have a slightly
+  // limited range for the immediate offset (+/- 1 MB); create extra offset
+  // label symbols with regular intervals to allow referencing a
+  // non-temporary symbol that is close enough.
+  UseOffsetLabels = Header.Machine == COFF::IMAGE_FILE_MACHINE_ARM64;
 }
 
 COFFSymbol *WinCOFFObjectWriter::createSymbol(StringRef Name) {
   Symbols.push_back(std::make_unique<COFFSymbol>(Name));
   return Symbols.back().get();
 }
 
 COFFSymbol *WinCOFFObjectWriter::GetOrCreateCOFFSymbol(const MCSymbol *Symbol) {
static uint32_t getAlignment(const MCSectionCOFF &Sec) {
   case 8192:
     return COFF::IMAGE_SCN_ALIGN_8192BYTES;
   }
   llvm_unreachable("unsupported section alignment");
 }
 
 /// This function takes a section data object from the assembler
 /// and creates the associated COFF section staging object.
-void WinCOFFObjectWriter::defineSection(const MCSectionCOFF &MCSec) {
+void WinCOFFObjectWriter::defineSection(const MCSectionCOFF &MCSec,
+                                        const MCAsmLayout &Layout) {
   COFFSection *Section = createSection(MCSec.getName());
   COFFSymbol *Symbol = createSymbol(MCSec.getName());
   Section->Symbol = Symbol;
   Symbol->Section = Section;
   Symbol->Data.StorageClass = COFF::IMAGE_SYM_CLASS_STATIC;
 
   // Create a COMDAT symbol if needed.
   if (MCSec.getSelection() != COFF::IMAGE_COMDAT_SELECT_ASSOCIATIVE) {
void WinCOFFObjectWriter::defineSection(const MCSectionCOFF &MCSec,
 
   // Set section alignment.
   Section->Header.Characteristics = MCSec.getCharacteristics();
   Section->Header.Characteristics |= getAlignment(MCSec);
 
   // Bind internal COFF section to MC section.
   Section->MCSection = &MCSec;
   SectionMap[&MCSec] = Section;
+
+  if (UseOffsetLabels && !MCSec.getFragmentList().empty()) {
+    const uint32_t Interval = 1 << OffsetLabelIntervalBits;
+    uint32_t N = 1;
+    for (uint32_t Off = Interval, E = Layout.getSectionAddressSize(&MCSec);
+         Off < E; Off += Interval) {
+      auto Name = ("$L" + MCSec.getName() + "_" + Twine(N++)).str();
+      COFFSymbol *Label = createSymbol(Name);
+      Label->Section = Section;
+      Label->Data.StorageClass = COFF::IMAGE_SYM_CLASS_LABEL;
+      Label->Data.Value = Off;
+      Section->OffsetSymbols.push_back(Label);
+    }
+  }
 }
 
 static uint64_t getSymbolValue(const MCSymbol &Symbol,
                                const MCAsmLayout &Layout) {
   if (Symbol.isCommon() && Symbol.isExternal())
     return Symbol.getCommonSize();
 
   uint64_t Res;
CGProfileSection = Asm.getContext().getCOFFSection(
         ".llvm.call-graph-profile", COFF::IMAGE_SCN_LNK_REMOVE,
         SectionKind::getMetadata());
     Asm.registerSection(*CGProfileSection);
   }
 
   // "Define" each section & symbol. This creates section & symbol
   // entries in the staging area.
   for (const auto &Section : Asm)
-    defineSection(static_cast<const MCSectionCOFF &>(Section));
+    defineSection(static_cast<const MCSectionCOFF &>(Section), Layout);
 
   for (const MCSymbol &Symbol : Asm.symbols())
     if (!Symbol.isTemporary())
       DefineSymbol(Symbol, Asm, Layout);
 }
 
 bool WinCOFFObjectWriter::isSymbolRefDifferenceFullyResolvedImpl(
     const MCAssembler &Asm, const MCSymbol &SymA, const MCFragment &FB,
void WinCOFFObjectWriter::recordRelocation(MCAssembler &Asm,
   Reloc.Data.VirtualAddress = Layout.getFragmentOffset(Fragment);
 
   // Turn relocations for temporary symbols into section relocations.
   if (A.isTemporary()) {
     MCSection *TargetSection = &A.getSection();
     assert(
         SectionMap.find(TargetSection) != SectionMap.end() &&
         "Section must already have been defined in executePostLayoutBinding!");
-    Reloc.Symb = SectionMap[TargetSection]->Symbol;
+    COFFSection *Section = SectionMap[TargetSection];
+    Reloc.Symb = Section->Symbol;
     FixedValue += Layout.getSymbolOffset(A);
+    // Technically, we should do the final adjustments of FixedValue (below)
+    // before picking an offset symbol, otherwise we might choose one which
+    // is slightly too far away. The relocations where it really matters
+    // (arm64 adrp relocations) don't get any offset though.
+    if (UseOffsetLabels && !Section->OffsetSymbols.empty()) {
+      uint64_t LabelIndex = FixedValue >> OffsetLabelIntervalBits;
+      if (LabelIndex > 0) {
+        if (LabelIndex <= Section->OffsetSymbols.size())
+          Reloc.Symb = Section->OffsetSymbols[LabelIndex - 1];
+        else
+          Reloc.Symb = Section->OffsetSymbols.back();
+        FixedValue -= Reloc.Symb->Data.Value;
+      }
+    }
   } else {
     assert(
         SymbolMap.find(&A) != SymbolMap.end() &&
         "Symbol must already have been defined in executePostLayoutBinding!");
     Reloc.Symb = SymbolMap[&A];
   }
 
   ++Reloc.Symb->Relocations;

llvm/test/MC/AArch64/coff-relocations-offset.s

+// RUN: llvm-mc -triple aarch64-windows -filetype obj -o %t.obj %s
+// RUN: llvm-objdump -d -r %t.obj | FileCheck %s
+// RUN: llvm-readobj --syms %t.obj | FileCheck %s --check-prefix=SYMBOLS
+
+    .text
+main:
+    adrp x0, .Ltmp0
+    adrp x0, .Ltmp1
+    adrp x0, .Ltmp2+8
+
+    .section .rdata
+    .word 1
+.Ltmp0:
+    .word 2
+    .fill 1048576
+.Ltmp1: // 1 MB + 8 bytes
+    .fill (1048576-8-4)
+.Ltmp2: // 2 MB - 4 bytes
+    .word 3
+    // 2 MB here
+    .word 4
+    // .Ltmp2+8 points here
+    .word 5
+
+// CHECK:      0: 20 00 00 90   adrp    x0, 0x4000
+// CHECK-NEXT:          0000000000000000:  IMAGE_REL_ARM64_PAGEBASE_REL21       .rdata
+// CHECK-NEXT: 4: 40 00 00 90   adrp    x0, 0x8000
+// CHECK-NEXT:          0000000000000004:  IMAGE_REL_ARM64_PAGEBASE_REL21       $L.rdata_1
+// CHECK-NEXT: 8: 20 00 00 90   adrp    x0, 0x4000
+// CHECK-NEXT:          0000000000000008:  IMAGE_REL_ARM64_PAGEBASE_REL21       $L.rdata_2
+
+// SYMBOLS:      Symbol {
+// SYMBOLS:        Name: $L.rdata_1
+// SYMBOLS-NEXT:   Value: 1048576
+// SYMBOLS-NEXT:   Section: .rdata (4)
+// SYMBOLS-NEXT:   BaseType: Null (0x0)
+// SYMBOLS-NEXT:   ComplexType: Null (0x0)
+// SYMBOLS-NEXT:   StorageClass: Label (0x6)
+// SYMBOLS-NEXT:   AuxSymbolCount: 0
+// SYMBOLS-NEXT: }
+// SYMBOLS-NEXT: Symbol {
+// SYMBOLS-NEXT:   Name: $L.rdata_2
+// SYMBOLS-NEXT:   Value: 2097152
+// SYMBOLS-NEXT:   Section: .rdata (4)
+// SYMBOLS-NEXT:   BaseType: Null (0x0)
+// SYMBOLS-NEXT:   ComplexType: Null (0x0)
+// SYMBOLS-NEXT:   StorageClass: Label (0x6)
+// SYMBOLS-NEXT:   AuxSymbolCount: 0
+// SYMBOLS-NEXT: }