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 order they 52 // appear in the output file rather than the order they appeared in the input 53 // 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(!shouldOmitFromOutput(d->isec)); 70 v.push_back(d); 71 } 72 return v; 73 } 74 75 // Construct a map from symbols to their stringified representations. 76 // Demangling symbols (which is what toString() does) is slow, so 77 // we do that in batch using parallel-for. 78 static DenseMap<Symbol *, std::string> 79 getSymbolStrings(ArrayRef<Defined *> syms) { 80 std::vector<std::string> str(syms.size()); 81 parallelForEachN(0, syms.size(), [&](size_t i) { 82 raw_string_ostream os(str[i]); 83 os << toString(*syms[i]); 84 }); 85 86 DenseMap<Symbol *, std::string> ret; 87 for (size_t i = 0, e = syms.size(); i < e; ++i) 88 ret[syms[i]] = std::move(str[i]); 89 return ret; 90 } 91 92 void macho::writeMapFile() { 93 if (config->mapFile.empty()) 94 return; 95 96 TimeTraceScope timeScope("Write map file"); 97 98 // Open a map file for writing. 99 std::error_code ec; 100 raw_fd_ostream os(config->mapFile, ec, sys::fs::OF_None); 101 if (ec) { 102 error("cannot open " + config->mapFile + ": " + ec.message()); 103 return; 104 } 105 106 // Dump output path. 107 os << format("# Path: %s\n", config->outputFile.str().c_str()); 108 109 // Dump output architecture. 110 os << format("# Arch: %s\n", 111 getArchitectureName(config->arch()).str().c_str()); 112 113 // Dump table of object files. 114 os << "# Object files:\n"; 115 os << format("[%3u] %s\n", 0, (const char *)"linker synthesized"); 116 uint32_t fileIndex = 1; 117 DenseMap<lld::macho::InputFile *, uint32_t> readerToFileOrdinal; 118 for (InputFile *file : inputFiles) { 119 if (isa<ObjFile>(file)) { 120 os << format("[%3u] %s\n", fileIndex, file->getName().str().c_str()); 121 readerToFileOrdinal[file] = fileIndex++; 122 } 123 } 124 125 // Collect symbol info that we want to print out. 126 std::vector<Defined *> syms = getSymbols(); 127 SymbolMapTy sectionSyms = getSectionSyms(syms); 128 DenseMap<Symbol *, std::string> symStr = getSymbolStrings(syms); 129 130 // Dump table of sections 131 os << "# Sections:\n"; 132 os << "# Address\tSize \tSegment\tSection\n"; 133 for (OutputSegment *seg : outputSegments) 134 for (OutputSection *osec : seg->getSections()) { 135 if (osec->isHidden()) 136 continue; 137 138 os << format("0x%08llX\t0x%08llX\t%s\t%s\n", osec->addr, osec->getSize(), 139 seg->name.str().c_str(), osec->name.str().c_str()); 140 } 141 142 // Dump table of symbols 143 os << "# Symbols:\n"; 144 os << "# Address\t File Name\n"; 145 for (InputSection *isec : inputSections) { 146 auto symsIt = sectionSyms.find(isec); 147 assert(!shouldOmitFromOutput(isec) || (symsIt == sectionSyms.end())); 148 if (symsIt == sectionSyms.end()) 149 continue; 150 for (Symbol *sym : symsIt->second) { 151 os << format("0x%08llX\t[%3u] %s\n", sym->getVA(), 152 readerToFileOrdinal[sym->getFile()], symStr[sym].c_str()); 153 } 154 } 155 156 // TODO: when we implement -dead_strip, we should dump dead stripped symbols 157 } 158