[COFF] Fix SECREL and SECTION relocations against common symbols

[rnk]

Summary

They do the obvious thing: provide the section index of .bss and the
offset of the symbol in .bss.

[ruiu]

LGTM

[rnk]

• update return types

lld/COFF/Symbols.h

DefinedCommon(InputFile *F, StringRef N, uint64_t Size,
     this->IsExternal = true;
   }
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == DefinedCommonKind;
   }
 
   uint64_t getRVA() { return Data->getRVA(); }
+  uint64_t getSecrel() { return Data->OutputSectionOff; }
+  uint64_t getSectionIndex();
 
 private:
   friend SymbolTable;
   uint64_t getSize() const { return Size; }
   CommonChunk *Data;
   uint64_t Size;
 };
 

lld/COFF/Writer.cpp

void OutputSection::writeHeaderTo(uint8_t *Buf) {
   }
 }
 
 uint32_t Defined::getSecrel() {
   assert(this);
   switch (kind()) {
   case DefinedRegularKind:
     return cast<DefinedRegular>(this)->getSecrel();
+  case DefinedCommonKind:
+    return cast<DefinedCommon>(this)->getSecrel();
   case DefinedSyntheticKind:
     return cast<DefinedSynthetic>(this)->getSecrel();
   default:
     break;
   }
   fatal("SECREL relocation points to a non-regular symbol: " + toString(*this));
 }
 
 uint32_t DefinedRegular::getSecrel() {
   assert(getChunk()->isLive() && "relocation against discarded section");
   uint64_t Diff = getRVA() - getChunk()->getOutputSection()->getRVA();
   assert(Diff < UINT32_MAX && "section offset too large");
   return (uint32_t)Diff;
 }
 
 uint16_t Defined::getSectionIndex() {
   if (auto *D = dyn_cast<DefinedRegular>(this))
     return D->getChunk()->getOutputSection()->SectionIndex;
   if (isa<DefinedAbsolute>(this))
     return DefinedAbsolute::OutputSectionIndex;
+  if (auto *D = dyn_cast<DefinedCommon>(this))
+    return D->getSectionIndex();
   if (auto *D = dyn_cast<DefinedSynthetic>(this)) {
     if (!D->getChunk())
       return 0;
     return D->getChunk()->getOutputSection()->SectionIndex;
   }
   fatal("SECTION relocation points to a non-regular symbol: " +
         toString(*this));
 }
 
+uint64_t DefinedCommon::getSectionIndex() {
+  return Data->getOutputSection()->SectionIndex;
+}
+
 bool Defined::isExecutable() {
   const auto X = IMAGE_SCN_MEM_EXECUTE;
   if (auto *D = dyn_cast<DefinedRegular>(this))
     return D->getChunk()->getOutputSection()->getPermissions() & X;
   return isa<DefinedImportThunk>(this);
 }
 
 } // namespace coff

lld/test/COFF/secrel-common.s

+# RUN: llvm-mc %s -filetype=obj -triple=x86_64-windows-msvc -o %t.obj
+# RUN: lld-link -entry:main -nodefaultlib %t.obj -out:%t.exe
+# RUN: llvm-readobj %t.exe -sections -section-data | FileCheck %s
+
+# Section relocations against common symbols resolve to .bss.
+
+# CHECK: Sections [
+# CHECK:   Section {
+# CHECK:     Number: 1
+# CHECK:     Name: .bss (2E 62 73 73 00 00 00 00)
+# CHECK:     VirtualSize: 0x4
+# CHECK:   }
+# CHECK:   Section {
+# CHECK:     Number: 2
+# CHECK:     Name: .rdata (2E 72 64 61 74 61 00 00)
+# CHECK:     SectionData (
+# CHECK:       0000: 00000000 01000000 |........|
+# CHECK:     )
+# CHECK:   }
+# CHECK:   Section {
+# CHECK:     Number: 3
+# CHECK:     Name: .text (2E 74 65 78 74 00 00 00)
+# CHECK:     VirtualSize: 0x1
+# CHECK:     SectionData (
+# CHECK:       0000: C3                                   |.|
+# CHECK:     )
+# CHECK:   }
+# CHECK-NOT: Section
+# CHECK: ]
+
+.text
+.global main
+main:
+ret
+
+.comm   common_global,4,2
+
+.section .rdata,"dr"
+.secrel32 common_global
+.secidx common_global
+.short 0