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.
writeHeader(raw_ostream & OS,uint64_t VMA,uint64_t LMA,uint64_t Size,uint64_t Align)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.
getSymbols()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.
getSectionSyms(ArrayRef<Defined * > Syms)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>
getSymbolStrings(ArrayRef<Defined * > Syms)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.
printEhFrame(raw_ostream & OS,OutputSection * OSec)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 : In.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
writeMapFile()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 OutputSection* OSec = nullptr;
167 for (BaseCommand *Base : Script->SectionCommands) {
168 if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
169 if (Cmd->Provide && !Cmd->Sym)
170 continue;
171 uint64_t LMA = OSec ? OSec->getLMA() + Cmd->Addr - OSec->getVA(0) : 0;
172 writeHeader(OS, Cmd->Addr, LMA, Cmd->Size, 1);
173 OS << Cmd->CommandString << '\n';
174 continue;
175 }
176
177 OSec = cast<OutputSection>(Base);
178 writeHeader(OS, OSec->Addr, OSec->getLMA(), OSec->Size, OSec->Alignment);
179 OS << OSec->Name << '\n';
180
181 // Dump symbols for each input section.
182 for (BaseCommand *Base : OSec->SectionCommands) {
183 if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) {
184 for (InputSection *IS : ISD->Sections) {
185 if (IS == In.EhFrame) {
186 printEhFrame(OS, OSec);
187 continue;
188 }
189
190 writeHeader(OS, IS->getVA(0), OSec->getLMA() + IS->getOffset(0),
191 IS->getSize(), IS->Alignment);
192 OS << Indent8 << toString(IS) << '\n';
193 for (Symbol *Sym : SectionSyms[IS])
194 OS << SymStr[Sym] << '\n';
195 }
196 continue;
197 }
198
199 if (auto *Cmd = dyn_cast<ByteCommand>(Base)) {
200 writeHeader(OS, OSec->Addr + Cmd->Offset, OSec->getLMA() + Cmd->Offset,
201 Cmd->Size, 1);
202 OS << Indent8 << Cmd->CommandString << '\n';
203 continue;
204 }
205
206 if (auto *Cmd = dyn_cast<SymbolAssignment>(Base)) {
207 if (Cmd->Provide && !Cmd->Sym)
208 continue;
209 writeHeader(OS, Cmd->Addr, OSec->getLMA() + Cmd->Addr - OSec->getVA(0),
210 Cmd->Size, 1);
211 OS << Indent8 << Cmd->CommandString << '\n';
212 continue;
213 }
214 }
215 }
216 }
217
print(StringRef A,StringRef B)218 static void print(StringRef A, StringRef B) {
219 outs() << left_justify(A, 49) << " " << B << "\n";
220 }
221
222 // Output a cross reference table to stdout. This is for --cref.
223 //
224 // For each global symbol, we print out a file that defines the symbol
225 // followed by files that uses that symbol. Here is an example.
226 //
227 // strlen /lib/x86_64-linux-gnu/libc.so.6
228 // tools/lld/tools/lld/CMakeFiles/lld.dir/lld.cpp.o
229 // lib/libLLVMSupport.a(PrettyStackTrace.cpp.o)
230 //
231 // In this case, strlen is defined by libc.so.6 and used by other two
232 // files.
writeCrossReferenceTable()233 void elf::writeCrossReferenceTable() {
234 if (!Config->Cref)
235 return;
236
237 // Collect symbols and files.
238 MapVector<Symbol *, SetVector<InputFile *>> Map;
239 for (InputFile *File : ObjectFiles) {
240 for (Symbol *Sym : File->getSymbols()) {
241 if (isa<SharedSymbol>(Sym))
242 Map[Sym].insert(File);
243 if (auto *D = dyn_cast<Defined>(Sym))
244 if (!D->isLocal() && (!D->Section || D->Section->Live))
245 Map[D].insert(File);
246 }
247 }
248
249 // Print out a header.
250 outs() << "Cross Reference Table\n\n";
251 print("Symbol", "File");
252
253 // Print out a table.
254 for (auto KV : Map) {
255 Symbol *Sym = KV.first;
256 SetVector<InputFile *> &Files = KV.second;
257
258 print(toString(*Sym), toString(Sym->File));
259 for (InputFile *File : Files)
260 if (File != Sym->File)
261 print("", toString(File));
262 }
263 }
264