Revert r330966: Replace SharedSymbols with Defined when creating copy relocations.

[orivej]

Summary

This revert has one meaningful change in getSymSectionIndex in ELF/SyntheticSections.cpp: if Sym->getOutputSection() is not null, it should take priority over isa<Defined> check, as it did before r338247 (https://reviews.llvm.org/D49541).

Fixes https://bugs.llvm.org/show_bug.cgi?id=39104

TODO: add a test case.

[grimar]

I do not think we really need to revert it.
See: D52724

[orivej]

Discarded in favor of https://reviews.llvm.org/D52724

ELF/LinkerScript.cpp

if (Ctx)
       return {Ctx->OutSec, false, Dot - Ctx->OutSec->Addr, Loc};
     error(Loc + ": unable to get location counter value");
     return 0;
   }
 
   if (Symbol *Sym = Symtab->find(Name)) {
     if (auto *DS = dyn_cast<Defined>(Sym))
       return {DS->Section, false, DS->Value, Loc};
-    if (isa<SharedSymbol>(Sym))
-      if (!ErrorOnMissingSection)
-        return {nullptr, false, 0, Loc};
+    if (auto *SS = dyn_cast<SharedSymbol>(Sym))
+      if (!ErrorOnMissingSection || SS->CopyRelSec)
+        return {SS->CopyRelSec, false, 0, Loc};
   }
 
   error(Loc + ": symbol not found: " + Name);
   return 0;
 }
 
 // Returns the index of the segment named Name.
 static Optional<size_t> getPhdrIndex(ArrayRef<PhdrsCommand> Vec,

ELF/MapFile.cpp

 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf;
 
-typedef DenseMap<const SectionBase *, SmallVector<Defined *, 4>> SymbolMapTy;
+typedef DenseMap<const SectionBase *, SmallVector<Symbol *, 4>> SymbolMapTy;
 
 static const std::string Indent8 = "        ";          // 8 spaces
 static const std::string Indent16 = "                "; // 16 spaces
 
 // Print out the first three columns of a line.
 static void writeHeader(raw_ostream &OS, uint64_t VMA, uint64_t LMA,
                         uint64_t Size, uint64_t Align) {
   if (Config->Is64)
     OS << format("%16llx %16llx %8llx %5lld ", VMA, LMA, Size, Align);
   else
     OS << format("%8llx %8llx %8llx %5lld ", VMA, LMA, Size, Align);
 }
 
 // Returns a list of all symbols that we want to print out.
-static std::vector<Defined *> getSymbols() {
-  std::vector<Defined *> V;
-  for (InputFile *File : ObjectFiles)
-    for (Symbol *B : File->getSymbols())
+static std::vector<Symbol *> getSymbols() {
+  std::vector<Symbol *> V;
+  for (InputFile *File : ObjectFiles) {
+    for (Symbol *B : File->getSymbols()) {
+      if (auto *SS = dyn_cast<SharedSymbol>(B))
+        if (SS->CopyRelSec || SS->NeedsPltAddr)
+          V.push_back(SS);
       if (auto *DR = dyn_cast<Defined>(B))
-        if (!DR->isSection() && DR->Section && DR->Section->Live &&
-            (DR->File == File || DR->NeedsPltAddr || DR->Section->Bss))
+        if (DR->File == File && !DR->isSection() && DR->Section &&
+            DR->Section->Live)
           V.push_back(DR);
+    }
+  }
   return V;
 }
 
 // Returns a map from sections to their symbols.
-static SymbolMapTy getSectionSyms(ArrayRef<Defined *> Syms) {
+static SymbolMapTy getSectionSyms(ArrayRef<Symbol *> Syms) {
   SymbolMapTy Ret;
-  for (Defined *DR : Syms)
-    Ret[DR->Section].push_back(DR);
+  for (Symbol *S : Syms) {
+    if (auto *DR = dyn_cast<Defined>(S)) {
+      Ret[DR->Section].push_back(S);
+      continue;
+    }
+
+    SharedSymbol *SS = cast<SharedSymbol>(S);
+    if (SS->CopyRelSec)
+      Ret[SS->CopyRelSec].push_back(S);
+    else
+      Ret[In.Plt].push_back(S);
+  }
 
   // Sort symbols by address. We want to print out symbols in the
   // order in the output file rather than the order they appeared
   // in the input files.
   for (auto &It : Ret) {
-    SmallVectorImpl<Defined *> &V = It.second;
-    std::stable_sort(V.begin(), V.end(), [](Defined *A, Defined *B) {
+    SmallVectorImpl<Symbol *> &V = It.second;
+    std::stable_sort(V.begin(), V.end(), [](Symbol *A, Symbol *B) {
       return A->getVA() < B->getVA();
     });
   }
   return Ret;
 }
 
 // Construct a map from symbols to their stringified representations.
 // Demangling symbols (which is what toString() does) is slow, so
 // we do that in batch using parallel-for.
 static DenseMap<Symbol *, std::string>
-getSymbolStrings(ArrayRef<Defined *> Syms) {
+getSymbolStrings(ArrayRef<Symbol *> Syms) {
   std::vector<std::string> Str(Syms.size());
   parallelForEachN(0, Syms.size(), [&](size_t I) {
     raw_string_ostream OS(Str[I]);
     OutputSection *OSec = Syms[I]->getOutputSection();
     uint64_t VMA = Syms[I]->getVA();
     uint64_t LMA = OSec ? OSec->getLMA() + VMA - OSec->getVA(0) : 0;
     writeHeader(OS, VMA, LMA, Syms[I]->getSize(), 1);
     OS << Indent16 << toString(*Syms[I]);
void elf::writeMapFile() {
   std::error_code EC;
   raw_fd_ostream OS(Config->MapFile, EC, sys::fs::F_None);
   if (EC) {
     error("cannot open " + Config->MapFile + ": " + EC.message());
     return;
   }
 
   // Collect symbol info that we want to print out.
-  std::vector<Defined *> Syms = getSymbols();
+  std::vector<Symbol *> Syms = getSymbols();
   SymbolMapTy SectionSyms = getSectionSyms(Syms);
   DenseMap<Symbol *, std::string> SymStr = getSymbolStrings(Syms);
 
   // Print out the header line.
   int W = Config->Is64 ? 16 : 8;
   OS << right_justify("VMA", W) << ' ' << right_justify("LMA", W)
      << "     Size Align Out     In      Symbol\n";
 

ELF/Relocations.cpp

for (const Elf_Sym &S : File.getGlobalELFSyms()) {
     StringRef Name = check(S.getName(File.getStringTable()));
     Symbol *Sym = Symtab->find(Name);
     if (auto *Alias = dyn_cast_or_null<SharedSymbol>(Sym))
       Ret.insert(Alias);
   }
   return Ret;
 }
 
-// When a symbol is copy relocated or we create a canonical plt entry, it is
-// effectively a defined symbol. In the case of copy relocation the symbol is
-// in .bss and in the case of a canonical plt entry it is in .plt. This function
-// replaces the existing symbol with a Defined pointing to the appropriate
-// location.
-static void replaceWithDefined(Symbol &Sym, SectionBase *Sec, uint64_t Value,
-                               uint64_t Size) {
-  Symbol Old = Sym;
-  replaceSymbol<Defined>(&Sym, Sym.File, Sym.getName(), Sym.Binding,
-                         Sym.StOther, Sym.Type, Value, Size, Sec);
-  Sym.PltIndex = Old.PltIndex;
-  Sym.GotIndex = Old.GotIndex;
-  Sym.VerdefIndex = Old.VerdefIndex;
-  Sym.IsPreemptible = true;
-  Sym.ExportDynamic = true;
-  Sym.IsUsedInRegularObj = true;
-  Sym.Used = true;
-}
-
 // Reserve space in .bss or .bss.rel.ro for copy relocation.
 //
 // The copy relocation is pretty much a hack. If you use a copy relocation
 // in your program, not only the symbol name but the symbol's size, RW/RO
 // bit and alignment become part of the ABI. In addition to that, if the
 // symbol has aliases, the aliases become part of the ABI. That's subtle,
 // but if you violate that implicit ABI, that can cause very counter-
 // intuitive consequences.
template <class ELFT> static void addCopyRelSymbol(SharedSymbol &SS) {
   if (IsReadOnly)
     In.BssRelRo->getParent()->addSection(Sec);
   else
     In.Bss->getParent()->addSection(Sec);
 
   // Look through the DSO's dynamic symbol table for aliases and create a
   // dynamic symbol for each one. This causes the copy relocation to correctly
   // interpose any aliases.
-  for (SharedSymbol *Sym : getSymbolsAt<ELFT>(SS))
-    replaceWithDefined(*Sym, Sec, 0, Sym->Size);
+  for (SharedSymbol *Sym : getSymbolsAt<ELFT>(SS)) {
+    Sym->CopyRelSec = Sec;
+    Sym->IsUsedInRegularObj = true;
+    Sym->Used = true;
+  }
 
   In.RelaDyn->addReloc(Target->CopyRel, Sec, 0, &SS);
 }
 
 // MIPS has an odd notion of "paired" relocations to calculate addends.
 // For example, if a relocation is of R_MIPS_HI16, there must be a
 // R_MIPS_LO16 relocation after that, and an addend is calculated using
 // the two relocations.
static void processRelocAux(InputSectionBase &Sec, RelExpr Expr, RelType Type,
   if (Config->Shared) {
     errorOrWarn("relocation " + toString(Type) +
                 " cannot be used against symbol " + toString(Sym) +
                 "; recompile with -fPIC" + getLocation(Sec, Sym, Offset));
     return;
   }
 
   // If the symbol is undefined we already reported any relevant errors.
-  if (Sym.isUndefined())
+  if (!Sym.isShared()) {
+    assert(Sym.isUndefined());
     return;
+  }
 
   if (!canDefineSymbolInExecutable(Sym)) {
     error("cannot preempt symbol: " + toString(Sym) +
           getLocation(Sec, Sym, Offset));
     return;
   }
 
   if (Sym.isObject()) {
     // Produce a copy relocation.
-    if (auto *SS = dyn_cast<SharedSymbol>(&Sym)) {
+    auto &SS = cast<SharedSymbol>(Sym);
+    if (!SS.CopyRelSec) {
       if (!Config->ZCopyreloc)
         error("unresolvable relocation " + toString(Type) +
-              " against symbol '" + toString(*SS) +
+              " against symbol '" + toString(SS) +
               "'; recompile with -fPIC or remove '-z nocopyreloc'" +
               getLocation(Sec, Sym, Offset));
-      addCopyRelSymbol<ELFT>(*SS);
+      addCopyRelSymbol<ELFT>(SS);
     }
     Sec.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
     return;
   }
 
   if (Sym.isFunc()) {
     // This handles a non PIC program call to function in a shared library. In
     // an ideal world, we could just report an error saying the relocation can
if (Sym.isFunc()) {
     //   compiled without -fPIE/-fPIC and doesn't maintain ebx.
     // * If a library definition gets preempted to the executable, it will have
     //   the wrong ebx value.
     if (Config->Pie && Config->EMachine == EM_386)
       errorOrWarn("symbol '" + toString(Sym) +
                   "' cannot be preempted; recompile with -fPIE" +
                   getLocation(Sec, Sym, Offset));
     if (!Sym.isInPlt())
-      addPltEntry<ELFT>(In.Plt, In.GotPlt, In.RelaPlt, Target->PltRel, Sym);
-    if (!Sym.isDefined())
-      replaceWithDefined(Sym, In.Plt, Sym.getPltOffset(), 0);
+      addPltEntry<ELFT>(In.Plt, In.GotPlt, In.RelaPlt, Target->PltRel,
+                        Sym);
     Sym.NeedsPltAddr = true;
-    Sec.Relocations.push_back({Expr, Type, Offset, Addend, &Sym});
+    Sec.Relocations.push_back({toPlt(Expr), Type, Offset, Addend, &Sym});
     return;
   }
 
   errorOrWarn("symbol '" + toString(Sym) + "' has no type" +
               getLocation(Sec, Sym, Offset));
 }
 
 template <class ELFT, class RelTy>

ELF/Symbols.h

protected:
   mutable uint32_t NameSize;
 
 public:
   uint32_t DynsymIndex = 0;
   uint32_t GotIndex = -1;
   uint32_t PltIndex = -1;
   uint32_t GlobalDynIndex = -1;
 
-  // This field is a index to the symbol's version definition.
-  uint32_t VerdefIndex = -1;
-
   // Version definition index.
   uint16_t VersionId;
 
   // Symbol binding. This is not overwritten by replaceSymbol to track
   // changes during resolution. In particular:
   //  - An undefined weak is still weak when it resolves to a shared library.
   //  - An undefined weak will not fetch archive members, but we have to
   //    remember it is weak.
public:
 
   uint64_t getVA(int64_t Addend = 0) const;
 
   uint64_t getGotOffset() const;
   uint64_t getGotVA() const;
   uint64_t getGotPltOffset() const;
   uint64_t getGotPltVA() const;
   uint64_t getPltVA() const;
-  uint64_t getPltOffset() const;
   uint64_t getSize() const;
   OutputSection *getOutputSection() const;
 
 protected:
   Symbol(Kind K, InputFile *File, StringRefZ Name, uint8_t Binding,
          uint8_t StOther, uint8_t Type)
       : File(File), NameData(Name.Data), NameSize(Name.Size), Binding(Binding),
         Type(Type), StOther(StOther), SymbolKind(K), NeedsPltAddr(false),

 
 class SharedSymbol : public Symbol {
 public:
   static bool classof(const Symbol *S) { return S->kind() == SharedKind; }
 
   SharedSymbol(InputFile &File, StringRef Name, uint8_t Binding,
                uint8_t StOther, uint8_t Type, uint64_t Value, uint64_t Size,
                uint32_t Alignment, uint32_t VerdefIndex)
-      : Symbol(SharedKind, &File, Name, Binding, StOther, Type),
-        Alignment(Alignment), Value(Value), Size(Size) {
-    this->VerdefIndex = VerdefIndex;
+      : Symbol(SharedKind, &File, Name, Binding, StOther, Type), Value(Value),
+        Size(Size), VerdefIndex(VerdefIndex), Alignment(Alignment) {
     // GNU ifunc is a mechanism to allow user-supplied functions to
     // resolve PLT slot values at load-time. This is contrary to the
     // regular symbol resolution scheme in which symbols are resolved just
     // by name. Using this hook, you can program how symbols are solved
     // for you program. For example, you can make "memcpy" to be resolved
     // to a SSE-enabled version of memcpy only when a machine running the
     // program supports the SSE instruction set.
     //
     // Naturally, such symbols should always be called through their PLT
     // slots. What GNU ifunc symbols point to are resolver functions, and
     // calling them directly doesn't make sense (unless you are writing a
     // loader).
     //
     // For DSO symbols, we always call them through PLT slots anyway.
     // So there's no difference between GNU ifunc and regular function
     // symbols if they are in DSOs. So we can handle GNU_IFUNC as FUNC.
     if (this->Type == llvm::ELF::STT_GNU_IFUNC)
       this->Type = llvm::ELF::STT_FUNC;
   }
 
   template <class ELFT> SharedFile<ELFT> &getFile() const {
     return *cast<SharedFile<ELFT>>(File);
   }
 
-  uint32_t Alignment;
+  // If not null, there is a copy relocation to this section.
+  InputSection *CopyRelSec = nullptr;
 
   uint64_t Value; // st_value
   uint64_t Size;  // st_size
+
+  // This field is a index to the symbol's version definition.
+  uint32_t VerdefIndex;
+
+  uint32_t Alignment;
 };
 
 // LazyArchive and LazyObject represent a symbols that is not yet in the link,
 // but we know where to find it if needed. If the resolver finds both Undefined
 // and Lazy for the same name, it will ask the Lazy to load a file.
 //
 // A special complication is the handling of weak undefined symbols. They should
 // not load a file, but we have to remember we have seen both the weak undefined

ELF/Symbols.cpp

if (D.isTls() && !Config->Relocatable) {
       // during section finalization.)
       if (!Out::TlsPhdr || !Out::TlsPhdr->FirstSec)
         fatal(toString(D.File) +
               " has an STT_TLS symbol but doesn't have an SHF_TLS section");
       return VA - Out::TlsPhdr->FirstSec->Addr;
     }
     return VA;
   }
-  case Symbol::SharedKind:
+  case Symbol::SharedKind: {
+    auto &SS = cast<SharedSymbol>(Sym);
+    if (SS.CopyRelSec)
+      return SS.CopyRelSec->getVA(0);
+    if (SS.NeedsPltAddr)
+      return Sym.getPltVA();
+    return 0;
+  }
   case Symbol::UndefinedKind:
     return 0;
   case Symbol::LazyArchiveKind:
   case Symbol::LazyObjectKind:
     assert(Sym.IsUsedInRegularObj && "lazy symbol reached writer");
     return 0;
   }
   llvm_unreachable("invalid symbol kind");

 }
 
 uint64_t Symbol::getPltVA() const {
   if (this->IsInIplt)
     return In.Iplt->getVA() + PltIndex * Target->PltEntrySize;
   return In.Plt->getVA() + Target->getPltEntryOffset(PltIndex);
 }
 
-uint64_t Symbol::getPltOffset() const {
-  assert(!this->IsInIplt);
-  return Target->getPltEntryOffset(PltIndex);
-}
-
 uint64_t Symbol::getSize() const {
   if (const auto *DR = dyn_cast<Defined>(this))
     return DR->Size;
   return cast<SharedSymbol>(this)->Size;
 }
 
 OutputSection *Symbol::getOutputSection() const {
   if (auto *S = dyn_cast<Defined>(this)) {
     if (auto *Sec = S->Section)
       return Sec->Repl->getOutputSection();
     return nullptr;
   }
+
+  if (auto *S = dyn_cast<SharedSymbol>(this)) {
+    if (S->CopyRelSec)
+      return S->CopyRelSec->getParent();
+    return nullptr;
+  }
+
   return nullptr;
 }
 
 // If a symbol name contains '@', the characters after that is
 // a symbol version name. This function parses that.
 void Symbol::parseSymbolVersion() {
   StringRef S = getName();
   size_t Pos = S.find('@');

ELF/SyntheticSections.h

template <class ELFT> class VersionNeedSection final : public SyntheticSection {
   // string table offsets of their sonames.
   std::vector<std::pair<SharedFile<ELFT> *, size_t>> Needed;
 
   // The next available version identifier.
   unsigned NextIndex;
 
 public:
   VersionNeedSection();
-  void addSymbol(Symbol *Sym);
+  void addSymbol(SharedSymbol *SS);
   void finalizeContents() override;
   void writeTo(uint8_t *Buf) override;
   size_t getSize() const override;
   size_t getNeedNum() const { return Needed.size(); }
   bool empty() const override;
 };
 
 // MergeSyntheticSection is a class that allows us to put mergeable sections

ELF/SyntheticSections.cpp

if (!Config->DefineCommon)
     if (auto *D = dyn_cast<Defined>(Sym))
       return dyn_cast_or_null<BssSection>(D->Section);
   return nullptr;
 }
 
 static uint32_t getSymSectionIndex(Symbol *Sym) {
   if (getCommonSec(Sym))
     return SHN_COMMON;
-  if (!isa<Defined>(Sym) || Sym->NeedsPltAddr)
-    return SHN_UNDEF;
   if (const OutputSection *OS = Sym->getOutputSection())
     return OS->SectionIndex >= SHN_LORESERVE ? (uint32_t)SHN_XINDEX
                                              : OS->SectionIndex;
+  if (isa<Defined>(Sym))
     return SHN_ABS;
+  return SHN_UNDEF;
 }
 
 // Write the internal symbol table contents to the output symbol table.
 template <class ELFT> void SymbolTableSection<ELFT>::writeTo(uint8_t *Buf) {
   // The first entry is a null entry as per the ELF spec.
   memset(Buf, 0, sizeof(Elf_Sym));
   Buf += sizeof(Elf_Sym);
 

 // Add symbols to this symbol hash table. Note that this function
 // destructively sort a given vector -- which is needed because
 // GNU-style hash table places some sorting requirements.
 void GnuHashTableSection::addSymbols(std::vector<SymbolTableEntry> &V) {
   // We cannot use 'auto' for Mid because GCC 6.1 cannot deduce
   // its type correctly.
   std::vector<SymbolTableEntry>::iterator Mid =
       std::stable_partition(V.begin(), V.end(), [](const SymbolTableEntry &S) {
+        // Shared symbols that this executable preempts are special. The dynamic
+        // linker has to look them up, so they have to be in the hash table.
+        if (auto *SS = dyn_cast<SharedSymbol>(S.Sym))
+          return SS->CopyRelSec == nullptr && !SS->NeedsPltAddr;
         return !S.Sym->isDefined();
       });
 
   // We chose load factor 4 for the on-disk hash table. For each hash
   // collision, the dynamic linker will compare a uint32_t hash value.
   // Since the integer comparison is quite fast, we believe we can
   // make the load factor even larger. 4 is just a conservative choice.
   //
VersionNeedSection<ELFT>::VersionNeedSection()
     : SyntheticSection(SHF_ALLOC, SHT_GNU_verneed, sizeof(uint32_t),
                        ".gnu.version_r") {
   // Identifiers in verneed section start at 2 because 0 and 1 are reserved
   // for VER_NDX_LOCAL and VER_NDX_GLOBAL.
   // First identifiers are reserved by verdef section if it exist.
   NextIndex = getVerDefNum() + 1;
 }
 
-template <class ELFT> void VersionNeedSection<ELFT>::addSymbol(Symbol *SS) {
-  auto &File = cast<SharedFile<ELFT>>(*SS->File);
+template <class ELFT>
+void VersionNeedSection<ELFT>::addSymbol(SharedSymbol *SS) {
+  SharedFile<ELFT> &File = SS->getFile<ELFT>();
   if (SS->VerdefIndex == VER_NDX_GLOBAL) {
     SS->VersionId = VER_NDX_GLOBAL;
     return;
   }
 
   // If we don't already know that we need an Elf_Verneed for this DSO, prepare
   // to create one by adding it to our needed list and creating a dynstr entry
   // for the soname.

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::finalizeSections() {
   for (Symbol *Sym : Symtab->getSymbols()) {
     if (!includeInSymtab(*Sym))
       continue;
     if (In.SymTab)
       In.SymTab->addSymbol(Sym);
 
     if (In.DynSymTab && Sym->includeInDynsym()) {
       In.DynSymTab->addSymbol(Sym);
-      if (auto *File = dyn_cast_or_null<SharedFile<ELFT>>(Sym->File))
-        if (File->IsNeeded && !Sym->isUndefined())
-          InX<ELFT>::VerNeed->addSymbol(Sym);
+      if (auto *SS = dyn_cast<SharedSymbol>(Sym))
+        if (cast<SharedFile<ELFT>>(Sym->File)->IsNeeded)
+          InX<ELFT>::VerNeed->addSymbol(SS);
     }
   }
 
   // Do not proceed if there was an undefined symbol.
   if (errorCount())
     return;
 
   if (In.MipsGot)

test/ELF/map-file.s

 // CHECK-NEXT: 20102a           20102a        0     1         {{.*}}{{/|\\}}map-file.s.tmp2.o:(.text.zed)
 // CHECK-NEXT: 20102a           20102a        0     1                 zed
 // CHECK-NEXT: 20102c           20102c        0     4         {{.*}}{{/|\\}}map-file.s.tmp3.o:(.text)
 // CHECK-NEXT: 20102c           20102c        0     1                 bah
 // CHECK-NEXT: 20102c           20102c        1     4         {{.*}}{{/|\\}}map-file.s.tmp4.a(map-file.s.tmp4.o):(.text)
 // CHECK-NEXT: 20102c           20102c        0     1                 baz
 // CHECK-NEXT: 201030           201030       30    16 .plt
 // CHECK-NEXT: 201030           201030       30    16         <internal>:(.plt)
-// CHECK-NEXT: 201040           201040        0     1                 sharedFunc1
-// CHECK-NEXT: 201050           201050        0     1                 sharedFunc2
+// CHECK-NEXT: 201040                0        0     1                 sharedFunc1
+// CHECK-NEXT: 201050                0        0     1                 sharedFunc2
 // CHECK-NEXT: 202000           202000       28     8 .got.plt
 // CHECK-NEXT: 202000           202000       28     8         <internal>:(.got.plt)
 // CHECK-NEXT: 203000           203000      100     8 .dynamic
 // CHECK-NEXT: 203000           203000      100     8         <internal>:(.dynamic)
 // CHECK-NEXT: 204000           204000       10    16 .bss
 // CHECK-NEXT: 204000           204000        4    16         {{.*}}{{/|\\}}map-file.s.tmp1.o:(COMMON)
 // CHECK-NEXT: 204000           204000        4     1                 common
 // CHECK-NEXT: 204004           204004        4     1         <internal>:(.bss)