Mercurial > hg > CbC > CbC_llvm

comparison lld/MachO/MapFile.cpp @ 207:2e18cbf3894f

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
LLVM12
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Tue, 08 Jun 2021 06:07:14 +0900
parents
children 5f17cb93ff66
comparison
equal deleted inserted replaced
173:0572611fdcc8 207:2e18cbf3894f
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 outputFile, arch, input files, output sections and
11 // symbol:
12 //
13 // # Path: test
14 // # Arch: x86_84
15 // # Object files:
16 // [ 0] linker synthesized
17 // [ 1] a.o
18 // # Sections:
19 // # Address Size Segment Section
20 // 0x1000005C0 0x0000004C __TEXT __text
21 // # Symbols:
22 // # Address File Name
23 // 0x1000005C0 [ 1] _main
24 //
25 //===----------------------------------------------------------------------===//
26
27 #include "MapFile.h"
28 #include "Config.h"
29 #include "InputFiles.h"
30 #include "InputSection.h"
31 #include "OutputSection.h"
32 #include "OutputSegment.h"
33 #include "Symbols.h"
34 #include "Target.h"
35 #include "llvm/Support/Parallel.h"
36 #include "llvm/Support/TimeProfiler.h"
37
38 using namespace llvm;
39 using namespace llvm::sys;
40 using namespace lld;
41 using namespace lld::macho;
42
43 using SymbolMapTy = DenseMap<const InputSection *, SmallVector<Defined *, 4>>;
44
45 // Returns a map from sections to their symbols.
46 static SymbolMapTy getSectionSyms(ArrayRef<Defined *> syms) {
47 SymbolMapTy ret;
48 for (Defined *dr : syms)
49 ret[dr->isec].push_back(dr);
50
51 // Sort symbols by address. We want to print out symbols in the
52 // order in the output file rather than the order they appeared
53 // in the input files.
54 for (auto &it : ret)
55 llvm::stable_sort(it.second, [](Defined *a, Defined *b) {
56 return a->getVA() < b->getVA();
57 });
58 return ret;
59 }
60
61 // Returns a list of all symbols that we want to print out.
62 static std::vector<Defined *> getSymbols() {
63 std::vector<Defined *> v;
64 for (InputFile *file : inputFiles)
65 if (isa<ObjFile>(file))
66 for (Symbol *sym : file->symbols) {
67 if (auto *d = dyn_cast_or_null<Defined>(sym))
68 if (d->isLive() && d->isec && d->getFile() == file) {
69 assert(!d->isec->isCoalescedWeak() &&
70 "file->symbols should store resolved symbols");
71 v.push_back(d);
72 }
73 }
74 return v;
75 }
76
77 // Construct a map from symbols to their stringified representations.
78 // Demangling symbols (which is what toString() does) is slow, so
79 // we do that in batch using parallel-for.
80 static DenseMap<Symbol *, std::string>
81 getSymbolStrings(ArrayRef<Defined *> syms) {
82 std::vector<std::string> str(syms.size());
83 parallelForEachN(0, syms.size(), [&](size_t i) {
84 raw_string_ostream os(str[i]);
85 os << toString(*syms[i]);
86 });
87
88 DenseMap<Symbol *, std::string> ret;
89 for (size_t i = 0, e = syms.size(); i < e; ++i)
90 ret[syms[i]] = std::move(str[i]);
91 return ret;
92 }
93
94 void macho::writeMapFile() {
95 if (config->mapFile.empty())
96 return;
97
98 TimeTraceScope timeScope("Write map file");
99
100 // Open a map file for writing.
101 std::error_code ec;
102 raw_fd_ostream os(config->mapFile, ec, sys::fs::OF_None);
103 if (ec) {
104 error("cannot open " + config->mapFile + ": " + ec.message());
105 return;
106 }
107
108 // Dump output path.
109 os << format("# Path: %s\n", config->outputFile.str().c_str());
110
111 // Dump output architecture.
112 os << format("# Arch: %s\n",
113 getArchitectureName(config->arch()).str().c_str());
114
115 // Dump table of object files.
116 os << "# Object files:\n";
117 os << format("[%3u] %s\n", 0, (const char *)"linker synthesized");
118 uint32_t fileIndex = 1;
119 DenseMap<lld::macho::InputFile *, uint32_t> readerToFileOrdinal;
120 for (InputFile *file : inputFiles) {
121 if (isa<ObjFile>(file)) {
122 os << format("[%3u] %s\n", fileIndex, file->getName().str().c_str());
123 readerToFileOrdinal[file] = fileIndex++;
124 }
125 }
126
127 // Collect symbol info that we want to print out.
128 std::vector<Defined *> syms = getSymbols();
129 SymbolMapTy sectionSyms = getSectionSyms(syms);
130 DenseMap<Symbol *, std::string> symStr = getSymbolStrings(syms);
131
132 // Dump table of sections
133 os << "# Sections:\n";
134 os << "# Address\tSize \tSegment\tSection\n";
135 for (OutputSegment *seg : outputSegments)
136 for (OutputSection *osec : seg->getSections()) {
137 if (osec->isHidden())
138 continue;
139
140 os << format("0x%08llX\t0x%08llX\t%s\t%s\n", osec->addr, osec->getSize(),
141 seg->name.str().c_str(), osec->name.str().c_str());
142 }
143
144 // Dump table of symbols
145 os << "# Symbols:\n";
146 os << "# Address\t File Name\n";
147 for (InputSection *isec : inputSections) {
148 auto symsIt = sectionSyms.find(isec);
149 assert(!isec->shouldOmitFromOutput() || (symsIt == sectionSyms.end()));
150 if (symsIt == sectionSyms.end())
151 continue;
152 for (Symbol *sym : symsIt->second) {
153 os << format("0x%08llX\t[%3u] %s\n", sym->getVA(),
154 readerToFileOrdinal[sym->getFile()], symStr[sym].c_str());
155 }
156 }
157
158 // TODO: when we implement -dead_strip, we should dump dead stripped symbols
159 }