Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 1 | //===-- llvm-nm.cpp - Symbol table dumping utility for llvm ---------------===// |
Misha Brukman | 650ba8e | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | 09344dc | 2003-10-20 17:47:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 345353d | 2007-12-29 20:44:31 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | 650ba8e | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | 09344dc | 2003-10-20 17:47:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 9 | // |
Michael J. Spencer | 838e5ad | 2012-06-06 23:34:10 +0000 | [diff] [blame] | 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. |
Misha Brukman | 650ba8e | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 13 | // |
Michael J. Spencer | 838e5ad | 2012-06-06 23:34:10 +0000 | [diff] [blame] | 14 | // This "nm" supports many of the features of GNU "nm", including its different |
| 15 | // output formats. |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 16 | // |
| 17 | //===----------------------------------------------------------------------===// |
| 18 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 19 | #include "llvm/IR/Function.h" |
| 20 | #include "llvm/IR/GlobalAlias.h" |
| 21 | #include "llvm/IR/GlobalVariable.h" |
Chandler Carruth | 9fb823b | 2013-01-02 11:36:10 +0000 | [diff] [blame] | 22 | #include "llvm/IR/LLVMContext.h" |
Michael J. Spencer | 2bc774a | 2011-09-27 19:37:18 +0000 | [diff] [blame] | 23 | #include "llvm/Object/Archive.h" |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 24 | #include "llvm/Object/COFF.h" |
| 25 | #include "llvm/Object/ELFObjectFile.h" |
Chandler Carruth | 442f784 | 2014-03-04 10:07:28 +0000 | [diff] [blame] | 26 | #include "llvm/Object/IRObjectFile.h" |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 27 | #include "llvm/Object/MachO.h" |
Alexey Samsonov | e6388e6 | 2013-06-18 15:03:28 +0000 | [diff] [blame] | 28 | #include "llvm/Object/MachOUniversal.h" |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 29 | #include "llvm/Object/ObjectFile.h" |
Rui Ueyama | f078eff | 2014-03-18 23:37:53 +0000 | [diff] [blame] | 30 | #include "llvm/Support/COFF.h" |
Reid Spencer | 7c16caa | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 31 | #include "llvm/Support/CommandLine.h" |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 32 | #include "llvm/Support/FileSystem.h" |
Chandler Carruth | 4d88a1c | 2012-12-04 10:44:52 +0000 | [diff] [blame] | 33 | #include "llvm/Support/Format.h" |
Chris Lattner | 76d4632 | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 34 | #include "llvm/Support/ManagedStatic.h" |
Chris Lattner | ef8f389 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 35 | #include "llvm/Support/MemoryBuffer.h" |
Chris Lattner | e3fc2d1 | 2009-03-06 05:34:10 +0000 | [diff] [blame] | 36 | #include "llvm/Support/PrettyStackTrace.h" |
Michael J. Spencer | bc96f37 | 2011-12-13 23:17:29 +0000 | [diff] [blame] | 37 | #include "llvm/Support/Program.h" |
Michael J. Spencer | 447762d | 2010-11-29 18:16:10 +0000 | [diff] [blame] | 38 | #include "llvm/Support/Signals.h" |
Chandler Carruth | 4d88a1c | 2012-12-04 10:44:52 +0000 | [diff] [blame] | 39 | #include "llvm/Support/raw_ostream.h" |
Jeff Cohen | b622c11 | 2007-03-05 00:00:42 +0000 | [diff] [blame] | 40 | #include <algorithm> |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 41 | #include <cctype> |
Alkis Evlogimenos | f68f40e | 2004-04-21 16:11:40 +0000 | [diff] [blame] | 42 | #include <cerrno> |
Brian Gaeke | 55447b4 | 2003-11-19 21:52:09 +0000 | [diff] [blame] | 43 | #include <cstring> |
Rafael Espindola | a6e9c3e | 2014-06-12 17:38:55 +0000 | [diff] [blame] | 44 | #include <system_error> |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 45 | #include <vector> |
Brian Gaeke | 960707c | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 46 | using namespace llvm; |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 47 | using namespace object; |
Brian Gaeke | 960707c | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 48 | |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 49 | namespace { |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 50 | enum OutputFormatTy { bsd, sysv, posix, darwin }; |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 51 | cl::opt<OutputFormatTy> OutputFormat( |
| 52 | "format", cl::desc("Specify output format"), |
| 53 | cl::values(clEnumVal(bsd, "BSD format"), clEnumVal(sysv, "System V format"), |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 54 | clEnumVal(posix, "POSIX.2 format"), |
| 55 | clEnumVal(darwin, "Darwin -m format"), clEnumValEnd), |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 56 | cl::init(bsd)); |
| 57 | cl::alias OutputFormat2("f", cl::desc("Alias for --format"), |
| 58 | cl::aliasopt(OutputFormat)); |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 59 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 60 | cl::list<std::string> InputFilenames(cl::Positional, cl::desc("<input files>"), |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 61 | cl::ZeroOrMore); |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 62 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 63 | cl::opt<bool> UndefinedOnly("undefined-only", |
| 64 | cl::desc("Show only undefined symbols")); |
| 65 | cl::alias UndefinedOnly2("u", cl::desc("Alias for --undefined-only"), |
| 66 | cl::aliasopt(UndefinedOnly)); |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 67 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 68 | cl::opt<bool> DynamicSyms("dynamic", |
| 69 | cl::desc("Display the dynamic symbols instead " |
| 70 | "of normal symbols.")); |
| 71 | cl::alias DynamicSyms2("D", cl::desc("Alias for --dynamic"), |
| 72 | cl::aliasopt(DynamicSyms)); |
Michael J. Spencer | 8c4729f | 2012-02-28 00:40:37 +0000 | [diff] [blame] | 73 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 74 | cl::opt<bool> DefinedOnly("defined-only", |
| 75 | cl::desc("Show only defined symbols")); |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 76 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 77 | cl::opt<bool> ExternalOnly("extern-only", |
| 78 | cl::desc("Show only external symbols")); |
| 79 | cl::alias ExternalOnly2("g", cl::desc("Alias for --extern-only"), |
| 80 | cl::aliasopt(ExternalOnly)); |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 81 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 82 | cl::opt<bool> BSDFormat("B", cl::desc("Alias for --format=bsd")); |
| 83 | cl::opt<bool> POSIXFormat("P", cl::desc("Alias for --format=posix")); |
Kevin Enderby | 14a96ac | 2014-06-20 00:04:16 +0000 | [diff] [blame] | 84 | cl::opt<bool> DarwinFormat("m", cl::desc("Alias for --format=darwin")); |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 85 | |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 86 | static cl::list<std::string> |
| 87 | ArchFlags("arch", cl::desc("architecture(s) from a Mach-O file to dump"), |
| 88 | cl::ZeroOrMore); |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 89 | bool ArchAll = false; |
| 90 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 91 | cl::opt<bool> PrintFileName( |
| 92 | "print-file-name", |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 93 | cl::desc("Precede each symbol with the object file it came from")); |
| 94 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 95 | cl::alias PrintFileNameA("A", cl::desc("Alias for --print-file-name"), |
| 96 | cl::aliasopt(PrintFileName)); |
| 97 | cl::alias PrintFileNameo("o", cl::desc("Alias for --print-file-name"), |
| 98 | cl::aliasopt(PrintFileName)); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 99 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 100 | cl::opt<bool> DebugSyms("debug-syms", |
| 101 | cl::desc("Show all symbols, even debugger only")); |
| 102 | cl::alias DebugSymsa("a", cl::desc("Alias for --debug-syms"), |
| 103 | cl::aliasopt(DebugSyms)); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 104 | |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 105 | cl::opt<bool> NumericSort("numeric-sort", cl::desc("Sort symbols by address")); |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 106 | cl::alias NumericSortn("n", cl::desc("Alias for --numeric-sort"), |
| 107 | cl::aliasopt(NumericSort)); |
| 108 | cl::alias NumericSortv("v", cl::desc("Alias for --numeric-sort"), |
| 109 | cl::aliasopt(NumericSort)); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 110 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 111 | cl::opt<bool> NoSort("no-sort", cl::desc("Show symbols in order encountered")); |
| 112 | cl::alias NoSortp("p", cl::desc("Alias for --no-sort"), cl::aliasopt(NoSort)); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 113 | |
Kevin Enderby | 25a614b | 2014-07-02 23:23:58 +0000 | [diff] [blame^] | 114 | cl::opt<bool> ReverseSort("reverse-sort", cl::desc("Sort in reverse order")); |
| 115 | cl::alias ReverseSortr("r", cl::desc("Alias for --reverse-sort"), |
| 116 | cl::aliasopt(ReverseSort)); |
| 117 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 118 | cl::opt<bool> PrintSize("print-size", |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 119 | cl::desc("Show symbol size instead of address")); |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 120 | cl::alias PrintSizeS("S", cl::desc("Alias for --print-size"), |
| 121 | cl::aliasopt(PrintSize)); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 122 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 123 | cl::opt<bool> SizeSort("size-sort", cl::desc("Sort symbols by size")); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 124 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 125 | cl::opt<bool> WithoutAliases("without-aliases", cl::Hidden, |
| 126 | cl::desc("Exclude aliases from output")); |
Jan Sjödin | 4d0c299 | 2012-09-18 18:47:58 +0000 | [diff] [blame] | 127 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 128 | cl::opt<bool> ArchiveMap("print-armap", cl::desc("Print the archive map")); |
| 129 | cl::alias ArchiveMaps("s", cl::desc("Alias for --print-armap"), |
| 130 | cl::aliasopt(ArchiveMap)); |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 131 | bool PrintAddress = true; |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 132 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 133 | bool MultipleFiles = false; |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 134 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 135 | bool HadError = false; |
Rafael Espindola | 8b82a4d | 2013-07-03 15:46:03 +0000 | [diff] [blame] | 136 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 137 | std::string ToolName; |
Chris Lattner | aa237256 | 2006-05-24 17:04:05 +0000 | [diff] [blame] | 138 | } |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 139 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 140 | static void error(Twine Message, Twine Path = Twine()) { |
| 141 | HadError = true; |
| 142 | errs() << ToolName << ": " << Path << ": " << Message << ".\n"; |
Michael J. Spencer | bc96f37 | 2011-12-13 23:17:29 +0000 | [diff] [blame] | 143 | } |
| 144 | |
Rafael Espindola | 4453e4294 | 2014-06-13 03:07:50 +0000 | [diff] [blame] | 145 | static bool error(std::error_code EC, Twine Path = Twine()) { |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 146 | if (EC) { |
| 147 | error(EC.message(), Path); |
Michael J. Spencer | bc96f37 | 2011-12-13 23:17:29 +0000 | [diff] [blame] | 148 | return true; |
| 149 | } |
| 150 | return false; |
| 151 | } |
| 152 | |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 153 | namespace { |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 154 | struct NMSymbol { |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 155 | uint64_t Address; |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 156 | uint64_t Size; |
| 157 | char TypeChar; |
| 158 | StringRef Name; |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 159 | DataRefImpl Symb; |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 160 | }; |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 161 | } |
| 162 | |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 163 | static bool compareSymbolAddress(const NMSymbol &A, const NMSymbol &B) { |
Kevin Enderby | 25a614b | 2014-07-02 23:23:58 +0000 | [diff] [blame^] | 164 | if (!ReverseSort) { |
| 165 | if (A.Address < B.Address) |
| 166 | return true; |
| 167 | else if (A.Address == B.Address && A.Name < B.Name) |
| 168 | return true; |
| 169 | else if (A.Address == B.Address && A.Name == B.Name && A.Size < B.Size) |
| 170 | return true; |
| 171 | else |
| 172 | return false; |
| 173 | } else { |
| 174 | if (A.Address > B.Address) |
| 175 | return true; |
| 176 | else if (A.Address == B.Address && A.Name > B.Name) |
| 177 | return true; |
| 178 | else if (A.Address == B.Address && A.Name == B.Name && A.Size > B.Size) |
| 179 | return true; |
| 180 | else |
| 181 | return false; |
| 182 | } |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 183 | } |
| 184 | |
| 185 | static bool compareSymbolSize(const NMSymbol &A, const NMSymbol &B) { |
Kevin Enderby | 25a614b | 2014-07-02 23:23:58 +0000 | [diff] [blame^] | 186 | if (!ReverseSort) { |
| 187 | if (A.Size < B.Size) |
| 188 | return true; |
| 189 | else if (A.Size == B.Size && A.Name < B.Name) |
| 190 | return true; |
| 191 | else if (A.Size == B.Size && A.Name == B.Name && A.Address < B.Address) |
| 192 | return true; |
| 193 | else |
| 194 | return false; |
| 195 | } else { |
| 196 | if (A.Size > B.Size) |
| 197 | return true; |
| 198 | else if (A.Size == B.Size && A.Name > B.Name) |
| 199 | return true; |
| 200 | else if (A.Size == B.Size && A.Name == B.Name && A.Address > B.Address) |
| 201 | return true; |
| 202 | else |
| 203 | return false; |
| 204 | } |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | static bool compareSymbolName(const NMSymbol &A, const NMSymbol &B) { |
Kevin Enderby | 25a614b | 2014-07-02 23:23:58 +0000 | [diff] [blame^] | 208 | if (!ReverseSort) { |
| 209 | if (A.Name < B.Name) |
| 210 | return true; |
| 211 | else if (A.Name == B.Name && A.Size < B.Size) |
| 212 | return true; |
| 213 | else if (A.Name == B.Name && A.Size == B.Size && A.Address < B.Address) |
| 214 | return true; |
| 215 | else |
| 216 | return false; |
| 217 | } else { |
| 218 | if (A.Name > B.Name) |
| 219 | return true; |
| 220 | else if (A.Name == B.Name && A.Size > B.Size) |
| 221 | return true; |
| 222 | else if (A.Name == B.Name && A.Size == B.Size && A.Address > B.Address) |
| 223 | return true; |
| 224 | else |
| 225 | return false; |
| 226 | } |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 227 | } |
| 228 | |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 229 | static char isSymbolList64Bit(SymbolicFile *Obj) { |
Kevin Enderby | 15e2471 | 2014-05-12 20:45:00 +0000 | [diff] [blame] | 230 | if (isa<IRObjectFile>(Obj)) |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 231 | return false; |
Kevin Enderby | 15e2471 | 2014-05-12 20:45:00 +0000 | [diff] [blame] | 232 | else if (isa<COFFObjectFile>(Obj)) |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 233 | return false; |
| 234 | else if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(Obj)) |
| 235 | return MachO->is64Bit(); |
Kevin Enderby | 15e2471 | 2014-05-12 20:45:00 +0000 | [diff] [blame] | 236 | else if (isa<ELF32LEObjectFile>(Obj)) |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 237 | return false; |
Kevin Enderby | 15e2471 | 2014-05-12 20:45:00 +0000 | [diff] [blame] | 238 | else if (isa<ELF64LEObjectFile>(Obj)) |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 239 | return true; |
Kevin Enderby | 15e2471 | 2014-05-12 20:45:00 +0000 | [diff] [blame] | 240 | else if (isa<ELF32BEObjectFile>(Obj)) |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 241 | return false; |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 242 | else if (isa<ELF64BEObjectFile>(Obj)) |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 243 | return true; |
| 244 | else |
| 245 | return false; |
| 246 | } |
| 247 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 248 | static StringRef CurrentFilename; |
| 249 | typedef std::vector<NMSymbol> SymbolListT; |
| 250 | static SymbolListT SymbolList; |
| 251 | |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 252 | // darwinPrintSymbol() is used to print a symbol from a Mach-O file when the |
| 253 | // the OutputFormat is darwin. It produces the same output as darwin's nm(1) -m |
| 254 | // output. |
| 255 | static void darwinPrintSymbol(MachOObjectFile *MachO, SymbolListT::iterator I, |
| 256 | char *SymbolAddrStr, const char *printBlanks) { |
| 257 | MachO::mach_header H; |
| 258 | MachO::mach_header_64 H_64; |
| 259 | uint32_t Filetype, Flags; |
| 260 | MachO::nlist_64 STE_64; |
| 261 | MachO::nlist STE; |
| 262 | uint8_t NType; |
| 263 | uint16_t NDesc; |
| 264 | uint64_t NValue; |
| 265 | if (MachO->is64Bit()) { |
| 266 | H_64 = MachO->MachOObjectFile::getHeader64(); |
| 267 | Filetype = H_64.filetype; |
| 268 | Flags = H_64.flags; |
| 269 | STE_64 = MachO->getSymbol64TableEntry(I->Symb); |
| 270 | NType = STE_64.n_type; |
| 271 | NDesc = STE_64.n_desc; |
| 272 | NValue = STE_64.n_value; |
| 273 | } else { |
| 274 | H = MachO->MachOObjectFile::getHeader(); |
| 275 | Filetype = H.filetype; |
| 276 | Flags = H.flags; |
| 277 | STE = MachO->getSymbolTableEntry(I->Symb); |
| 278 | NType = STE.n_type; |
| 279 | NDesc = STE.n_desc; |
| 280 | NValue = STE.n_value; |
| 281 | } |
| 282 | |
| 283 | if (PrintAddress) { |
| 284 | if ((NType & MachO::N_TYPE) == MachO::N_INDR) |
| 285 | strcpy(SymbolAddrStr, printBlanks); |
| 286 | outs() << SymbolAddrStr << ' '; |
| 287 | } |
| 288 | |
| 289 | switch (NType & MachO::N_TYPE) { |
| 290 | case MachO::N_UNDF: |
| 291 | if (NValue != 0) { |
| 292 | outs() << "(common) "; |
| 293 | if (MachO::GET_COMM_ALIGN(NDesc) != 0) |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 294 | outs() << "(alignment 2^" << (int)MachO::GET_COMM_ALIGN(NDesc) << ") "; |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 295 | } else { |
| 296 | if ((NType & MachO::N_TYPE) == MachO::N_PBUD) |
| 297 | outs() << "(prebound "; |
| 298 | else |
| 299 | outs() << "("; |
| 300 | if ((NDesc & MachO::REFERENCE_TYPE) == |
| 301 | MachO::REFERENCE_FLAG_UNDEFINED_LAZY) |
| 302 | outs() << "undefined [lazy bound]) "; |
| 303 | else if ((NDesc & MachO::REFERENCE_TYPE) == |
| 304 | MachO::REFERENCE_FLAG_UNDEFINED_LAZY) |
| 305 | outs() << "undefined [private lazy bound]) "; |
| 306 | else if ((NDesc & MachO::REFERENCE_TYPE) == |
| 307 | MachO::REFERENCE_FLAG_PRIVATE_UNDEFINED_NON_LAZY) |
| 308 | outs() << "undefined [private]) "; |
| 309 | else |
| 310 | outs() << "undefined) "; |
| 311 | } |
| 312 | break; |
| 313 | case MachO::N_ABS: |
| 314 | outs() << "(absolute) "; |
| 315 | break; |
| 316 | case MachO::N_INDR: |
| 317 | outs() << "(indirect) "; |
| 318 | break; |
| 319 | case MachO::N_SECT: { |
| 320 | section_iterator Sec = MachO->section_end(); |
| 321 | MachO->getSymbolSection(I->Symb, Sec); |
| 322 | DataRefImpl Ref = Sec->getRawDataRefImpl(); |
| 323 | StringRef SectionName; |
| 324 | MachO->getSectionName(Ref, SectionName); |
| 325 | StringRef SegmentName = MachO->getSectionFinalSegmentName(Ref); |
| 326 | outs() << "(" << SegmentName << "," << SectionName << ") "; |
| 327 | break; |
| 328 | } |
| 329 | default: |
| 330 | outs() << "(?) "; |
| 331 | break; |
| 332 | } |
| 333 | |
| 334 | if (NType & MachO::N_EXT) { |
| 335 | if (NDesc & MachO::REFERENCED_DYNAMICALLY) |
| 336 | outs() << "[referenced dynamically] "; |
| 337 | if (NType & MachO::N_PEXT) { |
| 338 | if ((NDesc & MachO::N_WEAK_DEF) == MachO::N_WEAK_DEF) |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 339 | outs() << "weak private external "; |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 340 | else |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 341 | outs() << "private external "; |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 342 | } else { |
| 343 | if ((NDesc & MachO::N_WEAK_REF) == MachO::N_WEAK_REF || |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 344 | (NDesc & MachO::N_WEAK_DEF) == MachO::N_WEAK_DEF) { |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 345 | if ((NDesc & (MachO::N_WEAK_REF | MachO::N_WEAK_DEF)) == |
| 346 | (MachO::N_WEAK_REF | MachO::N_WEAK_DEF)) |
| 347 | outs() << "weak external automatically hidden "; |
| 348 | else |
| 349 | outs() << "weak external "; |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 350 | } else |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 351 | outs() << "external "; |
| 352 | } |
| 353 | } else { |
| 354 | if (NType & MachO::N_PEXT) |
| 355 | outs() << "non-external (was a private external) "; |
| 356 | else |
| 357 | outs() << "non-external "; |
| 358 | } |
| 359 | |
| 360 | if (Filetype == MachO::MH_OBJECT && |
| 361 | (NDesc & MachO::N_NO_DEAD_STRIP) == MachO::N_NO_DEAD_STRIP) |
| 362 | outs() << "[no dead strip] "; |
| 363 | |
| 364 | if (Filetype == MachO::MH_OBJECT && |
| 365 | ((NType & MachO::N_TYPE) != MachO::N_UNDF) && |
| 366 | (NDesc & MachO::N_SYMBOL_RESOLVER) == MachO::N_SYMBOL_RESOLVER) |
| 367 | outs() << "[symbol resolver] "; |
| 368 | |
| 369 | if (Filetype == MachO::MH_OBJECT && |
| 370 | ((NType & MachO::N_TYPE) != MachO::N_UNDF) && |
| 371 | (NDesc & MachO::N_ALT_ENTRY) == MachO::N_ALT_ENTRY) |
| 372 | outs() << "[alt entry] "; |
| 373 | |
| 374 | if ((NDesc & MachO::N_ARM_THUMB_DEF) == MachO::N_ARM_THUMB_DEF) |
| 375 | outs() << "[Thumb] "; |
| 376 | |
| 377 | if ((NType & MachO::N_TYPE) == MachO::N_INDR) { |
| 378 | outs() << I->Name << " (for "; |
| 379 | StringRef IndirectName; |
| 380 | if (MachO->getIndirectName(I->Symb, IndirectName)) |
| 381 | outs() << "?)"; |
| 382 | else |
| 383 | outs() << IndirectName << ")"; |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 384 | } else |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 385 | outs() << I->Name; |
| 386 | |
| 387 | if ((Flags & MachO::MH_TWOLEVEL) == MachO::MH_TWOLEVEL && |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 388 | (((NType & MachO::N_TYPE) == MachO::N_UNDF && NValue == 0) || |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 389 | (NType & MachO::N_TYPE) == MachO::N_PBUD)) { |
| 390 | uint32_t LibraryOrdinal = MachO::GET_LIBRARY_ORDINAL(NDesc); |
| 391 | if (LibraryOrdinal != 0) { |
| 392 | if (LibraryOrdinal == MachO::EXECUTABLE_ORDINAL) |
| 393 | outs() << " (from executable)"; |
| 394 | else if (LibraryOrdinal == MachO::DYNAMIC_LOOKUP_ORDINAL) |
| 395 | outs() << " (dynamically looked up)"; |
| 396 | else { |
| 397 | StringRef LibraryName; |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 398 | if (MachO->getLibraryShortNameByIndex(LibraryOrdinal - 1, LibraryName)) |
| 399 | outs() << " (from bad library ordinal " << LibraryOrdinal << ")"; |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 400 | else |
| 401 | outs() << " (from " << LibraryName << ")"; |
| 402 | } |
| 403 | } |
| 404 | } |
| 405 | |
| 406 | outs() << "\n"; |
| 407 | } |
| 408 | |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 409 | static void sortAndPrintSymbolList(SymbolicFile *Obj, bool printName) { |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 410 | if (!NoSort) { |
| 411 | if (NumericSort) |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 412 | std::sort(SymbolList.begin(), SymbolList.end(), compareSymbolAddress); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 413 | else if (SizeSort) |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 414 | std::sort(SymbolList.begin(), SymbolList.end(), compareSymbolSize); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 415 | else |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 416 | std::sort(SymbolList.begin(), SymbolList.end(), compareSymbolName); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 417 | } |
| 418 | |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 419 | if (OutputFormat == posix && MultipleFiles && printName) { |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 420 | outs() << '\n' << CurrentFilename << ":\n"; |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 421 | } else if (OutputFormat == bsd && MultipleFiles && printName) { |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 422 | outs() << "\n" << CurrentFilename << ":\n"; |
| 423 | } else if (OutputFormat == sysv) { |
| 424 | outs() << "\n\nSymbols from " << CurrentFilename << ":\n\n" |
| 425 | << "Name Value Class Type" |
| 426 | << " Size Line Section\n"; |
| 427 | } |
| 428 | |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 429 | const char *printBlanks, *printFormat; |
| 430 | if (isSymbolList64Bit(Obj)) { |
| 431 | printBlanks = " "; |
| 432 | printFormat = "%016" PRIx64; |
| 433 | } else { |
| 434 | printBlanks = " "; |
| 435 | printFormat = "%08" PRIx64; |
| 436 | } |
| 437 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 438 | for (SymbolListT::iterator I = SymbolList.begin(), E = SymbolList.end(); |
| 439 | I != E; ++I) { |
| 440 | if ((I->TypeChar != 'U') && UndefinedOnly) |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 441 | continue; |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 442 | if ((I->TypeChar == 'U') && DefinedOnly) |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 443 | continue; |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 444 | if (SizeSort && !PrintAddress && I->Size == UnknownAddressOrSize) |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 445 | continue; |
| 446 | |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 447 | char SymbolAddrStr[18] = ""; |
| 448 | char SymbolSizeStr[18] = ""; |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 449 | |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 450 | if (OutputFormat == sysv || I->Address == UnknownAddressOrSize) |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 451 | strcpy(SymbolAddrStr, printBlanks); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 452 | if (OutputFormat == sysv) |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 453 | strcpy(SymbolSizeStr, printBlanks); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 454 | |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 455 | if (I->Address != UnknownAddressOrSize) |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 456 | format(printFormat, I->Address) |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 457 | .print(SymbolAddrStr, sizeof(SymbolAddrStr)); |
Rafael Espindola | 0115b08 | 2014-01-30 21:51:42 +0000 | [diff] [blame] | 458 | if (I->Size != UnknownAddressOrSize) |
Kevin Enderby | 6abc2e5 | 2014-05-09 23:57:49 +0000 | [diff] [blame] | 459 | format(printFormat, I->Size).print(SymbolSizeStr, sizeof(SymbolSizeStr)); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 460 | |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 461 | // If OutputFormat is darwin and we have a MachOObjectFile print as darwin's |
| 462 | // nm(1) -m output, else if OutputFormat is darwin and not a Mach-O object |
| 463 | // fall back to OutputFormat bsd (see below). |
| 464 | MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(Obj); |
| 465 | if (OutputFormat == darwin && MachO) { |
| 466 | darwinPrintSymbol(MachO, I, SymbolAddrStr, printBlanks); |
| 467 | } else if (OutputFormat == posix) { |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 468 | outs() << I->Name << " " << I->TypeChar << " " << SymbolAddrStr |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 469 | << SymbolSizeStr << "\n"; |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 470 | } else if (OutputFormat == bsd || (OutputFormat == darwin && !MachO)) { |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 471 | if (PrintAddress) |
| 472 | outs() << SymbolAddrStr << ' '; |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 473 | if (PrintSize) { |
| 474 | outs() << SymbolSizeStr; |
Rafael Espindola | 0115b08 | 2014-01-30 21:51:42 +0000 | [diff] [blame] | 475 | if (I->Size != UnknownAddressOrSize) |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 476 | outs() << ' '; |
| 477 | } |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 478 | outs() << I->TypeChar << " " << I->Name << "\n"; |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 479 | } else if (OutputFormat == sysv) { |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 480 | std::string PaddedName(I->Name); |
| 481 | while (PaddedName.length() < 20) |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 482 | PaddedName += " "; |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 483 | outs() << PaddedName << "|" << SymbolAddrStr << "| " << I->TypeChar |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 484 | << " | |" << SymbolSizeStr << "| |\n"; |
| 485 | } |
| 486 | } |
| 487 | |
| 488 | SymbolList.clear(); |
| 489 | } |
| 490 | |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 491 | template <class ELFT> |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 492 | static char getSymbolNMTypeChar(ELFObjectFile<ELFT> &Obj, |
| 493 | basic_symbol_iterator I) { |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 494 | typedef typename ELFObjectFile<ELFT>::Elf_Sym Elf_Sym; |
| 495 | typedef typename ELFObjectFile<ELFT>::Elf_Shdr Elf_Shdr; |
| 496 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 497 | // OK, this is ELF |
| 498 | symbol_iterator SymI(I); |
| 499 | |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 500 | DataRefImpl Symb = I->getRawDataRefImpl(); |
| 501 | const Elf_Sym *ESym = Obj.getSymbol(Symb); |
| 502 | const ELFFile<ELFT> &EF = *Obj.getELFFile(); |
| 503 | const Elf_Shdr *ESec = EF.getSection(ESym); |
| 504 | |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 505 | if (ESec) { |
| 506 | switch (ESec->sh_type) { |
| 507 | case ELF::SHT_PROGBITS: |
| 508 | case ELF::SHT_DYNAMIC: |
| 509 | switch (ESec->sh_flags) { |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 510 | case (ELF::SHF_ALLOC | ELF::SHF_EXECINSTR): |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 511 | return 't'; |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 512 | case (ELF::SHF_TLS | ELF::SHF_ALLOC | ELF::SHF_WRITE): |
| 513 | case (ELF::SHF_ALLOC | ELF::SHF_WRITE): |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 514 | return 'd'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 515 | case ELF::SHF_ALLOC: |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 516 | case (ELF::SHF_ALLOC | ELF::SHF_MERGE): |
| 517 | case (ELF::SHF_ALLOC | ELF::SHF_MERGE | ELF::SHF_STRINGS): |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 518 | return 'r'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 519 | } |
| 520 | break; |
| 521 | case ELF::SHT_NOBITS: |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 522 | return 'b'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 523 | } |
| 524 | } |
| 525 | |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 526 | if (ESym->getType() == ELF::STT_SECTION) { |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 527 | StringRef Name; |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 528 | if (error(SymI->getName(Name))) |
Rafael Espindola | 7437589 | 2014-02-04 00:21:18 +0000 | [diff] [blame] | 529 | return '?'; |
| 530 | return StringSwitch<char>(Name) |
| 531 | .StartsWith(".debug", 'N') |
| 532 | .StartsWith(".note", 'n') |
| 533 | .Default('?'); |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 534 | } |
| 535 | |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 536 | return '?'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 537 | } |
| 538 | |
Rafael Espindola | 7437589 | 2014-02-04 00:21:18 +0000 | [diff] [blame] | 539 | static char getSymbolNMTypeChar(COFFObjectFile &Obj, symbol_iterator I) { |
Alexey Samsonov | 27dc839 | 2014-03-18 06:53:02 +0000 | [diff] [blame] | 540 | const coff_symbol *Symb = Obj.getCOFFSymbol(*I); |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 541 | // OK, this is COFF. |
| 542 | symbol_iterator SymI(I); |
| 543 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 544 | StringRef Name; |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 545 | if (error(SymI->getName(Name))) |
Rafael Espindola | 7437589 | 2014-02-04 00:21:18 +0000 | [diff] [blame] | 546 | return '?'; |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 547 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 548 | char Ret = StringSwitch<char>(Name) |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 549 | .StartsWith(".debug", 'N') |
| 550 | .StartsWith(".sxdata", 'N') |
| 551 | .Default('?'); |
| 552 | |
Rafael Espindola | 7437589 | 2014-02-04 00:21:18 +0000 | [diff] [blame] | 553 | if (Ret != '?') |
| 554 | return Ret; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 555 | |
| 556 | uint32_t Characteristics = 0; |
Rui Ueyama | f078eff | 2014-03-18 23:37:53 +0000 | [diff] [blame] | 557 | if (!COFF::isReservedSectionNumber(Symb->SectionNumber)) { |
Rafael Espindola | b5155a5 | 2014-02-10 20:24:04 +0000 | [diff] [blame] | 558 | section_iterator SecI = Obj.section_end(); |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 559 | if (error(SymI->getSection(SecI))) |
Rafael Espindola | 7437589 | 2014-02-04 00:21:18 +0000 | [diff] [blame] | 560 | return '?'; |
Alexey Samsonov | 27dc839 | 2014-03-18 06:53:02 +0000 | [diff] [blame] | 561 | const coff_section *Section = Obj.getCOFFSection(*SecI); |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 562 | Characteristics = Section->Characteristics; |
| 563 | } |
| 564 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 565 | switch (Symb->SectionNumber) { |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 566 | case COFF::IMAGE_SYM_DEBUG: |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 567 | return 'n'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 568 | default: |
| 569 | // Check section type. |
| 570 | if (Characteristics & COFF::IMAGE_SCN_CNT_CODE) |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 571 | return 't'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 572 | else if (Characteristics & COFF::IMAGE_SCN_MEM_READ && |
| 573 | ~Characteristics & COFF::IMAGE_SCN_MEM_WRITE) // Read only. |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 574 | return 'r'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 575 | else if (Characteristics & COFF::IMAGE_SCN_CNT_INITIALIZED_DATA) |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 576 | return 'd'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 577 | else if (Characteristics & COFF::IMAGE_SCN_CNT_UNINITIALIZED_DATA) |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 578 | return 'b'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 579 | else if (Characteristics & COFF::IMAGE_SCN_LNK_INFO) |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 580 | return 'i'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 581 | |
| 582 | // Check for section symbol. |
David Majnemer | ddf28f2 | 2014-03-19 04:47:47 +0000 | [diff] [blame] | 583 | else if (Symb->isSectionDefinition()) |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 584 | return 's'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 585 | } |
| 586 | |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 587 | return '?'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 588 | } |
| 589 | |
| 590 | static uint8_t getNType(MachOObjectFile &Obj, DataRefImpl Symb) { |
| 591 | if (Obj.is64Bit()) { |
| 592 | MachO::nlist_64 STE = Obj.getSymbol64TableEntry(Symb); |
| 593 | return STE.n_type; |
| 594 | } |
| 595 | MachO::nlist STE = Obj.getSymbolTableEntry(Symb); |
| 596 | return STE.n_type; |
| 597 | } |
| 598 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 599 | static char getSymbolNMTypeChar(MachOObjectFile &Obj, basic_symbol_iterator I) { |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 600 | DataRefImpl Symb = I->getRawDataRefImpl(); |
| 601 | uint8_t NType = getNType(Obj, Symb); |
| 602 | |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 603 | switch (NType & MachO::N_TYPE) { |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 604 | case MachO::N_ABS: |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 605 | return 's'; |
Tim Northover | eaef074 | 2014-05-30 13:22:59 +0000 | [diff] [blame] | 606 | case MachO::N_INDR: |
| 607 | return 'i'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 608 | case MachO::N_SECT: { |
Rafael Espindola | b5155a5 | 2014-02-10 20:24:04 +0000 | [diff] [blame] | 609 | section_iterator Sec = Obj.section_end(); |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 610 | Obj.getSymbolSection(Symb, Sec); |
| 611 | DataRefImpl Ref = Sec->getRawDataRefImpl(); |
| 612 | StringRef SectionName; |
| 613 | Obj.getSectionName(Ref, SectionName); |
| 614 | StringRef SegmentName = Obj.getSectionFinalSegmentName(Ref); |
| 615 | if (SegmentName == "__TEXT" && SectionName == "__text") |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 616 | return 't'; |
Kevin Enderby | 1e1b992 | 2014-06-19 22:49:21 +0000 | [diff] [blame] | 617 | else if (SegmentName == "__DATA" && SectionName == "__data") |
| 618 | return 'd'; |
| 619 | else if (SegmentName == "__DATA" && SectionName == "__bss") |
| 620 | return 'b'; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 621 | else |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 622 | return 's'; |
| 623 | } |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 624 | } |
| 625 | |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 626 | return '?'; |
| 627 | } |
| 628 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 629 | static char getSymbolNMTypeChar(const GlobalValue &GV) { |
Rafael Espindola | 64c1e18 | 2014-06-03 02:41:57 +0000 | [diff] [blame] | 630 | if (GV.getType()->getElementType()->isFunctionTy()) |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 631 | return 't'; |
| 632 | // FIXME: should we print 'b'? At the IR level we cannot be sure if this |
| 633 | // will be in bss or not, but we could approximate. |
Rafael Espindola | 64c1e18 | 2014-06-03 02:41:57 +0000 | [diff] [blame] | 634 | return 'd'; |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 635 | } |
| 636 | |
| 637 | static char getSymbolNMTypeChar(IRObjectFile &Obj, basic_symbol_iterator I) { |
| 638 | const GlobalValue &GV = Obj.getSymbolGV(I->getRawDataRefImpl()); |
| 639 | return getSymbolNMTypeChar(GV); |
| 640 | } |
| 641 | |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 642 | template <class ELFT> |
| 643 | static bool isObject(ELFObjectFile<ELFT> &Obj, symbol_iterator I) { |
| 644 | typedef typename ELFObjectFile<ELFT>::Elf_Sym Elf_Sym; |
| 645 | |
| 646 | DataRefImpl Symb = I->getRawDataRefImpl(); |
| 647 | const Elf_Sym *ESym = Obj.getSymbol(Symb); |
| 648 | |
| 649 | return ESym->getType() == ELF::STT_OBJECT; |
| 650 | } |
| 651 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 652 | static bool isObject(SymbolicFile *Obj, basic_symbol_iterator I) { |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 653 | if (ELF32LEObjectFile *ELF = dyn_cast<ELF32LEObjectFile>(Obj)) |
| 654 | return isObject(*ELF, I); |
| 655 | if (ELF64LEObjectFile *ELF = dyn_cast<ELF64LEObjectFile>(Obj)) |
| 656 | return isObject(*ELF, I); |
| 657 | if (ELF32BEObjectFile *ELF = dyn_cast<ELF32BEObjectFile>(Obj)) |
| 658 | return isObject(*ELF, I); |
| 659 | if (ELF64BEObjectFile *ELF = dyn_cast<ELF64BEObjectFile>(Obj)) |
| 660 | return isObject(*ELF, I); |
| 661 | return false; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 662 | } |
| 663 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 664 | static char getNMTypeChar(SymbolicFile *Obj, basic_symbol_iterator I) { |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 665 | uint32_t Symflags = I->getFlags(); |
| 666 | if ((Symflags & object::SymbolRef::SF_Weak) && !isa<MachOObjectFile>(Obj)) { |
| 667 | char Ret = isObject(Obj, I) ? 'v' : 'w'; |
| 668 | if (!(Symflags & object::SymbolRef::SF_Undefined)) |
| 669 | Ret = toupper(Ret); |
| 670 | return Ret; |
| 671 | } |
| 672 | |
| 673 | if (Symflags & object::SymbolRef::SF_Undefined) |
| 674 | return 'U'; |
| 675 | |
| 676 | if (Symflags & object::SymbolRef::SF_Common) |
| 677 | return 'C'; |
| 678 | |
| 679 | char Ret = '?'; |
| 680 | if (Symflags & object::SymbolRef::SF_Absolute) |
| 681 | Ret = 'a'; |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 682 | else if (IRObjectFile *IR = dyn_cast<IRObjectFile>(Obj)) |
| 683 | Ret = getSymbolNMTypeChar(*IR, I); |
Rafael Espindola | 22fe9c1 | 2014-02-05 05:19:19 +0000 | [diff] [blame] | 684 | else if (COFFObjectFile *COFF = dyn_cast<COFFObjectFile>(Obj)) |
| 685 | Ret = getSymbolNMTypeChar(*COFF, I); |
| 686 | else if (MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(Obj)) |
| 687 | Ret = getSymbolNMTypeChar(*MachO, I); |
| 688 | else if (ELF32LEObjectFile *ELF = dyn_cast<ELF32LEObjectFile>(Obj)) |
| 689 | Ret = getSymbolNMTypeChar(*ELF, I); |
| 690 | else if (ELF64LEObjectFile *ELF = dyn_cast<ELF64LEObjectFile>(Obj)) |
| 691 | Ret = getSymbolNMTypeChar(*ELF, I); |
| 692 | else if (ELF32BEObjectFile *ELF = dyn_cast<ELF32BEObjectFile>(Obj)) |
| 693 | Ret = getSymbolNMTypeChar(*ELF, I); |
| 694 | else |
| 695 | Ret = getSymbolNMTypeChar(*cast<ELF64BEObjectFile>(Obj), I); |
| 696 | |
| 697 | if (Symflags & object::SymbolRef::SF_Global) |
| 698 | Ret = toupper(Ret); |
| 699 | |
| 700 | return Ret; |
Rafael Espindola | 586af97a | 2013-11-02 21:16:09 +0000 | [diff] [blame] | 701 | } |
| 702 | |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 703 | static void dumpSymbolNamesFromObject(SymbolicFile *Obj, bool printName) { |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 704 | basic_symbol_iterator IBegin = Obj->symbol_begin(); |
| 705 | basic_symbol_iterator IEnd = Obj->symbol_end(); |
Michael J. Spencer | 8c4729f | 2012-02-28 00:40:37 +0000 | [diff] [blame] | 706 | if (DynamicSyms) { |
Rafael Espindola | 196666c | 2014-01-30 20:45:33 +0000 | [diff] [blame] | 707 | if (!Obj->isELF()) { |
| 708 | error("File format has no dynamic symbol table", Obj->getFileName()); |
| 709 | return; |
| 710 | } |
Alexey Samsonov | 65056a3 | 2014-02-26 12:51:19 +0000 | [diff] [blame] | 711 | std::pair<symbol_iterator, symbol_iterator> IDyn = |
| 712 | getELFDynamicSymbolIterators(Obj); |
| 713 | IBegin = IDyn.first; |
| 714 | IEnd = IDyn.second; |
Michael J. Spencer | 8c4729f | 2012-02-28 00:40:37 +0000 | [diff] [blame] | 715 | } |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 716 | std::string NameBuffer; |
| 717 | raw_string_ostream OS(NameBuffer); |
| 718 | for (basic_symbol_iterator I = IBegin; I != IEnd; ++I) { |
Rafael Espindola | 20122a4 | 2014-01-31 20:57:12 +0000 | [diff] [blame] | 719 | uint32_t SymFlags = I->getFlags(); |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 720 | if (!DebugSyms && (SymFlags & SymbolRef::SF_FormatSpecific)) |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 721 | continue; |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 722 | if (WithoutAliases) { |
| 723 | if (IRObjectFile *IR = dyn_cast<IRObjectFile>(Obj)) { |
| 724 | const GlobalValue &GV = IR->getSymbolGV(I->getRawDataRefImpl()); |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 725 | if (isa<GlobalAlias>(GV)) |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 726 | continue; |
| 727 | } |
| 728 | } |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 729 | NMSymbol S; |
Rafael Espindola | 0115b08 | 2014-01-30 21:51:42 +0000 | [diff] [blame] | 730 | S.Size = UnknownAddressOrSize; |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 731 | S.Address = UnknownAddressOrSize; |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 732 | if ((PrintSize || SizeSort) && isa<ObjectFile>(Obj)) { |
| 733 | symbol_iterator SymI = I; |
| 734 | if (error(SymI->getSize(S.Size))) |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 735 | break; |
Michael J. Spencer | 1d6167f | 2011-06-25 17:55:23 +0000 | [diff] [blame] | 736 | } |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 737 | if (PrintAddress && isa<ObjectFile>(Obj)) |
| 738 | if (error(symbol_iterator(I)->getAddress(S.Address))) |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 739 | break; |
| 740 | S.TypeChar = getNMTypeChar(Obj, I); |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 741 | if (error(I->printName(OS))) |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 742 | break; |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 743 | OS << '\0'; |
Kevin Enderby | 980b258 | 2014-06-05 21:21:57 +0000 | [diff] [blame] | 744 | S.Symb = I->getRawDataRefImpl(); |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 745 | SymbolList.push_back(S); |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 746 | } |
| 747 | |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 748 | OS.flush(); |
| 749 | const char *P = NameBuffer.c_str(); |
| 750 | for (unsigned I = 0; I < SymbolList.size(); ++I) { |
| 751 | SymbolList[I].Name = P; |
| 752 | P += strlen(P) + 1; |
| 753 | } |
| 754 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 755 | CurrentFilename = Obj->getFileName(); |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 756 | sortAndPrintSymbolList(Obj, printName); |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 757 | } |
| 758 | |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 759 | // checkMachOAndArchFlags() checks to see if the SymbolicFile is a Mach-O file |
| 760 | // and if it is and there is a list of architecture flags is specified then |
| 761 | // check to make sure this Mach-O file is one of those architectures or all |
| 762 | // architectures was specificed. If not then an error is generated and this |
| 763 | // routine returns false. Else it returns true. |
| 764 | static bool checkMachOAndArchFlags(SymbolicFile *O, std::string &Filename) { |
| 765 | if (isa<MachOObjectFile>(O) && !ArchAll && ArchFlags.size() != 0) { |
| 766 | MachOObjectFile *MachO = dyn_cast<MachOObjectFile>(O); |
| 767 | bool ArchFound = false; |
| 768 | MachO::mach_header H; |
| 769 | MachO::mach_header_64 H_64; |
| 770 | Triple T; |
| 771 | if (MachO->is64Bit()) { |
| 772 | H_64 = MachO->MachOObjectFile::getHeader64(); |
| 773 | T = MachOObjectFile::getArch(H_64.cputype, H_64.cpusubtype); |
| 774 | } else { |
| 775 | H = MachO->MachOObjectFile::getHeader(); |
| 776 | T = MachOObjectFile::getArch(H.cputype, H.cpusubtype); |
| 777 | } |
| 778 | unsigned i; |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 779 | for (i = 0; i < ArchFlags.size(); ++i) { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 780 | if (ArchFlags[i] == T.getArchName()) |
| 781 | ArchFound = true; |
| 782 | break; |
| 783 | } |
| 784 | if (!ArchFound) { |
| 785 | error(ArchFlags[i], |
| 786 | "file: " + Filename + " does not contain architecture"); |
| 787 | return false; |
| 788 | } |
| 789 | } |
| 790 | return true; |
| 791 | } |
| 792 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 793 | static void dumpSymbolNamesFromFile(std::string &Filename) { |
Ahmed Charles | 56440fd | 2014-03-06 05:51:42 +0000 | [diff] [blame] | 794 | std::unique_ptr<MemoryBuffer> Buffer; |
Michael J. Spencer | bc96f37 | 2011-12-13 23:17:29 +0000 | [diff] [blame] | 795 | if (error(MemoryBuffer::getFileOrSTDIN(Filename, Buffer), Filename)) |
| 796 | return; |
| 797 | |
Owen Anderson | 19251ec | 2009-07-15 22:16:10 +0000 | [diff] [blame] | 798 | LLVMContext &Context = getGlobalContext(); |
Rafael Espindola | 6304e94 | 2014-06-23 22:00:37 +0000 | [diff] [blame] | 799 | ErrorOr<Binary *> BinaryOrErr = createBinary(Buffer, &Context); |
Rafael Espindola | ce82a07 | 2014-01-30 19:24:00 +0000 | [diff] [blame] | 800 | if (error(BinaryOrErr.getError(), Filename)) |
| 801 | return; |
Rafael Espindola | c3f9b5a | 2014-06-23 21:53:12 +0000 | [diff] [blame] | 802 | Buffer.release(); |
Ahmed Charles | 56440fd | 2014-03-06 05:51:42 +0000 | [diff] [blame] | 803 | std::unique_ptr<Binary> Bin(BinaryOrErr.get()); |
Shankar Easwaran | 15b28be | 2012-11-13 18:38:42 +0000 | [diff] [blame] | 804 | |
Rafael Espindola | 0115b08 | 2014-01-30 21:51:42 +0000 | [diff] [blame] | 805 | if (Archive *A = dyn_cast<Archive>(Bin.get())) { |
Rafael Espindola | ce82a07 | 2014-01-30 19:24:00 +0000 | [diff] [blame] | 806 | if (ArchiveMap) { |
Rafael Espindola | 0115b08 | 2014-01-30 21:51:42 +0000 | [diff] [blame] | 807 | Archive::symbol_iterator I = A->symbol_begin(); |
| 808 | Archive::symbol_iterator E = A->symbol_end(); |
Rafael Espindola | ce82a07 | 2014-01-30 19:24:00 +0000 | [diff] [blame] | 809 | if (I != E) { |
Rafael Espindola | 0115b08 | 2014-01-30 21:51:42 +0000 | [diff] [blame] | 810 | outs() << "Archive map\n"; |
Rafael Espindola | ce82a07 | 2014-01-30 19:24:00 +0000 | [diff] [blame] | 811 | for (; I != E; ++I) { |
Rafael Espindola | ae46002 | 2014-06-16 16:08:36 +0000 | [diff] [blame] | 812 | ErrorOr<Archive::child_iterator> C = I->getMember(); |
| 813 | if (error(C.getError())) |
Michael J. Spencer | 9718f45 | 2013-02-03 10:48:50 +0000 | [diff] [blame] | 814 | return; |
Rafael Espindola | ae46002 | 2014-06-16 16:08:36 +0000 | [diff] [blame] | 815 | ErrorOr<StringRef> FileNameOrErr = C.get()->getName(); |
| 816 | if (error(FileNameOrErr.getError())) |
Rafael Espindola | ce82a07 | 2014-01-30 19:24:00 +0000 | [diff] [blame] | 817 | return; |
Rafael Espindola | ae46002 | 2014-06-16 16:08:36 +0000 | [diff] [blame] | 818 | StringRef SymName = I->getName(); |
| 819 | outs() << SymName << " in " << FileNameOrErr.get() << "\n"; |
Michael J. Spencer | 2bc774a | 2011-09-27 19:37:18 +0000 | [diff] [blame] | 820 | } |
Rafael Espindola | ce82a07 | 2014-01-30 19:24:00 +0000 | [diff] [blame] | 821 | outs() << "\n"; |
Michael J. Spencer | 2bc774a | 2011-09-27 19:37:18 +0000 | [diff] [blame] | 822 | } |
| 823 | } |
Alexey Samsonov | e6388e6 | 2013-06-18 15:03:28 +0000 | [diff] [blame] | 824 | |
Rafael Espindola | 0115b08 | 2014-01-30 21:51:42 +0000 | [diff] [blame] | 825 | for (Archive::child_iterator I = A->child_begin(), E = A->child_end(); |
Rafael Espindola | ce82a07 | 2014-01-30 19:24:00 +0000 | [diff] [blame] | 826 | I != E; ++I) { |
Rafael Espindola | ae46002 | 2014-06-16 16:08:36 +0000 | [diff] [blame] | 827 | ErrorOr<std::unique_ptr<Binary>> ChildOrErr = I->getAsBinary(&Context); |
| 828 | if (ChildOrErr.getError()) |
Rafael Espindola | ce82a07 | 2014-01-30 19:24:00 +0000 | [diff] [blame] | 829 | continue; |
Rafael Espindola | ae46002 | 2014-06-16 16:08:36 +0000 | [diff] [blame] | 830 | if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 831 | if (!checkMachOAndArchFlags(O, Filename)) |
| 832 | return; |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 833 | outs() << "\n"; |
Kevin Enderby | 1983fcf | 2014-06-19 22:03:18 +0000 | [diff] [blame] | 834 | if (isa<MachOObjectFile>(O)) { |
| 835 | outs() << Filename << "(" << O->getFileName() << ")"; |
| 836 | } else |
| 837 | outs() << O->getFileName(); |
| 838 | outs() << ":\n"; |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 839 | dumpSymbolNamesFromObject(O, false); |
Rafael Espindola | ce82a07 | 2014-01-30 19:24:00 +0000 | [diff] [blame] | 840 | } |
| 841 | } |
| 842 | return; |
| 843 | } |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 844 | if (MachOUniversalBinary *UB = dyn_cast<MachOUniversalBinary>(Bin.get())) { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 845 | // If we have a list of architecture flags specified dump only those. |
| 846 | if (!ArchAll && ArchFlags.size() != 0) { |
| 847 | // Look for a slice in the universal binary that matches each ArchFlag. |
| 848 | bool ArchFound; |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 849 | for (unsigned i = 0; i < ArchFlags.size(); ++i) { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 850 | ArchFound = false; |
| 851 | for (MachOUniversalBinary::object_iterator I = UB->begin_objects(), |
| 852 | E = UB->end_objects(); |
| 853 | I != E; ++I) { |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 854 | if (ArchFlags[i] == I->getArchTypeName()) { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 855 | ArchFound = true; |
| 856 | ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 857 | I->getAsObjectFile(); |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 858 | std::unique_ptr<Archive> A; |
| 859 | if (ObjOrErr) { |
| 860 | std::unique_ptr<ObjectFile> Obj = std::move(ObjOrErr.get()); |
| 861 | if (ArchFlags.size() > 1) { |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 862 | outs() << "\n" << Obj->getFileName() << " (for architecture " |
| 863 | << I->getArchTypeName() << ")" |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 864 | << ":\n"; |
| 865 | } |
| 866 | dumpSymbolNamesFromObject(Obj.get(), false); |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 867 | } else if (!I->getAsArchive(A)) { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 868 | for (Archive::child_iterator AI = A->child_begin(), |
| 869 | AE = A->child_end(); |
| 870 | AI != AE; ++AI) { |
| 871 | ErrorOr<std::unique_ptr<Binary>> ChildOrErr = |
| 872 | AI->getAsBinary(&Context); |
| 873 | if (ChildOrErr.getError()) |
| 874 | continue; |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 875 | if (SymbolicFile *O = |
| 876 | dyn_cast<SymbolicFile>(&*ChildOrErr.get())) { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 877 | outs() << "\n" << A->getFileName(); |
| 878 | outs() << "(" << O->getFileName() << ")"; |
| 879 | if (ArchFlags.size() > 1) { |
| 880 | outs() << " (for architecture " << I->getArchTypeName() |
| 881 | << ")"; |
| 882 | } |
| 883 | outs() << ":\n"; |
| 884 | dumpSymbolNamesFromObject(O, false); |
| 885 | } |
| 886 | } |
| 887 | } |
| 888 | } |
| 889 | } |
| 890 | if (!ArchFound) { |
| 891 | error(ArchFlags[i], |
| 892 | "file: " + Filename + " does not contain architecture"); |
| 893 | return; |
| 894 | } |
| 895 | } |
| 896 | return; |
| 897 | } |
| 898 | // No architecture flags were specified so if this contains a slice that |
| 899 | // matches the host architecture dump only that. |
| 900 | if (!ArchAll) { |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 901 | StringRef HostArchName = MachOObjectFile::getHostArch().getArchName(); |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 902 | for (MachOUniversalBinary::object_iterator I = UB->begin_objects(), |
| 903 | E = UB->end_objects(); |
| 904 | I != E; ++I) { |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 905 | if (HostArchName == I->getArchTypeName()) { |
| 906 | ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile(); |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 907 | std::unique_ptr<Archive> A; |
| 908 | if (ObjOrErr) { |
| 909 | std::unique_ptr<ObjectFile> Obj = std::move(ObjOrErr.get()); |
| 910 | dumpSymbolNamesFromObject(Obj.get(), false); |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 911 | } else if (!I->getAsArchive(A)) { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 912 | for (Archive::child_iterator AI = A->child_begin(), |
| 913 | AE = A->child_end(); |
| 914 | AI != AE; ++AI) { |
| 915 | ErrorOr<std::unique_ptr<Binary>> ChildOrErr = |
| 916 | AI->getAsBinary(&Context); |
| 917 | if (ChildOrErr.getError()) |
| 918 | continue; |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 919 | if (SymbolicFile *O = |
| 920 | dyn_cast<SymbolicFile>(&*ChildOrErr.get())) { |
| 921 | outs() << "\n" << A->getFileName() << "(" << O->getFileName() |
| 922 | << ")" |
| 923 | << ":\n"; |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 924 | dumpSymbolNamesFromObject(O, false); |
| 925 | } |
| 926 | } |
| 927 | } |
| 928 | return; |
| 929 | } |
| 930 | } |
| 931 | } |
| 932 | // Either all architectures have been specified or none have been specified |
| 933 | // and this does not contain the host architecture so dump all the slices. |
Kevin Enderby | 1983fcf | 2014-06-19 22:03:18 +0000 | [diff] [blame] | 934 | bool moreThanOneArch = UB->getNumberOfObjects() > 1; |
Rafael Espindola | 0115b08 | 2014-01-30 21:51:42 +0000 | [diff] [blame] | 935 | for (MachOUniversalBinary::object_iterator I = UB->begin_objects(), |
| 936 | E = UB->end_objects(); |
Alexey Samsonov | e6388e6 | 2013-06-18 15:03:28 +0000 | [diff] [blame] | 937 | I != E; ++I) { |
Rafael Espindola | 4f7932b | 2014-06-23 20:41:02 +0000 | [diff] [blame] | 938 | ErrorOr<std::unique_ptr<ObjectFile>> ObjOrErr = I->getAsObjectFile(); |
Kevin Enderby | e858a65 | 2014-05-14 21:18:50 +0000 | [diff] [blame] | 939 | std::unique_ptr<Archive> A; |
Rafael Espindola | 4f7932b | 2014-06-23 20:41:02 +0000 | [diff] [blame] | 940 | if (ObjOrErr) { |
| 941 | std::unique_ptr<ObjectFile> Obj = std::move(ObjOrErr.get()); |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 942 | if (moreThanOneArch) |
| 943 | outs() << "\n"; |
Kevin Enderby | 1983fcf | 2014-06-19 22:03:18 +0000 | [diff] [blame] | 944 | outs() << Obj->getFileName(); |
| 945 | if (isa<MachOObjectFile>(Obj.get()) && moreThanOneArch) |
| 946 | outs() << " (for architecture " << I->getArchTypeName() << ")"; |
| 947 | outs() << ":\n"; |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 948 | dumpSymbolNamesFromObject(Obj.get(), false); |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 949 | } else if (!I->getAsArchive(A)) { |
Kevin Enderby | e858a65 | 2014-05-14 21:18:50 +0000 | [diff] [blame] | 950 | for (Archive::child_iterator AI = A->child_begin(), AE = A->child_end(); |
| 951 | AI != AE; ++AI) { |
Rafael Espindola | ae46002 | 2014-06-16 16:08:36 +0000 | [diff] [blame] | 952 | ErrorOr<std::unique_ptr<Binary>> ChildOrErr = |
| 953 | AI->getAsBinary(&Context); |
| 954 | if (ChildOrErr.getError()) |
Kevin Enderby | e858a65 | 2014-05-14 21:18:50 +0000 | [diff] [blame] | 955 | continue; |
Rafael Espindola | ae46002 | 2014-06-16 16:08:36 +0000 | [diff] [blame] | 956 | if (SymbolicFile *O = dyn_cast<SymbolicFile>(&*ChildOrErr.get())) { |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 957 | outs() << "\n" << A->getFileName(); |
Kevin Enderby | 1983fcf | 2014-06-19 22:03:18 +0000 | [diff] [blame] | 958 | if (isa<MachOObjectFile>(O)) { |
| 959 | outs() << "(" << O->getFileName() << ")"; |
| 960 | if (moreThanOneArch) |
| 961 | outs() << " (for architecture " << I->getArchTypeName() << ")"; |
| 962 | } else |
| 963 | outs() << ":" << O->getFileName(); |
| 964 | outs() << ":\n"; |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 965 | dumpSymbolNamesFromObject(O, false); |
Kevin Enderby | e858a65 | 2014-05-14 21:18:50 +0000 | [diff] [blame] | 966 | } |
| 967 | } |
| 968 | } |
Alexey Samsonov | e6388e6 | 2013-06-18 15:03:28 +0000 | [diff] [blame] | 969 | } |
Brian Gaeke | 618026a | 2003-11-19 21:57:30 +0000 | [diff] [blame] | 970 | return; |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 971 | } |
Rafael Espindola | f12b828 | 2014-02-21 20:10:59 +0000 | [diff] [blame] | 972 | if (SymbolicFile *O = dyn_cast<SymbolicFile>(Bin.get())) { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 973 | if (!checkMachOAndArchFlags(O, Filename)) |
| 974 | return; |
Kevin Enderby | 2664610 | 2014-06-20 21:29:27 +0000 | [diff] [blame] | 975 | dumpSymbolNamesFromObject(O, true); |
Rafael Espindola | ce82a07 | 2014-01-30 19:24:00 +0000 | [diff] [blame] | 976 | return; |
| 977 | } |
| 978 | error("unrecognizable file type", Filename); |
| 979 | return; |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 980 | } |
| 981 | |
| 982 | int main(int argc, char **argv) { |
Chris Lattner | e3fc2d1 | 2009-03-06 05:34:10 +0000 | [diff] [blame] | 983 | // Print a stack trace if we signal out. |
Chris Lattner | ef8f389 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 984 | sys::PrintStackTraceOnErrorSignal(); |
Chris Lattner | e3fc2d1 | 2009-03-06 05:34:10 +0000 | [diff] [blame] | 985 | PrettyStackTraceProgram X(argc, argv); |
Michael J. Spencer | 618d219 | 2010-08-31 06:36:46 +0000 | [diff] [blame] | 986 | |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 987 | llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. |
Chris Lattner | e3fc2d1 | 2009-03-06 05:34:10 +0000 | [diff] [blame] | 988 | cl::ParseCommandLineOptions(argc, argv, "llvm symbol table dumper\n"); |
Chris Lattner | 12439ff | 2004-02-19 20:32:12 +0000 | [diff] [blame] | 989 | |
Michael J. Spencer | bc96f37 | 2011-12-13 23:17:29 +0000 | [diff] [blame] | 990 | // llvm-nm only reads binary files. |
Rafael Espindola | cb2eca0 | 2013-06-12 20:58:35 +0000 | [diff] [blame] | 991 | if (error(sys::ChangeStdinToBinary())) |
Michael J. Spencer | bc96f37 | 2011-12-13 23:17:29 +0000 | [diff] [blame] | 992 | return 1; |
| 993 | |
Chris Lattner | ef8f389 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 994 | ToolName = argv[0]; |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 995 | if (BSDFormat) |
| 996 | OutputFormat = bsd; |
| 997 | if (POSIXFormat) |
| 998 | OutputFormat = posix; |
Kevin Enderby | 14a96ac | 2014-06-20 00:04:16 +0000 | [diff] [blame] | 999 | if (DarwinFormat) |
| 1000 | OutputFormat = darwin; |
Chris Lattner | 4aae1f4 | 2003-10-16 18:45:23 +0000 | [diff] [blame] | 1001 | |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 1002 | // The relative order of these is important. If you pass --size-sort it should |
| 1003 | // only print out the size. However, if you pass -S --size-sort, it should |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 1004 | // print out both the size and address. |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 1005 | if (SizeSort && !PrintSize) |
Rafael Espindola | b4865d6 | 2014-04-03 00:19:35 +0000 | [diff] [blame] | 1006 | PrintAddress = false; |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 1007 | if (OutputFormat == sysv || SizeSort) |
| 1008 | PrintSize = true; |
Michael J. Spencer | b8672a5 | 2011-01-20 06:38:57 +0000 | [diff] [blame] | 1009 | |
Chris Lattner | ef8f389 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 1010 | switch (InputFilenames.size()) { |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 1011 | case 0: |
Kevin Enderby | 4fc2edb | 2014-06-23 20:27:53 +0000 | [diff] [blame] | 1012 | InputFilenames.push_back("a.out"); |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 1013 | case 1: |
| 1014 | break; |
| 1015 | default: |
| 1016 | MultipleFiles = true; |
Chris Lattner | 4aae1f4 | 2003-10-16 18:45:23 +0000 | [diff] [blame] | 1017 | } |
Chris Lattner | ef8f389 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 1018 | |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 1019 | for (unsigned i = 0; i < ArchFlags.size(); ++i) { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 1020 | if (ArchFlags[i] == "all") { |
| 1021 | ArchAll = true; |
Kevin Enderby | 8f6dcf5 | 2014-07-01 22:44:51 +0000 | [diff] [blame] | 1022 | } else { |
Kevin Enderby | 4c8dfe4 | 2014-06-30 18:45:23 +0000 | [diff] [blame] | 1023 | Triple T = MachOObjectFile::getArch(ArchFlags[i]); |
| 1024 | if (T.getArch() == Triple::UnknownArch) |
| 1025 | error("Unknown architecture named '" + ArchFlags[i] + "'", |
| 1026 | "for the -arch option"); |
| 1027 | } |
| 1028 | } |
| 1029 | |
Chris Lattner | ef8f389 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 1030 | std::for_each(InputFilenames.begin(), InputFilenames.end(), |
Rafael Espindola | 619581c | 2014-01-29 04:56:19 +0000 | [diff] [blame] | 1031 | dumpSymbolNamesFromFile); |
Rafael Espindola | 8b82a4d | 2013-07-03 15:46:03 +0000 | [diff] [blame] | 1032 | |
| 1033 | if (HadError) |
| 1034 | return 1; |
| 1035 | |
Chris Lattner | ef8f389 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 1036 | return 0; |
Brian Gaeke | 0af759d | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 1037 | } |