← Back to branch summary

~pali/+junk/llvm-toolchain-3.7

« back to all changes in this revision

Viewing changes to tools/llvm-nm/llvm-nm.cpp

  • Committer: Package Import Robot
  • Author(s): Sylvestre Ledru
  • Date: 2015-07-15 17:51:08 UTC
  • Revision ID: package-import@ubuntu.com-20150715175108-l8mynwovkx4zx697
Tags: upstream-3.7~+rc2
Import upstream version 3.7~+rc2

Show diffs side-by-side

added added

removed removed

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