1 //===-- llvm-nm.cpp - Symbol table dumping utility for llvm ---------------===//
2 //
3 // The LLVM Compiler Infrastructure
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 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.
13 //
14 // This "nm" supports many of the features of GNU "nm", including its different
15 // output formats.
16 //
17 //===----------------------------------------------------------------------===//
18
19 #include "llvm/ADT/StringSwitch.h"
20 #include "llvm/IR/Function.h"
21 #include "llvm/IR/GlobalAlias.h"
22 #include "llvm/IR/GlobalVariable.h"
23 #include "llvm/IR/LLVMContext.h"
24 #include "llvm/IR/Module.h"
25 #include "llvm/Object/Archive.h"
26 #include "llvm/Object/COFF.h"
27 #include "llvm/Object/ELFObjectFile.h"
28 #include "llvm/Object/IRObjectFile.h"
29 #include "llvm/Object/MachO.h"
30 #include "llvm/Object/MachOUniversal.h"
31 #include "llvm/Object/ObjectFile.h"
32 #include "llvm/Support/COFF.h"
33 #include "llvm/Support/CommandLine.h"
34 #include "llvm/Support/FileSystem.h"
35 #include "llvm/Support/Format.h"
36 #include "llvm/Support/ManagedStatic.h"
37 #include "llvm/Support/MemoryBuffer.h"
38 #include "llvm/Support/PrettyStackTrace.h"
39 #include "llvm/Support/Program.h"
40 #include "llvm/Support/Signals.h"
41 #include "llvm/Support/TargetSelect.h"
42 #include "llvm/Support/raw_ostream.h"
43 #include <algorithm>
44 #include <cctype>
45 #include <cerrno>
46 #include <cstring>
47 #include <system_error>
48 #include <vector>
49
50 using namespace llvm;
51 using namespace object;
52
53 namespace {
54 enum OutputFormatTy { bsd, sysv, posix, darwin };
55 cl::opt<OutputFormatTy> OutputFormat(
56 "format", cl::desc("Specify output format"),
57 cl::values(clEnumVal(bsd, "BSD format"), clEnumVal(sysv, "System V format"),
58 clEnumVal(posix, "POSIX.2 format"),
59 clEnumVal(darwin, "Darwin -m format"), clEnumValEnd),
60 cl::init(bsd));
61 cl::alias OutputFormat2("f", cl::desc("Alias for --format"),
62 cl::aliasopt(OutputFormat));
63
64 cl::list<std::string> InputFilenames(cl::Positional, cl::desc("<input files>"),
65 cl::ZeroOrMore);
66
67 cl::opt<bool> UndefinedOnly("undefined-only",
68 cl::desc("Show only undefined symbols"));
69 cl::alias UndefinedOnly2("u", cl::desc("Alias for --undefined-only"),
70 cl::aliasopt(UndefinedOnly), cl::Grouping);
71
72 cl::opt<bool> DynamicSyms("dynamic",
73 cl::desc("Display the dynamic symbols instead "
74 "of normal symbols."));
75 cl::alias DynamicSyms2("D", cl::desc("Alias for --dynamic"),
76 cl::aliasopt(DynamicSyms), cl::Grouping);
77
78 cl::opt<bool> DefinedOnly("defined-only",
79 cl::desc("Show only defined symbols"));
80 cl::alias DefinedOnly2("U", cl::desc("Alias for --defined-only"),
81 cl::aliasopt(DefinedOnly), cl::Grouping);
82
83 cl::opt<bool> ExternalOnly("extern-only",
84 cl::desc("Show only external symbols"));
85 cl::alias ExternalOnly2("g", cl::desc("Alias for --extern-only"),
86 cl::aliasopt(ExternalOnly), cl::Grouping);
87
88 cl::opt<bool> BSDFormat("B", cl::desc("Alias for --format=bsd"),
89 cl::Grouping);
90 cl::opt<bool> POSIXFormat("P", cl::desc("Alias for --format=posix"),
91 cl::Grouping);
92 cl::opt<bool> DarwinFormat("m", cl::desc("Alias for --format=darwin"),
93 cl::Grouping);
94
95 static cl::list<std::string>
96 ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"),
97 cl::ZeroOrMore);
98 bool ArchAll = false;
99
100 cl::opt<bool> PrintFileName(
101 "print-file-name",
102 cl::desc("Precede each symbol with the object file it came from"));
103
104 cl::alias PrintFileNameA("A", cl::desc("Alias for --print-file-name"),
105 cl::aliasopt(PrintFileName), cl::Grouping);
106 cl::alias PrintFileNameo("o", cl::desc("Alias for --print-file-name"),
107 cl::aliasopt(PrintFileName), cl::Grouping);
108
109 cl::opt<bool> DebugSyms("debug-syms",
110 cl::desc("Show all symbols, even debugger only"));
111 cl::alias DebugSymsa("a", cl::desc("Alias for --debug-syms"),
112 cl::aliasopt(DebugSyms), cl::Grouping);
113
114 cl::opt<bool> NumericSort("numeric-sort", cl::desc("Sort symbols by address"));
115 cl::alias NumericSortn("n", cl::desc("Alias for --numeric-sort"),
116 cl::aliasopt(NumericSort), cl::Grouping);
117 cl::alias NumericSortv("v", cl::desc("Alias for --numeric-sort"),
118 cl::aliasopt(NumericSort), cl::Grouping);
119
120 cl::opt<bool> NoSort("no-sort", cl::desc("Show symbols in order encountered"));
121 cl::alias NoSortp("p", cl::desc("Alias for --no-sort"), cl::aliasopt(NoSort),
122 cl::Grouping);
123
124 cl::opt<bool> ReverseSort("reverse-sort", cl::desc("Sort in reverse order"));
125 cl::alias ReverseSortr("r", cl::desc("Alias for --reverse-sort"),
126 cl::aliasopt(ReverseSort), cl::Grouping);
127
128 cl::opt<bool> PrintSize("print-size",
129 cl::desc("Show symbol size instead of address"));
130 cl::alias PrintSizeS("S", cl::desc("Alias for --print-size"),
131 cl::aliasopt(PrintSize), cl::Grouping);
132
133 cl::opt<bool> SizeSort("size-sort", cl::desc("Sort symbols by size"));
134
135 cl::opt<bool> WithoutAliases("without-aliases", cl::Hidden,
136 cl::desc("Exclude aliases from output"));
137
138 cl::opt<bool> ArchiveMap("print-armap", cl::desc("Print the archive map"));
139 cl::alias ArchiveMaps("M", cl::desc("Alias for --print-armap"),
140 cl::aliasopt(ArchiveMap), cl::Grouping);
141
142 enum Radix { d, o, x };
143 cl::opt<Radix>
144 AddressRadix("radix", cl::desc("Radix (o/d/x) for printing symbol Values"),
145 cl::values(clEnumVal(d, "decimal"), clEnumVal(o, "octal"),
146 clEnumVal(x, "hexadecimal"), clEnumValEnd),
147 cl::init(x));
148 cl::alias RadixAlias("t", cl::desc("Alias for --radix"),
149 cl::aliasopt(AddressRadix));
150
151 cl::opt<bool> JustSymbolName("just-symbol-name",
152 cl::desc("Print just the symbol's name"));
153 cl::alias JustSymbolNames("j", cl::desc("Alias for --just-symbol-name"),
154 cl::aliasopt(JustSymbolName), cl::Grouping);
155
156 // FIXME: This option takes exactly two strings and should be allowed anywhere
157 // on the command line. Such that "llvm-nm -s __TEXT __text foo.o" would work.
158 // But that does not as the CommandLine Library does not have a way to make
159 // this work. For now the "-s __TEXT __text" has to be last on the command
160 // line.
161 cl::list<std::string> SegSect("s", cl::Positional, cl::ZeroOrMore,
162 cl::desc("Dump only symbols from this segment "
163 "and section name, Mach-O only"));
164
165 cl::opt<bool> FormatMachOasHex("x", cl::desc("Print symbol entry in hex, "
166 "Mach-O only"), cl::Grouping);
167
168 cl::opt<bool> NoLLVMBitcode("no-llvm-bc",
169 cl::desc("Disable LLVM bitcode reader"));
170
171 bool PrintAddress = true;
172
173 bool MultipleFiles = false;
174
175 bool HadError = false;
176
177 std::string ToolName;
178 } // anonymous namespace
179
error(Twine Message,Twine Path=Twine ())180 static void error(Twine Message, Twine Path = Twine()) {
181 HadError = true;
182 errs() << ToolName << ": " << Path << ": " << Message << ".\n";
183 }
184
error(std::error_code EC,Twine Path=Twine ())185 static bool error(std::error_code EC, Twine Path = Twine()) {
186 if (EC) {
187 error(EC.message(), Path);
188 return true;
189 }
190 return false;
191 }
192
193 // This version of error() prints the archive name and member name, for example:
194 // "libx.a(foo.o)" after the ToolName before the error message. It sets
195 // HadError but returns allowing the code to move on to other archive members.
error(llvm::Error E,StringRef FileName,const Archive::Child & C,StringRef ArchitectureName=StringRef ())196 static void error(llvm::Error E, StringRef FileName, const Archive::Child &C,
197 StringRef ArchitectureName = StringRef()) {
198 HadError = true;
199 errs() << ToolName << ": " << FileName;
200
201 ErrorOr<StringRef> NameOrErr = C.getName();
202 // TODO: if we have a error getting the name then it would be nice to print
203 // the index of which archive member this is and or its offset in the
204 // archive instead of "???" as the name.
205 if (NameOrErr.getError())
206 errs() << "(" << "???" << ")";
207 else
208 errs() << "(" << NameOrErr.get() << ")";
209
210 if (!ArchitectureName.empty())
211 errs() << " (for architecture " << ArchitectureName << ") ";
212
213 std::string Buf;
214 raw_string_ostream OS(Buf);
215 logAllUnhandledErrors(std::move(E), OS, "");
216 OS.flush();
217 errs() << " " << Buf << "\n";
218 }
219
220 // This version of error() prints the file name and which architecture slice it
221 // is from, for example: "foo.o (for architecture i386)" after the ToolName
222 // before the error message. It sets HadError but returns allowing the code to
223 // move on to other architecture slices.
error(llvm::Error E,StringRef FileName,StringRef ArchitectureName=StringRef ())224 static void error(llvm::Error E, StringRef FileName,
225 StringRef ArchitectureName = StringRef()) {
226 HadError = true;
227 errs() << ToolName << ": " << FileName;
228
229 if (!ArchitectureName.empty())
230 errs() << " (for architecture " << ArchitectureName << ") ";
231
232 std::string Buf;
233 raw_string_ostream OS(Buf);
234 logAllUnhandledErrors(std::move(E), OS, "");
235 OS.flush();
236 errs() << " " << Buf << "\n";
237 }
238
239 namespace {
240 struct NMSymbol {
241 uint64_t Address;
242 uint64_t Size;
243 char TypeChar;
244 StringRef Name;
245 BasicSymbolRef Sym;
246 };
247 } // anonymous namespace
248
compareSymbolAddress(const NMSymbol & A,const NMSymbol & B)249 static bool compareSymbolAddress(const NMSymbol &A, const NMSymbol &B) {
250 bool ADefined = !(A.Sym.getFlags() & SymbolRef::SF_Undefined);
251 bool BDefined = !(B.Sym.getFlags() & SymbolRef::SF_Undefined);
252 return std::make_tuple(ADefined, A.Address, A.Name, A.Size) <
253 std::make_tuple(BDefined, B.Address, B.Name, B.Size);
254 }
255
compareSymbolSize(const NMSymbol & A,const NMSymbol & B)256 static bool compareSymbolSize(const NMSymbol &A, const NMSymbol &B) {
257 return std::make_tuple(A.Size, A.Name, A.Address) <
258 std::make_tuple(B.Size, B.Name, B.Address);
259 }
260
compareSymbolName(const NMSymbol & A,const NMSymbol & B)261 static bool compareSymbolName(const NMSymbol &A, const NMSymbol &B) {
262 return std::make_tuple(A.Name, A.Size, A.Address) <
263 std::make_tuple(B.Name, B.Size, B.Address);
264 }
265
isSymbolList64Bit(SymbolicFile & Obj)266 static char isSymbolList64Bit(SymbolicFile &Obj) {
267 if (isa<IRObjectFile>(Obj)) {
268 IRObjectFile *IRobj = dyn_cast<IRObjectFile>(&Obj);
269 Module &M = IRobj->getModule();
270 if (M.getTargetTriple().empty())
271 return false;
272 Triple T(M.getTargetTriple());
273 return T.isArch64Bit();
274 }
275 if (isa<COFFObjectFile>(Obj))
276 return false;
277 if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
278 return MachO->is64Bit();
279 return cast<ELFObjectFileBase>(Obj).getBytesInAddress() == 8;
280 }
281
282 static StringRef CurrentFilename;
283 typedef std::vector<NMSymbol> SymbolListT;
284 static SymbolListT SymbolList;
285
286 static char getSymbolNMTypeChar(IRObjectFile &Obj, basic_symbol_iterator I);
287
288 // darwinPrintSymbol() is used to print a symbol from a Mach-O file when the
289 // the OutputFormat is darwin or we are printing Mach-O symbols in hex. For
290 // the darwin format it produces the same output as darwin's nm(1) -m output
291 // and when printing Mach-O symbols in hex it produces the same output as
292 // darwin's nm(1) -x format.
darwinPrintSymbol(SymbolicFile & Obj,SymbolListT::iterator I,char * SymbolAddrStr,const char * printBlanks,const char * printDashes,const char * printFormat)293 static void darwinPrintSymbol(SymbolicFile &Obj, SymbolListT::iterator I,
294 char *SymbolAddrStr, const char *printBlanks,
295 const char *printDashes, const char *printFormat) {
296 MachO::mach_header H;
297 MachO::mach_header_64 H_64;
298 uint32_t Filetype = MachO::MH_OBJECT;
299 uint32_t Flags = 0;
300 uint8_t NType = 0;
301 uint8_t NSect = 0;
302 uint16_t NDesc = 0;
303 uint32_t NStrx = 0;
304 uint64_t NValue = 0;
305 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj);
306 if (Obj.isIR()) {
307 uint32_t SymFlags = I->Sym.getFlags();
308 if (SymFlags & SymbolRef::SF_Global)
309 NType |= MachO::N_EXT;
310 if (SymFlags & SymbolRef::SF_Hidden)
311 NType |= MachO::N_PEXT;
312 if (SymFlags & SymbolRef::SF_Undefined)
313 NType |= MachO::N_EXT | MachO::N_UNDF;
314 else {
315 // Here we have a symbol definition. So to fake out a section name we
316 // use 1, 2 and 3 for section numbers. See below where they are used to
317 // print out fake section names.
318 NType |= MachO::N_SECT;
319 if (SymFlags & SymbolRef::SF_Const)
320 NSect = 3;
321 else {
322 IRObjectFile *IRobj = dyn_cast<IRObjectFile>(&Obj);
323 NSect = (getSymbolNMTypeChar(*IRobj, I->Sym) == 't') ? 1 : 2;
324 }
325 }
326 if (SymFlags & SymbolRef::SF_Weak)
327 NDesc |= MachO::N_WEAK_DEF;
328 } else {
329 DataRefImpl SymDRI = I->Sym.getRawDataRefImpl();
330 if (MachO->is64Bit()) {
331 H_64 = MachO->MachOObjectFile::getHeader64();
332 Filetype = H_64.filetype;
333 Flags = H_64.flags;
334 MachO::nlist_64 STE_64 = MachO->getSymbol64TableEntry(SymDRI);
335 NType = STE_64.n_type;
336 NSect = STE_64.n_sect;
337 NDesc = STE_64.n_desc;
338 NStrx = STE_64.n_strx;
339 NValue = STE_64.n_value;
340 } else {
341 H = MachO->MachOObjectFile::getHeader();
342 Filetype = H.filetype;
343 Flags = H.flags;
344 MachO::nlist STE = MachO->getSymbolTableEntry(SymDRI);
345 NType = STE.n_type;
346 NSect = STE.n_sect;
347 NDesc = STE.n_desc;
348 NStrx = STE.n_strx;
349 NValue = STE.n_value;
350 }
351 }
352
353 // If we are printing Mach-O symbols in hex do that and return.
354 if (FormatMachOasHex) {
355 char Str[18] = "";
356 format(printFormat, NValue).print(Str, sizeof(Str));
357 outs() << Str << ' ';
358 format("%02x", NType).print(Str, sizeof(Str));
359 outs() << Str << ' ';
360 format("%02x", NSect).print(Str, sizeof(Str));
361 outs() << Str << ' ';
362 format("%04x", NDesc).print(Str, sizeof(Str));
363 outs() << Str << ' ';
364 format("%08x", NStrx).print(Str, sizeof(Str));
365 outs() << Str << ' ';
366 outs() << I->Name << "\n";
367 return;
368 }
369
370 if (PrintAddress) {
371 if ((NType & MachO::N_TYPE) == MachO::N_INDR)
372 strcpy(SymbolAddrStr, printBlanks);
373 if (Obj.isIR() && (NType & MachO::N_TYPE) == MachO::N_TYPE)
374 strcpy(SymbolAddrStr, printDashes);
375 outs() << SymbolAddrStr << ' ';
376 }
377
378 switch (NType & MachO::N_TYPE) {
379 case MachO::N_UNDF:
380 if (NValue != 0) {
381 outs() << "(common) ";
382 if (MachO::GET_COMM_ALIGN(NDesc) != 0)
383 outs() << "(alignment 2^" << (int)MachO::GET_COMM_ALIGN(NDesc) << ") ";
384 } else {
385 if ((NType & MachO::N_TYPE) == MachO::N_PBUD)
386 outs() << "(prebound ";
387 else
388 outs() << "(";
389 if ((NDesc & MachO::REFERENCE_TYPE) ==
390 MachO::REFERENCE_FLAG_UNDEFINED_LAZY)
391 outs() << "undefined [lazy bound]) ";
392 else if ((NDesc & MachO::REFERENCE_TYPE) ==
393 MachO::REFERENCE_FLAG_PRIVATE_UNDEFINED_LAZY)
394 outs() << "undefined [private lazy bound]) ";
395 else if ((NDesc & MachO::REFERENCE_TYPE) ==
396 MachO::REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY)
397 outs() << "undefined [private]) ";
398 else
399 outs() << "undefined) ";
400 }
401 break;
402 case MachO::N_ABS:
403 outs() << "(absolute) ";
404 break;
405 case MachO::N_INDR:
406 outs() << "(indirect) ";
407 break;
408 case MachO::N_SECT: {
409 if (Obj.isIR()) {
410 // For llvm bitcode files print out a fake section name using the values
411 // use 1, 2 and 3 for section numbers as set above.
412 if (NSect == 1)
413 outs() << "(LTO,CODE) ";
414 else if (NSect == 2)
415 outs() << "(LTO,DATA) ";
416 else if (NSect == 3)
417 outs() << "(LTO,RODATA) ";
418 else
419 outs() << "(?,?) ";
420 break;
421 }
422 Expected<section_iterator> SecOrErr =
423 MachO->getSymbolSection(I->Sym.getRawDataRefImpl());
424 if (!SecOrErr) {
425 consumeError(SecOrErr.takeError());
426 outs() << "(?,?) ";
427 break;
428 }
429 section_iterator Sec = *SecOrErr;
430 DataRefImpl Ref = Sec->getRawDataRefImpl();
431 StringRef SectionName;
432 MachO->getSectionName(Ref, SectionName);
433 StringRef SegmentName = MachO->getSectionFinalSegmentName(Ref);
434 outs() << "(" << SegmentName << "," << SectionName << ") ";
435 break;
436 }
437 default:
438 outs() << "(?) ";
439 break;
440 }
441
442 if (NType & MachO::N_EXT) {
443 if (NDesc & MachO::REFERENCED_DYNAMICALLY)
444 outs() << "[referenced dynamically] ";
445 if (NType & MachO::N_PEXT) {
446 if ((NDesc & MachO::N_WEAK_DEF) == MachO::N_WEAK_DEF)
447 outs() << "weak private external ";
448 else
449 outs() << "private external ";
450 } else {
451 if ((NDesc & MachO::N_WEAK_REF) == MachO::N_WEAK_REF ||
452 (NDesc & MachO::N_WEAK_DEF) == MachO::N_WEAK_DEF) {
453 if ((NDesc & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF)) ==
454 (MachO::N_WEAK_REF | MachO::N_WEAK_DEF))
455 outs() << "weak external automatically hidden ";
456 else
457 outs() << "weak external ";
458 } else
459 outs() << "external ";
460 }
461 } else {
462 if (NType & MachO::N_PEXT)
463 outs() << "non-external (was a private external) ";
464 else
465 outs() << "non-external ";
466 }
467
468 if (Filetype == MachO::MH_OBJECT &&
469 (NDesc & MachO::N_NO_DEAD_STRIP) == MachO::N_NO_DEAD_STRIP)
470 outs() << "[no dead strip] ";
471
472 if (Filetype == MachO::MH_OBJECT &&
473 ((NType & MachO::N_TYPE) != MachO::N_UNDF) &&
474 (NDesc & MachO::N_SYMBOL_RESOLVER) == MachO::N_SYMBOL_RESOLVER)
475 outs() << "[symbol resolver] ";
476
477 if (Filetype == MachO::MH_OBJECT &&
478 ((NType & MachO::N_TYPE) != MachO::N_UNDF) &&
479 (NDesc & MachO::N_ALT_ENTRY) == MachO::N_ALT_ENTRY)
480 outs() << "[alt entry] ";
481
482 if ((NDesc & MachO::N_ARM_THUMB_DEF) == MachO::N_ARM_THUMB_DEF)
483 outs() << "[Thumb] ";
484
485 if ((NType & MachO::N_TYPE) == MachO::N_INDR) {
486 outs() << I->Name << " (for ";
487 StringRef IndirectName;
488 if (!MachO ||
489 MachO->getIndirectName(I->Sym.getRawDataRefImpl(), IndirectName))
490 outs() << "?)";
491 else
492 outs() << IndirectName << ")";
493 } else
494 outs() << I->Name;
495
496 if ((Flags & MachO::MH_TWOLEVEL) == MachO::MH_TWOLEVEL &&
497 (((NType & MachO::N_TYPE) == MachO::N_UNDF && NValue == 0) ||
498 (NType & MachO::N_TYPE) == MachO::N_PBUD)) {
499 uint32_t LibraryOrdinal = MachO::GET_LIBRARY_ORDINAL(NDesc);
500 if (LibraryOrdinal != 0) {
501 if (LibraryOrdinal == MachO::EXECUTABLE_ORDINAL)
502 outs() << " (from executable)";
503 else if (LibraryOrdinal == MachO::DYNAMIC_LOOKUP_ORDINAL)
504 outs() << " (dynamically looked up)";
505 else {
506 StringRef LibraryName;
507 if (!MachO ||
508 MachO->getLibraryShortNameByIndex(LibraryOrdinal - 1, LibraryName))
509 outs() << " (from bad library ordinal " << LibraryOrdinal << ")";
510 else
511 outs() << " (from " << LibraryName << ")";
512 }
513 }
514 }
515
516 outs() << "\n";
517 }
518
519 // Table that maps Darwin's Mach-O stab constants to strings to allow printing.
520 struct DarwinStabName {
521 uint8_t NType;
522 const char *Name;
523 };
524 static const struct DarwinStabName DarwinStabNames[] = {
525 {MachO::N_GSYM, "GSYM"},
526 {MachO::N_FNAME, "FNAME"},
527 {MachO::N_FUN, "FUN"},
528 {MachO::N_STSYM, "STSYM"},
529 {MachO::N_LCSYM, "LCSYM"},
530 {MachO::N_BNSYM, "BNSYM"},
531 {MachO::N_PC, "PC"},
532 {MachO::N_AST, "AST"},
533 {MachO::N_OPT, "OPT"},
534 {MachO::N_RSYM, "RSYM"},
535 {MachO::N_SLINE, "SLINE"},
536 {MachO::N_ENSYM, "ENSYM"},
537 {MachO::N_SSYM, "SSYM"},
538 {MachO::N_SO, "SO"},
539 {MachO::N_OSO, "OSO"},
540 {MachO::N_LSYM, "LSYM"},
541 {MachO::N_BINCL, "BINCL"},
542 {MachO::N_SOL, "SOL"},
543 {MachO::N_PARAMS, "PARAM"},
544 {MachO::N_VERSION, "VERS"},
545 {MachO::N_OLEVEL, "OLEV"},
546 {MachO::N_PSYM, "PSYM"},
547 {MachO::N_EINCL, "EINCL"},
548 {MachO::N_ENTRY, "ENTRY"},
549 {MachO::N_LBRAC, "LBRAC"},
550 {MachO::N_EXCL, "EXCL"},
551 {MachO::N_RBRAC, "RBRAC"},
552 {MachO::N_BCOMM, "BCOMM"},
553 {MachO::N_ECOMM, "ECOMM"},
554 {MachO::N_ECOML, "ECOML"},
555 {MachO::N_LENG, "LENG"},
556 {0, nullptr}};
557
getDarwinStabString(uint8_t NType)558 static const char *getDarwinStabString(uint8_t NType) {
559 for (unsigned i = 0; DarwinStabNames[i].Name; i++) {
560 if (DarwinStabNames[i].NType == NType)
561 return DarwinStabNames[i].Name;
562 }
563 return nullptr;
564 }
565
566 // darwinPrintStab() prints the n_sect, n_desc along with a symbolic name of
567 // a stab n_type value in a Mach-O file.
darwinPrintStab(MachOObjectFile * MachO,SymbolListT::iterator I)568 static void darwinPrintStab(MachOObjectFile *MachO, SymbolListT::iterator I) {
569 MachO::nlist_64 STE_64;
570 MachO::nlist STE;
571 uint8_t NType;
572 uint8_t NSect;
573 uint16_t NDesc;
574 DataRefImpl SymDRI = I->Sym.getRawDataRefImpl();
575 if (MachO->is64Bit()) {
576 STE_64 = MachO->getSymbol64TableEntry(SymDRI);
577 NType = STE_64.n_type;
578 NSect = STE_64.n_sect;
579 NDesc = STE_64.n_desc;
580 } else {
581 STE = MachO->getSymbolTableEntry(SymDRI);
582 NType = STE.n_type;
583 NSect = STE.n_sect;
584 NDesc = STE.n_desc;
585 }
586
587 char Str[18] = "";
588 format("%02x", NSect).print(Str, sizeof(Str));
589 outs() << ' ' << Str << ' ';
590 format("%04x", NDesc).print(Str, sizeof(Str));
591 outs() << Str << ' ';
592 if (const char *stabString = getDarwinStabString(NType))
593 format("%5.5s", stabString).print(Str, sizeof(Str));
594 else
595 format(" %02x", NType).print(Str, sizeof(Str));
596 outs() << Str;
597 }
598
sortAndPrintSymbolList(SymbolicFile & Obj,bool printName,const std::string & ArchiveName,const std::string & ArchitectureName)599 static void sortAndPrintSymbolList(SymbolicFile &Obj, bool printName,
600 const std::string &ArchiveName,
601 const std::string &ArchitectureName) {
602 if (!NoSort) {
603 std::function<bool(const NMSymbol &, const NMSymbol &)> Cmp;
604 if (NumericSort)
605 Cmp = compareSymbolAddress;
606 else if (SizeSort)
607 Cmp = compareSymbolSize;
608 else
609 Cmp = compareSymbolName;
610
611 if (ReverseSort)
612 Cmp = [=](const NMSymbol &A, const NMSymbol &B) { return Cmp(B, A); };
613 std::sort(SymbolList.begin(), SymbolList.end(), Cmp);
614 }
615
616 if (!PrintFileName) {
617 if (OutputFormat == posix && MultipleFiles && printName) {
618 outs() << '\n' << CurrentFilename << ":\n";
619 } else if (OutputFormat == bsd && MultipleFiles && printName) {
620 outs() << "\n" << CurrentFilename << ":\n";
621 } else if (OutputFormat == sysv) {
622 outs() << "\n\nSymbols from " << CurrentFilename << ":\n\n"
623 << "Name Value Class Type"
624 << " Size Line Section\n";
625 }
626 }
627
628 const char *printBlanks, *printDashes, *printFormat;
629 if (isSymbolList64Bit(Obj)) {
630 printBlanks = " ";
631 printDashes = "----------------";
632 switch (AddressRadix) {
633 case Radix::o:
634 printFormat = OutputFormat == posix ? "%" PRIo64 : "%016" PRIo64;
635 break;
636 case Radix::x:
637 printFormat = OutputFormat == posix ? "%" PRIx64 : "%016" PRIx64;
638 break;
639 default:
640 printFormat = OutputFormat == posix ? "%" PRId64 : "%016" PRId64;
641 }
642 } else {
643 printBlanks = " ";
644 printDashes = "--------";
645 switch (AddressRadix) {
646 case Radix::o:
647 printFormat = OutputFormat == posix ? "%" PRIo64 : "%08" PRIo64;
648 break;
649 case Radix::x:
650 printFormat = OutputFormat == posix ? "%" PRIx64 : "%08" PRIx64;
651 break;
652 default:
653 printFormat = OutputFormat == posix ? "%" PRId64 : "%08" PRId64;
654 }
655 }
656
657 for (SymbolListT::iterator I = SymbolList.begin(), E = SymbolList.end();
658 I != E; ++I) {
659 uint32_t SymFlags = I->Sym.getFlags();
660 bool Undefined = SymFlags & SymbolRef::SF_Undefined;
661 bool Global = SymFlags & SymbolRef::SF_Global;
662 if ((!Undefined && UndefinedOnly) || (Undefined && DefinedOnly) ||
663 (!Global && ExternalOnly) || (SizeSort && !PrintAddress))
664 continue;
665 if (PrintFileName) {
666 if (!ArchitectureName.empty())
667 outs() << "(for architecture " << ArchitectureName << "):";
668 if (OutputFormat == posix && !ArchiveName.empty())
669 outs() << ArchiveName << "[" << CurrentFilename << "]: ";
670 else {
671 if (!ArchiveName.empty())
672 outs() << ArchiveName << ":";
673 outs() << CurrentFilename << ": ";
674 }
675 }
676 if ((JustSymbolName || (UndefinedOnly && isa<MachOObjectFile>(Obj) &&
677 OutputFormat != darwin)) && OutputFormat != posix) {
678 outs() << I->Name << "\n";
679 continue;
680 }
681
682 char SymbolAddrStr[18] = "";
683 char SymbolSizeStr[18] = "";
684
685 if (OutputFormat == sysv || I->TypeChar == 'U') {
686 if (OutputFormat == posix)
687 format(printFormat, I->Address)
688 .print(SymbolAddrStr, sizeof(SymbolAddrStr));
689 else
690 strcpy(SymbolAddrStr, printBlanks);
691 }
692 if (OutputFormat == sysv)
693 strcpy(SymbolSizeStr, printBlanks);
694
695 if (I->TypeChar != 'U') {
696 if (Obj.isIR())
697 strcpy(SymbolAddrStr, printDashes);
698 else
699 format(printFormat, I->Address)
700 .print(SymbolAddrStr, sizeof(SymbolAddrStr));
701 }
702 format(printFormat, I->Size).print(SymbolSizeStr, sizeof(SymbolSizeStr));
703
704 // If OutputFormat is darwin or we are printing Mach-O symbols in hex and
705 // we have a MachOObjectFile, call darwinPrintSymbol to print as darwin's
706 // nm(1) -m output or hex, else if OutputFormat is darwin or we are
707 // printing Mach-O symbols in hex and not a Mach-O object fall back to
708 // OutputFormat bsd (see below).
709 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj);
710 if ((OutputFormat == darwin || FormatMachOasHex) && (MachO || Obj.isIR())) {
711 darwinPrintSymbol(Obj, I, SymbolAddrStr, printBlanks, printDashes,
712 printFormat);
713 } else if (OutputFormat == posix) {
714 outs() << I->Name << " " << I->TypeChar << " ";
715 if (MachO)
716 outs() << SymbolAddrStr << " " << "0" /* SymbolSizeStr */ << "\n";
717 else
718 outs() << SymbolAddrStr << " " << SymbolSizeStr << "\n";
719 } else if (OutputFormat == bsd || (OutputFormat == darwin && !MachO)) {
720 if (PrintAddress)
721 outs() << SymbolAddrStr << ' ';
722 if (PrintSize) {
723 outs() << SymbolSizeStr;
724 outs() << ' ';
725 }
726 outs() << I->TypeChar;
727 if (I->TypeChar == '-' && MachO)
728 darwinPrintStab(MachO, I);
729 outs() << " " << I->Name << "\n";
730 } else if (OutputFormat == sysv) {
731 std::string PaddedName(I->Name);
732 while (PaddedName.length() < 20)
733 PaddedName += " ";
734 outs() << PaddedName << "|" << SymbolAddrStr << "| " << I->TypeChar
735 << " | |" << SymbolSizeStr << "| |\n";
736 }
737 }
738
739 SymbolList.clear();
740 }
741
getSymbolNMTypeChar(ELFObjectFileBase & Obj,basic_symbol_iterator I)742 static char getSymbolNMTypeChar(ELFObjectFileBase &Obj,
743 basic_symbol_iterator I) {
744 // OK, this is ELF
745 elf_symbol_iterator SymI(I);
746
747 Expected<elf_section_iterator> SecIOrErr = SymI->getSection();
748 if (!SecIOrErr) {
749 consumeError(SecIOrErr.takeError());
750 return '?';
751 }
752
753 elf_section_iterator SecI = *SecIOrErr;
754 if (SecI != Obj.section_end()) {
755 switch (SecI->getType()) {
756 case ELF::SHT_PROGBITS:
757 case ELF::SHT_DYNAMIC:
758 switch (SecI->getFlags()) {
759 case (ELF::SHF_ALLOC | ELF::SHF_EXECINSTR):
760 return 't';
761 case (ELF::SHF_TLS | ELF::SHF_ALLOC | ELF::SHF_WRITE):
762 case (ELF::SHF_ALLOC | ELF::SHF_WRITE):
763 return 'd';
764 case ELF::SHF_ALLOC:
765 case (ELF::SHF_ALLOC | ELF::SHF_MERGE):
766 case (ELF::SHF_ALLOC | ELF::SHF_MERGE | ELF::SHF_STRINGS):
767 return 'r';
768 }
769 break;
770 case ELF::SHT_NOBITS:
771 return 'b';
772 }
773 }
774
775 if (SymI->getELFType() == ELF::STT_SECTION) {
776 Expected<StringRef> Name = SymI->getName();
777 if (!Name) {
778 consumeError(Name.takeError());
779 return '?';
780 }
781 return StringSwitch<char>(*Name)
782 .StartsWith(".debug", 'N')
783 .StartsWith(".note", 'n')
784 .Default('?');
785 }
786
787 return 'n';
788 }
789
getSymbolNMTypeChar(COFFObjectFile & Obj,symbol_iterator I)790 static char getSymbolNMTypeChar(COFFObjectFile &Obj, symbol_iterator I) {
791 COFFSymbolRef Symb = Obj.getCOFFSymbol(*I);
792 // OK, this is COFF.
793 symbol_iterator SymI(I);
794
795 Expected<StringRef> Name = SymI->getName();
796 if (!Name) {
797 consumeError(Name.takeError());
798 return '?';
799 }
800
801 char Ret = StringSwitch<char>(*Name)
802 .StartsWith(".debug", 'N')
803 .StartsWith(".sxdata", 'N')
804 .Default('?');
805
806 if (Ret != '?')
807 return Ret;
808
809 uint32_t Characteristics = 0;
810 if (!COFF::isReservedSectionNumber(Symb.getSectionNumber())) {
811 Expected<section_iterator> SecIOrErr = SymI->getSection();
812 if (!SecIOrErr) {
813 consumeError(SecIOrErr.takeError());
814 return '?';
815 }
816 section_iterator SecI = *SecIOrErr;
817 const coff_section *Section = Obj.getCOFFSection(*SecI);
818 Characteristics = Section->Characteristics;
819 }
820
821 switch (Symb.getSectionNumber()) {
822 case COFF::IMAGE_SYM_DEBUG:
823 return 'n';
824 default:
825 // Check section type.
826 if (Characteristics & COFF::IMAGE_SCN_CNT_CODE)
827 return 't';
828 if (Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA)
829 return Characteristics & COFF::IMAGE_SCN_MEM_WRITE ? 'd' : 'r';
830 if (Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA)
831 return 'b';
832 if (Characteristics & COFF::IMAGE_SCN_LNK_INFO)
833 return 'i';
834 // Check for section symbol.
835 if (Symb.isSectionDefinition())
836 return 's';
837 }
838
839 return '?';
840 }
841
getSymbolNMTypeChar(MachOObjectFile & Obj,basic_symbol_iterator I)842 static char getSymbolNMTypeChar(MachOObjectFile &Obj, basic_symbol_iterator I) {
843 DataRefImpl Symb = I->getRawDataRefImpl();
844 uint8_t NType = Obj.is64Bit() ? Obj.getSymbol64TableEntry(Symb).n_type
845 : Obj.getSymbolTableEntry(Symb).n_type;
846
847 if (NType & MachO::N_STAB)
848 return '-';
849
850 switch (NType & MachO::N_TYPE) {
851 case MachO::N_ABS:
852 return 's';
853 case MachO::N_INDR:
854 return 'i';
855 case MachO::N_SECT: {
856 Expected<section_iterator> SecOrErr = Obj.getSymbolSection(Symb);
857 if (!SecOrErr) {
858 consumeError(SecOrErr.takeError());
859 return 's';
860 }
861 section_iterator Sec = *SecOrErr;
862 DataRefImpl Ref = Sec->getRawDataRefImpl();
863 StringRef SectionName;
864 Obj.getSectionName(Ref, SectionName);
865 StringRef SegmentName = Obj.getSectionFinalSegmentName(Ref);
866 if (SegmentName == "__TEXT" && SectionName == "__text")
867 return 't';
868 if (SegmentName == "__DATA" && SectionName == "__data")
869 return 'd';
870 if (SegmentName == "__DATA" && SectionName == "__bss")
871 return 'b';
872 return 's';
873 }
874 }
875
876 return '?';
877 }
878
getSymbolNMTypeChar(const GlobalValue & GV)879 static char getSymbolNMTypeChar(const GlobalValue &GV) {
880 // FIXME: should we print 'b'? At the IR level we cannot be sure if this
881 // will be in bss or not, but we could approximate.
882 return GV.getValueType()->isFunctionTy() ? 't' : 'd';
883 }
884
getSymbolNMTypeChar(IRObjectFile & Obj,basic_symbol_iterator I)885 static char getSymbolNMTypeChar(IRObjectFile &Obj, basic_symbol_iterator I) {
886 const GlobalValue *GV = Obj.getSymbolGV(I->getRawDataRefImpl());
887 return !GV ? 't' : getSymbolNMTypeChar(*GV);
888 }
889
isObject(SymbolicFile & Obj,basic_symbol_iterator I)890 static bool isObject(SymbolicFile &Obj, basic_symbol_iterator I) {
891 return !dyn_cast<ELFObjectFileBase>(&Obj)
892 ? false
893 : elf_symbol_iterator(I)->getELFType() == ELF::STT_OBJECT;
894 }
895
getNMTypeChar(SymbolicFile & Obj,basic_symbol_iterator I)896 static char getNMTypeChar(SymbolicFile &Obj, basic_symbol_iterator I) {
897 uint32_t Symflags = I->getFlags();
898 if ((Symflags & object::SymbolRef::SF_Weak) && !isa<MachOObjectFile>(Obj)) {
899 char Ret = isObject(Obj, I) ? 'v' : 'w';
900 return (!(Symflags & object::SymbolRef::SF_Undefined)) ? toupper(Ret) : Ret;
901 }
902
903 if (Symflags & object::SymbolRef::SF_Undefined)
904 return 'U';
905
906 if (Symflags & object::SymbolRef::SF_Common)
907 return 'C';
908
909 char Ret = '?';
910 if (Symflags & object::SymbolRef::SF_Absolute)
911 Ret = 'a';
912 else if (IRObjectFile *IR = dyn_cast<IRObjectFile>(&Obj)) {
913 Ret = getSymbolNMTypeChar(*IR, I);
914 Triple Host(sys::getDefaultTargetTriple());
915 if (Ret == 'd' && Host.isOSDarwin() && Symflags & SymbolRef::SF_Const)
916 Ret = 's';
917 }
918 else if (COFFObjectFile *COFF = dyn_cast<COFFObjectFile>(&Obj))
919 Ret = getSymbolNMTypeChar(*COFF, I);
920 else if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj))
921 Ret = getSymbolNMTypeChar(*MachO, I);
922 else
923 Ret = getSymbolNMTypeChar(cast<ELFObjectFileBase>(Obj), I);
924
925 if (Symflags & object::SymbolRef::SF_Global)
926 Ret = toupper(Ret);
927
928 return Ret;
929 }
930
931 // getNsectForSegSect() is used to implement the Mach-O "-s segname sectname"
932 // option to dump only those symbols from that section in a Mach-O file.
933 // It is called once for each Mach-O file from dumpSymbolNamesFromObject()
934 // to get the section number for that named section from the command line
935 // arguments. It returns the section number for that section in the Mach-O
936 // file or zero it is not present.
getNsectForSegSect(MachOObjectFile * Obj)937 static unsigned getNsectForSegSect(MachOObjectFile *Obj) {
938 unsigned Nsect = 1;
939 for (auto &S : Obj->sections()) {
940 DataRefImpl Ref = S.getRawDataRefImpl();
941 StringRef SectionName;
942 Obj->getSectionName(Ref, SectionName);
943 StringRef SegmentName = Obj->getSectionFinalSegmentName(Ref);
944 if (SegmentName == SegSect[0] && SectionName == SegSect[1])
945 return Nsect;
946 Nsect++;
947 }
948 return 0;
949 }
950
951 // getNsectInMachO() is used to implement the Mach-O "-s segname sectname"
952 // option to dump only those symbols from that section in a Mach-O file.
953 // It is called once for each symbol in a Mach-O file from
954 // dumpSymbolNamesFromObject() and returns the section number for that symbol
955 // if it is in a section, else it returns 0.
getNsectInMachO(MachOObjectFile & Obj,BasicSymbolRef Sym)956 static unsigned getNsectInMachO(MachOObjectFile &Obj, BasicSymbolRef Sym) {
957 DataRefImpl Symb = Sym.getRawDataRefImpl();
958 if (Obj.is64Bit()) {
959 MachO::nlist_64 STE = Obj.getSymbol64TableEntry(Symb);
960 return (STE.n_type & MachO::N_TYPE) == MachO::N_SECT ? STE.n_sect : 0;
961 }
962 MachO::nlist STE = Obj.getSymbolTableEntry(Symb);
963 return (STE.n_type & MachO::N_TYPE) == MachO::N_SECT ? STE.n_sect : 0;
964 }
965
966 static void
dumpSymbolNamesFromObject(SymbolicFile & Obj,bool printName,const std::string & ArchiveName=std::string (),const std::string & ArchitectureName=std::string ())967 dumpSymbolNamesFromObject(SymbolicFile &Obj, bool printName,
968 const std::string &ArchiveName = std::string(),
969 const std::string &ArchitectureName = std::string()) {
970 auto Symbols = Obj.symbols();
971 if (DynamicSyms) {
972 const auto *E = dyn_cast<ELFObjectFileBase>(&Obj);
973 if (!E) {
974 error("File format has no dynamic symbol table", Obj.getFileName());
975 return;
976 }
977 auto DynSymbols = E->getDynamicSymbolIterators();
978 Symbols =
979 make_range<basic_symbol_iterator>(DynSymbols.begin(), DynSymbols.end());
980 }
981 std::string NameBuffer;
982 raw_string_ostream OS(NameBuffer);
983 // If a "-s segname sectname" option was specified and this is a Mach-O
984 // file get the section number for that section in this object file.
985 unsigned int Nsect = 0;
986 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(&Obj);
987 if (SegSect.size() != 0 && MachO) {
988 Nsect = getNsectForSegSect(MachO);
989 // If this section is not in the object file no symbols are printed.
990 if (Nsect == 0)
991 return;
992 }
993 for (BasicSymbolRef Sym : Symbols) {
994 uint32_t SymFlags = Sym.getFlags();
995 if (!DebugSyms && (SymFlags & SymbolRef::SF_FormatSpecific))
996 continue;
997 if (WithoutAliases) {
998 if (IRObjectFile *IR = dyn_cast<IRObjectFile>(&Obj)) {
999 const GlobalValue *GV = IR->getSymbolGV(Sym.getRawDataRefImpl());
1000 if (GV && isa<GlobalAlias>(GV))
1001 continue;
1002 }
1003 }
1004 // If a "-s segname sectname" option was specified and this is a Mach-O
1005 // file and this section appears in this file, Nsect will be non-zero then
1006 // see if this symbol is a symbol from that section and if not skip it.
1007 if (Nsect && Nsect != getNsectInMachO(*MachO, Sym))
1008 continue;
1009 NMSymbol S;
1010 S.Size = 0;
1011 S.Address = 0;
1012 if (PrintSize) {
1013 if (isa<ELFObjectFileBase>(&Obj))
1014 S.Size = ELFSymbolRef(Sym).getSize();
1015 }
1016 if (PrintAddress && isa<ObjectFile>(Obj)) {
1017 SymbolRef SymRef(Sym);
1018 Expected<uint64_t> AddressOrErr = SymRef.getAddress();
1019 if (!AddressOrErr) {
1020 consumeError(AddressOrErr.takeError());
1021 break;
1022 }
1023 S.Address = *AddressOrErr;
1024 }
1025 S.TypeChar = getNMTypeChar(Obj, Sym);
1026 std::error_code EC = Sym.printName(OS);
1027 if (EC && MachO)
1028 OS << "bad string index";
1029 else
1030 error(EC);
1031 OS << '\0';
1032 S.Sym = Sym;
1033 SymbolList.push_back(S);
1034 }
1035
1036 OS.flush();
1037 const char *P = NameBuffer.c_str();
1038 for (unsigned I = 0; I < SymbolList.size(); ++I) {
1039 SymbolList[I].Name = P;
1040 P += strlen(P) + 1;
1041 }
1042
1043 CurrentFilename = Obj.getFileName();
1044 sortAndPrintSymbolList(Obj, printName, ArchiveName, ArchitectureName);
1045 }
1046
1047 // checkMachOAndArchFlags() checks to see if the SymbolicFile is a Mach-O file
1048 // and if it is and there is a list of architecture flags is specified then
1049 // check to make sure this Mach-O file is one of those architectures or all
1050 // architectures was specificed. If not then an error is generated and this
1051 // routine returns false. Else it returns true.
checkMachOAndArchFlags(SymbolicFile * O,std::string & Filename)1052 static bool checkMachOAndArchFlags(SymbolicFile *O, std::string &Filename) {
1053 MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O);
1054
1055 if (!MachO || ArchAll || ArchFlags.size() == 0)
1056 return true;
1057
1058 MachO::mach_header H;
1059 MachO::mach_header_64 H_64;
1060 Triple T;
1061 if (MachO->is64Bit()) {
1062 H_64 = MachO->MachOObjectFile::getHeader64();
1063 T = MachOObjectFile::getArchTriple(H_64.cputype, H_64.cpusubtype);
1064 } else {
1065 H = MachO->MachOObjectFile::getHeader();
1066 T = MachOObjectFile::getArchTriple(H.cputype, H.cpusubtype);
1067 }
1068 if (std::none_of(
1069 ArchFlags.begin(), ArchFlags.end(),
1070 [&](const std::string &Name) { return Name == T.getArchName(); })) {
1071 error("No architecture specified", Filename);
1072 return false;
1073 }
1074 return true;
1075 }
1076
dumpSymbolNamesFromFile(std::string & Filename)1077 static void dumpSymbolNamesFromFile(std::string &Filename) {
1078 ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
1079 MemoryBuffer::getFileOrSTDIN(Filename);
1080 if (error(BufferOrErr.getError(), Filename))
1081 return;
1082
1083 LLVMContext Context;
1084 Expected<std::unique_ptr<Binary>> BinaryOrErr = createBinary(
1085 BufferOrErr.get()->getMemBufferRef(), NoLLVMBitcode ? nullptr : &Context);
1086 if (!BinaryOrErr) {
1087 error(errorToErrorCode(BinaryOrErr.takeError()), Filename);
1088 return;
1089 }
1090 Binary &Bin = *BinaryOrErr.get();
1091
1092 if (Archive *A = dyn_cast<Archive>(&Bin)) {
1093 if (ArchiveMap) {
1094 Archive::symbol_iterator I = A->symbol_begin();
1095 Archive::symbol_iterator E = A->symbol_end();
1096 if (I != E) {
1097 outs() << "Archive map\n";
1098 for (; I != E; ++I) {
1099 ErrorOr<Archive::Child> C = I->getMember();
1100 if (error(C.getError()))
1101 return;
1102 ErrorOr<StringRef> FileNameOrErr = C->getName();
1103 if (error(FileNameOrErr.getError()))
1104 return;
1105 StringRef SymName = I->getName();
1106 outs() << SymName << " in " << FileNameOrErr.get() << "\n";
1107 }
1108 outs() << "\n";
1109 }
1110 }
1111
1112 {
1113 Error Err;
1114 for (auto &C : A->children(Err)) {
1115 Expected<std::unique_ptr<Binary>> ChildOrErr = C.getAsBinary(&Context);
1116 if (!ChildOrErr) {
1117 if (auto E = isNotObjectErrorInvalidFileType(ChildOrErr.takeError()))
1118 error(std::move(E), Filename, C);
1119 continue;
1120 }
1121 if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
1122 if (!checkMachOAndArchFlags(O, Filename))
1123 return;
1124 if (!PrintFileName) {
1125 outs() << "\n";
1126 if (isa<MachOObjectFile>(O)) {
1127 outs() << Filename << "(" << O->getFileName() << ")";
1128 } else
1129 outs() << O->getFileName();
1130 outs() << ":\n";
1131 }
1132 dumpSymbolNamesFromObject(*O, false, Filename);
1133 }
1134 }
1135 if (Err)
1136 error(std::move(Err), A->getFileName());
1137 }
1138 return;
1139 }
1140 if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(&Bin)) {
1141 // If we have a list of architecture flags specified dump only those.
1142 if (!ArchAll && ArchFlags.size() != 0) {
1143 // Look for a slice in the universal binary that matches each ArchFlag.
1144 bool ArchFound;
1145 for (unsigned i = 0; i < ArchFlags.size(); ++i) {
1146 ArchFound = false;
1147 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1148 E = UB->end_objects();
1149 I != E; ++I) {
1150 if (ArchFlags[i] == I->getArchTypeName()) {
1151 ArchFound = true;
1152 Expected<std::unique_ptr<ObjectFile>> ObjOrErr =
1153 I->getAsObjectFile();
1154 std::string ArchiveName;
1155 std::string ArchitectureName;
1156 ArchiveName.clear();
1157 ArchitectureName.clear();
1158 if (ObjOrErr) {
1159 ObjectFile &Obj = *ObjOrErr.get();
1160 if (ArchFlags.size() > 1) {
1161 if (PrintFileName)
1162 ArchitectureName = I->getArchTypeName();
1163 else
1164 outs() << "\n" << Obj.getFileName() << " (for architecture "
1165 << I->getArchTypeName() << ")"
1166 << ":\n";
1167 }
1168 dumpSymbolNamesFromObject(Obj, false, ArchiveName,
1169 ArchitectureName);
1170 } else if (auto E = isNotObjectErrorInvalidFileType(
1171 ObjOrErr.takeError())) {
1172 error(std::move(E), Filename, ArchFlags.size() > 1 ?
1173 StringRef(I->getArchTypeName()) : StringRef());
1174 continue;
1175 } else if (Expected<std::unique_ptr<Archive>> AOrErr =
1176 I->getAsArchive()) {
1177 std::unique_ptr<Archive> &A = *AOrErr;
1178 Error Err;
1179 for (auto &C : A->children(Err)) {
1180 Expected<std::unique_ptr<Binary>> ChildOrErr =
1181 C.getAsBinary(&Context);
1182 if (!ChildOrErr) {
1183 if (auto E = isNotObjectErrorInvalidFileType(
1184 ChildOrErr.takeError())) {
1185 error(std::move(E), Filename, C, ArchFlags.size() > 1 ?
1186 StringRef(I->getArchTypeName()) : StringRef());
1187 }
1188 continue;
1189 }
1190 if (SymbolicFile *O =
1191 dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
1192 if (PrintFileName) {
1193 ArchiveName = A->getFileName();
1194 if (ArchFlags.size() > 1)
1195 ArchitectureName = I->getArchTypeName();
1196 } else {
1197 outs() << "\n" << A->getFileName();
1198 outs() << "(" << O->getFileName() << ")";
1199 if (ArchFlags.size() > 1) {
1200 outs() << " (for architecture " << I->getArchTypeName()
1201 << ")";
1202 }
1203 outs() << ":\n";
1204 }
1205 dumpSymbolNamesFromObject(*O, false, ArchiveName,
1206 ArchitectureName);
1207 }
1208 }
1209 if (Err)
1210 error(std::move(Err), A->getFileName());
1211 } else {
1212 consumeError(AOrErr.takeError());
1213 error(Filename + " for architecture " +
1214 StringRef(I->getArchTypeName()) +
1215 " is not a Mach-O file or an archive file",
1216 "Mach-O universal file");
1217 }
1218 }
1219 }
1220 if (!ArchFound) {
1221 error(ArchFlags[i],
1222 "file: " + Filename + " does not contain architecture");
1223 return;
1224 }
1225 }
1226 return;
1227 }
1228 // No architecture flags were specified so if this contains a slice that
1229 // matches the host architecture dump only that.
1230 if (!ArchAll) {
1231 StringRef HostArchName = MachOObjectFile::getHostArch().getArchName();
1232 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1233 E = UB->end_objects();
1234 I != E; ++I) {
1235 if (HostArchName == I->getArchTypeName()) {
1236 Expected<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
1237 std::string ArchiveName;
1238 ArchiveName.clear();
1239 if (ObjOrErr) {
1240 ObjectFile &Obj = *ObjOrErr.get();
1241 dumpSymbolNamesFromObject(Obj, false);
1242 } else if (auto E = isNotObjectErrorInvalidFileType(
1243 ObjOrErr.takeError())) {
1244 error(std::move(E), Filename);
1245 return;
1246 } else if (Expected<std::unique_ptr<Archive>> AOrErr =
1247 I->getAsArchive()) {
1248 std::unique_ptr<Archive> &A = *AOrErr;
1249 Error Err;
1250 for (auto &C : A->children(Err)) {
1251 Expected<std::unique_ptr<Binary>> ChildOrErr =
1252 C.getAsBinary(&Context);
1253 if (!ChildOrErr) {
1254 if (auto E = isNotObjectErrorInvalidFileType(
1255 ChildOrErr.takeError()))
1256 error(std::move(E), Filename, C);
1257 continue;
1258 }
1259 if (SymbolicFile *O =
1260 dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
1261 if (PrintFileName)
1262 ArchiveName = A->getFileName();
1263 else
1264 outs() << "\n" << A->getFileName() << "(" << O->getFileName()
1265 << ")"
1266 << ":\n";
1267 dumpSymbolNamesFromObject(*O, false, ArchiveName);
1268 }
1269 }
1270 if (Err)
1271 error(std::move(Err), A->getFileName());
1272 } else {
1273 consumeError(AOrErr.takeError());
1274 error(Filename + " for architecture " +
1275 StringRef(I->getArchTypeName()) +
1276 " is not a Mach-O file or an archive file",
1277 "Mach-O universal file");
1278 }
1279 return;
1280 }
1281 }
1282 }
1283 // Either all architectures have been specified or none have been specified
1284 // and this does not contain the host architecture so dump all the slices.
1285 bool moreThanOneArch = UB->getNumberOfObjects() > 1;
1286 for (MachOUniversalBinary::object_iterator I = UB->begin_objects(),
1287 E = UB->end_objects();
1288 I != E; ++I) {
1289 Expected<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile();
1290 std::string ArchiveName;
1291 std::string ArchitectureName;
1292 ArchiveName.clear();
1293 ArchitectureName.clear();
1294 if (ObjOrErr) {
1295 ObjectFile &Obj = *ObjOrErr.get();
1296 if (PrintFileName) {
1297 if (isa<MachOObjectFile>(Obj) && moreThanOneArch)
1298 ArchitectureName = I->getArchTypeName();
1299 } else {
1300 if (moreThanOneArch)
1301 outs() << "\n";
1302 outs() << Obj.getFileName();
1303 if (isa<MachOObjectFile>(Obj) && moreThanOneArch)
1304 outs() << " (for architecture " << I->getArchTypeName() << ")";
1305 outs() << ":\n";
1306 }
1307 dumpSymbolNamesFromObject(Obj, false, ArchiveName, ArchitectureName);
1308 } else if (auto E = isNotObjectErrorInvalidFileType(
1309 ObjOrErr.takeError())) {
1310 error(std::move(E), Filename, moreThanOneArch ?
1311 StringRef(I->getArchTypeName()) : StringRef());
1312 continue;
1313 } else if (Expected<std::unique_ptr<Archive>> AOrErr =
1314 I->getAsArchive()) {
1315 std::unique_ptr<Archive> &A = *AOrErr;
1316 Error Err;
1317 for (auto &C : A->children(Err)) {
1318 Expected<std::unique_ptr<Binary>> ChildOrErr =
1319 C.getAsBinary(&Context);
1320 if (!ChildOrErr) {
1321 if (auto E = isNotObjectErrorInvalidFileType(
1322 ChildOrErr.takeError()))
1323 error(std::move(E), Filename, C, moreThanOneArch ?
1324 StringRef(ArchitectureName) : StringRef());
1325 continue;
1326 }
1327 if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) {
1328 if (PrintFileName) {
1329 ArchiveName = A->getFileName();
1330 if (isa<MachOObjectFile>(O) && moreThanOneArch)
1331 ArchitectureName = I->getArchTypeName();
1332 } else {
1333 outs() << "\n" << A->getFileName();
1334 if (isa<MachOObjectFile>(O)) {
1335 outs() << "(" << O->getFileName() << ")";
1336 if (moreThanOneArch)
1337 outs() << " (for architecture " << I->getArchTypeName()
1338 << ")";
1339 } else
1340 outs() << ":" << O->getFileName();
1341 outs() << ":\n";
1342 }
1343 dumpSymbolNamesFromObject(*O, false, ArchiveName, ArchitectureName);
1344 }
1345 }
1346 if (Err)
1347 error(std::move(Err), A->getFileName());
1348 } else {
1349 consumeError(AOrErr.takeError());
1350 error(Filename + " for architecture " +
1351 StringRef(I->getArchTypeName()) +
1352 " is not a Mach-O file or an archive file",
1353 "Mach-O universal file");
1354 }
1355 }
1356 return;
1357 }
1358 if (SymbolicFile *O = dyn_cast<SymbolicFile>(&Bin)) {
1359 if (!checkMachOAndArchFlags(O, Filename))
1360 return;
1361 dumpSymbolNamesFromObject(*O, true);
1362 }
1363 }
1364
main(int argc,char ** argv)1365 int main(int argc, char **argv) {
1366 // Print a stack trace if we signal out.
1367 sys::PrintStackTraceOnErrorSignal(argv[0]);
1368 PrettyStackTraceProgram X(argc, argv);
1369
1370 llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
1371 cl::ParseCommandLineOptions(argc, argv, "llvm symbol table dumper\n");
1372
1373 // llvm-nm only reads binary files.
1374 if (error(sys::ChangeStdinToBinary()))
1375 return 1;
1376
1377 // These calls are needed so that we can read bitcode correctly.
1378 llvm::InitializeAllTargetInfos();
1379 llvm::InitializeAllTargetMCs();
1380 llvm::InitializeAllAsmParsers();
1381
1382 ToolName = argv[0];
1383 if (BSDFormat)
1384 OutputFormat = bsd;
1385 if (POSIXFormat)
1386 OutputFormat = posix;
1387 if (DarwinFormat)
1388 OutputFormat = darwin;
1389
1390 // The relative order of these is important. If you pass --size-sort it should
1391 // only print out the size. However, if you pass -S --size-sort, it should
1392 // print out both the size and address.
1393 if (SizeSort && !PrintSize)
1394 PrintAddress = false;
1395 if (OutputFormat == sysv || SizeSort)
1396 PrintSize = true;
1397 if (InputFilenames.empty())
1398 InputFilenames.push_back("a.out");
1399 if (InputFilenames.size() > 1)
1400 MultipleFiles = true;
1401
1402 for (unsigned i = 0; i < ArchFlags.size(); ++i) {
1403 if (ArchFlags[i] == "all") {
1404 ArchAll = true;
1405 } else {
1406 if (!MachOObjectFile::isValidArch(ArchFlags[i]))
1407 error("Unknown architecture named '" + ArchFlags[i] + "'",
1408 "for the -arch option");
1409 }
1410 }
1411
1412 if (SegSect.size() != 0 && SegSect.size() != 2)
1413 error("bad number of arguments (must be two arguments)",
1414 "for the -s option");
1415
1416 std::for_each(InputFilenames.begin(), InputFilenames.end(),
1417 dumpSymbolNamesFromFile);
1418
1419 if (HadError)
1420 return 1;
1421 }
1422