219 lines
6.2 KiB
C++
219 lines
6.2 KiB
C++
//===- llvm-readobj.cpp - Dump contents of an Object File -----------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This program is a utility that works like traditional Unix "readelf",
|
|
// except that it can handle any type of object file recognized by lib/Object.
|
|
//
|
|
// It makes use of the generic ObjectFile interface.
|
|
//
|
|
// Caution: This utility is new, experimental, unsupported, and incomplete.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Object/ObjectFile.h"
|
|
#include "llvm/Object/ELF.h"
|
|
#include "llvm/Analysis/Verifier.h"
|
|
#include "llvm/ADT/Triple.h"
|
|
#include "llvm/Support/Format.h"
|
|
#include "llvm/Support/CommandLine.h"
|
|
#include "llvm/Support/PrettyStackTrace.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/Signals.h"
|
|
#include "llvm/Support/FormattedStream.h"
|
|
|
|
using namespace llvm;
|
|
using namespace llvm::object;
|
|
|
|
static cl::opt<std::string>
|
|
InputFilename(cl::Positional, cl::desc("<input object>"), cl::init(""));
|
|
|
|
void DumpSymbolHeader() {
|
|
outs() << format(" %-32s", (const char*)"Name")
|
|
<< format(" %-4s", (const char*)"Type")
|
|
<< format(" %-16s", (const char*)"Address")
|
|
<< format(" %-16s", (const char*)"Size")
|
|
<< format(" %-16s", (const char*)"FileOffset")
|
|
<< format(" %-26s", (const char*)"Flags")
|
|
<< "\n";
|
|
}
|
|
|
|
const char *GetTypeStr(SymbolRef::Type Type) {
|
|
switch (Type) {
|
|
case SymbolRef::ST_Unknown: return "?";
|
|
case SymbolRef::ST_Data: return "DATA";
|
|
case SymbolRef::ST_Debug: return "DBG";
|
|
case SymbolRef::ST_File: return "FILE";
|
|
case SymbolRef::ST_Function: return "FUNC";
|
|
case SymbolRef::ST_Other: return "-";
|
|
}
|
|
return "INV";
|
|
}
|
|
|
|
std::string GetFlagStr(uint32_t Flags) {
|
|
std::string result;
|
|
if (Flags & SymbolRef::SF_Undefined)
|
|
result += "undef,";
|
|
if (Flags & SymbolRef::SF_Global)
|
|
result += "global,";
|
|
if (Flags & SymbolRef::SF_Weak)
|
|
result += "weak,";
|
|
if (Flags & SymbolRef::SF_Absolute)
|
|
result += "absolute,";
|
|
if (Flags & SymbolRef::SF_ThreadLocal)
|
|
result += "threadlocal,";
|
|
if (Flags & SymbolRef::SF_Common)
|
|
result += "common,";
|
|
if (Flags & SymbolRef::SF_FormatSpecific)
|
|
result += "formatspecific,";
|
|
|
|
// Remove trailing comma
|
|
if (result.size() > 0) {
|
|
result.erase(result.size() - 1);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void DumpSymbol(const SymbolRef &Sym, const ObjectFile *obj, bool IsDynamic) {
|
|
StringRef Name;
|
|
SymbolRef::Type Type;
|
|
uint32_t Flags;
|
|
uint64_t Address;
|
|
uint64_t Size;
|
|
uint64_t FileOffset;
|
|
Sym.getName(Name);
|
|
Sym.getAddress(Address);
|
|
Sym.getSize(Size);
|
|
Sym.getFileOffset(FileOffset);
|
|
Sym.getType(Type);
|
|
Sym.getFlags(Flags);
|
|
std::string FullName = Name;
|
|
|
|
// If this is a dynamic symbol from an ELF object, append
|
|
// the symbol's version to the name.
|
|
if (IsDynamic && obj->isELF()) {
|
|
StringRef Version;
|
|
bool IsDefault;
|
|
GetELFSymbolVersion(obj, Sym, Version, IsDefault);
|
|
if (!Version.empty()) {
|
|
FullName += (IsDefault ? "@@" : "@");
|
|
FullName += Version;
|
|
}
|
|
}
|
|
|
|
// format() can't handle StringRefs
|
|
outs() << format(" %-32s", FullName.c_str())
|
|
<< format(" %-4s", GetTypeStr(Type))
|
|
<< format(" %16" PRIx64, Address)
|
|
<< format(" %16" PRIx64, Size)
|
|
<< format(" %16" PRIx64, FileOffset)
|
|
<< " " << GetFlagStr(Flags)
|
|
<< "\n";
|
|
}
|
|
|
|
|
|
// Iterate through the normal symbols in the ObjectFile
|
|
void DumpSymbols(const ObjectFile *obj) {
|
|
error_code ec;
|
|
uint32_t count = 0;
|
|
outs() << "Symbols:\n";
|
|
symbol_iterator it = obj->begin_symbols();
|
|
symbol_iterator ie = obj->end_symbols();
|
|
while (it != ie) {
|
|
DumpSymbol(*it, obj, false);
|
|
it.increment(ec);
|
|
if (ec)
|
|
report_fatal_error("Symbol iteration failed");
|
|
++count;
|
|
}
|
|
outs() << " Total: " << count << "\n\n";
|
|
}
|
|
|
|
// Iterate through the dynamic symbols in the ObjectFile.
|
|
void DumpDynamicSymbols(const ObjectFile *obj) {
|
|
error_code ec;
|
|
uint32_t count = 0;
|
|
outs() << "Dynamic Symbols:\n";
|
|
symbol_iterator it = obj->begin_dynamic_symbols();
|
|
symbol_iterator ie = obj->end_dynamic_symbols();
|
|
while (it != ie) {
|
|
DumpSymbol(*it, obj, true);
|
|
it.increment(ec);
|
|
if (ec)
|
|
report_fatal_error("Symbol iteration failed");
|
|
++count;
|
|
}
|
|
outs() << " Total: " << count << "\n\n";
|
|
}
|
|
|
|
void DumpLibrary(const LibraryRef &lib) {
|
|
StringRef path;
|
|
lib.getPath(path);
|
|
outs() << " " << path << "\n";
|
|
}
|
|
|
|
// Iterate through needed libraries
|
|
void DumpLibrariesNeeded(const ObjectFile *obj) {
|
|
error_code ec;
|
|
uint32_t count = 0;
|
|
library_iterator it = obj->begin_libraries_needed();
|
|
library_iterator ie = obj->end_libraries_needed();
|
|
outs() << "Libraries needed:\n";
|
|
while (it != ie) {
|
|
DumpLibrary(*it);
|
|
it.increment(ec);
|
|
if (ec)
|
|
report_fatal_error("Needed libraries iteration failed");
|
|
++count;
|
|
}
|
|
outs() << " Total: " << count << "\n\n";
|
|
}
|
|
|
|
void DumpHeaders(const ObjectFile *obj) {
|
|
outs() << "File Format : " << obj->getFileFormatName() << "\n";
|
|
outs() << "Arch : "
|
|
<< Triple::getArchTypeName((llvm::Triple::ArchType)obj->getArch())
|
|
<< "\n";
|
|
outs() << "Address Size: " << (8*obj->getBytesInAddress()) << " bits\n";
|
|
outs() << "Load Name : " << obj->getLoadName() << "\n";
|
|
outs() << "\n";
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
error_code ec;
|
|
sys::PrintStackTraceOnErrorSignal();
|
|
PrettyStackTraceProgram X(argc, argv);
|
|
|
|
cl::ParseCommandLineOptions(argc, argv,
|
|
"LLVM Object Reader\n");
|
|
|
|
if (InputFilename.empty()) {
|
|
errs() << "Please specify an input filename\n";
|
|
return 1;
|
|
}
|
|
|
|
// Open the object file
|
|
OwningPtr<MemoryBuffer> File;
|
|
if (MemoryBuffer::getFile(InputFilename, File)) {
|
|
errs() << InputFilename << ": Open failed\n";
|
|
return 1;
|
|
}
|
|
|
|
ObjectFile *obj = ObjectFile::createObjectFile(File.take());
|
|
if (!obj) {
|
|
errs() << InputFilename << ": Object type not recognized\n";
|
|
}
|
|
|
|
DumpHeaders(obj);
|
|
DumpSymbols(obj);
|
|
DumpDynamicSymbols(obj);
|
|
DumpLibrariesNeeded(obj);
|
|
return 0;
|
|
}
|
|
|