2011-09-19 17:56:04 +00:00
|
|
|
//===-- MachODump.cpp - Object file dumping utility for llvm --------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This file implements the MachO-specific dumper for llvm-objdump.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm-objdump.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
MC: Disassembled CFG reconstruction.
This patch builds on some existing code to do CFG reconstruction from
a disassembled binary:
- MCModule represents the binary, and has a list of MCAtoms.
- MCAtom represents either disassembled instructions (MCTextAtom), or
contiguous data (MCDataAtom), and covers a specific range of addresses.
- MCBasicBlock and MCFunction form the reconstructed CFG. An MCBB is
backed by an MCTextAtom, and has the usual successors/predecessors.
- MCObjectDisassembler creates a module from an ObjectFile using a
disassembler. It first builds an atom for each section. It can also
construct the CFG, and this splits the text atoms into basic blocks.
MCModule and MCAtom were only sketched out; MCFunction and MCBB were
implemented under the experimental "-cfg" llvm-objdump -macho option.
This cleans them up for further use; llvm-objdump -d -cfg now generates
graphviz files for each function found in the binary.
In the future, MCObjectDisassembler may be the right place to do
"intelligent" disassembly: for example, handling constant islands is just
a matter of splitting the atom, using information that may be available
in the ObjectFile. Also, better initial atom formation than just using
sections is possible using symbols (and things like Mach-O's
function_starts load command).
This brings two minor regressions in llvm-objdump -macho -cfg:
- The printing of a relocation's referenced symbol.
- An annotation on loop BBs, i.e., which are their own successor.
Relocation printing is replaced by the MCSymbolizer; the basic CFG
annotation will be superseded by more related functionality.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182628 91177308-0d34-0410-b5e6-96231b3b80d8
2013-05-24 01:07:04 +00:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2012-12-04 10:44:52 +00:00
|
|
|
#include "llvm/ADT/Triple.h"
|
2011-09-21 01:13:19 +00:00
|
|
|
#include "llvm/DebugInfo/DIContext.h"
|
2011-09-19 17:56:04 +00:00
|
|
|
#include "llvm/MC/MCAsmInfo.h"
|
2014-04-15 04:40:56 +00:00
|
|
|
#include "llvm/MC/MCContext.h"
|
2011-09-19 17:56:04 +00:00
|
|
|
#include "llvm/MC/MCDisassembler.h"
|
|
|
|
#include "llvm/MC/MCInst.h"
|
|
|
|
#include "llvm/MC/MCInstPrinter.h"
|
|
|
|
#include "llvm/MC/MCInstrAnalysis.h"
|
|
|
|
#include "llvm/MC/MCInstrDesc.h"
|
|
|
|
#include "llvm/MC/MCInstrInfo.h"
|
2012-03-05 19:33:20 +00:00
|
|
|
#include "llvm/MC/MCRegisterInfo.h"
|
2011-09-19 17:56:04 +00:00
|
|
|
#include "llvm/MC/MCSubtargetInfo.h"
|
2012-12-04 10:44:52 +00:00
|
|
|
#include "llvm/Object/MachO.h"
|
2013-04-13 01:45:40 +00:00
|
|
|
#include "llvm/Support/Casting.h"
|
2011-09-19 17:56:04 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
#include "llvm/Support/Debug.h"
|
2014-08-01 13:07:19 +00:00
|
|
|
#include "llvm/Support/Endian.h"
|
2011-09-19 17:56:04 +00:00
|
|
|
#include "llvm/Support/Format.h"
|
|
|
|
#include "llvm/Support/GraphWriter.h"
|
2012-12-04 10:44:52 +00:00
|
|
|
#include "llvm/Support/MachO.h"
|
2011-09-19 17:56:04 +00:00
|
|
|
#include "llvm/Support/MemoryBuffer.h"
|
|
|
|
#include "llvm/Support/TargetRegistry.h"
|
|
|
|
#include "llvm/Support/TargetSelect.h"
|
|
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include <algorithm>
|
|
|
|
#include <cstring>
|
2014-06-12 17:38:55 +00:00
|
|
|
#include <system_error>
|
2011-09-19 17:56:04 +00:00
|
|
|
using namespace llvm;
|
|
|
|
using namespace object;
|
|
|
|
|
2011-09-21 01:13:19 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
UseDbg("g", cl::desc("Print line information from debug info if available"));
|
|
|
|
|
|
|
|
static cl::opt<std::string>
|
|
|
|
DSYMFile("dsym", cl::desc("Use .dSYM file for debug info"));
|
|
|
|
|
2013-04-18 18:08:55 +00:00
|
|
|
static const Target *GetTarget(const MachOObjectFile *MachOObj) {
|
2011-09-19 17:56:04 +00:00
|
|
|
// Figure out the target triple.
|
2012-02-03 06:35:22 +00:00
|
|
|
if (TripleName.empty()) {
|
|
|
|
llvm::Triple TT("unknown-unknown-unknown");
|
2013-04-11 03:34:37 +00:00
|
|
|
TT.setArch(Triple::ArchType(MachOObj->getArch()));
|
2012-02-03 06:35:22 +00:00
|
|
|
TripleName = TT.str();
|
2011-09-19 17:56:04 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Get the target specific parser.
|
|
|
|
std::string Error;
|
|
|
|
const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
|
|
|
|
if (TheTarget)
|
|
|
|
return TheTarget;
|
|
|
|
|
|
|
|
errs() << "llvm-objdump: error: unable to get target for '" << TripleName
|
|
|
|
<< "', see --version and --triple.\n";
|
2014-04-25 04:24:47 +00:00
|
|
|
return nullptr;
|
2011-09-19 17:56:04 +00:00
|
|
|
}
|
|
|
|
|
2011-10-17 21:37:35 +00:00
|
|
|
struct SymbolSorter {
|
|
|
|
bool operator()(const SymbolRef &A, const SymbolRef &B) {
|
|
|
|
SymbolRef::Type AType, BType;
|
|
|
|
A.getType(AType);
|
|
|
|
B.getType(BType);
|
|
|
|
|
|
|
|
uint64_t AAddr, BAddr;
|
|
|
|
if (AType != SymbolRef::ST_Function)
|
|
|
|
AAddr = 0;
|
|
|
|
else
|
|
|
|
A.getAddress(AAddr);
|
|
|
|
if (BType != SymbolRef::ST_Function)
|
|
|
|
BAddr = 0;
|
|
|
|
else
|
|
|
|
B.getAddress(BAddr);
|
|
|
|
return AAddr < BAddr;
|
|
|
|
}
|
2011-09-19 17:56:04 +00:00
|
|
|
};
|
|
|
|
|
2013-06-06 17:20:50 +00:00
|
|
|
// Types for the storted data in code table that is built before disassembly
|
|
|
|
// and the predicate function to sort them.
|
|
|
|
typedef std::pair<uint64_t, DiceRef> DiceTableEntry;
|
|
|
|
typedef std::vector<DiceTableEntry> DiceTable;
|
|
|
|
typedef DiceTable::iterator dice_table_iterator;
|
|
|
|
|
|
|
|
static bool
|
|
|
|
compareDiceTableEntries(const DiceTableEntry i,
|
|
|
|
const DiceTableEntry j) {
|
|
|
|
return i.first == j.first;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void DumpDataInCode(const char *bytes, uint64_t Size,
|
|
|
|
unsigned short Kind) {
|
|
|
|
uint64_t Value;
|
|
|
|
|
|
|
|
switch (Kind) {
|
2013-09-01 04:28:48 +00:00
|
|
|
case MachO::DICE_KIND_DATA:
|
2013-06-06 17:20:50 +00:00
|
|
|
switch (Size) {
|
|
|
|
case 4:
|
|
|
|
Value = bytes[3] << 24 |
|
|
|
|
bytes[2] << 16 |
|
|
|
|
bytes[1] << 8 |
|
|
|
|
bytes[0];
|
|
|
|
outs() << "\t.long " << Value;
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
Value = bytes[1] << 8 |
|
|
|
|
bytes[0];
|
|
|
|
outs() << "\t.short " << Value;
|
|
|
|
break;
|
|
|
|
case 1:
|
|
|
|
Value = bytes[0];
|
|
|
|
outs() << "\t.byte " << Value;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
outs() << "\t@ KIND_DATA\n";
|
|
|
|
break;
|
2013-09-01 04:28:48 +00:00
|
|
|
case MachO::DICE_KIND_JUMP_TABLE8:
|
2013-06-06 17:20:50 +00:00
|
|
|
Value = bytes[0];
|
|
|
|
outs() << "\t.byte " << Value << "\t@ KIND_JUMP_TABLE8";
|
|
|
|
break;
|
2013-09-01 04:28:48 +00:00
|
|
|
case MachO::DICE_KIND_JUMP_TABLE16:
|
2013-06-06 17:20:50 +00:00
|
|
|
Value = bytes[1] << 8 |
|
|
|
|
bytes[0];
|
|
|
|
outs() << "\t.short " << Value << "\t@ KIND_JUMP_TABLE16";
|
|
|
|
break;
|
2013-09-01 04:28:48 +00:00
|
|
|
case MachO::DICE_KIND_JUMP_TABLE32:
|
2013-06-06 17:20:50 +00:00
|
|
|
Value = bytes[3] << 24 |
|
|
|
|
bytes[2] << 16 |
|
|
|
|
bytes[1] << 8 |
|
|
|
|
bytes[0];
|
|
|
|
outs() << "\t.long " << Value << "\t@ KIND_JUMP_TABLE32";
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
outs() << "\t@ data in code kind = " << Kind << "\n";
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-17 07:28:19 +00:00
|
|
|
static void getSectionsAndSymbols(const MachO::mach_header Header,
|
|
|
|
MachOObjectFile *MachOObj,
|
|
|
|
std::vector<SectionRef> &Sections,
|
|
|
|
std::vector<SymbolRef> &Symbols,
|
|
|
|
SmallVectorImpl<uint64_t> &FoundFns,
|
|
|
|
uint64_t &BaseSegmentAddress) {
|
|
|
|
for (const SymbolRef &Symbol : MachOObj->symbols())
|
|
|
|
Symbols.push_back(Symbol);
|
2011-10-17 21:37:35 +00:00
|
|
|
|
2014-03-13 14:37:36 +00:00
|
|
|
for (const SectionRef &Section : MachOObj->sections()) {
|
2011-10-17 21:37:35 +00:00
|
|
|
StringRef SectName;
|
2014-03-13 14:37:36 +00:00
|
|
|
Section.getName(SectName);
|
|
|
|
Sections.push_back(Section);
|
2011-10-17 21:37:35 +00:00
|
|
|
}
|
2011-09-21 01:13:19 +00:00
|
|
|
|
2013-04-18 18:08:55 +00:00
|
|
|
MachOObjectFile::LoadCommandInfo Command =
|
2014-03-13 14:37:36 +00:00
|
|
|
MachOObj->getFirstLoadCommandInfo();
|
2013-06-06 17:20:50 +00:00
|
|
|
bool BaseSegmentAddressSet = false;
|
2013-04-19 11:36:47 +00:00
|
|
|
for (unsigned i = 0; ; ++i) {
|
2013-09-01 04:28:48 +00:00
|
|
|
if (Command.C.cmd == MachO::LC_FUNCTION_STARTS) {
|
2011-09-21 01:13:19 +00:00
|
|
|
// We found a function starts segment, parse the addresses for later
|
|
|
|
// consumption.
|
2013-09-01 04:28:48 +00:00
|
|
|
MachO::linkedit_data_command LLC =
|
2013-04-18 18:08:55 +00:00
|
|
|
MachOObj->getLinkeditDataLoadCommand(Command);
|
2011-09-21 01:13:19 +00:00
|
|
|
|
2013-09-01 04:28:48 +00:00
|
|
|
MachOObj->ReadULEB128s(LLC.dataoff, FoundFns);
|
2011-09-21 22:16:43 +00:00
|
|
|
}
|
2013-09-01 04:28:48 +00:00
|
|
|
else if (Command.C.cmd == MachO::LC_SEGMENT) {
|
|
|
|
MachO::segment_command SLC =
|
2013-06-06 17:20:50 +00:00
|
|
|
MachOObj->getSegmentLoadCommand(Command);
|
2013-09-01 04:28:48 +00:00
|
|
|
StringRef SegName = SLC.segname;
|
2013-06-06 17:20:50 +00:00
|
|
|
if(!BaseSegmentAddressSet && SegName != "__PAGEZERO") {
|
|
|
|
BaseSegmentAddressSet = true;
|
2013-09-01 04:28:48 +00:00
|
|
|
BaseSegmentAddress = SLC.vmaddr;
|
2013-06-06 17:20:50 +00:00
|
|
|
}
|
|
|
|
}
|
2013-04-19 11:36:47 +00:00
|
|
|
|
2013-09-01 04:28:48 +00:00
|
|
|
if (i == Header.ncmds - 1)
|
2013-04-19 11:36:47 +00:00
|
|
|
break;
|
|
|
|
else
|
|
|
|
Command = MachOObj->getNextLoadCommandInfo(Command);
|
2011-09-21 22:16:43 +00:00
|
|
|
}
|
2011-09-21 01:13:19 +00:00
|
|
|
}
|
|
|
|
|
2013-04-13 01:45:40 +00:00
|
|
|
static void DisassembleInputMachO2(StringRef Filename,
|
2013-04-18 18:08:55 +00:00
|
|
|
MachOObjectFile *MachOOF);
|
2013-04-13 01:45:40 +00:00
|
|
|
|
2011-09-19 17:56:04 +00:00
|
|
|
void llvm::DisassembleInputMachO(StringRef Filename) {
|
2014-07-06 17:43:13 +00:00
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> Buff =
|
|
|
|
MemoryBuffer::getFileOrSTDIN(Filename);
|
|
|
|
if (std::error_code EC = Buff.getError()) {
|
|
|
|
errs() << "llvm-objdump: " << Filename << ": " << EC.message() << "\n";
|
2011-09-19 17:56:04 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2014-07-31 03:12:45 +00:00
|
|
|
std::unique_ptr<MachOObjectFile> MachOOF =
|
|
|
|
std::move(ObjectFile::createMachOObjectFile(Buff.get()).get());
|
2011-09-19 17:56:04 +00:00
|
|
|
|
2013-04-18 18:08:55 +00:00
|
|
|
DisassembleInputMachO2(Filename, MachOOF.get());
|
2013-04-13 01:45:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static void DisassembleInputMachO2(StringRef Filename,
|
2013-04-18 18:08:55 +00:00
|
|
|
MachOObjectFile *MachOOF) {
|
2013-04-13 01:45:40 +00:00
|
|
|
const Target *TheTarget = GetTarget(MachOOF);
|
2011-09-19 17:56:04 +00:00
|
|
|
if (!TheTarget) {
|
|
|
|
// GetTarget prints out stuff.
|
|
|
|
return;
|
|
|
|
}
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<const MCInstrInfo> InstrInfo(TheTarget->createMCInstrInfo());
|
|
|
|
std::unique_ptr<MCInstrAnalysis> InstrAnalysis(
|
|
|
|
TheTarget->createMCInstrAnalysis(InstrInfo.get()));
|
2011-09-19 17:56:04 +00:00
|
|
|
|
2014-08-06 23:24:41 +00:00
|
|
|
// Package up features to be passed to target/subtarget
|
|
|
|
std::string FeaturesStr;
|
|
|
|
if (MAttrs.size()) {
|
|
|
|
SubtargetFeatures Features;
|
|
|
|
for (unsigned i = 0; i != MAttrs.size(); ++i)
|
|
|
|
Features.AddFeature(MAttrs[i]);
|
|
|
|
FeaturesStr = Features.getString();
|
|
|
|
}
|
|
|
|
|
2011-09-19 17:56:04 +00:00
|
|
|
// Set up disassembler.
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<const MCRegisterInfo> MRI(
|
|
|
|
TheTarget->createMCRegInfo(TripleName));
|
|
|
|
std::unique_ptr<const MCAsmInfo> AsmInfo(
|
2013-05-13 01:16:13 +00:00
|
|
|
TheTarget->createMCAsmInfo(*MRI, TripleName));
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<const MCSubtargetInfo> STI(
|
2014-08-06 23:24:41 +00:00
|
|
|
TheTarget->createMCSubtargetInfo(TripleName, MCPU, FeaturesStr));
|
2014-04-25 04:24:47 +00:00
|
|
|
MCContext Ctx(AsmInfo.get(), MRI.get(), nullptr);
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<const MCDisassembler> DisAsm(
|
2014-04-15 04:40:56 +00:00
|
|
|
TheTarget->createMCDisassembler(*STI, Ctx));
|
2011-09-19 17:56:04 +00:00
|
|
|
int AsmPrinterVariant = AsmInfo->getAssemblerDialect();
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<MCInstPrinter> IP(TheTarget->createMCInstPrinter(
|
|
|
|
AsmPrinterVariant, *AsmInfo, *InstrInfo, *MRI, *STI));
|
2011-09-20 17:53:01 +00:00
|
|
|
|
|
|
|
if (!InstrAnalysis || !AsmInfo || !STI || !DisAsm || !IP) {
|
2011-10-07 19:25:47 +00:00
|
|
|
errs() << "error: couldn't initialize disassembler for target "
|
2011-09-20 17:53:01 +00:00
|
|
|
<< TripleName << '\n';
|
2011-09-19 17:56:04 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2011-09-20 17:53:01 +00:00
|
|
|
outs() << '\n' << Filename << ":\n\n";
|
2011-09-19 17:56:04 +00:00
|
|
|
|
2013-09-01 04:28:48 +00:00
|
|
|
MachO::mach_header Header = MachOOF->getHeader();
|
2011-09-19 17:56:04 +00:00
|
|
|
|
MC: Disassembled CFG reconstruction.
This patch builds on some existing code to do CFG reconstruction from
a disassembled binary:
- MCModule represents the binary, and has a list of MCAtoms.
- MCAtom represents either disassembled instructions (MCTextAtom), or
contiguous data (MCDataAtom), and covers a specific range of addresses.
- MCBasicBlock and MCFunction form the reconstructed CFG. An MCBB is
backed by an MCTextAtom, and has the usual successors/predecessors.
- MCObjectDisassembler creates a module from an ObjectFile using a
disassembler. It first builds an atom for each section. It can also
construct the CFG, and this splits the text atoms into basic blocks.
MCModule and MCAtom were only sketched out; MCFunction and MCBB were
implemented under the experimental "-cfg" llvm-objdump -macho option.
This cleans them up for further use; llvm-objdump -d -cfg now generates
graphviz files for each function found in the binary.
In the future, MCObjectDisassembler may be the right place to do
"intelligent" disassembly: for example, handling constant islands is just
a matter of splitting the atom, using information that may be available
in the ObjectFile. Also, better initial atom formation than just using
sections is possible using symbols (and things like Mach-O's
function_starts load command).
This brings two minor regressions in llvm-objdump -macho -cfg:
- The printing of a relocation's referenced symbol.
- An annotation on loop BBs, i.e., which are their own successor.
Relocation printing is replaced by the MCSymbolizer; the basic CFG
annotation will be superseded by more related functionality.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182628 91177308-0d34-0410-b5e6-96231b3b80d8
2013-05-24 01:07:04 +00:00
|
|
|
// FIXME: FoundFns isn't used anymore. Using symbols/LC_FUNCTION_STARTS to
|
|
|
|
// determine function locations will eventually go in MCObjectDisassembler.
|
|
|
|
// FIXME: Using the -cfg command line option, this code used to be able to
|
|
|
|
// annotate relocations with the referenced symbol's name, and if this was
|
|
|
|
// inside a __[cf]string section, the data it points to. This is now replaced
|
|
|
|
// by the upcoming MCSymbolizer, which needs the appropriate setup done above.
|
2011-10-17 21:37:35 +00:00
|
|
|
std::vector<SectionRef> Sections;
|
|
|
|
std::vector<SymbolRef> Symbols;
|
2011-09-19 17:56:04 +00:00
|
|
|
SmallVector<uint64_t, 8> FoundFns;
|
2013-06-06 17:20:50 +00:00
|
|
|
uint64_t BaseSegmentAddress;
|
2011-09-19 17:56:04 +00:00
|
|
|
|
2013-06-06 17:20:50 +00:00
|
|
|
getSectionsAndSymbols(Header, MachOOF, Sections, Symbols, FoundFns,
|
|
|
|
BaseSegmentAddress);
|
2011-09-19 17:56:04 +00:00
|
|
|
|
|
|
|
// Sort the symbols by address, just in case they didn't come in that way.
|
2011-10-17 21:37:35 +00:00
|
|
|
std::sort(Symbols.begin(), Symbols.end(), SymbolSorter());
|
2011-09-19 17:56:04 +00:00
|
|
|
|
2013-06-06 17:20:50 +00:00
|
|
|
// Build a data in code table that is sorted on by the address of each entry.
|
|
|
|
uint64_t BaseAddress = 0;
|
2013-09-01 04:28:48 +00:00
|
|
|
if (Header.filetype == MachO::MH_OBJECT)
|
2013-06-06 17:20:50 +00:00
|
|
|
Sections[0].getAddress(BaseAddress);
|
|
|
|
else
|
|
|
|
BaseAddress = BaseSegmentAddress;
|
|
|
|
DiceTable Dices;
|
|
|
|
for (dice_iterator DI = MachOOF->begin_dices(), DE = MachOOF->end_dices();
|
2014-01-30 02:49:50 +00:00
|
|
|
DI != DE; ++DI) {
|
2013-06-06 17:20:50 +00:00
|
|
|
uint32_t Offset;
|
|
|
|
DI->getOffset(Offset);
|
|
|
|
Dices.push_back(std::make_pair(BaseAddress + Offset, *DI));
|
|
|
|
}
|
|
|
|
array_pod_sort(Dices.begin(), Dices.end());
|
|
|
|
|
2011-09-19 17:56:04 +00:00
|
|
|
#ifndef NDEBUG
|
|
|
|
raw_ostream &DebugOut = DebugFlag ? dbgs() : nulls();
|
|
|
|
#else
|
|
|
|
raw_ostream &DebugOut = nulls();
|
|
|
|
#endif
|
|
|
|
|
2014-03-06 05:51:42 +00:00
|
|
|
std::unique_ptr<DIContext> diContext;
|
2013-04-13 01:45:40 +00:00
|
|
|
ObjectFile *DbgObj = MachOOF;
|
2011-09-21 01:13:19 +00:00
|
|
|
// Try to find debug info and set up the DIContext for it.
|
|
|
|
if (UseDbg) {
|
|
|
|
// A separate DSym file path was specified, parse it as a macho file,
|
|
|
|
// get the sections and supply it to the section name parsing machinery.
|
|
|
|
if (!DSYMFile.empty()) {
|
2014-07-06 17:43:13 +00:00
|
|
|
ErrorOr<std::unique_ptr<MemoryBuffer>> Buf =
|
|
|
|
MemoryBuffer::getFileOrSTDIN(DSYMFile);
|
|
|
|
if (std::error_code EC = Buf.getError()) {
|
|
|
|
errs() << "llvm-objdump: " << Filename << ": " << EC.message() << '\n';
|
2011-09-21 01:13:19 +00:00
|
|
|
return;
|
|
|
|
}
|
2014-07-31 03:12:45 +00:00
|
|
|
DbgObj = ObjectFile::createMachOObjectFile(Buf.get()).get().release();
|
2011-09-21 01:13:19 +00:00
|
|
|
}
|
|
|
|
|
2012-11-12 21:40:38 +00:00
|
|
|
// Setup the DIContext
|
2014-07-31 20:19:36 +00:00
|
|
|
diContext.reset(DIContext::getDWARFContext(*DbgObj));
|
2011-09-21 01:13:19 +00:00
|
|
|
}
|
|
|
|
|
2011-09-19 17:56:04 +00:00
|
|
|
for (unsigned SectIdx = 0; SectIdx != Sections.size(); SectIdx++) {
|
MC: Disassembled CFG reconstruction.
This patch builds on some existing code to do CFG reconstruction from
a disassembled binary:
- MCModule represents the binary, and has a list of MCAtoms.
- MCAtom represents either disassembled instructions (MCTextAtom), or
contiguous data (MCDataAtom), and covers a specific range of addresses.
- MCBasicBlock and MCFunction form the reconstructed CFG. An MCBB is
backed by an MCTextAtom, and has the usual successors/predecessors.
- MCObjectDisassembler creates a module from an ObjectFile using a
disassembler. It first builds an atom for each section. It can also
construct the CFG, and this splits the text atoms into basic blocks.
MCModule and MCAtom were only sketched out; MCFunction and MCBB were
implemented under the experimental "-cfg" llvm-objdump -macho option.
This cleans them up for further use; llvm-objdump -d -cfg now generates
graphviz files for each function found in the binary.
In the future, MCObjectDisassembler may be the right place to do
"intelligent" disassembly: for example, handling constant islands is just
a matter of splitting the atom, using information that may be available
in the ObjectFile. Also, better initial atom formation than just using
sections is possible using symbols (and things like Mach-O's
function_starts load command).
This brings two minor regressions in llvm-objdump -macho -cfg:
- The printing of a relocation's referenced symbol.
- An annotation on loop BBs, i.e., which are their own successor.
Relocation printing is replaced by the MCSymbolizer; the basic CFG
annotation will be superseded by more related functionality.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182628 91177308-0d34-0410-b5e6-96231b3b80d8
2013-05-24 01:07:04 +00:00
|
|
|
|
|
|
|
bool SectIsText = false;
|
|
|
|
Sections[SectIdx].isText(SectIsText);
|
|
|
|
if (SectIsText == false)
|
|
|
|
continue;
|
|
|
|
|
2011-10-17 21:37:35 +00:00
|
|
|
StringRef SectName;
|
|
|
|
if (Sections[SectIdx].getName(SectName) ||
|
Add a function to get the segment name of a section.
On MachO, sections also have segment names. When a tool looking at a .o file
prints a segment name, this is what they mean. In reality, a .o has only one
anonymous, segment.
This patch adds a MachO only function to fetch that segment name. I named it
getSectionFinalSegmentName since the main use for the name seems to be inform
the linker with segment this section should go to.
The patch also changes MachOObjectFile::getSectionName to return just the
section name instead of computing SegmentName,SectionName.
The main difference from the previous patch is that it doesn't use
InMemoryStruct. It is extremely dangerous: if the endians match it returns
a pointer to the file buffer, if not, it returns a pointer to an internal buffer
that is overwritten in the next API call.
We should change all of this code to use
support::detail::packed_endian_specific_integral like ELF, but since these
functions only handle strings, they work with big and little endian machines
as is.
I have tested this by installing ubuntu 12.10 ppc on qemu, that is why it took
so long :-)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@170838 91177308-0d34-0410-b5e6-96231b3b80d8
2012-12-21 03:47:03 +00:00
|
|
|
SectName != "__text")
|
2011-09-20 17:53:01 +00:00
|
|
|
continue; // Skip non-text sections
|
2011-09-19 17:56:04 +00:00
|
|
|
|
Add a function to get the segment name of a section.
On MachO, sections also have segment names. When a tool looking at a .o file
prints a segment name, this is what they mean. In reality, a .o has only one
anonymous, segment.
This patch adds a MachO only function to fetch that segment name. I named it
getSectionFinalSegmentName since the main use for the name seems to be inform
the linker with segment this section should go to.
The patch also changes MachOObjectFile::getSectionName to return just the
section name instead of computing SegmentName,SectionName.
The main difference from the previous patch is that it doesn't use
InMemoryStruct. It is extremely dangerous: if the endians match it returns
a pointer to the file buffer, if not, it returns a pointer to an internal buffer
that is overwritten in the next API call.
We should change all of this code to use
support::detail::packed_endian_specific_integral like ELF, but since these
functions only handle strings, they work with big and little endian machines
as is.
I have tested this by installing ubuntu 12.10 ppc on qemu, that is why it took
so long :-)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@170838 91177308-0d34-0410-b5e6-96231b3b80d8
2012-12-21 03:47:03 +00:00
|
|
|
DataRefImpl DR = Sections[SectIdx].getRawDataRefImpl();
|
MC: Disassembled CFG reconstruction.
This patch builds on some existing code to do CFG reconstruction from
a disassembled binary:
- MCModule represents the binary, and has a list of MCAtoms.
- MCAtom represents either disassembled instructions (MCTextAtom), or
contiguous data (MCDataAtom), and covers a specific range of addresses.
- MCBasicBlock and MCFunction form the reconstructed CFG. An MCBB is
backed by an MCTextAtom, and has the usual successors/predecessors.
- MCObjectDisassembler creates a module from an ObjectFile using a
disassembler. It first builds an atom for each section. It can also
construct the CFG, and this splits the text atoms into basic blocks.
MCModule and MCAtom were only sketched out; MCFunction and MCBB were
implemented under the experimental "-cfg" llvm-objdump -macho option.
This cleans them up for further use; llvm-objdump -d -cfg now generates
graphviz files for each function found in the binary.
In the future, MCObjectDisassembler may be the right place to do
"intelligent" disassembly: for example, handling constant islands is just
a matter of splitting the atom, using information that may be available
in the ObjectFile. Also, better initial atom formation than just using
sections is possible using symbols (and things like Mach-O's
function_starts load command).
This brings two minor regressions in llvm-objdump -macho -cfg:
- The printing of a relocation's referenced symbol.
- An annotation on loop BBs, i.e., which are their own successor.
Relocation printing is replaced by the MCSymbolizer; the basic CFG
annotation will be superseded by more related functionality.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182628 91177308-0d34-0410-b5e6-96231b3b80d8
2013-05-24 01:07:04 +00:00
|
|
|
|
2013-04-05 15:15:22 +00:00
|
|
|
StringRef SegmentName = MachOOF->getSectionFinalSegmentName(DR);
|
|
|
|
if (SegmentName != "__TEXT")
|
Add a function to get the segment name of a section.
On MachO, sections also have segment names. When a tool looking at a .o file
prints a segment name, this is what they mean. In reality, a .o has only one
anonymous, segment.
This patch adds a MachO only function to fetch that segment name. I named it
getSectionFinalSegmentName since the main use for the name seems to be inform
the linker with segment this section should go to.
The patch also changes MachOObjectFile::getSectionName to return just the
section name instead of computing SegmentName,SectionName.
The main difference from the previous patch is that it doesn't use
InMemoryStruct. It is extremely dangerous: if the endians match it returns
a pointer to the file buffer, if not, it returns a pointer to an internal buffer
that is overwritten in the next API call.
We should change all of this code to use
support::detail::packed_endian_specific_integral like ELF, but since these
functions only handle strings, they work with big and little endian machines
as is.
I have tested this by installing ubuntu 12.10 ppc on qemu, that is why it took
so long :-)
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@170838 91177308-0d34-0410-b5e6-96231b3b80d8
2012-12-21 03:47:03 +00:00
|
|
|
continue;
|
|
|
|
|
2011-10-17 21:37:35 +00:00
|
|
|
StringRef Bytes;
|
|
|
|
Sections[SectIdx].getContents(Bytes);
|
2011-09-19 17:56:04 +00:00
|
|
|
StringRefMemoryObject memoryObject(Bytes);
|
|
|
|
bool symbolTableWorked = false;
|
|
|
|
|
2011-09-20 17:53:01 +00:00
|
|
|
// Parse relocations.
|
2014-03-14 14:22:49 +00:00
|
|
|
std::vector<std::pair<uint64_t, SymbolRef>> Relocs;
|
|
|
|
for (const RelocationRef &Reloc : Sections[SectIdx].relocations()) {
|
2011-10-17 21:37:35 +00:00
|
|
|
uint64_t RelocOffset, SectionAddress;
|
2014-03-14 14:22:49 +00:00
|
|
|
Reloc.getOffset(RelocOffset);
|
2011-10-17 21:37:35 +00:00
|
|
|
Sections[SectIdx].getAddress(SectionAddress);
|
|
|
|
RelocOffset -= SectionAddress;
|
|
|
|
|
2014-03-14 14:22:49 +00:00
|
|
|
symbol_iterator RelocSym = Reloc.getSymbol();
|
2011-10-17 21:37:35 +00:00
|
|
|
|
2013-06-05 01:33:53 +00:00
|
|
|
Relocs.push_back(std::make_pair(RelocOffset, *RelocSym));
|
2011-09-19 17:56:04 +00:00
|
|
|
}
|
|
|
|
array_pod_sort(Relocs.begin(), Relocs.end());
|
|
|
|
|
2011-09-20 17:53:01 +00:00
|
|
|
// Disassemble symbol by symbol.
|
2011-09-19 17:56:04 +00:00
|
|
|
for (unsigned SymIdx = 0; SymIdx != Symbols.size(); SymIdx++) {
|
2011-10-17 21:37:35 +00:00
|
|
|
StringRef SymName;
|
|
|
|
Symbols[SymIdx].getName(SymName);
|
|
|
|
|
|
|
|
SymbolRef::Type ST;
|
|
|
|
Symbols[SymIdx].getType(ST);
|
|
|
|
if (ST != SymbolRef::ST_Function)
|
|
|
|
continue;
|
|
|
|
|
2011-09-20 17:53:01 +00:00
|
|
|
// Make sure the symbol is defined in this section.
|
2011-10-17 21:37:35 +00:00
|
|
|
bool containsSym = false;
|
|
|
|
Sections[SectIdx].containsSymbol(Symbols[SymIdx], containsSym);
|
|
|
|
if (!containsSym)
|
2011-09-19 17:56:04 +00:00
|
|
|
continue;
|
|
|
|
|
2011-09-20 17:53:01 +00:00
|
|
|
// Start at the address of the symbol relative to the section's address.
|
2012-02-03 05:42:17 +00:00
|
|
|
uint64_t SectionAddress = 0;
|
2011-10-17 21:37:35 +00:00
|
|
|
uint64_t Start = 0;
|
2012-02-03 05:42:17 +00:00
|
|
|
Sections[SectIdx].getAddress(SectionAddress);
|
2011-11-29 17:40:10 +00:00
|
|
|
Symbols[SymIdx].getAddress(Start);
|
2012-02-03 05:42:17 +00:00
|
|
|
Start -= SectionAddress;
|
2011-10-17 21:37:35 +00:00
|
|
|
|
2011-09-20 17:53:01 +00:00
|
|
|
// Stop disassembling either at the beginning of the next symbol or at
|
|
|
|
// the end of the section.
|
2012-05-15 18:57:14 +00:00
|
|
|
bool containsNextSym = false;
|
2011-10-17 21:37:35 +00:00
|
|
|
uint64_t NextSym = 0;
|
|
|
|
uint64_t NextSymIdx = SymIdx+1;
|
|
|
|
while (Symbols.size() > NextSymIdx) {
|
|
|
|
SymbolRef::Type NextSymType;
|
|
|
|
Symbols[NextSymIdx].getType(NextSymType);
|
|
|
|
if (NextSymType == SymbolRef::ST_Function) {
|
|
|
|
Sections[SectIdx].containsSymbol(Symbols[NextSymIdx],
|
|
|
|
containsNextSym);
|
2011-11-29 17:40:10 +00:00
|
|
|
Symbols[NextSymIdx].getAddress(NextSym);
|
2012-02-03 05:42:17 +00:00
|
|
|
NextSym -= SectionAddress;
|
2011-10-17 21:37:35 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
++NextSymIdx;
|
|
|
|
}
|
2011-09-19 17:56:04 +00:00
|
|
|
|
2011-10-17 21:37:35 +00:00
|
|
|
uint64_t SectSize;
|
|
|
|
Sections[SectIdx].getSize(SectSize);
|
|
|
|
uint64_t End = containsNextSym ? NextSym : SectSize;
|
|
|
|
uint64_t Size;
|
2011-09-19 17:56:04 +00:00
|
|
|
|
|
|
|
symbolTableWorked = true;
|
|
|
|
|
MC: Disassembled CFG reconstruction.
This patch builds on some existing code to do CFG reconstruction from
a disassembled binary:
- MCModule represents the binary, and has a list of MCAtoms.
- MCAtom represents either disassembled instructions (MCTextAtom), or
contiguous data (MCDataAtom), and covers a specific range of addresses.
- MCBasicBlock and MCFunction form the reconstructed CFG. An MCBB is
backed by an MCTextAtom, and has the usual successors/predecessors.
- MCObjectDisassembler creates a module from an ObjectFile using a
disassembler. It first builds an atom for each section. It can also
construct the CFG, and this splits the text atoms into basic blocks.
MCModule and MCAtom were only sketched out; MCFunction and MCBB were
implemented under the experimental "-cfg" llvm-objdump -macho option.
This cleans them up for further use; llvm-objdump -d -cfg now generates
graphviz files for each function found in the binary.
In the future, MCObjectDisassembler may be the right place to do
"intelligent" disassembly: for example, handling constant islands is just
a matter of splitting the atom, using information that may be available
in the ObjectFile. Also, better initial atom formation than just using
sections is possible using symbols (and things like Mach-O's
function_starts load command).
This brings two minor regressions in llvm-objdump -macho -cfg:
- The printing of a relocation's referenced symbol.
- An annotation on loop BBs, i.e., which are their own successor.
Relocation printing is replaced by the MCSymbolizer; the basic CFG
annotation will be superseded by more related functionality.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182628 91177308-0d34-0410-b5e6-96231b3b80d8
2013-05-24 01:07:04 +00:00
|
|
|
outs() << SymName << ":\n";
|
|
|
|
DILineInfo lastLine;
|
|
|
|
for (uint64_t Index = Start; Index < End; Index += Size) {
|
|
|
|
MCInst Inst;
|
|
|
|
|
2013-06-06 17:20:50 +00:00
|
|
|
uint64_t SectAddress = 0;
|
|
|
|
Sections[SectIdx].getAddress(SectAddress);
|
|
|
|
outs() << format("%8" PRIx64 ":\t", SectAddress + Index);
|
|
|
|
|
|
|
|
// Check the data in code table here to see if this is data not an
|
|
|
|
// instruction to be disassembled.
|
|
|
|
DiceTable Dice;
|
|
|
|
Dice.push_back(std::make_pair(SectAddress + Index, DiceRef()));
|
|
|
|
dice_table_iterator DTI = std::search(Dices.begin(), Dices.end(),
|
|
|
|
Dice.begin(), Dice.end(),
|
|
|
|
compareDiceTableEntries);
|
|
|
|
if (DTI != Dices.end()){
|
|
|
|
uint16_t Length;
|
|
|
|
DTI->second.getLength(Length);
|
|
|
|
DumpBytes(StringRef(Bytes.data() + Index, Length));
|
|
|
|
uint16_t Kind;
|
|
|
|
DTI->second.getKind(Kind);
|
|
|
|
DumpDataInCode(Bytes.data() + Index, Length, Kind);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
MC: Disassembled CFG reconstruction.
This patch builds on some existing code to do CFG reconstruction from
a disassembled binary:
- MCModule represents the binary, and has a list of MCAtoms.
- MCAtom represents either disassembled instructions (MCTextAtom), or
contiguous data (MCDataAtom), and covers a specific range of addresses.
- MCBasicBlock and MCFunction form the reconstructed CFG. An MCBB is
backed by an MCTextAtom, and has the usual successors/predecessors.
- MCObjectDisassembler creates a module from an ObjectFile using a
disassembler. It first builds an atom for each section. It can also
construct the CFG, and this splits the text atoms into basic blocks.
MCModule and MCAtom were only sketched out; MCFunction and MCBB were
implemented under the experimental "-cfg" llvm-objdump -macho option.
This cleans them up for further use; llvm-objdump -d -cfg now generates
graphviz files for each function found in the binary.
In the future, MCObjectDisassembler may be the right place to do
"intelligent" disassembly: for example, handling constant islands is just
a matter of splitting the atom, using information that may be available
in the ObjectFile. Also, better initial atom formation than just using
sections is possible using symbols (and things like Mach-O's
function_starts load command).
This brings two minor regressions in llvm-objdump -macho -cfg:
- The printing of a relocation's referenced symbol.
- An annotation on loop BBs, i.e., which are their own successor.
Relocation printing is replaced by the MCSymbolizer; the basic CFG
annotation will be superseded by more related functionality.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182628 91177308-0d34-0410-b5e6-96231b3b80d8
2013-05-24 01:07:04 +00:00
|
|
|
if (DisAsm->getInstruction(Inst, Size, memoryObject, Index,
|
|
|
|
DebugOut, nulls())) {
|
|
|
|
DumpBytes(StringRef(Bytes.data() + Index, Size));
|
|
|
|
IP->printInst(&Inst, outs(), "");
|
|
|
|
|
|
|
|
// Print debug info.
|
|
|
|
if (diContext) {
|
|
|
|
DILineInfo dli =
|
|
|
|
diContext->getLineInfoForAddress(SectAddress + Index);
|
|
|
|
// Print valid line info if it changed.
|
2014-04-18 21:36:39 +00:00
|
|
|
if (dli != lastLine && dli.Line != 0)
|
|
|
|
outs() << "\t## " << dli.FileName << ':' << dli.Line << ':'
|
|
|
|
<< dli.Column;
|
MC: Disassembled CFG reconstruction.
This patch builds on some existing code to do CFG reconstruction from
a disassembled binary:
- MCModule represents the binary, and has a list of MCAtoms.
- MCAtom represents either disassembled instructions (MCTextAtom), or
contiguous data (MCDataAtom), and covers a specific range of addresses.
- MCBasicBlock and MCFunction form the reconstructed CFG. An MCBB is
backed by an MCTextAtom, and has the usual successors/predecessors.
- MCObjectDisassembler creates a module from an ObjectFile using a
disassembler. It first builds an atom for each section. It can also
construct the CFG, and this splits the text atoms into basic blocks.
MCModule and MCAtom were only sketched out; MCFunction and MCBB were
implemented under the experimental "-cfg" llvm-objdump -macho option.
This cleans them up for further use; llvm-objdump -d -cfg now generates
graphviz files for each function found in the binary.
In the future, MCObjectDisassembler may be the right place to do
"intelligent" disassembly: for example, handling constant islands is just
a matter of splitting the atom, using information that may be available
in the ObjectFile. Also, better initial atom formation than just using
sections is possible using symbols (and things like Mach-O's
function_starts load command).
This brings two minor regressions in llvm-objdump -macho -cfg:
- The printing of a relocation's referenced symbol.
- An annotation on loop BBs, i.e., which are their own successor.
Relocation printing is replaced by the MCSymbolizer; the basic CFG
annotation will be superseded by more related functionality.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182628 91177308-0d34-0410-b5e6-96231b3b80d8
2013-05-24 01:07:04 +00:00
|
|
|
lastLine = dli;
|
2011-09-19 17:56:04 +00:00
|
|
|
}
|
MC: Disassembled CFG reconstruction.
This patch builds on some existing code to do CFG reconstruction from
a disassembled binary:
- MCModule represents the binary, and has a list of MCAtoms.
- MCAtom represents either disassembled instructions (MCTextAtom), or
contiguous data (MCDataAtom), and covers a specific range of addresses.
- MCBasicBlock and MCFunction form the reconstructed CFG. An MCBB is
backed by an MCTextAtom, and has the usual successors/predecessors.
- MCObjectDisassembler creates a module from an ObjectFile using a
disassembler. It first builds an atom for each section. It can also
construct the CFG, and this splits the text atoms into basic blocks.
MCModule and MCAtom were only sketched out; MCFunction and MCBB were
implemented under the experimental "-cfg" llvm-objdump -macho option.
This cleans them up for further use; llvm-objdump -d -cfg now generates
graphviz files for each function found in the binary.
In the future, MCObjectDisassembler may be the right place to do
"intelligent" disassembly: for example, handling constant islands is just
a matter of splitting the atom, using information that may be available
in the ObjectFile. Also, better initial atom formation than just using
sections is possible using symbols (and things like Mach-O's
function_starts load command).
This brings two minor regressions in llvm-objdump -macho -cfg:
- The printing of a relocation's referenced symbol.
- An annotation on loop BBs, i.e., which are their own successor.
Relocation printing is replaced by the MCSymbolizer; the basic CFG
annotation will be superseded by more related functionality.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182628 91177308-0d34-0410-b5e6-96231b3b80d8
2013-05-24 01:07:04 +00:00
|
|
|
outs() << "\n";
|
|
|
|
} else {
|
|
|
|
errs() << "llvm-objdump: warning: invalid instruction encoding\n";
|
|
|
|
if (Size == 0)
|
|
|
|
Size = 1; // skip illegible bytes
|
2011-09-19 17:56:04 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
MC: Disassembled CFG reconstruction.
This patch builds on some existing code to do CFG reconstruction from
a disassembled binary:
- MCModule represents the binary, and has a list of MCAtoms.
- MCAtom represents either disassembled instructions (MCTextAtom), or
contiguous data (MCDataAtom), and covers a specific range of addresses.
- MCBasicBlock and MCFunction form the reconstructed CFG. An MCBB is
backed by an MCTextAtom, and has the usual successors/predecessors.
- MCObjectDisassembler creates a module from an ObjectFile using a
disassembler. It first builds an atom for each section. It can also
construct the CFG, and this splits the text atoms into basic blocks.
MCModule and MCAtom were only sketched out; MCFunction and MCBB were
implemented under the experimental "-cfg" llvm-objdump -macho option.
This cleans them up for further use; llvm-objdump -d -cfg now generates
graphviz files for each function found in the binary.
In the future, MCObjectDisassembler may be the right place to do
"intelligent" disassembly: for example, handling constant islands is just
a matter of splitting the atom, using information that may be available
in the ObjectFile. Also, better initial atom formation than just using
sections is possible using symbols (and things like Mach-O's
function_starts load command).
This brings two minor regressions in llvm-objdump -macho -cfg:
- The printing of a relocation's referenced symbol.
- An annotation on loop BBs, i.e., which are their own successor.
Relocation printing is replaced by the MCSymbolizer; the basic CFG
annotation will be superseded by more related functionality.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@182628 91177308-0d34-0410-b5e6-96231b3b80d8
2013-05-24 01:07:04 +00:00
|
|
|
if (!symbolTableWorked) {
|
2012-05-18 00:13:56 +00:00
|
|
|
// Reading the symbol table didn't work, disassemble the whole section.
|
|
|
|
uint64_t SectAddress;
|
|
|
|
Sections[SectIdx].getAddress(SectAddress);
|
|
|
|
uint64_t SectSize;
|
|
|
|
Sections[SectIdx].getSize(SectSize);
|
|
|
|
uint64_t InstSize;
|
|
|
|
for (uint64_t Index = 0; Index < SectSize; Index += InstSize) {
|
2012-07-19 00:17:40 +00:00
|
|
|
MCInst Inst;
|
|
|
|
|
|
|
|
if (DisAsm->getInstruction(Inst, InstSize, memoryObject, Index,
|
|
|
|
DebugOut, nulls())) {
|
|
|
|
outs() << format("%8" PRIx64 ":\t", SectAddress + Index);
|
|
|
|
DumpBytes(StringRef(Bytes.data() + Index, InstSize));
|
|
|
|
IP->printInst(&Inst, outs(), "");
|
|
|
|
outs() << "\n";
|
|
|
|
} else {
|
|
|
|
errs() << "llvm-objdump: warning: invalid instruction encoding\n";
|
|
|
|
if (InstSize == 0)
|
|
|
|
InstSize = 1; // skip illegible bytes
|
|
|
|
}
|
2012-05-18 00:13:56 +00:00
|
|
|
}
|
|
|
|
}
|
2011-09-19 17:56:04 +00:00
|
|
|
}
|
|
|
|
}
|
2014-08-01 13:07:19 +00:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
struct CompactUnwindEntry {
|
|
|
|
uint32_t OffsetInSection;
|
|
|
|
|
|
|
|
uint64_t FunctionAddr;
|
|
|
|
uint32_t Length;
|
|
|
|
uint32_t CompactEncoding;
|
|
|
|
uint64_t PersonalityAddr;
|
|
|
|
uint64_t LSDAAddr;
|
|
|
|
|
|
|
|
RelocationRef FunctionReloc;
|
|
|
|
RelocationRef PersonalityReloc;
|
|
|
|
RelocationRef LSDAReloc;
|
|
|
|
|
|
|
|
CompactUnwindEntry(StringRef Contents, unsigned Offset, bool Is64)
|
|
|
|
: OffsetInSection(Offset) {
|
|
|
|
if (Is64)
|
|
|
|
read<uint64_t>(Contents.data() + Offset);
|
|
|
|
else
|
|
|
|
read<uint32_t>(Contents.data() + Offset);
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
|
|
|
template<typename T>
|
|
|
|
static uint64_t readNext(const char *&Buf) {
|
|
|
|
using llvm::support::little;
|
|
|
|
using llvm::support::unaligned;
|
|
|
|
|
|
|
|
uint64_t Val = support::endian::read<T, little, unaligned>(Buf);
|
|
|
|
Buf += sizeof(T);
|
|
|
|
return Val;
|
|
|
|
}
|
|
|
|
|
|
|
|
template<typename UIntPtr>
|
|
|
|
void read(const char *Buf) {
|
|
|
|
FunctionAddr = readNext<UIntPtr>(Buf);
|
|
|
|
Length = readNext<uint32_t>(Buf);
|
|
|
|
CompactEncoding = readNext<uint32_t>(Buf);
|
|
|
|
PersonalityAddr = readNext<UIntPtr>(Buf);
|
|
|
|
LSDAAddr = readNext<UIntPtr>(Buf);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
/// Given a relocation from __compact_unwind, consisting of the RelocationRef
|
|
|
|
/// and data being relocated, determine the best base Name and Addend to use for
|
|
|
|
/// display purposes.
|
|
|
|
///
|
|
|
|
/// 1. An Extern relocation will directly reference a symbol (and the data is
|
|
|
|
/// then already an addend), so use that.
|
|
|
|
/// 2. Otherwise the data is an offset in the object file's layout; try to find
|
|
|
|
// a symbol before it in the same section, and use the offset from there.
|
|
|
|
/// 3. Finally, if all that fails, fall back to an offset from the start of the
|
|
|
|
/// referenced section.
|
|
|
|
static void findUnwindRelocNameAddend(const MachOObjectFile *Obj,
|
|
|
|
std::map<uint64_t, SymbolRef> &Symbols,
|
|
|
|
const RelocationRef &Reloc,
|
|
|
|
uint64_t Addr,
|
|
|
|
StringRef &Name, uint64_t &Addend) {
|
|
|
|
if (Reloc.getSymbol() != Obj->symbol_end()) {
|
|
|
|
Reloc.getSymbol()->getName(Name);
|
|
|
|
Addend = Addr;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
auto RE = Obj->getRelocation(Reloc.getRawDataRefImpl());
|
|
|
|
SectionRef RelocSection = Obj->getRelocationSection(RE);
|
|
|
|
|
|
|
|
uint64_t SectionAddr;
|
|
|
|
RelocSection.getAddress(SectionAddr);
|
|
|
|
|
|
|
|
auto Sym = Symbols.upper_bound(Addr);
|
|
|
|
if (Sym == Symbols.begin()) {
|
|
|
|
// The first symbol in the object is after this reference, the best we can
|
|
|
|
// do is section-relative notation.
|
|
|
|
RelocSection.getName(Name);
|
|
|
|
Addend = Addr - SectionAddr;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Go back one so that SymbolAddress <= Addr.
|
|
|
|
--Sym;
|
|
|
|
|
|
|
|
section_iterator SymSection = Obj->section_end();
|
|
|
|
Sym->second.getSection(SymSection);
|
|
|
|
if (RelocSection == *SymSection) {
|
|
|
|
// There's a valid symbol in the same section before this reference.
|
|
|
|
Sym->second.getName(Name);
|
|
|
|
Addend = Addr - Sym->first;
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
// There is a symbol before this reference, but it's in a different
|
|
|
|
// section. Probably not helpful to mention it, so use the section name.
|
|
|
|
RelocSection.getName(Name);
|
|
|
|
Addend = Addr - SectionAddr;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void printUnwindRelocDest(const MachOObjectFile *Obj,
|
|
|
|
std::map<uint64_t, SymbolRef> &Symbols,
|
|
|
|
const RelocationRef &Reloc,
|
|
|
|
uint64_t Addr) {
|
|
|
|
StringRef Name;
|
|
|
|
uint64_t Addend;
|
|
|
|
|
|
|
|
findUnwindRelocNameAddend(Obj, Symbols, Reloc, Addr, Name, Addend);
|
|
|
|
|
|
|
|
outs() << Name;
|
|
|
|
if (Addend)
|
|
|
|
outs() << " + " << format("0x%x", Addend);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
printMachOCompactUnwindSection(const MachOObjectFile *Obj,
|
|
|
|
std::map<uint64_t, SymbolRef> &Symbols,
|
|
|
|
const SectionRef &CompactUnwind) {
|
|
|
|
|
|
|
|
assert(Obj->isLittleEndian() &&
|
|
|
|
"There should not be a big-endian .o with __compact_unwind");
|
|
|
|
|
|
|
|
bool Is64 = Obj->is64Bit();
|
|
|
|
uint32_t PointerSize = Is64 ? sizeof(uint64_t) : sizeof(uint32_t);
|
|
|
|
uint32_t EntrySize = 3 * PointerSize + 2 * sizeof(uint32_t);
|
|
|
|
|
|
|
|
StringRef Contents;
|
|
|
|
CompactUnwind.getContents(Contents);
|
|
|
|
|
|
|
|
SmallVector<CompactUnwindEntry, 4> CompactUnwinds;
|
|
|
|
|
|
|
|
// First populate the initial raw offsets, encodings and so on from the entry.
|
|
|
|
for (unsigned Offset = 0; Offset < Contents.size(); Offset += EntrySize) {
|
|
|
|
CompactUnwindEntry Entry(Contents.data(), Offset, Is64);
|
|
|
|
CompactUnwinds.push_back(Entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Next we need to look at the relocations to find out what objects are
|
|
|
|
// actually being referred to.
|
|
|
|
for (const RelocationRef &Reloc : CompactUnwind.relocations()) {
|
|
|
|
uint64_t RelocAddress;
|
|
|
|
Reloc.getOffset(RelocAddress);
|
|
|
|
|
|
|
|
uint32_t EntryIdx = RelocAddress / EntrySize;
|
|
|
|
uint32_t OffsetInEntry = RelocAddress - EntryIdx * EntrySize;
|
|
|
|
CompactUnwindEntry &Entry = CompactUnwinds[EntryIdx];
|
|
|
|
|
|
|
|
if (OffsetInEntry == 0)
|
|
|
|
Entry.FunctionReloc = Reloc;
|
|
|
|
else if (OffsetInEntry == PointerSize + 2 * sizeof(uint32_t))
|
|
|
|
Entry.PersonalityReloc = Reloc;
|
|
|
|
else if (OffsetInEntry == 2 * PointerSize + 2 * sizeof(uint32_t))
|
|
|
|
Entry.LSDAReloc = Reloc;
|
|
|
|
else
|
|
|
|
llvm_unreachable("Unexpected relocation in __compact_unwind section");
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finally, we're ready to print the data we've gathered.
|
|
|
|
outs() << "Contents of __compact_unwind section:\n";
|
|
|
|
for (auto &Entry : CompactUnwinds) {
|
2014-08-08 12:00:09 +00:00
|
|
|
outs() << " Entry at offset " << format("0x" PRIx32, Entry.OffsetInSection)
|
2014-08-01 13:07:19 +00:00
|
|
|
<< ":\n";
|
|
|
|
|
|
|
|
// 1. Start of the region this entry applies to.
|
|
|
|
outs() << " start: "
|
2014-08-08 12:00:09 +00:00
|
|
|
<< format("0x%" PRIx64, Entry.FunctionAddr) << ' ';
|
2014-08-01 13:07:19 +00:00
|
|
|
printUnwindRelocDest(Obj, Symbols, Entry.FunctionReloc,
|
|
|
|
Entry.FunctionAddr);
|
|
|
|
outs() << '\n';
|
|
|
|
|
|
|
|
// 2. Length of the region this entry applies to.
|
|
|
|
outs() << " length: "
|
2014-08-08 12:00:09 +00:00
|
|
|
<< format("0x%" PRIx32, Entry.Length) << '\n';
|
2014-08-01 13:07:19 +00:00
|
|
|
// 3. The 32-bit compact encoding.
|
|
|
|
outs() << " compact encoding: "
|
2014-08-08 12:00:09 +00:00
|
|
|
<< format("0x%08" PRIx32, Entry.CompactEncoding) << '\n';
|
2014-08-01 13:07:19 +00:00
|
|
|
|
|
|
|
// 4. The personality function, if present.
|
|
|
|
if (Entry.PersonalityReloc.getObjectFile()) {
|
|
|
|
outs() << " personality function: "
|
2014-08-08 12:00:09 +00:00
|
|
|
<< format("0x%" PRIx64, Entry.PersonalityAddr) << ' ';
|
2014-08-01 13:07:19 +00:00
|
|
|
printUnwindRelocDest(Obj, Symbols, Entry.PersonalityReloc,
|
|
|
|
Entry.PersonalityAddr);
|
|
|
|
outs() << '\n';
|
|
|
|
}
|
|
|
|
|
|
|
|
// 5. This entry's language-specific data area.
|
|
|
|
if (Entry.LSDAReloc.getObjectFile()) {
|
|
|
|
outs() << " LSDA: "
|
2014-08-08 12:00:09 +00:00
|
|
|
<< format("0x%" PRIx64, Entry.LSDAAddr) << ' ';
|
2014-08-01 13:07:19 +00:00
|
|
|
printUnwindRelocDest(Obj, Symbols, Entry.LSDAReloc, Entry.LSDAAddr);
|
|
|
|
outs() << '\n';
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void llvm::printMachOUnwindInfo(const MachOObjectFile *Obj) {
|
|
|
|
std::map<uint64_t, SymbolRef> Symbols;
|
|
|
|
for (const SymbolRef &SymRef : Obj->symbols()) {
|
|
|
|
// Discard any undefined or absolute symbols. They're not going to take part
|
|
|
|
// in the convenience lookup for unwind info and just take up resources.
|
|
|
|
section_iterator Section = Obj->section_end();
|
|
|
|
SymRef.getSection(Section);
|
|
|
|
if (Section == Obj->section_end())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
uint64_t Addr;
|
|
|
|
SymRef.getAddress(Addr);
|
|
|
|
Symbols.insert(std::make_pair(Addr, SymRef));
|
|
|
|
}
|
|
|
|
|
|
|
|
for (const SectionRef &Section : Obj->sections()) {
|
|
|
|
StringRef SectName;
|
|
|
|
Section.getName(SectName);
|
|
|
|
if (SectName == "__compact_unwind")
|
|
|
|
printMachOCompactUnwindSection(Obj, Symbols, Section);
|
|
|
|
else if (SectName == "__unwind_info")
|
|
|
|
outs() << "llvm-objdump: warning: unhandled __unwind_info section\n";
|
|
|
|
else if (SectName == "__eh_frame")
|
|
|
|
outs() << "llvm-objdump: warning: unhandled __eh_frame section\n";
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|