blob: d6386ade2634cd3f8960f57a96dd9dc26de18557 [file] [log] [blame]
Brian Gaeke0af759d2003-10-16 04:43:15 +00001//===-- llvm-nm.cpp - Symbol table dumping utility for llvm ---------------===//
Misha Brukman650ba8e2005-04-22 00:00:37 +00002//
John Criswell09344dc2003-10-20 17:47:21 +00003// The LLVM Compiler Infrastructure
4//
Chris Lattner345353d2007-12-29 20:44:31 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Misha Brukman650ba8e2005-04-22 00:00:37 +00007//
John Criswell09344dc2003-10-20 17:47:21 +00008//===----------------------------------------------------------------------===//
Brian Gaeke0af759d2003-10-16 04:43:15 +00009//
Michael J. Spencer838e5ad2012-06-06 23:34:10 +000010// This program is a utility that works like traditional Unix "nm", that is, it
11// prints out the names of symbols in a bitcode or object file, along with some
12// information about each symbol.
Misha Brukman650ba8e2005-04-22 00:00:37 +000013//
Michael J. Spencer838e5ad2012-06-06 23:34:10 +000014// This "nm" supports many of the features of GNU "nm", including its different
15// output formats.
Brian Gaeke0af759d2003-10-16 04:43:15 +000016//
17//===----------------------------------------------------------------------===//
18
Rafael Espindolaf12b8282014-02-21 20:10:59 +000019#include "llvm/IR/Function.h"
20#include "llvm/IR/GlobalAlias.h"
21#include "llvm/IR/GlobalVariable.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000022#include "llvm/IR/LLVMContext.h"
Michael J. Spencer2bc774a2011-09-27 19:37:18 +000023#include "llvm/Object/Archive.h"
Rafael Espindola586af97a2013-11-02 21:16:09 +000024#include "llvm/Object/COFF.h"
25#include "llvm/Object/ELFObjectFile.h"
Chandler Carruth442f7842014-03-04 10:07:28 +000026#include "llvm/Object/IRObjectFile.h"
Rafael Espindola586af97a2013-11-02 21:16:09 +000027#include "llvm/Object/MachO.h"
Alexey Samsonove6388e62013-06-18 15:03:28 +000028#include "llvm/Object/MachOUniversal.h"
Michael J. Spencerb8672a52011-01-20 06:38:57 +000029#include "llvm/Object/ObjectFile.h"
Rui Ueyamaf078eff2014-03-18 23:37:53 +000030#include "llvm/Support/COFF.h"
Reid Spencer7c16caa2004-09-01 22:55:40 +000031#include "llvm/Support/CommandLine.h"
Michael J. Spencerb8672a52011-01-20 06:38:57 +000032#include "llvm/Support/FileSystem.h"
Chandler Carruth4d88a1c2012-12-04 10:44:52 +000033#include "llvm/Support/Format.h"
Chris Lattner76d46322006-12-06 01:18:01 +000034#include "llvm/Support/ManagedStatic.h"
Chris Lattneref8f3892007-05-06 05:36:18 +000035#include "llvm/Support/MemoryBuffer.h"
Chris Lattnere3fc2d12009-03-06 05:34:10 +000036#include "llvm/Support/PrettyStackTrace.h"
Michael J. Spencerbc96f372011-12-13 23:17:29 +000037#include "llvm/Support/Program.h"
Michael J. Spencer447762d2010-11-29 18:16:10 +000038#include "llvm/Support/Signals.h"
Rafael Espindola13b69d62014-07-03 18:59:23 +000039#include "llvm/Support/TargetSelect.h"
Chandler Carruthd9903882015-01-14 11:23:27 +000040#include "llvm/Support/raw_ostream.h"
Jeff Cohenb622c112007-03-05 00:00:42 +000041#include <algorithm>
Brian Gaeke0af759d2003-10-16 04:43:15 +000042#include <cctype>
Alkis Evlogimenosf68f40e2004-04-21 16:11:40 +000043#include <cerrno>
Brian Gaeke55447b42003-11-19 21:52:09 +000044#include <cstring>
Rafael Espindolaa6e9c3e2014-06-12 17:38:55 +000045#include <system_error>
Michael J. Spencerb8672a52011-01-20 06:38:57 +000046#include <vector>
Brian Gaeke960707c2003-11-11 22:41:34 +000047using namespace llvm;
Michael J. Spencerb8672a52011-01-20 06:38:57 +000048using namespace object;
Brian Gaeke960707c2003-11-11 22:41:34 +000049
Brian Gaeke0af759d2003-10-16 04:43:15 +000050namespace {
Kevin Enderby980b2582014-06-05 21:21:57 +000051enum OutputFormatTy { bsd, sysv, posix, darwin };
Rafael Espindola619581c2014-01-29 04:56:19 +000052cl::opt<OutputFormatTy> OutputFormat(
53 "format", cl::desc("Specify output format"),
54 cl::values(clEnumVal(bsd, "BSD format"), clEnumVal(sysv, "System V format"),
Kevin Enderby980b2582014-06-05 21:21:57 +000055 clEnumVal(posix, "POSIX.2 format"),
56 clEnumVal(darwin, "Darwin -m format"), clEnumValEnd),
Rafael Espindola619581c2014-01-29 04:56:19 +000057 cl::init(bsd));
58cl::alias OutputFormat2("f", cl::desc("Alias for --format"),
59 cl::aliasopt(OutputFormat));
Brian Gaeke0af759d2003-10-16 04:43:15 +000060
Rafael Espindolaf12b8282014-02-21 20:10:59 +000061cl::list<std::string> InputFilenames(cl::Positional, cl::desc("<input files>"),
Rafael Espindola619581c2014-01-29 04:56:19 +000062 cl::ZeroOrMore);
Brian Gaeke0af759d2003-10-16 04:43:15 +000063
Rafael Espindola619581c2014-01-29 04:56:19 +000064cl::opt<bool> UndefinedOnly("undefined-only",
65 cl::desc("Show only undefined symbols"));
66cl::alias UndefinedOnly2("u", cl::desc("Alias for --undefined-only"),
67 cl::aliasopt(UndefinedOnly));
Brian Gaeke0af759d2003-10-16 04:43:15 +000068
Rafael Espindola619581c2014-01-29 04:56:19 +000069cl::opt<bool> DynamicSyms("dynamic",
70 cl::desc("Display the dynamic symbols instead "
71 "of normal symbols."));
72cl::alias DynamicSyms2("D", cl::desc("Alias for --dynamic"),
73 cl::aliasopt(DynamicSyms));
Michael J. Spencer8c4729f2012-02-28 00:40:37 +000074
Rafael Espindola619581c2014-01-29 04:56:19 +000075cl::opt<bool> DefinedOnly("defined-only",
76 cl::desc("Show only defined symbols"));
Kevin Enderbyacaaf902014-07-03 18:18:50 +000077cl::alias DefinedOnly2("U", cl::desc("Alias for --defined-only"),
78 cl::aliasopt(DefinedOnly));
Brian Gaeke0af759d2003-10-16 04:43:15 +000079
Rafael Espindola619581c2014-01-29 04:56:19 +000080cl::opt<bool> ExternalOnly("extern-only",
81 cl::desc("Show only external symbols"));
82cl::alias ExternalOnly2("g", cl::desc("Alias for --extern-only"),
83 cl::aliasopt(ExternalOnly));
Brian Gaeke0af759d2003-10-16 04:43:15 +000084
Rafael Espindola619581c2014-01-29 04:56:19 +000085cl::opt<bool> BSDFormat("B", cl::desc("Alias for --format=bsd"));
86cl::opt<bool> POSIXFormat("P", cl::desc("Alias for --format=posix"));
Kevin Enderby14a96ac2014-06-20 00:04:16 +000087cl::opt<bool> DarwinFormat("m", cl::desc("Alias for --format=darwin"));
Brian Gaeke0af759d2003-10-16 04:43:15 +000088
Kevin Enderby8f6dcf52014-07-01 22:44:51 +000089static cl::list<std::string>
Kevin Enderbybe84b292014-07-17 22:56:27 +000090 ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"),
91 cl::ZeroOrMore);
Kevin Enderby4c8dfe42014-06-30 18:45:23 +000092bool ArchAll = false;
93
Rafael Espindola619581c2014-01-29 04:56:19 +000094cl::opt<bool> PrintFileName(
95 "print-file-name",
Michael J. Spencerb8672a52011-01-20 06:38:57 +000096 cl::desc("Precede each symbol with the object file it came from"));
97
Rafael Espindola619581c2014-01-29 04:56:19 +000098cl::alias PrintFileNameA("A", cl::desc("Alias for --print-file-name"),
99 cl::aliasopt(PrintFileName));
100cl::alias PrintFileNameo("o", cl::desc("Alias for --print-file-name"),
101 cl::aliasopt(PrintFileName));
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000102
Rafael Espindola619581c2014-01-29 04:56:19 +0000103cl::opt<bool> DebugSyms("debug-syms",
104 cl::desc("Show all symbols, even debugger only"));
105cl::alias DebugSymsa("a", cl::desc("Alias for --debug-syms"),
106 cl::aliasopt(DebugSyms));
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000107
Rafael Espindolab4865d62014-04-03 00:19:35 +0000108cl::opt<bool> NumericSort("numeric-sort", cl::desc("Sort symbols by address"));
Rafael Espindola619581c2014-01-29 04:56:19 +0000109cl::alias NumericSortn("n", cl::desc("Alias for --numeric-sort"),
110 cl::aliasopt(NumericSort));
111cl::alias NumericSortv("v", cl::desc("Alias for --numeric-sort"),
112 cl::aliasopt(NumericSort));
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000113
Rafael Espindola619581c2014-01-29 04:56:19 +0000114cl::opt<bool> NoSort("no-sort", cl::desc("Show symbols in order encountered"));
115cl::alias NoSortp("p", cl::desc("Alias for --no-sort"), cl::aliasopt(NoSort));
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000116
Kevin Enderby25a614b2014-07-02 23:23:58 +0000117cl::opt<bool> ReverseSort("reverse-sort", cl::desc("Sort in reverse order"));
118cl::alias ReverseSortr("r", cl::desc("Alias for --reverse-sort"),
119 cl::aliasopt(ReverseSort));
120
Rafael Espindola619581c2014-01-29 04:56:19 +0000121cl::opt<bool> PrintSize("print-size",
Rafael Espindolab4865d62014-04-03 00:19:35 +0000122 cl::desc("Show symbol size instead of address"));
Rafael Espindola619581c2014-01-29 04:56:19 +0000123cl::alias PrintSizeS("S", cl::desc("Alias for --print-size"),
124 cl::aliasopt(PrintSize));
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000125
Rafael Espindola619581c2014-01-29 04:56:19 +0000126cl::opt<bool> SizeSort("size-sort", cl::desc("Sort symbols by size"));
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000127
Rafael Espindola619581c2014-01-29 04:56:19 +0000128cl::opt<bool> WithoutAliases("without-aliases", cl::Hidden,
129 cl::desc("Exclude aliases from output"));
Jan Sjödin4d0c2992012-09-18 18:47:58 +0000130
Rafael Espindola619581c2014-01-29 04:56:19 +0000131cl::opt<bool> ArchiveMap("print-armap", cl::desc("Print the archive map"));
Kevin Enderby8da4bd62014-07-08 23:47:31 +0000132cl::alias ArchiveMaps("M", cl::desc("Alias for --print-armap"),
Rafael Espindola619581c2014-01-29 04:56:19 +0000133 cl::aliasopt(ArchiveMap));
Kevin Enderby0fd8aac2014-07-03 21:51:07 +0000134
135cl::opt<bool> JustSymbolName("just-symbol-name",
136 cl::desc("Print just the symbol's name"));
137cl::alias JustSymbolNames("j", cl::desc("Alias for --just-symbol-name"),
138 cl::aliasopt(JustSymbolName));
Kevin Enderbyfe6ad972014-07-11 20:30:00 +0000139
140// FIXME: This option takes exactly two strings and should be allowed anywhere
141// on the command line. Such that "llvm-nm -s __TEXT __text foo.o" would work.
142// But that does not as the CommandLine Library does not have a way to make
143// this work. For now the "-s __TEXT __text" has to be last on the command
144// line.
145cl::list<std::string> SegSect("s", cl::Positional, cl::ZeroOrMore,
146 cl::desc("Dump only symbols from this segment "
147 "and section name, Mach-O only"));
148
Kevin Enderby77b968e2014-07-16 17:38:26 +0000149cl::opt<bool> FormatMachOasHex("x", cl::desc("Print symbol entry in hex, "
150 "Mach-O only"));
151
Peter Collingbourne10039c02014-09-18 21:28:49 +0000152cl::opt<bool> NoLLVMBitcode("no-llvm-bc",
153 cl::desc("Disable LLVM bitcode reader"));
154
Rafael Espindolab4865d62014-04-03 00:19:35 +0000155bool PrintAddress = true;
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000156
Rafael Espindola619581c2014-01-29 04:56:19 +0000157bool MultipleFiles = false;
Brian Gaeke0af759d2003-10-16 04:43:15 +0000158
Rafael Espindola619581c2014-01-29 04:56:19 +0000159bool HadError = false;
Rafael Espindola8b82a4d2013-07-03 15:46:03 +0000160
Rafael Espindola619581c2014-01-29 04:56:19 +0000161std::string ToolName;
Chris Lattneraa2372562006-05-24 17:04:05 +0000162}
Brian Gaeke0af759d2003-10-16 04:43:15 +0000163
Rafael Espindola619581c2014-01-29 04:56:19 +0000164static void error(Twine Message, Twine Path = Twine()) {
165 HadError = true;
166 errs() << ToolName << ": " << Path << ": " << Message << ".\n";
Michael J. Spencerbc96f372011-12-13 23:17:29 +0000167}
168
Rafael Espindola4453e42942014-06-13 03:07:50 +0000169static bool error(std::error_code EC, Twine Path = Twine()) {
Rafael Espindola619581c2014-01-29 04:56:19 +0000170 if (EC) {
171 error(EC.message(), Path);
Michael J. Spencerbc96f372011-12-13 23:17:29 +0000172 return true;
173 }
174 return false;
175}
176
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000177namespace {
Rafael Espindola619581c2014-01-29 04:56:19 +0000178struct NMSymbol {
Rafael Espindolab4865d62014-04-03 00:19:35 +0000179 uint64_t Address;
Rafael Espindola619581c2014-01-29 04:56:19 +0000180 uint64_t Size;
181 char TypeChar;
182 StringRef Name;
Kevin Enderby980b2582014-06-05 21:21:57 +0000183 DataRefImpl Symb;
Rafael Espindola619581c2014-01-29 04:56:19 +0000184};
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000185}
186
Rafael Espindolab4865d62014-04-03 00:19:35 +0000187static bool compareSymbolAddress(const NMSymbol &A, const NMSymbol &B) {
Kevin Enderby25a614b2014-07-02 23:23:58 +0000188 if (!ReverseSort) {
189 if (A.Address < B.Address)
190 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000191 if (A.Address == B.Address && A.Name < B.Name)
Kevin Enderby25a614b2014-07-02 23:23:58 +0000192 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000193 if (A.Address == B.Address && A.Name == B.Name && A.Size < B.Size)
Kevin Enderby25a614b2014-07-02 23:23:58 +0000194 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000195 return false;
Kevin Enderby25a614b2014-07-02 23:23:58 +0000196 }
David Blaikie328c0c12015-03-23 21:17:43 +0000197
198 if (A.Address > B.Address)
199 return true;
200 if (A.Address == B.Address && A.Name > B.Name)
201 return true;
202 if (A.Address == B.Address && A.Name == B.Name && A.Size > B.Size)
203 return true;
204 return false;
Rafael Espindola619581c2014-01-29 04:56:19 +0000205}
206
207static bool compareSymbolSize(const NMSymbol &A, const NMSymbol &B) {
Kevin Enderby25a614b2014-07-02 23:23:58 +0000208 if (!ReverseSort) {
209 if (A.Size < B.Size)
210 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000211 if (A.Size == B.Size && A.Name < B.Name)
Kevin Enderby25a614b2014-07-02 23:23:58 +0000212 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000213 if (A.Size == B.Size && A.Name == B.Name && A.Address < B.Address)
Kevin Enderby25a614b2014-07-02 23:23:58 +0000214 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000215 return false;
Kevin Enderby25a614b2014-07-02 23:23:58 +0000216 }
David Blaikie328c0c12015-03-23 21:17:43 +0000217
218 if (A.Size > B.Size)
219 return true;
220 if (A.Size == B.Size && A.Name > B.Name)
221 return true;
222 if (A.Size == B.Size && A.Name == B.Name && A.Address > B.Address)
223 return true;
224 return false;
Rafael Espindola619581c2014-01-29 04:56:19 +0000225}
226
227static bool compareSymbolName(const NMSymbol &A, const NMSymbol &B) {
Kevin Enderby25a614b2014-07-02 23:23:58 +0000228 if (!ReverseSort) {
229 if (A.Name < B.Name)
230 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000231 if (A.Name == B.Name && A.Size < B.Size)
Kevin Enderby25a614b2014-07-02 23:23:58 +0000232 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000233 if (A.Name == B.Name && A.Size == B.Size && A.Address < B.Address)
Kevin Enderby25a614b2014-07-02 23:23:58 +0000234 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000235 return false;
Kevin Enderby25a614b2014-07-02 23:23:58 +0000236 }
David Blaikie328c0c12015-03-23 21:17:43 +0000237 if (A.Name > B.Name)
238 return true;
239 if (A.Name == B.Name && A.Size > B.Size)
240 return true;
241 if (A.Name == B.Name && A.Size == B.Size && A.Address > B.Address)
242 return true;
243 return false;
Rafael Espindola619581c2014-01-29 04:56:19 +0000244}
245
Rafael Espindolaceb23382014-07-31 21:00:10 +0000246static char isSymbolList64Bit(SymbolicFile &Obj) {
Kevin Enderby15e24712014-05-12 20:45:00 +0000247 if (isa<IRObjectFile>(Obj))
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000248 return false;
David Blaikie328c0c12015-03-23 21:17:43 +0000249 if (isa<COFFObjectFile>(Obj))
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000250 return false;
David Blaikie328c0c12015-03-23 21:17:43 +0000251 if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000252 return MachO->is64Bit();
David Blaikie328c0c12015-03-23 21:17:43 +0000253 if (isa<ELF32LEObjectFile>(Obj))
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000254 return false;
David Blaikie328c0c12015-03-23 21:17:43 +0000255 if (isa<ELF64LEObjectFile>(Obj))
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000256 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000257 if (isa<ELF32BEObjectFile>(Obj))
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000258 return false;
David Blaikie328c0c12015-03-23 21:17:43 +0000259 if (isa<ELF64BEObjectFile>(Obj))
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000260 return true;
David Blaikie328c0c12015-03-23 21:17:43 +0000261 return false;
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000262}
263
Rafael Espindola619581c2014-01-29 04:56:19 +0000264static StringRef CurrentFilename;
265typedef std::vector<NMSymbol> SymbolListT;
266static SymbolListT SymbolList;
267
Kevin Enderby980b2582014-06-05 21:21:57 +0000268// darwinPrintSymbol() is used to print a symbol from a Mach-O file when the
Kevin Enderby77b968e2014-07-16 17:38:26 +0000269// the OutputFormat is darwin or we are printing Mach-O symbols in hex. For
270// the darwin format it produces the same output as darwin's nm(1) -m output
271// and when printing Mach-O symbols in hex it produces the same output as
272// darwin's nm(1) -x format.
Kevin Enderby980b2582014-06-05 21:21:57 +0000273static void darwinPrintSymbol(MachOObjectFile *MachO, SymbolListT::iterator I,
274 char *SymbolAddrStr, const char *printBlanks) {
275 MachO::mach_header H;
276 MachO::mach_header_64 H_64;
277 uint32_t Filetype, Flags;
278 MachO::nlist_64 STE_64;
279 MachO::nlist STE;
280 uint8_t NType;
Kevin Enderby77b968e2014-07-16 17:38:26 +0000281 uint8_t NSect;
Kevin Enderby980b2582014-06-05 21:21:57 +0000282 uint16_t NDesc;
Kevin Enderby77b968e2014-07-16 17:38:26 +0000283 uint32_t NStrx;
Kevin Enderby980b2582014-06-05 21:21:57 +0000284 uint64_t NValue;
285 if (MachO->is64Bit()) {
286 H_64 = MachO->MachOObjectFile::getHeader64();
287 Filetype = H_64.filetype;
288 Flags = H_64.flags;
289 STE_64 = MachO->getSymbol64TableEntry(I->Symb);
290 NType = STE_64.n_type;
Kevin Enderby77b968e2014-07-16 17:38:26 +0000291 NSect = STE_64.n_sect;
Kevin Enderby980b2582014-06-05 21:21:57 +0000292 NDesc = STE_64.n_desc;
Kevin Enderby77b968e2014-07-16 17:38:26 +0000293 NStrx = STE_64.n_strx;
Kevin Enderby980b2582014-06-05 21:21:57 +0000294 NValue = STE_64.n_value;
295 } else {
296 H = MachO->MachOObjectFile::getHeader();
297 Filetype = H.filetype;
298 Flags = H.flags;
299 STE = MachO->getSymbolTableEntry(I->Symb);
300 NType = STE.n_type;
Kevin Enderby77b968e2014-07-16 17:38:26 +0000301 NSect = STE.n_sect;
Kevin Enderby980b2582014-06-05 21:21:57 +0000302 NDesc = STE.n_desc;
Kevin Enderby77b968e2014-07-16 17:38:26 +0000303 NStrx = STE.n_strx;
Kevin Enderby980b2582014-06-05 21:21:57 +0000304 NValue = STE.n_value;
305 }
306
Kevin Enderby77b968e2014-07-16 17:38:26 +0000307 // If we are printing Mach-O symbols in hex do that and return.
308 if (FormatMachOasHex) {
309 char Str[18] = "";
310 const char *printFormat;
311 if (MachO->is64Bit())
312 printFormat = "%016" PRIx64;
313 else
314 printFormat = "%08" PRIx64;
315 format(printFormat, NValue).print(Str, sizeof(Str));
316 outs() << Str << ' ';
317 format("%02x", NType).print(Str, sizeof(Str));
318 outs() << Str << ' ';
319 format("%02x", NSect).print(Str, sizeof(Str));
320 outs() << Str << ' ';
321 format("%04x", NDesc).print(Str, sizeof(Str));
322 outs() << Str << ' ';
323 format("%08x", NStrx).print(Str, sizeof(Str));
324 outs() << Str << ' ';
325 outs() << I->Name << "\n";
326 return;
327 }
328
Kevin Enderby980b2582014-06-05 21:21:57 +0000329 if (PrintAddress) {
330 if ((NType & MachO::N_TYPE) == MachO::N_INDR)
331 strcpy(SymbolAddrStr, printBlanks);
332 outs() << SymbolAddrStr << ' ';
333 }
334
335 switch (NType & MachO::N_TYPE) {
336 case MachO::N_UNDF:
337 if (NValue != 0) {
338 outs() << "(common) ";
339 if (MachO::GET_COMM_ALIGN(NDesc) != 0)
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000340 outs() << "(alignment 2^" << (int)MachO::GET_COMM_ALIGN(NDesc) << ") ";
Kevin Enderby980b2582014-06-05 21:21:57 +0000341 } else {
342 if ((NType & MachO::N_TYPE) == MachO::N_PBUD)
343 outs() << "(prebound ";
344 else
345 outs() << "(";
346 if ((NDesc & MachO::REFERENCE_TYPE) ==
347 MachO::REFERENCE_FLAG_UNDEFINED_LAZY)
348 outs() << "undefined [lazy bound]) ";
349 else if ((NDesc & MachO::REFERENCE_TYPE) ==
350 MachO::REFERENCE_FLAG_UNDEFINED_LAZY)
351 outs() << "undefined [private lazy bound]) ";
352 else if ((NDesc & MachO::REFERENCE_TYPE) ==
353 MachO::REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY)
354 outs() << "undefined [private]) ";
355 else
356 outs() << "undefined) ";
357 }
358 break;
359 case MachO::N_ABS:
360 outs() << "(absolute) ";
361 break;
362 case MachO::N_INDR:
363 outs() << "(indirect) ";
364 break;
365 case MachO::N_SECT: {
366 section_iterator Sec = MachO->section_end();
367 MachO->getSymbolSection(I->Symb, Sec);
368 DataRefImpl Ref = Sec->getRawDataRefImpl();
369 StringRef SectionName;
370 MachO->getSectionName(Ref, SectionName);
371 StringRef SegmentName = MachO->getSectionFinalSegmentName(Ref);
372 outs() << "(" << SegmentName << "," << SectionName << ") ";
373 break;
374 }
375 default:
376 outs() << "(?) ";
377 break;
378 }
379
380 if (NType & MachO::N_EXT) {
381 if (NDesc & MachO::REFERENCED_DYNAMICALLY)
382 outs() << "[referenced dynamically] ";
383 if (NType & MachO::N_PEXT) {
384 if ((NDesc & MachO::N_WEAK_DEF) == MachO::N_WEAK_DEF)
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000385 outs() << "weak private external ";
Kevin Enderby980b2582014-06-05 21:21:57 +0000386 else
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000387 outs() << "private external ";
Kevin Enderby980b2582014-06-05 21:21:57 +0000388 } else {
389 if ((NDesc & MachO::N_WEAK_REF) == MachO::N_WEAK_REF ||
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000390 (NDesc & MachO::N_WEAK_DEF) == MachO::N_WEAK_DEF) {
Kevin Enderby980b2582014-06-05 21:21:57 +0000391 if ((NDesc & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF)) ==
392 (MachO::N_WEAK_REF | MachO::N_WEAK_DEF))
393 outs() << "weak external automatically hidden ";
394 else
395 outs() << "weak external ";
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000396 } else
Kevin Enderby980b2582014-06-05 21:21:57 +0000397 outs() << "external ";
398 }
399 } else {
400 if (NType & MachO::N_PEXT)
401 outs() << "non-external (was a private external) ";
402 else
403 outs() << "non-external ";
404 }
405
406 if (Filetype == MachO::MH_OBJECT &&
407 (NDesc & MachO::N_NO_DEAD_STRIP) == MachO::N_NO_DEAD_STRIP)
408 outs() << "[no dead strip] ";
409
410 if (Filetype == MachO::MH_OBJECT &&
411 ((NType & MachO::N_TYPE) != MachO::N_UNDF) &&
412 (NDesc & MachO::N_SYMBOL_RESOLVER) == MachO::N_SYMBOL_RESOLVER)
413 outs() << "[symbol resolver] ";
414
415 if (Filetype == MachO::MH_OBJECT &&
416 ((NType & MachO::N_TYPE) != MachO::N_UNDF) &&
417 (NDesc & MachO::N_ALT_ENTRY) == MachO::N_ALT_ENTRY)
418 outs() << "[alt entry] ";
419
420 if ((NDesc & MachO::N_ARM_THUMB_DEF) == MachO::N_ARM_THUMB_DEF)
421 outs() << "[Thumb] ";
422
423 if ((NType & MachO::N_TYPE) == MachO::N_INDR) {
424 outs() << I->Name << " (for ";
425 StringRef IndirectName;
426 if (MachO->getIndirectName(I->Symb, IndirectName))
427 outs() << "?)";
428 else
429 outs() << IndirectName << ")";
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000430 } else
Kevin Enderby980b2582014-06-05 21:21:57 +0000431 outs() << I->Name;
432
433 if ((Flags & MachO::MH_TWOLEVEL) == MachO::MH_TWOLEVEL &&
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000434 (((NType & MachO::N_TYPE) == MachO::N_UNDF && NValue == 0) ||
Kevin Enderby980b2582014-06-05 21:21:57 +0000435 (NType & MachO::N_TYPE) == MachO::N_PBUD)) {
436 uint32_t LibraryOrdinal = MachO::GET_LIBRARY_ORDINAL(NDesc);
437 if (LibraryOrdinal != 0) {
438 if (LibraryOrdinal == MachO::EXECUTABLE_ORDINAL)
439 outs() << " (from executable)";
440 else if (LibraryOrdinal == MachO::DYNAMIC_LOOKUP_ORDINAL)
441 outs() << " (dynamically looked up)";
442 else {
443 StringRef LibraryName;
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000444 if (MachO->getLibraryShortNameByIndex(LibraryOrdinal - 1, LibraryName))
445 outs() << " (from bad library ordinal " << LibraryOrdinal << ")";
Kevin Enderby980b2582014-06-05 21:21:57 +0000446 else
447 outs() << " (from " << LibraryName << ")";
448 }
449 }
450 }
451
452 outs() << "\n";
453}
454
Kevin Enderby407cc212014-07-17 22:47:16 +0000455// Table that maps Darwin's Mach-O stab constants to strings to allow printing.
456struct DarwinStabName {
457 uint8_t NType;
458 const char *Name;
459};
460static const struct DarwinStabName DarwinStabNames[] = {
461 {MachO::N_GSYM, "GSYM"},
462 {MachO::N_FNAME, "FNAME"},
463 {MachO::N_FUN, "FUN"},
464 {MachO::N_STSYM, "STSYM"},
465 {MachO::N_LCSYM, "LCSYM"},
466 {MachO::N_BNSYM, "BNSYM"},
467 {MachO::N_PC, "PC"},
468 {MachO::N_AST, "AST"},
469 {MachO::N_OPT, "OPT"},
470 {MachO::N_RSYM, "RSYM"},
471 {MachO::N_SLINE, "SLINE"},
472 {MachO::N_ENSYM, "ENSYM"},
473 {MachO::N_SSYM, "SSYM"},
474 {MachO::N_SO, "SO"},
475 {MachO::N_OSO, "OSO"},
476 {MachO::N_LSYM, "LSYM"},
477 {MachO::N_BINCL, "BINCL"},
478 {MachO::N_SOL, "SOL"},
479 {MachO::N_PARAMS, "PARAM"},
480 {MachO::N_VERSION, "VERS"},
481 {MachO::N_OLEVEL, "OLEV"},
482 {MachO::N_PSYM, "PSYM"},
483 {MachO::N_EINCL, "EINCL"},
484 {MachO::N_ENTRY, "ENTRY"},
485 {MachO::N_LBRAC, "LBRAC"},
486 {MachO::N_EXCL, "EXCL"},
487 {MachO::N_RBRAC, "RBRAC"},
488 {MachO::N_BCOMM, "BCOMM"},
489 {MachO::N_ECOMM, "ECOMM"},
490 {MachO::N_ECOML, "ECOML"},
491 {MachO::N_LENG, "LENG"},
492 {0, 0}};
493static const char *getDarwinStabString(uint8_t NType) {
494 for (unsigned i = 0; DarwinStabNames[i].Name; i++) {
495 if (DarwinStabNames[i].NType == NType)
496 return DarwinStabNames[i].Name;
497 }
498 return 0;
499}
500
501// darwinPrintStab() prints the n_sect, n_desc along with a symbolic name of
502// a stab n_type value in a Mach-O file.
503static void darwinPrintStab(MachOObjectFile *MachO, SymbolListT::iterator I) {
504 MachO::nlist_64 STE_64;
505 MachO::nlist STE;
506 uint8_t NType;
507 uint8_t NSect;
508 uint16_t NDesc;
509 if (MachO->is64Bit()) {
510 STE_64 = MachO->getSymbol64TableEntry(I->Symb);
511 NType = STE_64.n_type;
512 NSect = STE_64.n_sect;
513 NDesc = STE_64.n_desc;
514 } else {
515 STE = MachO->getSymbolTableEntry(I->Symb);
516 NType = STE.n_type;
517 NSect = STE.n_sect;
518 NDesc = STE.n_desc;
519 }
520
521 char Str[18] = "";
522 format("%02x", NSect).print(Str, sizeof(Str));
523 outs() << ' ' << Str << ' ';
524 format("%04x", NDesc).print(Str, sizeof(Str));
525 outs() << Str << ' ';
526 if (const char *stabString = getDarwinStabString(NType))
527 format("%5.5s", stabString).print(Str, sizeof(Str));
528 else
529 format(" %02x", NType).print(Str, sizeof(Str));
530 outs() << Str;
531}
532
Rafael Espindolaceb23382014-07-31 21:00:10 +0000533static void sortAndPrintSymbolList(SymbolicFile &Obj, bool printName,
Kevin Enderby08e1bbd2014-07-24 23:31:52 +0000534 std::string ArchiveName,
535 std::string ArchitectureName) {
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000536 if (!NoSort) {
537 if (NumericSort)
Rafael Espindolab4865d62014-04-03 00:19:35 +0000538 std::sort(SymbolList.begin(), SymbolList.end(), compareSymbolAddress);
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000539 else if (SizeSort)
Rafael Espindola619581c2014-01-29 04:56:19 +0000540 std::sort(SymbolList.begin(), SymbolList.end(), compareSymbolSize);
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000541 else
Rafael Espindola619581c2014-01-29 04:56:19 +0000542 std::sort(SymbolList.begin(), SymbolList.end(), compareSymbolName);
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000543 }
544
Kevin Enderby08e1bbd2014-07-24 23:31:52 +0000545 if (!PrintFileName) {
546 if (OutputFormat == posix && MultipleFiles && printName) {
547 outs() << '\n' << CurrentFilename << ":\n";
548 } else if (OutputFormat == bsd && MultipleFiles && printName) {
549 outs() << "\n" << CurrentFilename << ":\n";
550 } else if (OutputFormat == sysv) {
551 outs() << "\n\nSymbols from " << CurrentFilename << ":\n\n"
552 << "Name Value Class Type"
553 << " Size Line Section\n";
554 }
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000555 }
556
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000557 const char *printBlanks, *printFormat;
558 if (isSymbolList64Bit(Obj)) {
559 printBlanks = " ";
560 printFormat = "%016" PRIx64;
561 } else {
562 printBlanks = " ";
563 printFormat = "%08" PRIx64;
564 }
565
Rafael Espindola619581c2014-01-29 04:56:19 +0000566 for (SymbolListT::iterator I = SymbolList.begin(), E = SymbolList.end();
567 I != E; ++I) {
568 if ((I->TypeChar != 'U') && UndefinedOnly)
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000569 continue;
Rafael Espindola619581c2014-01-29 04:56:19 +0000570 if ((I->TypeChar == 'U') && DefinedOnly)
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000571 continue;
Rafael Espindolad7a32ea2015-06-24 10:20:30 +0000572 if (SizeSort && !PrintAddress)
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000573 continue;
Kevin Enderby08e1bbd2014-07-24 23:31:52 +0000574 if (PrintFileName) {
575 if (!ArchitectureName.empty())
576 outs() << "(for architecture " << ArchitectureName << "):";
577 if (!ArchiveName.empty())
578 outs() << ArchiveName << ":";
579 outs() << CurrentFilename << ": ";
580 }
Kevin Enderby49b4f532014-07-28 23:17:38 +0000581 if (JustSymbolName || (UndefinedOnly && isa<MachOObjectFile>(Obj))) {
Kevin Enderby0fd8aac2014-07-03 21:51:07 +0000582 outs() << I->Name << "\n";
583 continue;
584 }
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000585
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000586 char SymbolAddrStr[18] = "";
587 char SymbolSizeStr[18] = "";
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000588
Rafael Espindolad7a32ea2015-06-24 10:20:30 +0000589 if (OutputFormat == sysv || I->Address == UnknownAddress)
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000590 strcpy(SymbolAddrStr, printBlanks);
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000591 if (OutputFormat == sysv)
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000592 strcpy(SymbolSizeStr, printBlanks);
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000593
Rafael Espindolad7a32ea2015-06-24 10:20:30 +0000594 if (I->Address != UnknownAddress)
Kevin Enderby6abc2e52014-05-09 23:57:49 +0000595 format(printFormat, I->Address)
Rafael Espindolab4865d62014-04-03 00:19:35 +0000596 .print(SymbolAddrStr, sizeof(SymbolAddrStr));
Rafael Espindolad7a32ea2015-06-24 10:20:30 +0000597 format(printFormat, I->Size).print(SymbolSizeStr, sizeof(SymbolSizeStr));
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000598
Kevin Enderby77b968e2014-07-16 17:38:26 +0000599 // If OutputFormat is darwin or we are printing Mach-O symbols in hex and
600 // we have a MachOObjectFile, call darwinPrintSymbol to print as darwin's
601 // nm(1) -m output or hex, else if OutputFormat is darwin or we are
602 // printing Mach-O symbols in hex and not a Mach-O object fall back to
603 // OutputFormat bsd (see below).
Rafael Espindolaceb23382014-07-31 21:00:10 +0000604 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj);
Kevin Enderby77b968e2014-07-16 17:38:26 +0000605 if ((OutputFormat == darwin || FormatMachOasHex) && MachO) {
Kevin Enderby980b2582014-06-05 21:21:57 +0000606 darwinPrintSymbol(MachO, I, SymbolAddrStr, printBlanks);
607 } else if (OutputFormat == posix) {
Rafael Espindolab4865d62014-04-03 00:19:35 +0000608 outs() << I->Name << " " << I->TypeChar << " " << SymbolAddrStr
Rafael Espindola619581c2014-01-29 04:56:19 +0000609 << SymbolSizeStr << "\n";
Kevin Enderby980b2582014-06-05 21:21:57 +0000610 } else if (OutputFormat == bsd || (OutputFormat == darwin && !MachO)) {
Rafael Espindolab4865d62014-04-03 00:19:35 +0000611 if (PrintAddress)
612 outs() << SymbolAddrStr << ' ';
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000613 if (PrintSize) {
614 outs() << SymbolSizeStr;
Rafael Espindolad7a32ea2015-06-24 10:20:30 +0000615 outs() << ' ';
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000616 }
Kevin Enderby407cc212014-07-17 22:47:16 +0000617 outs() << I->TypeChar;
618 if (I->TypeChar == '-' && MachO)
619 darwinPrintStab(MachO, I);
620 outs() << " " << I->Name << "\n";
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000621 } else if (OutputFormat == sysv) {
Rafael Espindola619581c2014-01-29 04:56:19 +0000622 std::string PaddedName(I->Name);
623 while (PaddedName.length() < 20)
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000624 PaddedName += " ";
Rafael Espindolab4865d62014-04-03 00:19:35 +0000625 outs() << PaddedName << "|" << SymbolAddrStr << "| " << I->TypeChar
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000626 << " | |" << SymbolSizeStr << "| |\n";
627 }
628 }
629
630 SymbolList.clear();
631}
632
Rafael Espindolab39953d2015-06-26 13:11:15 +0000633static char getSymbolNMTypeChar(ELFObjectFileBase &Obj,
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000634 basic_symbol_iterator I) {
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000635 // OK, this is ELF
Rafael Espindolab39953d2015-06-26 13:11:15 +0000636 elf_symbol_iterator SymI(I);
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000637
Rafael Espindolab39953d2015-06-26 13:11:15 +0000638 elf_section_iterator SecI = Obj.section_end();
639 if (error(SymI->getSection(SecI)))
640 return '?';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000641
Rafael Espindolab39953d2015-06-26 13:11:15 +0000642 if (SecI != Obj.section_end()) {
643 switch (SecI->getType()) {
Rafael Espindola586af97a2013-11-02 21:16:09 +0000644 case ELF::SHT_PROGBITS:
645 case ELF::SHT_DYNAMIC:
Rafael Espindolab39953d2015-06-26 13:11:15 +0000646 switch (SecI->getFlags()) {
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000647 case (ELF::SHF_ALLOC | ELF::SHF_EXECINSTR):
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000648 return 't';
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000649 case (ELF::SHF_TLS | ELF::SHF_ALLOC | ELF::SHF_WRITE):
650 case (ELF::SHF_ALLOC | ELF::SHF_WRITE):
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000651 return 'd';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000652 case ELF::SHF_ALLOC:
Kevin Enderby8f6dcf52014-07-01 22:44:51 +0000653 case (ELF::SHF_ALLOC | ELF::SHF_MERGE):
654 case (ELF::SHF_ALLOC | ELF::SHF_MERGE | ELF::SHF_STRINGS):
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000655 return 'r';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000656 }
657 break;
658 case ELF::SHT_NOBITS:
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000659 return 'b';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000660 }
661 }
662
Rafael Espindolab39953d2015-06-26 13:11:15 +0000663 if (SymI->getELFType() == ELF::STT_SECTION) {
Rafael Espindola586af97a2013-11-02 21:16:09 +0000664 StringRef Name;
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000665 if (error(SymI->getName(Name)))
Rafael Espindola74375892014-02-04 00:21:18 +0000666 return '?';
667 return StringSwitch<char>(Name)
668 .StartsWith(".debug", 'N')
669 .StartsWith(".note", 'n')
670 .Default('?');
Rafael Espindola586af97a2013-11-02 21:16:09 +0000671 }
672
Rafael Espindola60c1a8c2015-06-25 16:01:53 +0000673 return 'n';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000674}
675
Rafael Espindola74375892014-02-04 00:21:18 +0000676static char getSymbolNMTypeChar(COFFObjectFile &Obj, symbol_iterator I) {
David Majnemer44f51e52014-09-10 12:51:52 +0000677 COFFSymbolRef Symb = Obj.getCOFFSymbol(*I);
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000678 // OK, this is COFF.
679 symbol_iterator SymI(I);
680
Rafael Espindola619581c2014-01-29 04:56:19 +0000681 StringRef Name;
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000682 if (error(SymI->getName(Name)))
Rafael Espindola74375892014-02-04 00:21:18 +0000683 return '?';
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000684
Rafael Espindola619581c2014-01-29 04:56:19 +0000685 char Ret = StringSwitch<char>(Name)
Rafael Espindola586af97a2013-11-02 21:16:09 +0000686 .StartsWith(".debug", 'N')
687 .StartsWith(".sxdata", 'N')
688 .Default('?');
689
Rafael Espindola74375892014-02-04 00:21:18 +0000690 if (Ret != '?')
691 return Ret;
Rafael Espindola586af97a2013-11-02 21:16:09 +0000692
693 uint32_t Characteristics = 0;
David Majnemer44f51e52014-09-10 12:51:52 +0000694 if (!COFF::isReservedSectionNumber(Symb.getSectionNumber())) {
Rafael Espindolab5155a52014-02-10 20:24:04 +0000695 section_iterator SecI = Obj.section_end();
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000696 if (error(SymI->getSection(SecI)))
Rafael Espindola74375892014-02-04 00:21:18 +0000697 return '?';
Alexey Samsonov27dc8392014-03-18 06:53:02 +0000698 const coff_section *Section = Obj.getCOFFSection(*SecI);
Rafael Espindola586af97a2013-11-02 21:16:09 +0000699 Characteristics = Section->Characteristics;
700 }
701
David Majnemer44f51e52014-09-10 12:51:52 +0000702 switch (Symb.getSectionNumber()) {
Rafael Espindola586af97a2013-11-02 21:16:09 +0000703 case COFF::IMAGE_SYM_DEBUG:
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000704 return 'n';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000705 default:
706 // Check section type.
707 if (Characteristics & COFF::IMAGE_SCN_CNT_CODE)
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000708 return 't';
David Majnemerc7d7c6f2014-10-31 05:07:00 +0000709 if (Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA)
710 return Characteristics & COFF::IMAGE_SCN_MEM_WRITE ? 'd' : 'r';
711 if (Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000712 return 'b';
David Majnemerc7d7c6f2014-10-31 05:07:00 +0000713 if (Characteristics & COFF::IMAGE_SCN_LNK_INFO)
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000714 return 'i';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000715 // Check for section symbol.
David Majnemerc7d7c6f2014-10-31 05:07:00 +0000716 if (Symb.isSectionDefinition())
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000717 return 's';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000718 }
719
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000720 return '?';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000721}
722
723static uint8_t getNType(MachOObjectFile &Obj, DataRefImpl Symb) {
724 if (Obj.is64Bit()) {
725 MachO::nlist_64 STE = Obj.getSymbol64TableEntry(Symb);
726 return STE.n_type;
727 }
728 MachO::nlist STE = Obj.getSymbolTableEntry(Symb);
729 return STE.n_type;
730}
731
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000732static char getSymbolNMTypeChar(MachOObjectFile &Obj, basic_symbol_iterator I) {
Rafael Espindola586af97a2013-11-02 21:16:09 +0000733 DataRefImpl Symb = I->getRawDataRefImpl();
734 uint8_t NType = getNType(Obj, Symb);
735
Kevin Enderby407cc212014-07-17 22:47:16 +0000736 if (NType & MachO::N_STAB)
737 return '-';
738
Rafael Espindola586af97a2013-11-02 21:16:09 +0000739 switch (NType & MachO::N_TYPE) {
Rafael Espindola586af97a2013-11-02 21:16:09 +0000740 case MachO::N_ABS:
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000741 return 's';
Tim Northovereaef0742014-05-30 13:22:59 +0000742 case MachO::N_INDR:
743 return 'i';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000744 case MachO::N_SECT: {
Rafael Espindolab5155a52014-02-10 20:24:04 +0000745 section_iterator Sec = Obj.section_end();
Rafael Espindola586af97a2013-11-02 21:16:09 +0000746 Obj.getSymbolSection(Symb, Sec);
747 DataRefImpl Ref = Sec->getRawDataRefImpl();
748 StringRef SectionName;
749 Obj.getSectionName(Ref, SectionName);
750 StringRef SegmentName = Obj.getSectionFinalSegmentName(Ref);
751 if (SegmentName == "__TEXT" && SectionName == "__text")
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000752 return 't';
Kevin Enderby1e1b9922014-06-19 22:49:21 +0000753 else if (SegmentName == "__DATA" && SectionName == "__data")
754 return 'd';
755 else if (SegmentName == "__DATA" && SectionName == "__bss")
756 return 'b';
Rafael Espindola586af97a2013-11-02 21:16:09 +0000757 else
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000758 return 's';
759 }
Rafael Espindola586af97a2013-11-02 21:16:09 +0000760 }
761
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000762 return '?';
763}
764
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000765static char getSymbolNMTypeChar(const GlobalValue &GV) {
Rafael Espindola64c1e182014-06-03 02:41:57 +0000766 if (GV.getType()->getElementType()->isFunctionTy())
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000767 return 't';
768 // FIXME: should we print 'b'? At the IR level we cannot be sure if this
769 // will be in bss or not, but we could approximate.
Rafael Espindola64c1e182014-06-03 02:41:57 +0000770 return 'd';
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000771}
772
773static char getSymbolNMTypeChar(IRObjectFile &Obj, basic_symbol_iterator I) {
Rafael Espindola13b69d62014-07-03 18:59:23 +0000774 const GlobalValue *GV = Obj.getSymbolGV(I->getRawDataRefImpl());
775 if (!GV)
776 return 't';
777 return getSymbolNMTypeChar(*GV);
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000778}
779
Rafael Espindolaceb23382014-07-31 21:00:10 +0000780static bool isObject(SymbolicFile &Obj, basic_symbol_iterator I) {
Rafael Espindola6eb5d872015-06-26 13:24:23 +0000781 auto *ELF = dyn_cast<ELFObjectFileBase>(&Obj);
782 if (!ELF)
783 return false;
784
785 return elf_symbol_iterator(I)->getELFType() == ELF::STT_OBJECT;
Rafael Espindola586af97a2013-11-02 21:16:09 +0000786}
787
Rafael Espindolaceb23382014-07-31 21:00:10 +0000788static char getNMTypeChar(SymbolicFile &Obj, basic_symbol_iterator I) {
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000789 uint32_t Symflags = I->getFlags();
790 if ((Symflags & object::SymbolRef::SF_Weak) && !isa<MachOObjectFile>(Obj)) {
791 char Ret = isObject(Obj, I) ? 'v' : 'w';
792 if (!(Symflags & object::SymbolRef::SF_Undefined))
793 Ret = toupper(Ret);
794 return Ret;
795 }
796
797 if (Symflags & object::SymbolRef::SF_Undefined)
798 return 'U';
799
800 if (Symflags & object::SymbolRef::SF_Common)
801 return 'C';
802
803 char Ret = '?';
804 if (Symflags & object::SymbolRef::SF_Absolute)
805 Ret = 'a';
Rafael Espindolaceb23382014-07-31 21:00:10 +0000806 else if (IRObjectFile *IR = dyn_cast<IRObjectFile>(&Obj))
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000807 Ret = getSymbolNMTypeChar(*IR, I);
Rafael Espindolaceb23382014-07-31 21:00:10 +0000808 else if (COFFObjectFile *COFF = dyn_cast<COFFObjectFile>(&Obj))
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000809 Ret = getSymbolNMTypeChar(*COFF, I);
Rafael Espindolaceb23382014-07-31 21:00:10 +0000810 else if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000811 Ret = getSymbolNMTypeChar(*MachO, I);
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000812 else
Rafael Espindolab39953d2015-06-26 13:11:15 +0000813 Ret = getSymbolNMTypeChar(cast<ELFObjectFileBase>(Obj), I);
Rafael Espindola22fe9c12014-02-05 05:19:19 +0000814
815 if (Symflags & object::SymbolRef::SF_Global)
816 Ret = toupper(Ret);
817
818 return Ret;
Rafael Espindola586af97a2013-11-02 21:16:09 +0000819}
820
Kevin Enderbyfe6ad972014-07-11 20:30:00 +0000821// getNsectForSegSect() is used to implement the Mach-O "-s segname sectname"
822// option to dump only those symbols from that section in a Mach-O file.
823// It is called once for each Mach-O file from dumpSymbolNamesFromObject()
824// to get the section number for that named section from the command line
825// arguments. It returns the section number for that section in the Mach-O
826// file or zero it is not present.
827static unsigned getNsectForSegSect(MachOObjectFile *Obj) {
828 unsigned Nsect = 1;
829 for (section_iterator I = Obj->section_begin(), E = Obj->section_end();
830 I != E; ++I) {
831 DataRefImpl Ref = I->getRawDataRefImpl();
832 StringRef SectionName;
833 Obj->getSectionName(Ref, SectionName);
834 StringRef SegmentName = Obj->getSectionFinalSegmentName(Ref);
835 if (SegmentName == SegSect[0] && SectionName == SegSect[1])
836 return Nsect;
837 Nsect++;
838 }
839 return 0;
840}
841
842// getNsectInMachO() is used to implement the Mach-O "-s segname sectname"
843// option to dump only those symbols from that section in a Mach-O file.
844// It is called once for each symbol in a Mach-O file from
845// dumpSymbolNamesFromObject() and returns the section number for that symbol
846// if it is in a section, else it returns 0.
Rafael Espindolab85e10c2015-06-25 15:00:38 +0000847static unsigned getNsectInMachO(MachOObjectFile &Obj, BasicSymbolRef Sym) {
848 DataRefImpl Symb = Sym.getRawDataRefImpl();
Kevin Enderbyfe6ad972014-07-11 20:30:00 +0000849 if (Obj.is64Bit()) {
850 MachO::nlist_64 STE = Obj.getSymbol64TableEntry(Symb);
851 if ((STE.n_type & MachO::N_TYPE) == MachO::N_SECT)
852 return STE.n_sect;
853 return 0;
854 }
855 MachO::nlist STE = Obj.getSymbolTableEntry(Symb);
856 if ((STE.n_type & MachO::N_TYPE) == MachO::N_SECT)
857 return STE.n_sect;
858 return 0;
859}
860
Rafael Espindolaceb23382014-07-31 21:00:10 +0000861static void dumpSymbolNamesFromObject(SymbolicFile &Obj, bool printName,
Kevin Enderby08e1bbd2014-07-24 23:31:52 +0000862 std::string ArchiveName = std::string(),
863 std::string ArchitectureName =
864 std::string()) {
Rafael Espindolab85e10c2015-06-25 15:00:38 +0000865 auto Symbols = Obj.symbols();
Michael J. Spencer8c4729f2012-02-28 00:40:37 +0000866 if (DynamicSyms) {
Rafael Espindola11afad02015-06-25 14:39:35 +0000867 const auto *E = dyn_cast<ELFObjectFileBase>(&Obj);
868 if (!E) {
Rafael Espindolaceb23382014-07-31 21:00:10 +0000869 error("File format has no dynamic symbol table", Obj.getFileName());
Rafael Espindola196666c2014-01-30 20:45:33 +0000870 return;
871 }
Rafael Espindolab85e10c2015-06-25 15:00:38 +0000872 auto DynSymbols = E->getDynamicSymbolIterators();
873 Symbols =
874 make_range<basic_symbol_iterator>(DynSymbols.begin(), DynSymbols.end());
Michael J. Spencer8c4729f2012-02-28 00:40:37 +0000875 }
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000876 std::string NameBuffer;
877 raw_string_ostream OS(NameBuffer);
Kevin Enderbyfe6ad972014-07-11 20:30:00 +0000878 // If a "-s segname sectname" option was specified and this is a Mach-O
879 // file get the section number for that section in this object file.
880 unsigned int Nsect = 0;
Rafael Espindolaceb23382014-07-31 21:00:10 +0000881 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj);
Kevin Enderbyfe6ad972014-07-11 20:30:00 +0000882 if (SegSect.size() != 0 && MachO) {
883 Nsect = getNsectForSegSect(MachO);
884 // If this section is not in the object file no symbols are printed.
885 if (Nsect == 0)
886 return;
887 }
Rafael Espindolab85e10c2015-06-25 15:00:38 +0000888 for (BasicSymbolRef Sym : Symbols) {
889 uint32_t SymFlags = Sym.getFlags();
Rafael Espindola619581c2014-01-29 04:56:19 +0000890 if (!DebugSyms && (SymFlags & SymbolRef::SF_FormatSpecific))
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000891 continue;
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000892 if (WithoutAliases) {
Rafael Espindolaceb23382014-07-31 21:00:10 +0000893 if (IRObjectFile *IR = dyn_cast<IRObjectFile>(&Obj)) {
Rafael Espindolab85e10c2015-06-25 15:00:38 +0000894 const GlobalValue *GV = IR->getSymbolGV(Sym.getRawDataRefImpl());
Rafael Espindola13b69d62014-07-03 18:59:23 +0000895 if (GV && isa<GlobalAlias>(GV))
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000896 continue;
897 }
898 }
Kevin Enderbyfe6ad972014-07-11 20:30:00 +0000899 // If a "-s segname sectname" option was specified and this is a Mach-O
900 // file and this section appears in this file, Nsect will be non-zero then
901 // see if this symbol is a symbol from that section and if not skip it.
Rafael Espindolab85e10c2015-06-25 15:00:38 +0000902 if (Nsect && Nsect != getNsectInMachO(*MachO, Sym))
Kevin Enderbyfe6ad972014-07-11 20:30:00 +0000903 continue;
Rafael Espindola619581c2014-01-29 04:56:19 +0000904 NMSymbol S;
Rafael Espindolad7a32ea2015-06-24 10:20:30 +0000905 S.Size = 0;
906 S.Address = UnknownAddress;
907 if (PrintSize) {
Rafael Espindoladbb6bd32015-06-25 22:10:04 +0000908 if (isa<ELFObjectFileBase>(&Obj))
909 S.Size = ELFSymbolRef(Sym).getSize();
Michael J. Spencer1d6167f2011-06-25 17:55:23 +0000910 }
Rafael Espindolab85e10c2015-06-25 15:00:38 +0000911 if (PrintAddress && isa<ObjectFile>(Obj)) {
912 if (error(SymbolRef(Sym).getAddress(S.Address)))
Rafael Espindola619581c2014-01-29 04:56:19 +0000913 break;
Rafael Espindolab85e10c2015-06-25 15:00:38 +0000914 }
915 S.TypeChar = getNMTypeChar(Obj, Sym);
916 if (error(Sym.printName(OS)))
Rafael Espindola619581c2014-01-29 04:56:19 +0000917 break;
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000918 OS << '\0';
Rafael Espindolab85e10c2015-06-25 15:00:38 +0000919 S.Symb = Sym.getRawDataRefImpl();
Rafael Espindola619581c2014-01-29 04:56:19 +0000920 SymbolList.push_back(S);
Michael J. Spencerb8672a52011-01-20 06:38:57 +0000921 }
922
Rafael Espindolaf12b8282014-02-21 20:10:59 +0000923 OS.flush();
924 const char *P = NameBuffer.c_str();
925 for (unsigned I = 0; I < SymbolList.size(); ++I) {
926 SymbolList[I].Name = P;
927 P += strlen(P) + 1;
928 }
929
Rafael Espindolaceb23382014-07-31 21:00:10 +0000930 CurrentFilename = Obj.getFileName();
Kevin Enderby08e1bbd2014-07-24 23:31:52 +0000931 sortAndPrintSymbolList(Obj, printName, ArchiveName, ArchitectureName);
Brian Gaeke0af759d2003-10-16 04:43:15 +0000932}
933
Kevin Enderby4c8dfe42014-06-30 18:45:23 +0000934// checkMachOAndArchFlags() checks to see if the SymbolicFile is a Mach-O file
935// and if it is and there is a list of architecture flags is specified then
936// check to make sure this Mach-O file is one of those architectures or all
937// architectures was specificed. If not then an error is generated and this
938// routine returns false. Else it returns true.
939static bool checkMachOAndArchFlags(SymbolicFile *O, std::string &Filename) {
David Blaikie328c0c12015-03-23 21:17:43 +0000940 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O);
941
942 if (!MachO || ArchAll || ArchFlags.size() == 0)
943 return true;
944
945 MachO::mach_header H;
946 MachO::mach_header_64 H_64;
947 Triple T;
948 if (MachO->is64Bit()) {
949 H_64 = MachO->MachOObjectFile::getHeader64();
950 T = MachOObjectFile::getArch(H_64.cputype, H_64.cpusubtype);
951 } else {
952 H = MachO->MachOObjectFile::getHeader();
953 T = MachOObjectFile::getArch(H.cputype, H.cpusubtype);
954 }
955 if (std::none_of(
956 ArchFlags.begin(), ArchFlags.end(),
957 [&](const std::string &Name) { return Name == T.getArchName(); })) {
958 error("No architecture specified", Filename);
959 return false;
Kevin Enderby4c8dfe42014-06-30 18:45:23 +0000960 }
961 return true;
962}
963
Rafael Espindola619581c2014-01-29 04:56:19 +0000964static void dumpSymbolNamesFromFile(std::string &Filename) {
Rafael Espindolaadf21f22014-07-06 17:43:13 +0000965 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
966 MemoryBuffer::getFileOrSTDIN(Filename);
967 if (error(BufferOrErr.getError(), Filename))
Michael J. Spencerbc96f372011-12-13 23:17:29 +0000968 return;
969
Owen Anderson19251ec2009-07-15 22:16:10 +0000970 LLVMContext &Context = getGlobalContext();
Peter Collingbourne10039c02014-09-18 21:28:49 +0000971 ErrorOr<std::unique_ptr<Binary>> BinaryOrErr = createBinary(
972 BufferOrErr.get()->getMemBufferRef(), NoLLVMBitcode ? nullptr : &Context);
Rafael Espindolace82a072014-01-30 19:24:00 +0000973 if (error(BinaryOrErr.getError(), Filename))
974 return;
Rafael Espindola3f6481d2014-08-01 14:31:55 +0000975 Binary &Bin = *BinaryOrErr.get();
Shankar Easwaran15b28be2012-11-13 18:38:42 +0000976
Rafael Espindola3f6481d2014-08-01 14:31:55 +0000977 if (Archive *A = dyn_cast<Archive>(&Bin)) {
Rafael Espindolace82a072014-01-30 19:24:00 +0000978 if (ArchiveMap) {
Rafael Espindola0115b082014-01-30 21:51:42 +0000979 Archive::symbol_iterator I = A->symbol_begin();
980 Archive::symbol_iterator E = A->symbol_end();
Rafael Espindolace82a072014-01-30 19:24:00 +0000981 if (I != E) {
Rafael Espindola0115b082014-01-30 21:51:42 +0000982 outs() << "Archive map\n";
Rafael Espindolace82a072014-01-30 19:24:00 +0000983 for (; I != E; ++I) {
Rafael Espindolaae460022014-06-16 16:08:36 +0000984 ErrorOr<Archive::child_iterator> C = I->getMember();
985 if (error(C.getError()))
Michael J. Spencer9718f452013-02-03 10:48:50 +0000986 return;
Rafael Espindolaae460022014-06-16 16:08:36 +0000987 ErrorOr<StringRef> FileNameOrErr = C.get()->getName();
988 if (error(FileNameOrErr.getError()))
Rafael Espindolace82a072014-01-30 19:24:00 +0000989 return;
Rafael Espindolaae460022014-06-16 16:08:36 +0000990 StringRef SymName = I->getName();
991 outs() << SymName << " in " << FileNameOrErr.get() << "\n";
Michael J. Spencer2bc774a2011-09-27 19:37:18 +0000992 }
Rafael Espindolace82a072014-01-30 19:24:00 +0000993 outs() << "\n";
Michael J. Spencer2bc774a2011-09-27 19:37:18 +0000994 }
995 }
Alexey Samsonove6388e62013-06-18 15:03:28 +0000996
Rafael Espindola0115b082014-01-30 21:51:42 +0000997 for (Archive::child_iterator I = A->child_begin(), E = A->child_end();
Rafael Espindolace82a072014-01-30 19:24:00 +0000998 I != E; ++I) {
Rafael Espindolaae460022014-06-16 16:08:36 +0000999 ErrorOr<std::unique_ptr<Binary>> ChildOrErr = I->getAsBinary(&Context);
1000 if (ChildOrErr.getError())
Rafael Espindolace82a072014-01-30 19:24:00 +00001001 continue;
Rafael Espindolaae460022014-06-16 16:08:36 +00001002 if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001003 if (!checkMachOAndArchFlags(O, Filename))
1004 return;
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001005 if (!PrintFileName) {
1006 outs() << "\n";
1007 if (isa<MachOObjectFile>(O)) {
1008 outs() << Filename << "(" << O->getFileName() << ")";
1009 } else
1010 outs() << O->getFileName();
1011 outs() << ":\n";
1012 }
Rafael Espindolaceb23382014-07-31 21:00:10 +00001013 dumpSymbolNamesFromObject(*O, false, Filename);
Rafael Espindolace82a072014-01-30 19:24:00 +00001014 }
1015 }
1016 return;
1017 }
Rafael Espindola3f6481d2014-08-01 14:31:55 +00001018 if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin)) {
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001019 // If we have a list of architecture flags specified dump only those.
1020 if (!ArchAll && ArchFlags.size() != 0) {
1021 // Look for a slice in the universal binary that matches each ArchFlag.
1022 bool ArchFound;
Kevin Enderby8f6dcf52014-07-01 22:44:51 +00001023 for (unsigned i = 0; i < ArchFlags.size(); ++i) {
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001024 ArchFound = false;
1025 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1026 E = UB->end_objects();
1027 I != E; ++I) {
Kevin Enderby8f6dcf52014-07-01 22:44:51 +00001028 if (ArchFlags[i] == I->getArchTypeName()) {
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001029 ArchFound = true;
1030 ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr =
Kevin Enderby8f6dcf52014-07-01 22:44:51 +00001031 I->getAsObjectFile();
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001032 std::string ArchiveName;
1033 std::string ArchitectureName;
1034 ArchiveName.clear();
1035 ArchitectureName.clear();
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001036 if (ObjOrErr) {
Rafael Espindola3f6481d2014-08-01 14:31:55 +00001037 ObjectFile &Obj = *ObjOrErr.get();
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001038 if (ArchFlags.size() > 1) {
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001039 if (PrintFileName)
1040 ArchitectureName = I->getArchTypeName();
1041 else
Rafael Espindola3f6481d2014-08-01 14:31:55 +00001042 outs() << "\n" << Obj.getFileName() << " (for architecture "
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001043 << I->getArchTypeName() << ")"
1044 << ":\n";
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001045 }
Rafael Espindola3f6481d2014-08-01 14:31:55 +00001046 dumpSymbolNamesFromObject(Obj, false, ArchiveName,
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001047 ArchitectureName);
Rafael Espindola0bfe8282014-12-09 21:05:36 +00001048 } else if (ErrorOr<std::unique_ptr<Archive>> AOrErr =
1049 I->getAsArchive()) {
1050 std::unique_ptr<Archive> &A = *AOrErr;
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001051 for (Archive::child_iterator AI = A->child_begin(),
1052 AE = A->child_end();
1053 AI != AE; ++AI) {
1054 ErrorOr<std::unique_ptr<Binary>> ChildOrErr =
1055 AI->getAsBinary(&Context);
1056 if (ChildOrErr.getError())
1057 continue;
Kevin Enderby8f6dcf52014-07-01 22:44:51 +00001058 if (SymbolicFile *O =
1059 dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001060 if (PrintFileName) {
1061 ArchiveName = A->getFileName();
1062 if (ArchFlags.size() > 1)
1063 ArchitectureName = I->getArchTypeName();
1064 } else {
1065 outs() << "\n" << A->getFileName();
1066 outs() << "(" << O->getFileName() << ")";
1067 if (ArchFlags.size() > 1) {
1068 outs() << " (for architecture " << I->getArchTypeName()
1069 << ")";
1070 }
1071 outs() << ":\n";
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001072 }
Rafael Espindolaceb23382014-07-31 21:00:10 +00001073 dumpSymbolNamesFromObject(*O, false, ArchiveName,
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001074 ArchitectureName);
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001075 }
1076 }
1077 }
1078 }
1079 }
1080 if (!ArchFound) {
1081 error(ArchFlags[i],
1082 "file: " + Filename + " does not contain architecture");
1083 return;
1084 }
1085 }
1086 return;
1087 }
1088 // No architecture flags were specified so if this contains a slice that
1089 // matches the host architecture dump only that.
1090 if (!ArchAll) {
Kevin Enderby8f6dcf52014-07-01 22:44:51 +00001091 StringRef HostArchName = MachOObjectFile::getHostArch().getArchName();
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001092 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1093 E = UB->end_objects();
1094 I != E; ++I) {
Kevin Enderby8f6dcf52014-07-01 22:44:51 +00001095 if (HostArchName == I->getArchTypeName()) {
1096 ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001097 std::string ArchiveName;
1098 ArchiveName.clear();
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001099 if (ObjOrErr) {
Rafael Espindola3f6481d2014-08-01 14:31:55 +00001100 ObjectFile &Obj = *ObjOrErr.get();
1101 dumpSymbolNamesFromObject(Obj, false);
Rafael Espindola0bfe8282014-12-09 21:05:36 +00001102 } else if (ErrorOr<std::unique_ptr<Archive>> AOrErr =
1103 I->getAsArchive()) {
1104 std::unique_ptr<Archive> &A = *AOrErr;
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001105 for (Archive::child_iterator AI = A->child_begin(),
1106 AE = A->child_end();
1107 AI != AE; ++AI) {
1108 ErrorOr<std::unique_ptr<Binary>> ChildOrErr =
1109 AI->getAsBinary(&Context);
1110 if (ChildOrErr.getError())
1111 continue;
Kevin Enderby8f6dcf52014-07-01 22:44:51 +00001112 if (SymbolicFile *O =
1113 dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001114 if (PrintFileName)
1115 ArchiveName = A->getFileName();
1116 else
1117 outs() << "\n" << A->getFileName() << "(" << O->getFileName()
1118 << ")"
1119 << ":\n";
Rafael Espindolaceb23382014-07-31 21:00:10 +00001120 dumpSymbolNamesFromObject(*O, false, ArchiveName);
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001121 }
1122 }
1123 }
1124 return;
1125 }
1126 }
1127 }
1128 // Either all architectures have been specified or none have been specified
1129 // and this does not contain the host architecture so dump all the slices.
Kevin Enderby1983fcf2014-06-19 22:03:18 +00001130 bool moreThanOneArch = UB->getNumberOfObjects() > 1;
Rafael Espindola0115b082014-01-30 21:51:42 +00001131 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1132 E = UB->end_objects();
Alexey Samsonove6388e62013-06-18 15:03:28 +00001133 I != E; ++I) {
Rafael Espindola4f7932b2014-06-23 20:41:02 +00001134 ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001135 std::string ArchiveName;
1136 std::string ArchitectureName;
1137 ArchiveName.clear();
1138 ArchitectureName.clear();
Rafael Espindola4f7932b2014-06-23 20:41:02 +00001139 if (ObjOrErr) {
Rafael Espindola3f6481d2014-08-01 14:31:55 +00001140 ObjectFile &Obj = *ObjOrErr.get();
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001141 if (PrintFileName) {
Rafael Espindola3f6481d2014-08-01 14:31:55 +00001142 if (isa<MachOObjectFile>(Obj) && moreThanOneArch)
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001143 ArchitectureName = I->getArchTypeName();
1144 } else {
1145 if (moreThanOneArch)
1146 outs() << "\n";
Rafael Espindola3f6481d2014-08-01 14:31:55 +00001147 outs() << Obj.getFileName();
1148 if (isa<MachOObjectFile>(Obj) && moreThanOneArch)
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001149 outs() << " (for architecture " << I->getArchTypeName() << ")";
1150 outs() << ":\n";
1151 }
Rafael Espindola3f6481d2014-08-01 14:31:55 +00001152 dumpSymbolNamesFromObject(Obj, false, ArchiveName, ArchitectureName);
Rafael Espindola0bfe8282014-12-09 21:05:36 +00001153 } else if (ErrorOr<std::unique_ptr<Archive>> AOrErr = I->getAsArchive()) {
1154 std::unique_ptr<Archive> &A = *AOrErr;
Kevin Enderbye858a652014-05-14 21:18:50 +00001155 for (Archive::child_iterator AI = A->child_begin(), AE = A->child_end();
1156 AI != AE; ++AI) {
Rafael Espindolaae460022014-06-16 16:08:36 +00001157 ErrorOr<std::unique_ptr<Binary>> ChildOrErr =
1158 AI->getAsBinary(&Context);
1159 if (ChildOrErr.getError())
Kevin Enderbye858a652014-05-14 21:18:50 +00001160 continue;
Rafael Espindolaae460022014-06-16 16:08:36 +00001161 if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
Kevin Enderby08e1bbd2014-07-24 23:31:52 +00001162 if (PrintFileName) {
1163 ArchiveName = A->getFileName();
1164 if (isa<MachOObjectFile>(O) && moreThanOneArch)
1165 ArchitectureName = I->getArchTypeName();
1166 } else {
1167 outs() << "\n" << A->getFileName();
1168 if (isa<MachOObjectFile>(O)) {
1169 outs() << "(" << O->getFileName() << ")";
1170 if (moreThanOneArch)
1171 outs() << " (for architecture " << I->getArchTypeName()
1172 << ")";
1173 } else
1174 outs() << ":" << O->getFileName();
1175 outs() << ":\n";
1176 }
Rafael Espindolaceb23382014-07-31 21:00:10 +00001177 dumpSymbolNamesFromObject(*O, false, ArchiveName, ArchitectureName);
Kevin Enderbye858a652014-05-14 21:18:50 +00001178 }
1179 }
1180 }
Alexey Samsonove6388e62013-06-18 15:03:28 +00001181 }
Brian Gaeke618026a2003-11-19 21:57:30 +00001182 return;
Brian Gaeke0af759d2003-10-16 04:43:15 +00001183 }
Rafael Espindola3f6481d2014-08-01 14:31:55 +00001184 if (SymbolicFile *O = dyn_cast<SymbolicFile>(&Bin)) {
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001185 if (!checkMachOAndArchFlags(O, Filename))
1186 return;
Rafael Espindolaceb23382014-07-31 21:00:10 +00001187 dumpSymbolNamesFromObject(*O, true);
Rafael Espindolace82a072014-01-30 19:24:00 +00001188 return;
1189 }
1190 error("unrecognizable file type", Filename);
1191 return;
Brian Gaeke0af759d2003-10-16 04:43:15 +00001192}
1193
1194int main(int argc, char **argv) {
Chris Lattnere3fc2d12009-03-06 05:34:10 +00001195 // Print a stack trace if we signal out.
Chris Lattneref8f3892007-05-06 05:36:18 +00001196 sys::PrintStackTraceOnErrorSignal();
Chris Lattnere3fc2d12009-03-06 05:34:10 +00001197 PrettyStackTraceProgram X(argc, argv);
Michael J. Spencer618d2192010-08-31 06:36:46 +00001198
Rafael Espindola619581c2014-01-29 04:56:19 +00001199 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
Chris Lattnere3fc2d12009-03-06 05:34:10 +00001200 cl::ParseCommandLineOptions(argc, argv, "llvm symbol table dumper\n");
Chris Lattner12439ff2004-02-19 20:32:12 +00001201
Michael J. Spencerbc96f372011-12-13 23:17:29 +00001202 // llvm-nm only reads binary files.
Rafael Espindolacb2eca02013-06-12 20:58:35 +00001203 if (error(sys::ChangeStdinToBinary()))
Michael J. Spencerbc96f372011-12-13 23:17:29 +00001204 return 1;
1205
Rafael Espindola13b69d62014-07-03 18:59:23 +00001206 llvm::InitializeAllTargetInfos();
1207 llvm::InitializeAllTargetMCs();
1208 llvm::InitializeAllAsmParsers();
1209
Chris Lattneref8f3892007-05-06 05:36:18 +00001210 ToolName = argv[0];
Rafael Espindola619581c2014-01-29 04:56:19 +00001211 if (BSDFormat)
1212 OutputFormat = bsd;
1213 if (POSIXFormat)
1214 OutputFormat = posix;
Kevin Enderby14a96ac2014-06-20 00:04:16 +00001215 if (DarwinFormat)
1216 OutputFormat = darwin;
Chris Lattner4aae1f42003-10-16 18:45:23 +00001217
Michael J. Spencerb8672a52011-01-20 06:38:57 +00001218 // The relative order of these is important. If you pass --size-sort it should
1219 // only print out the size. However, if you pass -S --size-sort, it should
Rafael Espindolab4865d62014-04-03 00:19:35 +00001220 // print out both the size and address.
Rafael Espindola619581c2014-01-29 04:56:19 +00001221 if (SizeSort && !PrintSize)
Rafael Espindolab4865d62014-04-03 00:19:35 +00001222 PrintAddress = false;
Rafael Espindola619581c2014-01-29 04:56:19 +00001223 if (OutputFormat == sysv || SizeSort)
1224 PrintSize = true;
Michael J. Spencerb8672a52011-01-20 06:38:57 +00001225
Chris Lattneref8f3892007-05-06 05:36:18 +00001226 switch (InputFilenames.size()) {
Rafael Espindola619581c2014-01-29 04:56:19 +00001227 case 0:
Kevin Enderby4fc2edb2014-06-23 20:27:53 +00001228 InputFilenames.push_back("a.out");
Rafael Espindola619581c2014-01-29 04:56:19 +00001229 case 1:
1230 break;
1231 default:
1232 MultipleFiles = true;
Chris Lattner4aae1f42003-10-16 18:45:23 +00001233 }
Chris Lattneref8f3892007-05-06 05:36:18 +00001234
Kevin Enderby8f6dcf52014-07-01 22:44:51 +00001235 for (unsigned i = 0; i < ArchFlags.size(); ++i) {
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001236 if (ArchFlags[i] == "all") {
1237 ArchAll = true;
Kevin Enderby8f6dcf52014-07-01 22:44:51 +00001238 } else {
Rafael Espindola72318b42014-08-08 16:30:17 +00001239 if (!MachOObjectFile::isValidArch(ArchFlags[i]))
Kevin Enderby4c8dfe42014-06-30 18:45:23 +00001240 error("Unknown architecture named '" + ArchFlags[i] + "'",
1241 "for the -arch option");
1242 }
1243 }
1244
Kevin Enderbyfe6ad972014-07-11 20:30:00 +00001245 if (SegSect.size() != 0 && SegSect.size() != 2)
1246 error("bad number of arguments (must be two arguments)",
1247 "for the -s option");
1248
Chris Lattneref8f3892007-05-06 05:36:18 +00001249 std::for_each(InputFilenames.begin(), InputFilenames.end(),
Rafael Espindola619581c2014-01-29 04:56:19 +00001250 dumpSymbolNamesFromFile);
Rafael Espindola8b82a4d2013-07-03 15:46:03 +00001251
1252 if (HadError)
1253 return 1;
1254
Chris Lattneref8f3892007-05-06 05:36:18 +00001255 return 0;
Brian Gaeke0af759d2003-10-16 04:43:15 +00001256}