2003-10-16 04:43:15 +00:00
|
|
|
//===-- llvm-nm.cpp - Symbol table dumping utility for llvm ---------------===//
|
2005-04-22 00:00:37 +00:00
|
|
|
//
|
2003-10-20 17:47:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:44:31 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 00:00:37 +00:00
|
|
|
//
|
2003-10-20 17:47:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2003-10-16 04:43:15 +00:00
|
|
|
//
|
|
|
|
// This program is a utility that works like traditional Unix "nm",
|
2007-07-05 17:07:56 +00:00
|
|
|
// that is, it prints out the names of symbols in a bitcode file,
|
2003-10-16 04:43:15 +00:00
|
|
|
// along with some information about each symbol.
|
2005-04-22 00:00:37 +00:00
|
|
|
//
|
2003-10-16 04:43:15 +00:00
|
|
|
// This "nm" does not print symbols' addresses. It supports many of
|
|
|
|
// the features of GNU "nm", including its different output formats.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
2009-07-01 16:58:40 +00:00
|
|
|
#include "llvm/LLVMContext.h"
|
2003-10-16 04:43:15 +00:00
|
|
|
#include "llvm/Module.h"
|
2007-05-06 05:36:18 +00:00
|
|
|
#include "llvm/Bitcode/ReaderWriter.h"
|
2007-05-06 09:29:57 +00:00
|
|
|
#include "llvm/Bitcode/Archive.h"
|
2004-09-01 22:55:40 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2006-12-06 01:18:01 +00:00
|
|
|
#include "llvm/Support/ManagedStatic.h"
|
2007-05-06 05:36:18 +00:00
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
2009-03-06 05:34:10 +00:00
|
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
2009-07-15 16:35:29 +00:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-11-29 18:16:10 +00:00
|
|
|
#include "llvm/Support/Signals.h"
|
2010-12-09 17:36:48 +00:00
|
|
|
#include "llvm/Support/system_error.h"
|
2007-03-05 00:00:42 +00:00
|
|
|
#include <algorithm>
|
2003-10-16 04:43:15 +00:00
|
|
|
#include <cctype>
|
2004-04-21 16:11:40 +00:00
|
|
|
#include <cerrno>
|
2003-11-19 21:52:09 +00:00
|
|
|
#include <cstring>
|
2003-11-11 22:41:34 +00:00
|
|
|
using namespace llvm;
|
|
|
|
|
2003-10-16 04:43:15 +00:00
|
|
|
namespace {
|
|
|
|
enum OutputFormatTy { bsd, sysv, posix };
|
|
|
|
cl::opt<OutputFormatTy>
|
|
|
|
OutputFormat("format",
|
|
|
|
cl::desc("Specify output format"),
|
|
|
|
cl::values(clEnumVal(bsd, "BSD format"),
|
|
|
|
clEnumVal(sysv, "System V format"),
|
2005-04-22 00:00:37 +00:00
|
|
|
clEnumVal(posix, "POSIX.2 format"),
|
2004-07-16 00:08:28 +00:00
|
|
|
clEnumValEnd), cl::init(bsd));
|
2003-10-16 04:43:15 +00:00
|
|
|
cl::alias OutputFormat2("f", cl::desc("Alias for --format"),
|
|
|
|
cl::aliasopt(OutputFormat));
|
|
|
|
|
2005-04-22 00:00:37 +00:00
|
|
|
cl::list<std::string>
|
2007-07-05 17:07:56 +00:00
|
|
|
InputFilenames(cl::Positional, cl::desc("<input bitcode files>"),
|
2003-10-16 18:45:23 +00:00
|
|
|
cl::ZeroOrMore);
|
2003-10-16 04:43:15 +00:00
|
|
|
|
|
|
|
cl::opt<bool> UndefinedOnly("undefined-only",
|
|
|
|
cl::desc("Show only undefined symbols"));
|
|
|
|
cl::alias UndefinedOnly2("u", cl::desc("Alias for --undefined-only"),
|
|
|
|
cl::aliasopt(UndefinedOnly));
|
|
|
|
|
|
|
|
cl::opt<bool> DefinedOnly("defined-only",
|
|
|
|
cl::desc("Show only defined symbols"));
|
|
|
|
|
|
|
|
cl::opt<bool> ExternalOnly("extern-only",
|
|
|
|
cl::desc("Show only external symbols"));
|
|
|
|
cl::alias ExternalOnly2("g", cl::desc("Alias for --extern-only"),
|
|
|
|
cl::aliasopt(ExternalOnly));
|
|
|
|
|
|
|
|
cl::opt<bool> BSDFormat("B", cl::desc("Alias for --format=bsd"));
|
|
|
|
cl::opt<bool> POSIXFormat("P", cl::desc("Alias for --format=posix"));
|
|
|
|
|
|
|
|
bool MultipleFiles = false;
|
|
|
|
|
|
|
|
std::string ToolName;
|
2006-05-24 17:04:05 +00:00
|
|
|
}
|
2003-10-16 04:43:15 +00:00
|
|
|
|
2006-12-06 01:18:01 +00:00
|
|
|
static char TypeCharForSymbol(GlobalValue &GV) {
|
2007-06-27 22:08:09 +00:00
|
|
|
if (GV.isDeclaration()) return 'U';
|
2006-12-06 01:18:01 +00:00
|
|
|
if (GV.hasLinkOnceLinkage()) return 'C';
|
2008-05-16 22:44:18 +00:00
|
|
|
if (GV.hasCommonLinkage()) return 'C';
|
2006-12-06 01:18:01 +00:00
|
|
|
if (GV.hasWeakLinkage()) return 'W';
|
2007-06-27 22:08:09 +00:00
|
|
|
if (isa<Function>(GV) && GV.hasInternalLinkage()) return 't';
|
2006-12-06 01:18:01 +00:00
|
|
|
if (isa<Function>(GV)) return 'T';
|
2007-06-27 22:08:09 +00:00
|
|
|
if (isa<GlobalVariable>(GV) && GV.hasInternalLinkage()) return 'd';
|
2006-12-06 01:18:01 +00:00
|
|
|
if (isa<GlobalVariable>(GV)) return 'D';
|
2007-06-27 22:08:09 +00:00
|
|
|
if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(&GV)) {
|
|
|
|
const GlobalValue *AliasedGV = GA->getAliasedGlobal();
|
|
|
|
if (isa<Function>(AliasedGV)) return 'T';
|
|
|
|
if (isa<GlobalVariable>(AliasedGV)) return 'D';
|
|
|
|
}
|
|
|
|
return '?';
|
2003-10-16 04:43:15 +00:00
|
|
|
}
|
|
|
|
|
2006-12-06 01:18:01 +00:00
|
|
|
static void DumpSymbolNameForGlobalValue(GlobalValue &GV) {
|
2009-04-13 05:44:34 +00:00
|
|
|
// Private linkage and available_externally linkage don't exist in symtab.
|
2010-08-24 20:00:52 +00:00
|
|
|
if (GV.hasPrivateLinkage() ||
|
|
|
|
GV.hasLinkerPrivateLinkage() ||
|
|
|
|
GV.hasLinkerPrivateWeakLinkage() ||
|
|
|
|
GV.hasLinkerPrivateWeakDefAutoLinkage() ||
|
|
|
|
GV.hasAvailableExternallyLinkage())
|
2010-07-01 21:55:59 +00:00
|
|
|
return;
|
2010-08-31 06:36:46 +00:00
|
|
|
|
2003-10-16 04:43:15 +00:00
|
|
|
const std::string SymbolAddrStr = " "; // Not used yet...
|
2009-04-13 05:44:34 +00:00
|
|
|
char TypeChar = TypeCharForSymbol(GV);
|
2003-10-16 04:43:15 +00:00
|
|
|
if ((TypeChar != 'U') && UndefinedOnly)
|
|
|
|
return;
|
|
|
|
if ((TypeChar == 'U') && DefinedOnly)
|
|
|
|
return;
|
2009-01-15 20:18:42 +00:00
|
|
|
if (GV.hasLocalLinkage () && ExternalOnly)
|
2003-10-16 04:43:15 +00:00
|
|
|
return;
|
|
|
|
if (OutputFormat == posix) {
|
2009-07-16 15:30:09 +00:00
|
|
|
outs() << GV.getName () << " " << TypeCharForSymbol(GV) << " "
|
|
|
|
<< SymbolAddrStr << "\n";
|
2003-10-16 04:43:15 +00:00
|
|
|
} else if (OutputFormat == bsd) {
|
2009-07-16 15:30:09 +00:00
|
|
|
outs() << SymbolAddrStr << " " << TypeCharForSymbol(GV) << " "
|
|
|
|
<< GV.getName () << "\n";
|
2003-10-16 04:43:15 +00:00
|
|
|
} else if (OutputFormat == sysv) {
|
|
|
|
std::string PaddedName (GV.getName ());
|
|
|
|
while (PaddedName.length () < 20)
|
|
|
|
PaddedName += " ";
|
2009-07-16 15:30:09 +00:00
|
|
|
outs() << PaddedName << "|" << SymbolAddrStr << "| "
|
|
|
|
<< TypeCharForSymbol(GV)
|
|
|
|
<< " | | | |\n";
|
2003-10-16 04:43:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-12-06 01:18:01 +00:00
|
|
|
static void DumpSymbolNamesFromModule(Module *M) {
|
2003-11-16 23:34:13 +00:00
|
|
|
const std::string &Filename = M->getModuleIdentifier ();
|
|
|
|
if (OutputFormat == posix && MultipleFiles) {
|
2009-07-16 15:30:09 +00:00
|
|
|
outs() << Filename << ":\n";
|
2003-11-16 23:34:13 +00:00
|
|
|
} else if (OutputFormat == bsd && MultipleFiles) {
|
2009-07-16 15:30:09 +00:00
|
|
|
outs() << "\n" << Filename << ":\n";
|
2003-11-16 23:34:13 +00:00
|
|
|
} else if (OutputFormat == sysv) {
|
2009-07-16 15:30:09 +00:00
|
|
|
outs() << "\n\nSymbols from " << Filename << ":\n\n"
|
|
|
|
<< "Name Value Class Type"
|
|
|
|
<< " Size Line Section\n";
|
2003-11-16 23:34:13 +00:00
|
|
|
}
|
2009-04-13 05:44:34 +00:00
|
|
|
std::for_each (M->begin(), M->end(), DumpSymbolNameForGlobalValue);
|
|
|
|
std::for_each (M->global_begin(), M->global_end(),
|
2007-06-27 22:08:09 +00:00
|
|
|
DumpSymbolNameForGlobalValue);
|
2009-04-13 05:44:34 +00:00
|
|
|
std::for_each (M->alias_begin(), M->alias_end(),
|
2007-06-27 22:08:09 +00:00
|
|
|
DumpSymbolNameForGlobalValue);
|
2003-10-16 04:43:15 +00:00
|
|
|
}
|
|
|
|
|
2006-12-06 01:18:01 +00:00
|
|
|
static void DumpSymbolNamesFromFile(std::string &Filename) {
|
2009-07-15 22:16:10 +00:00
|
|
|
LLVMContext &Context = getGlobalContext();
|
2003-10-16 04:43:15 +00:00
|
|
|
std::string ErrorMessage;
|
2004-12-13 03:01:26 +00:00
|
|
|
sys::Path aPath(Filename);
|
2003-11-19 22:15:00 +00:00
|
|
|
// Note: Currently we do not support reading an archive from stdin.
|
2007-05-06 09:29:57 +00:00
|
|
|
if (Filename == "-" || aPath.isBitcodeFile()) {
|
2010-12-16 03:29:14 +00:00
|
|
|
OwningPtr<MemoryBuffer> Buffer;
|
|
|
|
if (error_code ec = MemoryBuffer::getFileOrSTDIN(Filename, Buffer))
|
2010-12-09 17:36:48 +00:00
|
|
|
ErrorMessage = ec.message();
|
2007-05-06 05:36:18 +00:00
|
|
|
Module *Result = 0;
|
|
|
|
if (Buffer.get())
|
2009-07-01 21:22:36 +00:00
|
|
|
Result = ParseBitcodeFile(Buffer.get(), Context, &ErrorMessage);
|
2010-08-31 06:36:46 +00:00
|
|
|
|
2009-09-10 14:56:31 +00:00
|
|
|
if (Result) {
|
2007-05-06 05:36:18 +00:00
|
|
|
DumpSymbolNamesFromModule(Result);
|
2009-09-10 14:56:31 +00:00
|
|
|
delete Result;
|
|
|
|
} else
|
2009-07-15 16:35:29 +00:00
|
|
|
errs() << ToolName << ": " << Filename << ": " << ErrorMessage << "\n";
|
2010-08-31 06:36:46 +00:00
|
|
|
|
2004-12-13 03:01:26 +00:00
|
|
|
} else if (aPath.isArchive()) {
|
2006-07-07 20:56:50 +00:00
|
|
|
std::string ErrMsg;
|
2009-07-01 21:22:36 +00:00
|
|
|
Archive* archive = Archive::OpenAndLoad(sys::Path(Filename), Context,
|
2009-07-01 16:58:40 +00:00
|
|
|
&ErrorMessage);
|
2004-11-14 22:27:46 +00:00
|
|
|
if (!archive)
|
2009-07-15 16:35:29 +00:00
|
|
|
errs() << ToolName << ": " << Filename << ": " << ErrorMessage << "\n";
|
2003-11-16 23:34:13 +00:00
|
|
|
std::vector<Module *> Modules;
|
2006-12-06 01:18:01 +00:00
|
|
|
if (archive->getAllModules(Modules, &ErrorMessage)) {
|
2009-07-15 16:35:29 +00:00
|
|
|
errs() << ToolName << ": " << Filename << ": " << ErrorMessage << "\n";
|
2003-11-19 21:52:09 +00:00
|
|
|
return;
|
|
|
|
}
|
2003-11-16 23:34:13 +00:00
|
|
|
MultipleFiles = true;
|
2006-12-06 01:18:01 +00:00
|
|
|
std::for_each (Modules.begin(), Modules.end(), DumpSymbolNamesFromModule);
|
2003-11-19 21:57:30 +00:00
|
|
|
} else {
|
2009-07-15 16:35:29 +00:00
|
|
|
errs() << ToolName << ": " << Filename << ": "
|
|
|
|
<< "unrecognizable file type\n";
|
2003-11-19 21:57:30 +00:00
|
|
|
return;
|
2003-10-16 04:43:15 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int main(int argc, char **argv) {
|
2009-03-06 05:34:10 +00:00
|
|
|
// Print a stack trace if we signal out.
|
2007-05-06 05:36:18 +00:00
|
|
|
sys::PrintStackTraceOnErrorSignal();
|
2009-03-06 05:34:10 +00:00
|
|
|
PrettyStackTraceProgram X(argc, argv);
|
2010-08-31 06:36:46 +00:00
|
|
|
|
2009-03-06 05:34:10 +00:00
|
|
|
llvm_shutdown_obj Y; // Call llvm_shutdown() on exit.
|
|
|
|
cl::ParseCommandLineOptions(argc, argv, "llvm symbol table dumper\n");
|
2003-10-16 18:45:23 +00:00
|
|
|
|
2007-05-06 05:36:18 +00:00
|
|
|
ToolName = argv[0];
|
|
|
|
if (BSDFormat) OutputFormat = bsd;
|
|
|
|
if (POSIXFormat) OutputFormat = posix;
|
|
|
|
|
|
|
|
switch (InputFilenames.size()) {
|
|
|
|
case 0: InputFilenames.push_back("-");
|
|
|
|
case 1: break;
|
|
|
|
default: MultipleFiles = true;
|
2003-10-16 18:45:23 +00:00
|
|
|
}
|
2007-05-06 05:36:18 +00:00
|
|
|
|
|
|
|
std::for_each(InputFilenames.begin(), InputFilenames.end(),
|
|
|
|
DumpSymbolNamesFromFile);
|
|
|
|
return 0;
|
2003-10-16 04:43:15 +00:00
|
|
|
}
|