Compact symbols from 88 to 80 bytes

[• espindola]

Summary

This started by me noticing that shared symbols that are subject to a copy relocation look like a plain Defined symbol: they are defined in the .bss section and that is the only reason why SharedSymbols have a section.

I first tried to implement copy relocations by replacing the shared symbol with a Defined. This hits the issue of Defined not having a version definition. We could move Verdefindex to the base class, but that seems a bit odd.

What this patch does instead is move the Section to the base class and merge it with the file pointer. This reduces the size of both SharedSymbol and Defined. When there is a Section the file can be found by following the Section pointer.

A side effect is that copy relocation sections show up as being from the original .so. I actually like the map format change, but I can add logic to keep the old format if desired.

[ruiu]

How much do you gain by this change? This is I think undeniably a bit tricky, so if the difference is negligible, I wouldn't make this change. I actually tried to do a similar thing but decided not to do that in the end to keep these classes simple.

ELF/AArch64ErrataFix.cpp

std::map<InputSection *,
   for (InputFile *File : ObjectFiles) {
     auto *F = cast<ObjFile<ELF64LE>>(File);
     for (Symbol *B : F->getLocalSymbols()) {
       auto *Def = dyn_cast<Defined>(B);
       if (!Def)
         continue;
       if (!IsCodeMapSymbol(Def) && !IsDataMapSymbol(Def))
         continue;
-      if (auto *Sec = dyn_cast<InputSection>(Def->Section))
+      if (auto *Sec = dyn_cast<InputSection>(Def->getSection()))
         if (Sec->Flags & SHF_EXECINSTR)
           SectionMap[Sec].push_back(Def);
     }
   }
   // For each InputSection make sure the mapping symbols are in sorted in
   // ascending order and free from consecutive runs of mapping symbols with
   // the same type. For example we must remove the redundant $d.1 from $x.0
   // $d.0 $d.1 $x.1.

