1 //===- MapFile.cpp --------------------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This file implements the -Map option. It shows lists in order and
10 // hierarchically the output sections, input sections, input files and
11 // symbol:
12 //
13 // Address Size Align Out In Symbol
14 // 00201000 00000015 4 .text
15 // 00201000 0000000e 4 test.o:(.text)
16 // 0020100e 00000000 0 local
17 // 00201005 00000000 0 f(int)
18 //
19 //===----------------------------------------------------------------------===//
20
21 #include "MapFile.h"
22 #include "InputFiles.h"
23 #include "LinkerScript.h"
24 #include "OutputSections.h"
25 #include "SymbolTable.h"
26 #include "Symbols.h"
27 #include "SyntheticSections.h"
28 #include "lld/Common/Strings.h"
29 #include "llvm/ADT/MapVector.h"
30 #include "llvm/ADT/SetVector.h"
31 #include "llvm/Support/Parallel.h"
32 #include "llvm/Support/TimeProfiler.h"
33 #include "llvm/Support/raw_ostream.h"
34
35 using namespace llvm;
36 using namespace llvm::object;
37 using namespace lld;
38 using namespace lld::elf;
39
40 using SymbolMapTy = DenseMap<const SectionBase *, SmallVector<Defined *, 4>>;
41
42 static constexpr char indent8[] = " "; // 8 spaces
43 static constexpr char indent16[] = " "; // 16 spaces
44
45 // 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)46 static void writeHeader(raw_ostream &os, uint64_t vma, uint64_t lma,
47 uint64_t size, uint64_t align) {
48 if (config->is64)
49 os << format("%16llx %16llx %8llx %5lld ", vma, lma, size, align);
50 else
51 os << format("%8llx %8llx %8llx %5lld ", vma, lma, size, align);
52 }
53
54 // Returns a list of all symbols that we want to print out.
getSymbols()55 static std::vector<Defined *> getSymbols() {
56 std::vector<Defined *> v;
57 for (InputFile *file : objectFiles)
58 for (Symbol *b : file->getSymbols())
59 if (auto *dr = dyn_cast<Defined>(b))
60 if (!dr->isSection() && dr->section && dr->section->isLive() &&
61 (dr->file == file || dr->needsPltAddr || dr->section->bss))
62 v.push_back(dr);
63 return v;
64 }
65
66 // Returns a map from sections to their symbols.
getSectionSyms(ArrayRef<Defined * > syms)67 static SymbolMapTy getSectionSyms(ArrayRef<Defined *> syms) {
68 SymbolMapTy ret;
69 for (Defined *dr : syms)
70 ret[dr->section].push_back(dr);
71
72 // Sort symbols by address. We want to print out symbols in the
73 // order in the output file rather than the order they appeared
74 // in the input files.
75 for (auto &it : ret)
76 llvm::stable_sort(it.second, [](Defined *a, Defined *b) {
77 return a->getVA() < b->getVA();
78 });
79 return ret;
80 }
81
82 // Construct a map from symbols to their stringified representations.
83 // Demangling symbols (which is what toString() does) is slow, so
84 // we do that in batch using parallel-for.
85 static DenseMap<Symbol *, std::string>
getSymbolStrings(ArrayRef<Defined * > syms)86 getSymbolStrings(ArrayRef<Defined *> syms) {
87 std::vector<std::string> str(syms.size());
88 parallelForEachN(0, syms.size(), [&](size_t i) {
89 raw_string_ostream os(str[i]);
90 OutputSection *osec = syms[i]->getOutputSection();
91 uint64_t vma = syms[i]->getVA();
92 uint64_t lma = osec ? osec->getLMA() + vma - osec->getVA(0) : 0;
93 writeHeader(os, vma, lma, syms[i]->getSize(), 1);
94 os << indent16 << toString(*syms[i]);
95 });
96
97 DenseMap<Symbol *, std::string> ret;
98 for (size_t i = 0, e = syms.size(); i < e; ++i)
99 ret[syms[i]] = std::move(str[i]);
100 return ret;
101 }
102
103 // Print .eh_frame contents. Since the section consists of EhSectionPieces,
104 // we need a specialized printer for that section.
105 //
106 // .eh_frame tend to contain a lot of section pieces that are contiguous
107 // both in input file and output file. Such pieces are squashed before
108 // being displayed to make output compact.
printEhFrame(raw_ostream & os,const EhFrameSection * sec)109 static void printEhFrame(raw_ostream &os, const EhFrameSection *sec) {
110 std::vector<EhSectionPiece> pieces;
111
112 auto add = [&](const EhSectionPiece &p) {
113 // If P is adjacent to Last, squash the two.
114 if (!pieces.empty()) {
115 EhSectionPiece &last = pieces.back();
116 if (last.sec == p.sec && last.inputOff + last.size == p.inputOff &&
117 last.outputOff + last.size == p.outputOff) {
118 last.size += p.size;
119 return;
120 }
121 }
122 pieces.push_back(p);
123 };
124
125 // Gather section pieces.
126 for (const CieRecord *rec : sec->getCieRecords()) {
127 add(*rec->cie);
128 for (const EhSectionPiece *fde : rec->fdes)
129 add(*fde);
130 }
131
132 // Print out section pieces.
133 const OutputSection *osec = sec->getOutputSection();
134 for (EhSectionPiece &p : pieces) {
135 writeHeader(os, osec->addr + p.outputOff, osec->getLMA() + p.outputOff,
136 p.size, 1);
137 os << indent8 << toString(p.sec->file) << ":(" << p.sec->name << "+0x"
138 << Twine::utohexstr(p.inputOff) + ")\n";
139 }
140 }
141
writeMapFile()142 void elf::writeMapFile() {
143 if (config->mapFile.empty())
144 return;
145
146 llvm::TimeTraceScope timeScope("Write map file");
147
148 // Open a map file for writing.
149 std::error_code ec;
150 raw_fd_ostream os(config->mapFile, ec, sys::fs::OF_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 *isec : isd->sections) {
185 if (auto *ehSec = dyn_cast<EhFrameSection>(isec)) {
186 printEhFrame(os, ehSec);
187 continue;
188 }
189
190 writeHeader(os, isec->getVA(0), osec->getLMA() + isec->getOffset(0),
191 isec->getSize(), isec->alignment);
192 os << indent8 << toString(isec) << '\n';
193 for (Symbol *sym : sectionSyms[isec])
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 lld::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->isLive()))
245 map[d].insert(file);
246 }
247 }
248
249 // Print out a header.
250 lld::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
writeArchiveStats()265 void elf::writeArchiveStats() {
266 if (config->printArchiveStats.empty())
267 return;
268
269 std::error_code ec;
270 raw_fd_ostream os(config->printArchiveStats, ec, sys::fs::OF_None);
271 if (ec) {
272 error("--print-archive-stats=: cannot open " + config->printArchiveStats +
273 ": " + ec.message());
274 return;
275 }
276
277 os << "members\tfetched\tarchive\n";
278 for (const ArchiveFile *f : archiveFiles)
279 os << f->getMemberCount() << '\t' << f->getFetchedMemberCount() << '\t'
280 << f->getName() << '\n';
281 }
282