Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 1 | //===-- llvm-nm.cpp - Symbol table dumping utility for llvm ---------------===// |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | 7c0e022 | 2003-10-20 17:47:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 21c62da | 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 | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | 7c0e022 | 2003-10-20 17:47:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 9 | // |
| 10 | // This program is a utility that works like traditional Unix "nm", |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 11 | // that is, it prints out the names of symbols in a bitcode file, |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 12 | // along with some information about each symbol. |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 13 | // |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 14 | // This "nm" does not print symbols' addresses. It supports many of |
| 15 | // the features of GNU "nm", including its different output formats. |
| 16 | // |
| 17 | //===----------------------------------------------------------------------===// |
| 18 | |
Owen Anderson | 8b477ed | 2009-07-01 16:58:40 +0000 | [diff] [blame] | 19 | #include "llvm/LLVMContext.h" |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 20 | #include "llvm/Module.h" |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 21 | #include "llvm/Bitcode/ReaderWriter.h" |
Chris Lattner | 44dadff | 2007-05-06 09:29:57 +0000 | [diff] [blame] | 22 | #include "llvm/Bitcode/Archive.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 23 | #include "llvm/Support/CommandLine.h" |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 24 | #include "llvm/Support/ManagedStatic.h" |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 25 | #include "llvm/Support/MemoryBuffer.h" |
Chris Lattner | cc14d25 | 2009-03-06 05:34:10 +0000 | [diff] [blame] | 26 | #include "llvm/Support/PrettyStackTrace.h" |
Dan Gohman | 65f57c2 | 2009-07-15 16:35:29 +0000 | [diff] [blame] | 27 | #include "llvm/Support/raw_ostream.h" |
Chris Lattner | bed85ff | 2004-05-27 05:41:36 +0000 | [diff] [blame] | 28 | #include "llvm/System/Signals.h" |
Jeff Cohen | ca5183d | 2007-03-05 00:00:42 +0000 | [diff] [blame] | 29 | #include <algorithm> |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 30 | #include <cctype> |
Alkis Evlogimenos | 09233fb | 2004-04-21 16:11:40 +0000 | [diff] [blame] | 31 | #include <cerrno> |
Brian Gaeke | 08d03c7 | 2003-11-19 21:52:09 +0000 | [diff] [blame] | 32 | #include <cstring> |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 33 | using namespace llvm; |
| 34 | |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 35 | namespace { |
| 36 | enum OutputFormatTy { bsd, sysv, posix }; |
| 37 | cl::opt<OutputFormatTy> |
| 38 | OutputFormat("format", |
| 39 | cl::desc("Specify output format"), |
| 40 | cl::values(clEnumVal(bsd, "BSD format"), |
| 41 | clEnumVal(sysv, "System V format"), |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 42 | clEnumVal(posix, "POSIX.2 format"), |
Chris Lattner | 4d143ee | 2004-07-16 00:08:28 +0000 | [diff] [blame] | 43 | clEnumValEnd), cl::init(bsd)); |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 44 | cl::alias OutputFormat2("f", cl::desc("Alias for --format"), |
| 45 | cl::aliasopt(OutputFormat)); |
| 46 | |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 47 | cl::list<std::string> |
Gabor Greif | a99be51 | 2007-07-05 17:07:56 +0000 | [diff] [blame] | 48 | InputFilenames(cl::Positional, cl::desc("<input bitcode files>"), |
Chris Lattner | fc046d5 | 2003-10-16 18:45:23 +0000 | [diff] [blame] | 49 | cl::ZeroOrMore); |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 50 | |
| 51 | cl::opt<bool> UndefinedOnly("undefined-only", |
| 52 | cl::desc("Show only undefined symbols")); |
| 53 | cl::alias UndefinedOnly2("u", cl::desc("Alias for --undefined-only"), |
| 54 | cl::aliasopt(UndefinedOnly)); |
| 55 | |
| 56 | cl::opt<bool> DefinedOnly("defined-only", |
| 57 | cl::desc("Show only defined symbols")); |
| 58 | |
| 59 | cl::opt<bool> ExternalOnly("extern-only", |
| 60 | cl::desc("Show only external symbols")); |
| 61 | cl::alias ExternalOnly2("g", cl::desc("Alias for --extern-only"), |
| 62 | cl::aliasopt(ExternalOnly)); |
| 63 | |
| 64 | cl::opt<bool> BSDFormat("B", cl::desc("Alias for --format=bsd")); |
| 65 | cl::opt<bool> POSIXFormat("P", cl::desc("Alias for --format=posix")); |
| 66 | |
| 67 | bool MultipleFiles = false; |
| 68 | |
| 69 | std::string ToolName; |
Chris Lattner | d74ea2b | 2006-05-24 17:04:05 +0000 | [diff] [blame] | 70 | } |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 71 | |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 72 | static char TypeCharForSymbol(GlobalValue &GV) { |
Lauro Ramos Venancio | 4a828ee | 2007-06-27 22:08:09 +0000 | [diff] [blame] | 73 | if (GV.isDeclaration()) return 'U'; |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 74 | if (GV.hasLinkOnceLinkage()) return 'C'; |
Dale Johannesen | 7d5633e | 2008-05-16 22:44:18 +0000 | [diff] [blame] | 75 | if (GV.hasCommonLinkage()) return 'C'; |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 76 | if (GV.hasWeakLinkage()) return 'W'; |
Lauro Ramos Venancio | 4a828ee | 2007-06-27 22:08:09 +0000 | [diff] [blame] | 77 | if (isa<Function>(GV) && GV.hasInternalLinkage()) return 't'; |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 78 | if (isa<Function>(GV)) return 'T'; |
Lauro Ramos Venancio | 4a828ee | 2007-06-27 22:08:09 +0000 | [diff] [blame] | 79 | if (isa<GlobalVariable>(GV) && GV.hasInternalLinkage()) return 'd'; |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 80 | if (isa<GlobalVariable>(GV)) return 'D'; |
Lauro Ramos Venancio | 4a828ee | 2007-06-27 22:08:09 +0000 | [diff] [blame] | 81 | if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(&GV)) { |
| 82 | const GlobalValue *AliasedGV = GA->getAliasedGlobal(); |
| 83 | if (isa<Function>(AliasedGV)) return 'T'; |
| 84 | if (isa<GlobalVariable>(AliasedGV)) return 'D'; |
| 85 | } |
| 86 | return '?'; |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 87 | } |
| 88 | |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 89 | static void DumpSymbolNameForGlobalValue(GlobalValue &GV) { |
Chris Lattner | 266c7bb | 2009-04-13 05:44:34 +0000 | [diff] [blame] | 90 | // Private linkage and available_externally linkage don't exist in symtab. |
Bill Wendling | 3d10a5a | 2009-07-20 01:03:30 +0000 | [diff] [blame] | 91 | if (GV.hasPrivateLinkage() || GV.hasLinkerPrivateLinkage() || |
Bill Wendling | 207855c | 2010-06-29 21:24:00 +0000 | [diff] [blame^] | 92 | GV.hasLinkerWeakLinkage() || GV.hasAvailableExternallyLinkage()) |
| 93 | return; |
Chris Lattner | 266c7bb | 2009-04-13 05:44:34 +0000 | [diff] [blame] | 94 | |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 95 | const std::string SymbolAddrStr = " "; // Not used yet... |
Chris Lattner | 266c7bb | 2009-04-13 05:44:34 +0000 | [diff] [blame] | 96 | char TypeChar = TypeCharForSymbol(GV); |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 97 | if ((TypeChar != 'U') && UndefinedOnly) |
| 98 | return; |
| 99 | if ((TypeChar == 'U') && DefinedOnly) |
| 100 | return; |
Rafael Espindola | bb46f52 | 2009-01-15 20:18:42 +0000 | [diff] [blame] | 101 | if (GV.hasLocalLinkage () && ExternalOnly) |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 102 | return; |
| 103 | if (OutputFormat == posix) { |
Dan Gohman | ac95cc7 | 2009-07-16 15:30:09 +0000 | [diff] [blame] | 104 | outs() << GV.getName () << " " << TypeCharForSymbol(GV) << " " |
| 105 | << SymbolAddrStr << "\n"; |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 106 | } else if (OutputFormat == bsd) { |
Dan Gohman | ac95cc7 | 2009-07-16 15:30:09 +0000 | [diff] [blame] | 107 | outs() << SymbolAddrStr << " " << TypeCharForSymbol(GV) << " " |
| 108 | << GV.getName () << "\n"; |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 109 | } else if (OutputFormat == sysv) { |
| 110 | std::string PaddedName (GV.getName ()); |
| 111 | while (PaddedName.length () < 20) |
| 112 | PaddedName += " "; |
Dan Gohman | ac95cc7 | 2009-07-16 15:30:09 +0000 | [diff] [blame] | 113 | outs() << PaddedName << "|" << SymbolAddrStr << "| " |
| 114 | << TypeCharForSymbol(GV) |
| 115 | << " | | | |\n"; |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 116 | } |
| 117 | } |
| 118 | |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 119 | static void DumpSymbolNamesFromModule(Module *M) { |
Brian Gaeke | 1c0b698 | 2003-11-16 23:34:13 +0000 | [diff] [blame] | 120 | const std::string &Filename = M->getModuleIdentifier (); |
| 121 | if (OutputFormat == posix && MultipleFiles) { |
Dan Gohman | ac95cc7 | 2009-07-16 15:30:09 +0000 | [diff] [blame] | 122 | outs() << Filename << ":\n"; |
Brian Gaeke | 1c0b698 | 2003-11-16 23:34:13 +0000 | [diff] [blame] | 123 | } else if (OutputFormat == bsd && MultipleFiles) { |
Dan Gohman | ac95cc7 | 2009-07-16 15:30:09 +0000 | [diff] [blame] | 124 | outs() << "\n" << Filename << ":\n"; |
Brian Gaeke | 1c0b698 | 2003-11-16 23:34:13 +0000 | [diff] [blame] | 125 | } else if (OutputFormat == sysv) { |
Dan Gohman | ac95cc7 | 2009-07-16 15:30:09 +0000 | [diff] [blame] | 126 | outs() << "\n\nSymbols from " << Filename << ":\n\n" |
| 127 | << "Name Value Class Type" |
| 128 | << " Size Line Section\n"; |
Brian Gaeke | 1c0b698 | 2003-11-16 23:34:13 +0000 | [diff] [blame] | 129 | } |
Chris Lattner | 266c7bb | 2009-04-13 05:44:34 +0000 | [diff] [blame] | 130 | std::for_each (M->begin(), M->end(), DumpSymbolNameForGlobalValue); |
| 131 | std::for_each (M->global_begin(), M->global_end(), |
Lauro Ramos Venancio | 4a828ee | 2007-06-27 22:08:09 +0000 | [diff] [blame] | 132 | DumpSymbolNameForGlobalValue); |
Chris Lattner | 266c7bb | 2009-04-13 05:44:34 +0000 | [diff] [blame] | 133 | std::for_each (M->alias_begin(), M->alias_end(), |
Lauro Ramos Venancio | 4a828ee | 2007-06-27 22:08:09 +0000 | [diff] [blame] | 134 | DumpSymbolNameForGlobalValue); |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 135 | } |
| 136 | |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 137 | static void DumpSymbolNamesFromFile(std::string &Filename) { |
Owen Anderson | 0d7c695 | 2009-07-15 22:16:10 +0000 | [diff] [blame] | 138 | LLVMContext &Context = getGlobalContext(); |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 139 | std::string ErrorMessage; |
Reid Spencer | 11db4b8 | 2004-12-13 03:01:26 +0000 | [diff] [blame] | 140 | sys::Path aPath(Filename); |
Brian Gaeke | 8b1daa3 | 2003-11-19 22:15:00 +0000 | [diff] [blame] | 141 | // Note: Currently we do not support reading an archive from stdin. |
Chris Lattner | 44dadff | 2007-05-06 09:29:57 +0000 | [diff] [blame] | 142 | if (Filename == "-" || aPath.isBitcodeFile()) { |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 143 | std::auto_ptr<MemoryBuffer> Buffer( |
Chris Lattner | 065344d | 2007-05-06 23:45:49 +0000 | [diff] [blame] | 144 | MemoryBuffer::getFileOrSTDIN(Filename, &ErrorMessage)); |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 145 | Module *Result = 0; |
| 146 | if (Buffer.get()) |
Owen Anderson | 31895e7 | 2009-07-01 21:22:36 +0000 | [diff] [blame] | 147 | Result = ParseBitcodeFile(Buffer.get(), Context, &ErrorMessage); |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 148 | |
Nuno Lopes | 8018f5d | 2009-09-10 14:56:31 +0000 | [diff] [blame] | 149 | if (Result) { |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 150 | DumpSymbolNamesFromModule(Result); |
Nuno Lopes | 8018f5d | 2009-09-10 14:56:31 +0000 | [diff] [blame] | 151 | delete Result; |
| 152 | } else |
Dan Gohman | 65f57c2 | 2009-07-15 16:35:29 +0000 | [diff] [blame] | 153 | errs() << ToolName << ": " << Filename << ": " << ErrorMessage << "\n"; |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 154 | |
Reid Spencer | 11db4b8 | 2004-12-13 03:01:26 +0000 | [diff] [blame] | 155 | } else if (aPath.isArchive()) { |
Reid Spencer | 8d8a7ff | 2006-07-07 20:56:50 +0000 | [diff] [blame] | 156 | std::string ErrMsg; |
Owen Anderson | 31895e7 | 2009-07-01 21:22:36 +0000 | [diff] [blame] | 157 | Archive* archive = Archive::OpenAndLoad(sys::Path(Filename), Context, |
Owen Anderson | 8b477ed | 2009-07-01 16:58:40 +0000 | [diff] [blame] | 158 | &ErrorMessage); |
Reid Spencer | 63efb77 | 2004-11-14 22:27:46 +0000 | [diff] [blame] | 159 | if (!archive) |
Dan Gohman | 65f57c2 | 2009-07-15 16:35:29 +0000 | [diff] [blame] | 160 | errs() << ToolName << ": " << Filename << ": " << ErrorMessage << "\n"; |
Brian Gaeke | 1c0b698 | 2003-11-16 23:34:13 +0000 | [diff] [blame] | 161 | std::vector<Module *> Modules; |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 162 | if (archive->getAllModules(Modules, &ErrorMessage)) { |
Dan Gohman | 65f57c2 | 2009-07-15 16:35:29 +0000 | [diff] [blame] | 163 | errs() << ToolName << ": " << Filename << ": " << ErrorMessage << "\n"; |
Brian Gaeke | 08d03c7 | 2003-11-19 21:52:09 +0000 | [diff] [blame] | 164 | return; |
| 165 | } |
Brian Gaeke | 1c0b698 | 2003-11-16 23:34:13 +0000 | [diff] [blame] | 166 | MultipleFiles = true; |
Chris Lattner | c30598b | 2006-12-06 01:18:01 +0000 | [diff] [blame] | 167 | std::for_each (Modules.begin(), Modules.end(), DumpSymbolNamesFromModule); |
Brian Gaeke | 8204287 | 2003-11-19 21:57:30 +0000 | [diff] [blame] | 168 | } else { |
Dan Gohman | 65f57c2 | 2009-07-15 16:35:29 +0000 | [diff] [blame] | 169 | errs() << ToolName << ": " << Filename << ": " |
| 170 | << "unrecognizable file type\n"; |
Brian Gaeke | 8204287 | 2003-11-19 21:57:30 +0000 | [diff] [blame] | 171 | return; |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 172 | } |
| 173 | } |
| 174 | |
| 175 | int main(int argc, char **argv) { |
Chris Lattner | cc14d25 | 2009-03-06 05:34:10 +0000 | [diff] [blame] | 176 | // Print a stack trace if we signal out. |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 177 | sys::PrintStackTraceOnErrorSignal(); |
Chris Lattner | cc14d25 | 2009-03-06 05:34:10 +0000 | [diff] [blame] | 178 | PrettyStackTraceProgram X(argc, argv); |
| 179 | |
| 180 | llvm_shutdown_obj Y; // Call llvm_shutdown() on exit. |
| 181 | cl::ParseCommandLineOptions(argc, argv, "llvm symbol table dumper\n"); |
Chris Lattner | f73b4ca | 2004-02-19 20:32:12 +0000 | [diff] [blame] | 182 | |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 183 | ToolName = argv[0]; |
| 184 | if (BSDFormat) OutputFormat = bsd; |
| 185 | if (POSIXFormat) OutputFormat = posix; |
Chris Lattner | fc046d5 | 2003-10-16 18:45:23 +0000 | [diff] [blame] | 186 | |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 187 | switch (InputFilenames.size()) { |
| 188 | case 0: InputFilenames.push_back("-"); |
| 189 | case 1: break; |
| 190 | default: MultipleFiles = true; |
Chris Lattner | fc046d5 | 2003-10-16 18:45:23 +0000 | [diff] [blame] | 191 | } |
Chris Lattner | 4d5aad2 | 2007-05-06 05:36:18 +0000 | [diff] [blame] | 192 | |
| 193 | std::for_each(InputFilenames.begin(), InputFilenames.end(), |
| 194 | DumpSymbolNamesFromFile); |
| 195 | return 0; |
Brian Gaeke | 972d3d7 | 2003-10-16 04:43:15 +0000 | [diff] [blame] | 196 | } |