ELF/Arch/Mips.cpp

 template <class ELFT> bool MIPS<ELFT>::usesOnlyLowPageBits(RelType Type) const {
   return Type == R_MIPS_LO16 || Type == R_MIPS_GOT_OFST ||
          Type == R_MICROMIPS_LO16 || Type == R_MICROMIPS_GOT_OFST;
 }
 
 // Return true if the symbol is a PIC function.
 template <class ELFT> bool elf::isMipsPIC(const Defined *Sym) {
   typedef typename ELFT::Ehdr Elf_Ehdr;
-  if (!Sym->Section || !Sym->isFunc())
+  if (!Sym->getSection() || !Sym->isFunc())
     return false;
 
-  auto *Sec = cast<InputSectionBase>(Sym->Section);
+  auto *Sec = cast<InputSectionBase>(Sym->getSection());
   const Elf_Ehdr *Hdr = Sec->template getFile<ELFT>()->getObj().getHeader();
   return (Sym->StOther & STO_MIPS_MIPS16) == STO_MIPS_PIC ||
          (Hdr->e_flags & EF_MIPS_PIC);
 }
 
 template <class ELFT> TargetInfo *elf::getMipsTargetInfo() {
   static MIPS<ELFT> Target;
   return &Target;

ELF/GdbIndex.cpp

LLDDwarfObj<ELFT>::findAux(const InputSectionBase &Sec, uint64_t Pos,
   if (!DR) {
     error("unsupported relocation target while parsing debug info");
     return None;
   }
   uint64_t Val = DR->Value + getAddend<ELFT>(Rel);
 
   // FIXME: We should be consistent about always adding the file
   // offset or not.
-  if (DR->Section->Flags & ELF::SHF_ALLOC)
-    Val += cast<InputSection>(DR->Section)->getOffsetInFile();
+  if (DR->getSection()->Flags & ELF::SHF_ALLOC)
+    Val += cast<InputSection>(DR->getSection())->getOffsetInFile();
 
   return RelocAddrEntry{SecIndex, Val};
 }
 
 template <class ELFT>
 Optional<RelocAddrEntry> LLDDwarfObj<ELFT>::find(const llvm::DWARFSection &S,
                                                  uint64_t Pos) const {
   auto &Sec = static_cast<const LLDDWARFSection &>(S);

ELF/ICF.cpp

for (size_t I = 0; I < RA.size(); ++I) {
 
     auto *DA = dyn_cast<Defined>(&SA);
     auto *DB = dyn_cast<Defined>(&SB);
     if (!DA || !DB)
       return false;
 
     // Relocations referring to absolute symbols are constant-equal if their
     // values are equal.
-    if (!DA->Section && !DB->Section && DA->Value + AddA == DB->Value + AddB)
+    if (!DA->getSection() && !DB->getSection() &&
+        DA->Value + AddA == DB->Value + AddB)
       continue;
-    if (!DA->Section || !DB->Section)
+    if (!DA->getSection() || !DB->getSection())
       return false;
 
-    if (DA->Section->kind() != DB->Section->kind())
+    if (DA->getSection()->kind() != DB->getSection()->kind())
       return false;
 
     // Relocations referring to InputSections are constant-equal if their
     // section offsets are equal.
-    if (isa<InputSection>(DA->Section)) {
+    if (isa<InputSection>(DA->getSection())) {
       if (DA->Value + AddA == DB->Value + AddB)
         continue;
       return false;
     }
 
     // Relocations referring to MergeInputSections are constant-equal if their
     // offsets in the output section are equal.
-    auto *X = dyn_cast<MergeInputSection>(DA->Section);
+    auto *X = dyn_cast<MergeInputSection>(DA->getSection());
     if (!X)
       return false;
-    auto *Y = cast<MergeInputSection>(DB->Section);
+    auto *Y = cast<MergeInputSection>(DB->getSection());
     if (X->getParent() != Y->getParent())
       return false;
 
     uint64_t OffsetA =
         SA.isSection() ? X->getOffset(AddA) : X->getOffset(DA->Value) + AddA;
     uint64_t OffsetB =
         SB.isSection() ? Y->getOffset(AddB) : Y->getOffset(DB->Value) + AddB;
     if (OffsetA != OffsetB)
if (&SA == &SB)
       continue;
 
     auto *DA = cast<Defined>(&SA);
     auto *DB = cast<Defined>(&SB);
 
     // We already dealt with absolute and non-InputSection symbols in
     // constantEq, and for InputSections we have already checked everything
     // except the equivalence class.
-    if (!DA->Section)
+    if (!DA->getSection())
       continue;
-    auto *X = dyn_cast<InputSection>(DA->Section);
+    auto *X = dyn_cast<InputSection>(DA->getSection());
     if (!X)
       continue;
-    auto *Y = cast<InputSection>(DB->Section);
+    auto *Y = cast<InputSection>(DB->getSection());
 
     // Ineligible sections are in the special equivalence class 0.
     // They can never be the same in terms of the equivalence class.
     if (X->Class[Current] == 0)
       return false;
     if (X->Class[Current] != Y->Class[Current])
       return false;
   };

ELF/InputSection.cpp

DenseMap<SectionBase *, int> elf::buildSectionOrder() {
   int Priority = -Config->SymbolOrderingFile.size();
   for (StringRef S : Config->SymbolOrderingFile)
     SymbolOrder.insert({S, Priority++});
 
   // Build a map from sections to their priorities.
   for (InputFile *File : ObjectFiles) {
     for (Symbol *Sym : File->getSymbols()) {
       auto *D = dyn_cast<Defined>(Sym);
-      if (!D || !D->Section)
+      if (!D || !D->getSection())
         continue;
-      int &Priority = SectionOrder[D->Section];
+      int &Priority = SectionOrder[D->getSection()];
       Priority = std::min(Priority, SymbolOrder.lookup(D->getName()));
     }
   }
   return SectionOrder;
 }
 
 template <class ELFT>
 static ArrayRef<uint8_t> getSectionContents(ObjFile<ELFT> *File,
std::string InputSectionBase::getLocation(uint64_t Offset) {
   // source file name. If it's missing, we use an object file name.
   std::string SrcFile = getFile<ELFT>()->SourceFile;
   if (SrcFile.empty())
     SrcFile = toString(File);
 
   // Find a function symbol that encloses a given location.
   for (Symbol *B : File->getSymbols())
     if (auto *D = dyn_cast<Defined>(B))
-      if (D->Section == this && D->Type == STT_FUNC)
+      if (D->getSection() == this && D->Type == STT_FUNC)
         if (D->Value <= Offset && Offset < D->Value + D->Size)
           return SrcFile + ":(function " + toString(*D) + ")";
 
   // If there's no symbol, print out the offset in the section.
   return (SrcFile + ":(" + Name + "+0x" + utohexstr(Offset) + ")").str();
 }
 
 // Concatenates arguments to construct a string representing an error location.
std::string InputSectionBase::getObjMsg(uint64_t Off) {
 
   std::string Archive;
   if (!File->ArchiveName.empty())
     Archive = (" in archive " + File->ArchiveName).str();
 
   // Find a symbol that encloses a given location.
   for (Symbol *B : File->getSymbols())
     if (auto *D = dyn_cast<Defined>(B))
-      if (D->Section == this && D->Value <= Off && Off < D->Value + D->Size)
+      if (D->getSection() == this && D->Value <= Off &&
+          Off < D->Value + D->Size)
         return Filename + ":(" + toString(*D) + ")" + Archive;
 
   // If there's no symbol, print out the offset in the section.
   return (Filename + ":(" + Name + "+0x" + utohexstr(Off) + ")" + Archive)
       .str();
 }
 
 InputSectionBase InputSectionBase::Discarded;
if (Sym.Type == STT_SECTION) {
       // avoid having to parse and recreate .eh_frame, we just replace any
       // relocation in it pointing to discarded sections with R_*_NONE, which
       // hopefully creates a frame that is ignored at runtime.
       auto *D = dyn_cast<Defined>(&Sym);
       if (!D) {
         error("STT_SECTION symbol should be defined");
         continue;
       }
-      SectionBase *Section = D->Section;
+      SectionBase *Section = D->getSection();
       if (Section == &InputSection::Discarded) {
         P->setSymbolAndType(0, 0, false);
         continue;
       }
 
       if (Config->IsRela) {
         P->r_addend =
             Sym.getVA(getAddend<ELFT>(Rel)) - Section->getOutputSection()->Addr;

ELF/LTO.cpp

for (const lto::InputFile::Symbol &ObjSym : Obj.symbols()) {
     lto::SymbolResolution &R = Resols[SymNum];
     ++SymNum;
 
     // Ideally we shouldn't check for SF_Undefined but currently IRObjectFile
     // reports two symbols for module ASM defined. Without this check, lld
     // flags an undefined in IR with a definition in ASM as prevailing.
     // Once IRObjectFile is fixed to report only one symbol this hack can
     // be removed.
-    R.Prevailing = !ObjSym.isUndefined() && Sym->File == &F;
+    R.Prevailing = !ObjSym.isUndefined() && Sym->getFile() == &F;
 
     // We ask LTO to preserve following global symbols:
     // 1) All symbols when doing relocatable link, so that them can be used
     //    for doing final link.
     // 2) Symbols that are used in regular objects.
     // 3) C named sections if we have corresponding __start_/__stop_ symbol.
     // 4) Symbols that are defined in bitcode files and used for dynamic linking.
     R.VisibleToRegularObj = Config->Relocatable || Sym->IsUsedInRegularObj ||

ELF/LinkerScript.cpp

if (Cmd->Name == ".") {
     return;
   }
 
   if (!Cmd->Sym)
     return;
 
   ExprValue V = Cmd->Expression();
   if (V.isAbsolute()) {
-    Cmd->Sym->Section = nullptr;
+    Cmd->Sym->SectionOrFile = (InputSectionBase *)nullptr;
     Cmd->Sym->Value = V.getValue();
   } else {
-    Cmd->Sym->Section = V.Sec;
+    Cmd->Sym->SectionOrFile = V.Sec;
     Cmd->Sym->Value = V.getSectionOffset();
   }
 }
 
 static std::string getFilename(InputFile *File) {
   if (!File)
     return "";
   if (File->ArchiveName.empty())
if (Name == ".") {
     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};
+      return {DS->getSection(), false, DS->Value, Loc};
     if (auto *SS = dyn_cast<SharedSymbol>(Sym))
-      if (!ErrorOnMissingSection || SS->CopyRelSec)
-        return {SS->CopyRelSec, false, 0, Loc};
+      if (!ErrorOnMissingSection || SS->getSection())
+        return {SS->getSection(), 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

 
 static std::string indent(int Depth) { return std::string(Depth * 8, ' '); }
 
 // Returns a list of all symbols that we want to print out.
 static std::vector<Symbol *> getSymbols() {
   std::vector<Symbol *> V;
   for (InputFile *File : ObjectFiles) {
     for (Symbol *B : File->getSymbols()) {
+      auto *Sec = dyn_cast_or_null<InputSectionBase>(B->getSection());
       if (auto *SS = dyn_cast<SharedSymbol>(B))
-        if (SS->CopyRelSec || SS->NeedsPltAddr)
+        if (Sec || SS->NeedsPltAddr)
           V.push_back(SS);
       if (auto *DR = dyn_cast<Defined>(B))
-        if (DR->File == File && !DR->isSection() && DR->Section &&
-            DR->Section->Live)
+        if (Sec && Sec->File == File && !DR->isSection() && Sec->Live)
           V.push_back(DR);
     }
   }
   return V;
 }
 
 // Returns a map from sections to their symbols.
 static SymbolMapTy getSectionSyms(ArrayRef<Symbol *> Syms) {
   SymbolMapTy Ret;
   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);
+    if (auto *Sec = S->getSection())
+      Ret[Sec].push_back(S);
     else
       Ret[InX::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) {

ELF/MarkLive.cpp

static void resolveReloc(InputSectionBase &Sec, RelT &Rel,
 
   // If a symbol is referenced in a live section, it is used.
   B.Used = true;
   if (auto *SS = dyn_cast<SharedSymbol>(&B))
     if (!SS->isWeak())
       SS->getFile<ELFT>()->IsNeeded = true;
 
   if (auto *D = dyn_cast<Defined>(&B)) {
-    auto *RelSec = dyn_cast_or_null<InputSectionBase>(D->Section);
+    auto *RelSec = dyn_cast_or_null<InputSectionBase>(D->getSection());
     if (!RelSec)
       return;
     uint64_t Offset = D->Value;
     if (D->isSection())
       Offset += getAddend<ELFT>(Sec, Rel);
     Fn(RelSec, Offset);
     return;
   }
auto Enqueue = [&](InputSectionBase *Sec, uint64_t Offset) {
 
     // Add input section to the queue.
     if (InputSection *S = dyn_cast<InputSection>(Sec))
       Q.push_back(S);
   };
 
   auto MarkSymbol = [&](Symbol *Sym) {
     if (auto *D = dyn_cast_or_null<Defined>(Sym))
-      if (auto *IS = dyn_cast_or_null<InputSectionBase>(D->Section))
+      if (auto *IS = dyn_cast_or_null<InputSectionBase>(D->getSection()))
         Enqueue(IS, D->Value);
   };
 
   // Add GC root symbols.
   MarkSymbol(Symtab->find(Config->Entry));
   MarkSymbol(Symtab->find(Config->Init));
   MarkSymbol(Symtab->find(Config->Fini));
   for (StringRef S : Config->Undefined)

ELF/Relocations.cpp

 //
 // >>> defined in /home/alice/src/foo.o
 // >>> referenced by bar.c:12 (/home/alice/src/bar.c:12)
 // >>>               /home/alice/src/bar.o:(.text+0x1)
 template <class ELFT>
 static std::string getLocation(InputSectionBase &S, const Symbol &Sym,
                                uint64_t Off) {
   std::string Msg =
-      "\n>>> defined in " + toString(Sym.File) + "\n>>> referenced by ";
+      "\n>>> defined in " + toString(Sym.getFile()) + "\n>>> referenced by ";
   std::string Src = S.getSrcMsg<ELFT>(Sym, Off);
   if (!Src.empty())
     Msg += Src + "\n>>>               ";
   return Msg + S.getObjMsg(Off);
 }
 
 // This is a MIPS-specific rule.
 //

 }
 
 // True if non-preemptable symbol always has the same value regardless of where
 // the DSO is loaded.
 static bool isAbsolute(const Symbol &Sym) {
   if (Sym.isUndefWeak())
     return true;
   if (const auto *DR = dyn_cast<Defined>(&Sym))
-    return DR->Section == nullptr; // Absolute symbol.
+    return DR->getSection() == nullptr; // Absolute symbol.
   return false;
 }
 
 static bool isAbsoluteValue(const Symbol &Sym) {
   return isAbsolute(Sym) || Sym.isTls();
 }
 
 // Returns true if Expr refers a PLT entry.
template <class ELFT> static void addCopyRelSymbol(SharedSymbol *SS) {
   if (SymSize == 0)
     fatal("cannot create a copy relocation for symbol " + toString(*SS));
 
   // See if this symbol is in a read-only segment. If so, preserve the symbol's
   // memory protection by reserving space in the .bss.rel.ro section.
   bool IsReadOnly = isReadOnly<ELFT>(SS);
   BssSection *Sec = make<BssSection>(IsReadOnly ? ".bss.rel.ro" : ".bss",
                                      SymSize, SS->Alignment);
+  Sec->File = SS->getFile<ELFT>();
   if (IsReadOnly)
     InX::BssRelRo->getParent()->addSection(Sec);
   else
     InX::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)) {
-    Sym->CopyRelSec = Sec;
+    Sym->SectionOrFile = Sec;
     Sym->IsPreemptible = false;
     Sym->IsUsedInRegularObj = true;
     Sym->Used = true;
   }
 
   InX::RelaDyn->addReloc({Target->CopyRel, Sec, 0, false, SS, 0});
 }
 
if (Sym.getVisibility() != STV_DEFAULT) {
     error("cannot preempt symbol: " + toString(Sym) +
           getLocation<ELFT>(S, Sym, RelOff));
     return Expr;
   }
 
   if (Sym.isObject()) {
     // Produce a copy relocation.
     auto *B = dyn_cast<SharedSymbol>(&Sym);
-    if (B && !B->CopyRelSec) {
+    if (B && !B->getSection()) {
       if (Config->ZNocopyreloc)
         error("unresolvable relocation " + toString(Type) +
               " against symbol '" + toString(*B) +
               "'; recompile with -fPIC or remove '-z nocopyreloc'" +
               getLocation<ELFT>(S, Sym, RelOff));
 
       addCopyRelSymbol<ELFT>(B);
     }
if (Sym.isFunc()) {
     // plt. That is identified by special relocation types (R_X86_64_JUMP_SLOT,
     // R_386_JMP_SLOT, etc).
     Sym.NeedsPltAddr = true;
     Sym.IsPreemptible = false;
     return toPlt(Expr);
   }
 
   errorOrWarn("symbol '" + toString(Sym) + "' defined in " +
-              toString(Sym.File) + " has no type");
+              toString(Sym.getFile()) + " has no type");
   return Expr;
 }
 
 // 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.
 template <class ELFT, class RelTy>

ELF/SymbolTable.cpp

if (!CanOmitFromDynSym && (Config->Shared || Config->ExportDynamic))
     S->ExportDynamic = true;
 
   if (!File || File->kind() == InputFile::ObjKind)
     S->IsUsedInRegularObj = true;
 
   if (!WasInserted && S->Type != Symbol::UnknownType &&
       ((Type == STT_TLS) != S->isTls())) {
     error("TLS attribute mismatch: " + toString(*S) + "\n>>> defined in " +
-          toString(S->File) + "\n>>> defined in " + toString(File));
+          toString(S->getFile()) + "\n>>> defined in " + toString(File));
   }
 
   return {S, WasInserted};
 }
 
 template <class ELFT> Symbol *SymbolTable::addUndefined(StringRef Name) {
   return addUndefined<ELFT>(Name, STB_GLOBAL, STV_DEFAULT,
                             /*Type*/ 0,

 // if the new symbol should win, -1 if the new symbol should lose, or 0 if there
 // is a conflict. If the new symbol wins, also update the binding.
 static int compareDefinedNonCommon(Symbol *S, bool WasInserted, uint8_t Binding,
                                    bool IsAbsolute, uint64_t Value,
                                    StringRef Name) {
   if (int Cmp = compareDefined(S, WasInserted, Binding, Name))
     return Cmp;
   if (auto *R = dyn_cast<Defined>(S)) {
-    if (R->Section && isa<BssSection>(R->Section)) {
+    if (R->getSection() && isa<BssSection>(R->getSection())) {
       // Non-common symbols take precedence over common symbols.
       if (Config->WarnCommon)
         warn("common " + S->getName() + " is overridden");
       return 1;
     }
-    if (R->Section == nullptr && Binding == STB_GLOBAL && IsAbsolute &&
+    if (R->getSection() == nullptr && Binding == STB_GLOBAL && IsAbsolute &&
         R->Value == Value)
       return -1;
   }
   return 0;
 }
 
 Symbol *SymbolTable::addCommon(StringRef N, uint64_t Size, uint32_t Alignment,
                                uint8_t Binding, uint8_t StOther, uint8_t Type,
                                InputFile *File) {
   Symbol *S;
   bool WasInserted;
   std::tie(S, WasInserted) = insert(N, Type, getVisibility(StOther),
                                     /*CanOmitFromDynSym*/ false, File);
   int Cmp = compareDefined(S, WasInserted, Binding, N);
   if (Cmp > 0) {
     auto *Bss = make<BssSection>("COMMON", Size, Alignment);
     Bss->File = File;
     Bss->Live = !Config->GcSections;
     InputSections.push_back(Bss);
 
     replaceSymbol<Defined>(S, File, N, Binding, StOther, Type, 0, Size, Bss);
   } else if (Cmp == 0) {
     auto *D = cast<Defined>(S);
-    auto *Bss = dyn_cast_or_null<BssSection>(D->Section);
+    auto *Bss = dyn_cast_or_null<BssSection>(D->getSection());
     if (!Bss) {
       // Non-common symbols take precedence over common symbols.
       if (Config->WarnCommon)
         warn("common " + S->getName() + " is overridden");
       return S;
     }
 
     if (Config->WarnCommon)
       warn("multiple common of " + D->getName());
 
     Bss->Alignment = std::max(Bss->Alignment, Alignment);
     if (Size > Bss->Size) {
-      D->File = Bss->File = File;
+      Bss->File = File;
       D->Size = Bss->Size = Size;
     }
   }
   return S;
 }
 
 static void warnOrError(const Twine &Msg) {
   if (Config->AllowMultipleDefinition)
     warn(Msg);
   else
     error(Msg);
 }
 
 static void reportDuplicate(Symbol *Sym, InputFile *NewFile) {
   warnOrError("duplicate symbol: " + toString(*Sym) + "\n>>> defined in " +
-              toString(Sym->File) + "\n>>> defined in " + toString(NewFile));
+              toString(Sym->getFile()) + "\n>>> defined in " +
+              toString(NewFile));
 }
 
 template <class ELFT>
 static void reportDuplicate(Symbol *Sym, InputSectionBase *ErrSec,
                             typename ELFT::uint ErrOffset) {
   Defined *D = cast<Defined>(Sym);
-  if (!D->Section || !ErrSec) {
+  if (!D->getSection() || !ErrSec) {
     reportDuplicate(Sym, ErrSec ? ErrSec->File : nullptr);
     return;
   }
 
   // Construct and print an error message in the form of:
   //
   //   ld.lld: error: duplicate symbol: foo
   //   >>> defined at bar.c:30
   //   >>>            bar.o (/home/alice/src/bar.o)
   //   >>> defined at baz.c:563
   //   >>>            baz.o in archive libbaz.a
-  auto *Sec1 = cast<InputSectionBase>(D->Section);
+  auto *Sec1 = cast<InputSectionBase>(D->getSection());
   std::string Src1 = Sec1->getSrcMsg<ELFT>(*Sym, D->Value);
   std::string Obj1 = Sec1->getObjMsg(D->Value);
   std::string Src2 = ErrSec->getSrcMsg<ELFT>(*Sym, ErrOffset);
   std::string Obj2 = ErrSec->getObjMsg(ErrOffset);
 
   std::string Msg = "duplicate symbol: " + toString(*Sym) + "\n>>> defined at ";
   if (!Src1.empty())
     Msg += Src1 + "\n>>>            ";

ELF/Symbols.h

 // All symbols are handled as SymbolBodies regardless of their types.
 // This file defines various types of SymbolBodies.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_SYMBOLS_H
 #define LLD_ELF_SYMBOLS_H
 
+#include "InputFiles.h"
 #include "InputSection.h"
 #include "Strings.h"
 
 #include "lld/Common/LLVM.h"
 #include "llvm/Object/Archive.h"
 #include "llvm/Object/ELF.h"
 
 namespace lld {
public:
   unsigned CanInline : 1;
 
   // True if this symbol is specified by --trace-symbol option.
   unsigned Traced : 1;
 
   // This symbol version was found in a version script.
   unsigned InVersionScript : 1;
 
-  // The file from which this symbol was created.
-  InputFile *File;
+  // For symbols that don't have a section we store the file in here. If they do
+  // have a section the file can be found via the section.
+  llvm::PointerUnion<SectionBase *, InputFile *> SectionOrFile;
+  InputFile *getFile() const {
+    if (auto *Sec = dyn_cast_or_null<InputSectionBase>(getSection()))
+      return Sec->File;
+    return SectionOrFile.dyn_cast<InputFile *>();
+  }
+  SectionBase *getSection() const {
+    return SectionOrFile.dyn_cast<SectionBase *>();
+  }
 
   bool includeInDynsym() const;
   uint8_t computeBinding() const;
   bool isWeak() const { return Binding == llvm::ELF::STB_WEAK; }
 
   bool isUndefined() const { return SymbolKind == UndefinedKind; }
   bool isDefined() const { return SymbolKind == DefinedKind; }
   bool isShared() const { return SymbolKind == SharedKind; }
public:
   uint32_t GotIndex = -1;
   uint32_t GotPltIndex = -1;
   uint32_t PltIndex = -1;
   uint32_t GlobalDynIndex = -1;
 
 protected:
   Symbol(Kind K, InputFile *File, StringRefZ Name, uint8_t Binding,
          uint8_t StOther, uint8_t Type)
-      : Binding(Binding), File(File), SymbolKind(K), NeedsPltAddr(false),
-        IsInGlobalMipsGot(false), Is32BitMipsGot(false), IsInIplt(false),
-        IsInIgot(false), IsPreemptible(false), Used(!Config->GcSections),
-        Type(Type), StOther(StOther), Name(Name) {}
+      : Binding(Binding), SectionOrFile(File), SymbolKind(K),
+        NeedsPltAddr(false), IsInGlobalMipsGot(false), Is32BitMipsGot(false),
+        IsInIplt(false), IsInIgot(false), IsPreemptible(false),
+        Used(!Config->GcSections), Type(Type), StOther(StOther), Name(Name) {}
 
   const unsigned SymbolKind : 8;
 
 public:
   // True the symbol should point to its PLT entry.
   // For SharedSymbol only.
   unsigned NeedsPltAddr : 1;
   // True if this symbol has an entry in the global part of MIPS GOT.

 };
 
 // Represents a symbol that is defined in the current output file.
 class Defined : public Symbol {
 public:
   Defined(InputFile *File, StringRefZ Name, uint8_t Binding, uint8_t StOther,
           uint8_t Type, uint64_t Value, uint64_t Size, SectionBase *Section)
       : Symbol(DefinedKind, File, Name, Binding, StOther, Type), Value(Value),
-        Size(Size), Section(Section) {}
+        Size(Size) {
+    if (Section)
+      SectionOrFile = Section;
+  }
 
   static bool classof(const Symbol *S) { return S->isDefined(); }
 
   uint64_t Value;
   uint64_t Size;
-  SectionBase *Section;
 };
 
 class Undefined : public Symbol {
 public:
   Undefined(InputFile *File, StringRefZ Name, uint8_t Binding, uint8_t StOther,
             uint8_t Type)
       : Symbol(UndefinedKind, File, Name, Binding, StOther, Type) {}
 
SharedSymbol(InputFile *File, StringRef Name, uint8_t Binding,
     // 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);
+    return cast<SharedFile<ELFT>>(Symbol::getFile());
   }
 
-  // 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;
 };

ELF/Symbols.cpp

 Defined *ElfSym::MipsGp;
 Defined *ElfSym::MipsGpDisp;
 Defined *ElfSym::MipsLocalGp;
 
 static uint64_t getSymVA(const Symbol &Sym, int64_t &Addend) {
   switch (Sym.kind()) {
   case Symbol::DefinedKind: {
     auto &D = cast<Defined>(Sym);
-    SectionBase *IS = D.Section;
+    SectionBase *IS = D.getSection();
     if (auto *ISB = dyn_cast_or_null<InputSectionBase>(IS))
       IS = ISB->Repl;
 
     // According to the ELF spec reference to a local symbol from outside
     // the group are not allowed. Unfortunately .eh_frame breaks that rule
     // and must be treated specially. For now we just replace the symbol with
     // 0.
     if (IS == &InputSection::Discarded)
case Symbol::DefinedKind: {
     //
     // If you understand the data structures involved with this next
     // line (and how they get built), then you have a pretty good
     // understanding of the linker.
     uint64_t VA = (OutSec ? OutSec->Addr : 0) + IS->getOffset(Offset);
 
     if (D.isTls() && !Config->Relocatable) {
       if (!Out::TlsPhdr)
-        fatal(toString(D.File) +
+        fatal(toString(D.getFile()) +
               " has an STT_TLS symbol but doesn't have an SHF_TLS section");
       return VA - Out::TlsPhdr->p_vaddr;
     }
     return VA;
   }
   case Symbol::SharedKind: {
     auto &SS = cast<SharedSymbol>(Sym);
-    if (SS.CopyRelSec)
-      return SS.CopyRelSec->getParent()->Addr + SS.CopyRelSec->OutSecOff;
+    if (auto Sec = dyn_cast_or_null<InputSection>(SS.getSection()))
+      return Sec->getParent()->Addr + Sec->OutSecOff;
     if (SS.NeedsPltAddr)
       return Sym.getPltVA();
     return 0;
   }
   case Symbol::UndefinedKind:
     return 0;
   case Symbol::LazyArchiveKind:
   case Symbol::LazyObjectKind:
uint64_t Symbol::getSize() const {
   if (const auto *DR = dyn_cast<Defined>(this))
     return DR->Size;
   if (const auto *S = dyn_cast<SharedSymbol>(this))
     return S->Size;
   return 0;
 }
 
 OutputSection *Symbol::getOutputSection() const {
-  if (auto *S = dyn_cast<Defined>(this)) {
-    if (S->Section)
-      return S->Section->getOutputSection();
-    return nullptr;
-  }
-
-  if (auto *S = dyn_cast<SharedSymbol>(this)) {
-    if (S->CopyRelSec)
-      return S->CopyRelSec->getParent();
-    return nullptr;
-  }
-
+  if (auto *Sec = getSection())
+    return Sec->getOutputSection();
   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('@');
for (VersionDefinition &Ver : Config->VersionDefinitions) {
     return;
   }
 
   // It is an error if the specified version is not defined.
   // Usually version script is not provided when linking executable,
   // but we may still want to override a versioned symbol from DSO,
   // so we do not report error in this case.
   if (Config->Shared)
-    error(toString(File) + ": symbol " + S + " has undefined version " +
+    error(toString(getFile()) + ": symbol " + S + " has undefined version " +
           Verstr);
 }
 
 InputFile *Lazy::fetch() {
   if (auto *S = dyn_cast<LazyArchive>(this))
     return S->fetch();
   return cast<LazyObject>(this)->fetch();
 }
 
-ArchiveFile *LazyArchive::getFile() { return cast<ArchiveFile>(File); }
+ArchiveFile *LazyArchive::getFile() {
+  return cast<ArchiveFile>(Symbol::getFile());
+}
 
 InputFile *LazyArchive::fetch() {
   std::pair<MemoryBufferRef, uint64_t> MBInfo = getFile()->getMember(&Sym);
 
   // getMember returns an empty buffer if the member was already
   // read from the library.
   if (MBInfo.first.getBuffer().empty())
     return nullptr;
   return createObjectFile(MBInfo.first, getFile()->getName(), MBInfo.second);
 }
 
-LazyObjFile *LazyObject::getFile() { return cast<LazyObjFile>(File); }
+LazyObjFile *LazyObject::getFile() {
+  return cast<LazyObjFile>(Symbol::getFile());
+}
 
 InputFile *LazyObject::fetch() { return getFile()->fetch(); }
 
 uint8_t Symbol::computeBinding() const {
   if (Config->Relocatable)
     return Binding;
   if (Visibility != STV_DEFAULT && Visibility != STV_PROTECTED)
     return STB_LOCAL;

 void elf::printTraceSymbol(Symbol *Sym) {
   std::string S;
   if (Sym->isUndefined())
     S = ": reference to ";
   else if (Sym->isLazy())
     S = ": lazy definition of ";
   else if (Sym->isShared())
     S = ": shared definition of ";
-  else if (dyn_cast_or_null<BssSection>(cast<Defined>(Sym)->Section))
+  else if (dyn_cast_or_null<BssSection>(cast<Defined>(Sym)->getSection()))
     S = ": common definition of ";
   else
     S = ": definition of ";
 
-  message(toString(Sym->File) + S + Sym->getName());
+  message(toString(Sym->getFile()) + S + Sym->getName());
 }
 
 // Returns a symbol for an error message.
 std::string lld::toString(const Symbol &B) {
   if (Config->Demangle)
     if (Optional<std::string> S = demangleItanium(B.getName()))
       return *S;
   return B.getName();
 }

ELF/SyntheticSections.cpp

bool EhFrameSection::isFdeLive(EhSectionPiece &Fde, ArrayRef<RelTy> Rels) {
   if (FirstRelI == (unsigned)-1)
     return false;
 
   const RelTy &Rel = Rels[FirstRelI];
   Symbol &B = Sec->template getFile<ELFT>()->getRelocTargetSym(Rel);
 
   // FDEs for garbage-collected or merged-by-ICF sections are dead.
   if (auto *D = dyn_cast<Defined>(&B))
-    if (auto *Sec = cast_or_null<InputSectionBase>(D->Section))
+    if (auto *Sec = cast_or_null<InputSectionBase>(D->getSection()))
       return Sec->Live && (Sec == Sec->Repl);
   return false;
 }
 
 // .eh_frame is a sequence of CIE or FDE records. In general, there
 // is one CIE record per input object file which is followed by
 // a list of FDEs. This function searches an existing CIE or create a new
 // one and associates FDEs to the CIE.
for (SymbolTableEntry &Ent : Symbols) {
     }
 
     ESym->st_name = Ent.StrTabOffset;
 
     // Set a section index.
     BssSection *CommonSec = nullptr;
     if (!Config->DefineCommon)
       if (auto *D = dyn_cast<Defined>(Sym))
-        CommonSec = dyn_cast_or_null<BssSection>(D->Section);
+        CommonSec = dyn_cast_or_null<BssSection>(D->getSection());
     if (CommonSec)
       ESym->st_shndx = SHN_COMMON;
     else if (const OutputSection *OutSec = Sym->getOutputSection())
       ESym->st_shndx = OutSec->SectionIndex;
     else if (isa<Defined>(Sym))
       ESym->st_shndx = SHN_ABS;
     else
       ESym->st_shndx = SHN_UNDEF;

 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 SS->getSection() == nullptr && !SS->NeedsPltAddr;
         return !S.Sym->isDefined();
       });
   if (Mid == V.end())
     return;
 
   // 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

ELF/Thunks.cpp

 void MipsThunk::addSymbols(ThunkSection &IS) {
   ThunkSym =
       addSyntheticLocal(Saver.save("__LA25Thunk_" + Destination.getName()),
                         STT_FUNC, Offset, size(), &IS);
 }
 
 InputSection *MipsThunk::getTargetInputSection() const {
   auto &DR = cast<Defined>(Destination);
-  return dyn_cast<InputSection>(DR.Section);
+  return dyn_cast<InputSection>(DR.getSection());
 }
 
 // Write microMIPS R2-R5 LA25 thunk code
 // to call PIC function from the non-PIC one.
 void MicroMipsThunk::writeTo(uint8_t *Buf, ThunkSection &) const {
   uint64_t S = Destination.getVA() | 1;
   write16(Buf, 0x41b9, Config->Endianness);       // lui   $25, %hi(func)
   write16(Buf + 4, 0xd400, Config->Endianness);   // j     func
   write16(Buf + 8, 0x3339, Config->Endianness);   // addiu $25, $25, %lo(func)
   write16(Buf + 12, 0x0c00, Config->Endianness);  // nop
   Target->relocateOne(Buf, R_MICROMIPS_HI16, S);
   Target->relocateOne(Buf + 4, R_MICROMIPS_26_S1, S);
   Target->relocateOne(Buf + 8, R_MICROMIPS_LO16, S);
 }
 
 void MicroMipsThunk::addSymbols(ThunkSection &IS) {
   ThunkSym =
       addSyntheticLocal(Saver.save("__microLA25Thunk_" + Destination.getName()),
                         STT_FUNC, Offset, size(), &IS);
   ThunkSym->StOther |= STO_MIPS_MICROMIPS;
 }
 
 InputSection *MicroMipsThunk::getTargetInputSection() const {
   auto &DR = cast<Defined>(Destination);
-  return dyn_cast<InputSection>(DR.Section);
+  return dyn_cast<InputSection>(DR.getSection());
 }
 
 // Write microMIPS R6 LA25 thunk code
 // to call PIC function from the non-PIC one.
 void MicroMipsR6Thunk::writeTo(uint8_t *Buf, ThunkSection &) const {
   uint64_t S = Destination.getVA() | 1;
   uint64_t P = ThunkSym->getVA();
   write16(Buf, 0x1320, Config->Endianness);       // lui   $25, %hi(func)
   write16(Buf + 4, 0x3339, Config->Endianness);   // addiu $25, $25, %lo(func)
   write16(Buf + 8, 0x9400, Config->Endianness);   // bc    func
   Target->relocateOne(Buf, R_MICROMIPS_HI16, S);
   Target->relocateOne(Buf + 4, R_MICROMIPS_LO16, S);
   Target->relocateOne(Buf + 8, R_MICROMIPS_PC26_S1, S - P - 12);
 }
 
 void MicroMipsR6Thunk::addSymbols(ThunkSection &IS) {
   ThunkSym =
       addSyntheticLocal(Saver.save("__microLA25Thunk_" + Destination.getName()),
                         STT_FUNC, Offset, size(), &IS);
   ThunkSym->StOther |= STO_MIPS_MICROMIPS;
 }
 
 InputSection *MicroMipsR6Thunk::getTargetInputSection() const {
   auto &DR = cast<Defined>(Destination);
-  return dyn_cast<InputSection>(DR.Section);
+  return dyn_cast<InputSection>(DR.getSection());
 }
 
 Thunk::Thunk(Symbol &D) : Destination(D), Offset(0) {}
 
 Thunk::~Thunk() = default;
 
 static Thunk *addThunkAArch64(RelType Type, Symbol &S) {
   if (Type != R_AARCH64_CALL26 && Type != R_AARCH64_JUMP26)

ELF/Writer.cpp

template <class ELFT> static void createSyntheticSections() {
   InX::Bss = make<BssSection>(".bss", 0, 1);
   Add(InX::Bss);
 
   // If there is a SECTIONS command and a .data.rel.ro section name use name
   // .data.rel.ro.bss so that we match in the .data.rel.ro output section.
   // This makes sure our relro is contiguous.
   bool HasDataRelRo =
       Script->HasSectionsCommand && findSection(".data.rel.ro");
-  InX::BssRelRo = make<BssSection>(
-      HasDataRelRo ? ".data.rel.ro.bss" : ".bss.rel.ro", 0, 1);
+  InX::BssRelRo =
+      make<BssSection>(HasDataRelRo ? ".data.rel.ro.bss" : ".bss.rel.ro", 0, 1);
   Add(InX::BssRelRo);
 
   // Add MIPS-specific sections.
   if (Config->EMachine == EM_MIPS) {
     if (!Config->Shared && Config->HasDynSymTab) {
       InX::MipsRldMap = make<MipsRldMapSection>();
       Add(InX::MipsRldMap);
     }

 }
 
 static bool includeInSymtab(const Symbol &B) {
   if (!B.isLocal() && !B.IsUsedInRegularObj)
     return false;
 
   if (auto *D = dyn_cast<Defined>(&B)) {
     // Always include absolute symbols.
-    SectionBase *Sec = D->Section;
+    SectionBase *Sec = D->getSection();
     if (!Sec)
       return true;
     if (auto *IS = dyn_cast<InputSectionBase>(Sec)) {
       Sec = IS->Repl;
       IS = cast<InputSectionBase>(Sec);
       // Exclude symbols pointing to garbage-collected sections.
       if (!IS->Live)
         return false;
for (Symbol *B : F->getLocalSymbols()) {
       auto *DR = dyn_cast<Defined>(B);
 
       // No reason to keep local undefined symbol in symtab.
       if (!DR)
         continue;
       if (!includeInSymtab(*B))
         continue;
 
-      SectionBase *Sec = DR->Section;
+      SectionBase *Sec = DR->getSection();
       if (!shouldKeepInSymtab(Sec, B->getName(), *B))
         continue;
       InX::SymTab->addSymbol(B);
     }
   }
 }
 
 template <class ELFT> void Writer<ELFT>::addSectionSymbols() {

 // defining these symbols explicitly in the linker script.
 template <class ELFT> void Writer<ELFT>::setReservedSymbolSections() {
   if (ElfSym::GlobalOffsetTable) {
     // The _GLOBAL_OFFSET_TABLE_ symbol is defined by target convention to
     // be at some offset from the base of the .got section, usually 0 or the end
     // of the .got
     InputSection *GotSection = InX::MipsGot ? cast<InputSection>(InX::MipsGot)
                                             : cast<InputSection>(InX::Got);
-    ElfSym::GlobalOffsetTable->Section = GotSection;
+    ElfSym::GlobalOffsetTable->SectionOrFile = GotSection;
   }
 
   PhdrEntry *Last = nullptr;
   PhdrEntry *LastRO = nullptr;
 
   for (PhdrEntry *P : Phdrs) {
     if (P->p_type != PT_LOAD)
       continue;
     Last = P;
     if (!(P->p_flags & PF_W))
       LastRO = P;
   }
 
   if (LastRO) {
     // _etext is the first location after the last read-only loadable segment.
     if (ElfSym::Etext1)
-      ElfSym::Etext1->Section = LastRO->LastSec;
+      ElfSym::Etext1->SectionOrFile = LastRO->LastSec;
     if (ElfSym::Etext2)
-      ElfSym::Etext2->Section = LastRO->LastSec;
+      ElfSym::Etext2->SectionOrFile = LastRO->LastSec;
   }
 
   if (Last) {
     // _edata points to the end of the last mapped initialized section.
     OutputSection *Edata = nullptr;
     for (OutputSection *OS : OutputSections) {
       if (OS->Type != SHT_NOBITS)
         Edata = OS;
       if (OS == Last->LastSec)
         break;
     }
 
     if (ElfSym::Edata1)
-      ElfSym::Edata1->Section = Edata;
+      ElfSym::Edata1->SectionOrFile = Edata;
     if (ElfSym::Edata2)
-      ElfSym::Edata2->Section = Edata;
+      ElfSym::Edata2->SectionOrFile = Edata;
 
     // _end is the first location after the uninitialized data region.
     if (ElfSym::End1)
-      ElfSym::End1->Section = Last->LastSec;
+      ElfSym::End1->SectionOrFile = Last->LastSec;
     if (ElfSym::End2)
-      ElfSym::End2->Section = Last->LastSec;
+      ElfSym::End2->SectionOrFile = Last->LastSec;
   }
 
   if (ElfSym::Bss)
-    ElfSym::Bss->Section = findSection(".bss");
+    ElfSym::Bss->SectionOrFile = findSection(".bss");
 
   // Setup MIPS _gp_disp/__gnu_local_gp symbols which should
   // be equal to the _gp symbol's value.
   if (ElfSym::MipsGp) {
     // Find GP-relative section with the lowest address
     // and use this address to calculate default _gp value.
     for (OutputSection *OS : OutputSections) {
       if (OS->Flags & SHF_MIPS_GPREL) {
-        ElfSym::MipsGp->Section = OS;
+        ElfSym::MipsGp->SectionOrFile = OS;
         ElfSym::MipsGp->Value = 0x7ff0;
         break;
       }
     }
   }
 }
 
 // We want to find how similar two ranks are.
for (Symbol *Sym : Symtab->getSymbols()) {
     if (!includeInSymtab(*Sym))
       continue;
     if (InX::SymTab)
       InX::SymTab->addSymbol(Sym);
 
     if (InX::DynSymTab && Sym->includeInDynsym()) {
       InX::DynSymTab->addSymbol(Sym);
       if (auto *SS = dyn_cast<SharedSymbol>(Sym))
-        if (cast<SharedFile<ELFT>>(Sym->File)->IsNeeded)
+        if (cast<SharedFile<ELFT>>(Sym->getFile())->IsNeeded)
           In<ELFT>::VerNeed->addSymbol(SS);
     }
   }
 
   // Do not proceed if there was an undefined symbol.
   if (errorCount())
     return;
 

test/ELF/map-file.s

 // CHECK-NEXT: 0000000000201050 0000000000000000     0                 sharedFunc2
 // CHECK-NEXT: 0000000000202000 0000000000000028     8 .got.plt
 // CHECK-NEXT: 0000000000202000 0000000000000028     8         <internal>:(.got.plt)
 // CHECK-NEXT: 0000000000203000 0000000000000100     8 .dynamic
 // CHECK-NEXT: 0000000000203000 0000000000000100     8         <internal>:(.dynamic)
 // CHECK-NEXT: 0000000000204000 0000000000000010    16 .bss
 // CHECK-NEXT: 0000000000204000 0000000000000004    16         {{.*}}{{/|\\}}map-file.s.tmp1.o:(COMMON)
 // CHECK-NEXT: 0000000000204000 0000000000000004     0                 common
-// CHECK-NEXT: 0000000000204004 0000000000000004     1         <internal>:(.bss)
+// CHECK-NEXT: 0000000000204004 0000000000000004     1         {{.*}}map-file.s.tmp5.so:(.bss)
 // CHECK-NEXT: 0000000000204004 0000000000000004     0                 sharedFoo
-// CHECK-NEXT: 0000000000204008 0000000000000008     1         <internal>:(.bss)
+// CHECK-NEXT: 0000000000204008 0000000000000008     1         {{.*}}map-file.s.tmp5.so:(.bss)
 // CHECK-NEXT: 0000000000204008 0000000000000008     0                 sharedBar
 // CHECK-NEXT: 0000000000000000 0000000000000008     1 .comment
 // CHECK-NEXT: 0000000000000000 0000000000000008     1         <internal>:(.comment)
 // CHECK-NEXT: 0000000000000000 0000000000000198     8 .symtab
 // CHECK-NEXT: 0000000000000000 0000000000000198     8         <internal>:(.symtab)
 // CHECK-NEXT: 0000000000000000 0000000000000084     1 .shstrtab
 // CHECK-NEXT: 0000000000000000 0000000000000084     1         <internal>:(.shstrtab)
 // CHECK-NEXT: 0000000000000000 000000000000006d     1 .strtab
 // CHECK-NEXT: 0000000000000000 000000000000006d     1         <internal>:(.strtab)
 
 // RUN: not ld.lld %t1.o %t2.o %t3.o %t4.a -o %t -Map=/ 2>&1 \
 // RUN:  | FileCheck -check-prefix=FAIL %s
 // FAIL: cannot open map file /

test/ELF/relro-script.s

 // RUN: .dynamic : { *(.dynamic) } \
 // RUN: .got : { *(.got) } \
 // RUN: .got.plt : { *(.got.plt) } \
 // RUN: } " > %t.script
 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t3.o
 // RUN: ld.lld %t3.o %t.so -o %t --script=%t.script --print-map | FileCheck %s
 
 // CHECK: .data.rel.ro
-// CHECK-NEXT: <internal>:(.bss.rel.ro)
+// CHECK-NEXT: relro-script.s.tmp.so:(.bss.rel.ro)
         .section .text, "ax", @progbits
         .global _start
         .global bar
         .global foo
 _start:
         .quad bar
         .quad foo