contrib/llvm/tools/lld/ELF/MapFile.cpp

   1 //===- MapFile.cpp --------------------------------------------------------===//
   2 //
   3 //                             The LLVM Linker
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the -Map option. It shows lists in order and
  11 // hierarchically the output sections, input sections, input files and
  12 // symbol:
  13 //
  14 //   Address  Size     Align Out     In      Symbol
  15 //   00201000 00000015     4 .text
  16 //   00201000 0000000e     4         test.o:(.text)
  17 //   0020100e 00000000     0                 local
  18 //   00201005 00000000     0                 f(int)
  19 //
  20 //===----------------------------------------------------------------------===//
  21
  22 #include "MapFile.h"
  23 #include "InputFiles.h"
  24 #include "LinkerScript.h"
  25 #include "OutputSections.h"
  26 #include "SymbolTable.h"
  27 #include "Symbols.h"
  28 #include "SyntheticSections.h"
  29 #include "lld/Common/Strings.h"
  30 #include "lld/Common/Threads.h"
  31 #include "llvm/ADT/MapVector.h"
  32 #include "llvm/ADT/SetVector.h"
  33 #include "llvm/Support/raw_ostream.h"
  34
  35 using namespace llvm;
  36 using namespace llvm::object;
  37
  38 using namespace lld;
  39 using namespace lld::elf;
  40
  41 typedef DenseMap<const SectionBase *, SmallVector<Defined *, 4>> SymbolMapTy;
  42
  43 static const std::string Indent8 = "        ";          // 8 spaces
  44 static const std::string Indent16 = "                "; // 16 spaces
  45
  46 // Print out the first three columns of a line.
  47 static void writeHeader(raw_ostream &OS, uint64_t VMA, uint64_t LMA,
  48                         uint64_t Size, uint64_t Align) {
  49   if (Config->Is64)
  50     OS << format("%16llx %16llx %8llx %5lld ", VMA, LMA, Size, Align);
  51   else
  52     OS << format("%8llx %8llx %8llx %5lld ", VMA, LMA, Size, Align);
  53 }
  54
  55 // Returns a list of all symbols that we want to print out.
  56 static std::vector<Defined *> getSymbols() {
  57   std::vector<Defined *> V;
  58   for (InputFile *File : ObjectFiles)
  59     for (Symbol *B : File->getSymbols())
  60       if (auto *DR = dyn_cast<Defined>(B))
  61         if (!DR->isSection() && DR->Section && DR->Section->Live &&
  62             (DR->File == File || DR->NeedsPltAddr || DR->Section->Bss))
  63           V.push_back(DR);
  64   return V;
  65 }
  66
  67 // Returns a map from sections to their symbols.
  68 static SymbolMapTy getSectionSyms(ArrayRef<Defined *> Syms) {
  69   SymbolMapTy Ret;
  70   for (Defined *DR : Syms)
  71     Ret[DR->Section].push_back(DR);
  72
  73   // Sort symbols by address. We want to print out symbols in the
  74   // order in the output file rather than the order they appeared
  75   // in the input files.
  76   for (auto &It : Ret) {
  77     SmallVectorImpl<Defined *> &V = It.second;
  78     std::stable_sort(V.begin(), V.end(), [](Defined *A, Defined *B) {
  79       return A->getVA() < B->getVA();
  80     });
  81   }
  82   return Ret;
  83 }
  84
  85 // Construct a map from symbols to their stringified representations.
  86 // Demangling symbols (which is what toString() does) is slow, so
  87 // we do that in batch using parallel-for.
  88 static DenseMap<Symbol *, std::string>
  89 getSymbolStrings(ArrayRef<Defined *> Syms) {
  90   std::vector<std::string> Str(Syms.size());
  91   parallelForEachN(0, Syms.size(), [&](size_t I) {
  92     raw_string_ostream OS(Str[I]);
  93     OutputSection *OSec = Syms[I]->getOutputSection();
  94     uint64_t VMA = Syms[I]->getVA();
  95     uint64_t LMA = OSec ? OSec->getLMA() + VMA - OSec->getVA(0) : 0;
  96     writeHeader(OS, VMA, LMA, Syms[I]->getSize(), 1);
  97     OS << Indent16 << toString(*Syms[I]);
  98   });
  99
 100   DenseMap<Symbol *, std::string> Ret;
 101   for (size_t I = 0, E = Syms.size(); I < E; ++I)
 102     Ret[Syms[I]] = std::move(Str[I]);
 103   return Ret;
 104 }
 105
 106 // Print .eh_frame contents. Since the section consists of EhSectionPieces,
 107 // we need a specialized printer for that section.
 108 //
 109 // .eh_frame tend to contain a lot of section pieces that are contiguous
 110 // both in input file and output file. Such pieces are squashed before
 111 // being displayed to make output compact.
 112 static void printEhFrame(raw_ostream &OS, OutputSection *OSec) {
 113   std::vector<EhSectionPiece> Pieces;
 114
 115   auto Add = [&](const EhSectionPiece &P) {
 116     // If P is adjacent to Last, squash the two.
 117     if (!Pieces.empty()) {
 118       EhSectionPiece &Last = Pieces.back();
 119       if (Last.Sec == P.Sec && Last.InputOff + Last.Size == P.InputOff &&
 120           Last.OutputOff + Last.Size == P.OutputOff) {
 121         Last.Size += P.Size;
 122         return;
 123       }
 124     }
 125     Pieces.push_back(P);
 126   };
 127
 128   // Gather section pieces.
 129   for (const CieRecord *Rec : InX::EhFrame->getCieRecords()) {
 130     Add(*Rec->Cie);
 131     for (const EhSectionPiece *Fde : Rec->Fdes)
 132       Add(*Fde);
 133   }
 134
 135   // Print out section pieces.
 136   for (EhSectionPiece &P : Pieces) {
 137     writeHeader(OS, OSec->Addr + P.OutputOff, OSec->getLMA() + P.OutputOff,
 138                 P.Size, 1);
 139     OS << Indent8 << toString(P.Sec->File) << ":(" << P.Sec->Name << "+0x"
 140        << Twine::utohexstr(P.InputOff) + ")\n";
 141   }
 142 }
 143
 144 void elf::writeMapFile() {
 145   if (Config->MapFile.empty())
 146     return;
 147
 148   // Open a map file for writing.
 149   std::error_code EC;
 150   raw_fd_ostream OS(Config->MapFile, EC, sys::fs::F_None);
 151   if (EC) {
 152     error("cannot open " + Config->MapFile + ": " + EC.message());
 153     return;
 154   }
 155
 156   // Collect symbol info that we want to print out.
 157   std::vector<Defined *> Syms = getSymbols();
 158   SymbolMapTy SectionSyms = getSectionSyms(Syms);
 159   DenseMap<Symbol *, std::string> SymStr = getSymbolStrings(Syms);
 160
 161   // Print out the header line.
 162   int W = Config->Is64 ? 16 : 8;
 163   OS << right_justify("VMA", W) << ' ' << right_justify("LMA", W)
 164      << "     Size Align Out     In      Symbol\n";
 165
 166   for (BaseCommand *Base : Script->SectionCommands) {
 167     if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
 168       if (Cmd->Provide && !Cmd->Sym)
 169         continue;
 170       //FIXME: calculate and print LMA.
 171       writeHeader(OS, Cmd->Addr, 0, Cmd->Size, 1);
 172       OS << Cmd->CommandString << '\n';
 173       continue;
 174     }
 175
 176     auto *OSec = cast<OutputSection>(Base);
 177     writeHeader(OS, OSec->Addr, OSec->getLMA(), OSec->Size, OSec->Alignment);
 178     OS << OSec->Name << '\n';
 179
 180     // Dump symbols for each input section.
 181     for (BaseCommand *Base : OSec->SectionCommands) {
 182       if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) {
 183         for (InputSection *IS : ISD->Sections) {
 184           if (IS == InX::EhFrame) {
 185             printEhFrame(OS, OSec);
 186             continue;
 187           }
 188
 189           writeHeader(OS, IS->getVA(0), OSec->getLMA() + IS->getOffset(0),
 190                       IS->getSize(), IS->Alignment);
 191           OS << Indent8 << toString(IS) << '\n';
 192           for (Symbol *Sym : SectionSyms[IS])
 193             OS << SymStr[Sym] << '\n';
 194         }
 195         continue;
 196       }
 197
 198       if (auto *Cmd = dyn_cast<ByteCommand>(Base)) {
 199         writeHeader(OS, OSec->Addr + Cmd->Offset, OSec->getLMA() + Cmd->Offset,
 200                     Cmd->Size, 1);
 201         OS << Indent8 << Cmd->CommandString << '\n';
 202         continue;
 203       }
 204
 205       if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
 206         if (Cmd->Provide && !Cmd->Sym)
 207           continue;
 208         writeHeader(OS, Cmd->Addr, OSec->getLMA() + Cmd->Addr - OSec->getVA(0),
 209                     Cmd->Size, 1);
 210         OS << Indent8 << Cmd->CommandString << '\n';
 211         continue;
 212       }
 213     }
 214   }
 215 }
 216
 217 static void print(StringRef A, StringRef B) {
 218   outs() << left_justify(A, 49) << " " << B << "\n";
 219 }
 220
 221 // Output a cross reference table to stdout. This is for --cref.
 222 //
 223 // For each global symbol, we print out a file that defines the symbol
 224 // followed by files that uses that symbol. Here is an example.
 225 //
 226 //     strlen     /lib/x86_64-linux-gnu/libc.so.6
 227 //                tools/lld/tools/lld/CMakeFiles/lld.dir/lld.cpp.o
 228 //                lib/libLLVMSupport.a(PrettyStackTrace.cpp.o)
 229 //
 230 // In this case, strlen is defined by libc.so.6 and used by other two
 231 // files.
 232 void elf::writeCrossReferenceTable() {
 233   if (!Config->Cref)
 234     return;
 235
 236   // Collect symbols and files.
 237   MapVector<Symbol *, SetVector<InputFile *>> Map;
 238   for (InputFile *File : ObjectFiles) {
 239     for (Symbol *Sym : File->getSymbols()) {
 240       if (isa<SharedSymbol>(Sym))
 241         Map[Sym].insert(File);
 242       if (auto *D = dyn_cast<Defined>(Sym))
 243         if (!D->isLocal() && (!D->Section || D->Section->Live))
 244           Map[D].insert(File);
 245     }
 246   }
 247
 248   // Print out a header.
 249   outs() << "Cross Reference Table\n\n";
 250   print("Symbol", "File");
 251
 252   // Print out a table.
 253   for (auto KV : Map) {
 254     Symbol *Sym = KV.first;
 255     SetVector<InputFile *> &Files = KV.second;
 256
 257     print(toString(*Sym), toString(Sym->File));
 258     for (InputFile *File : Files)
 259       if (File != Sym->File)
 260         print("", toString(File));
 261   }
 262 }