mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-09-03 02:30:00 +00:00
05a81020d9
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@188888 91177308-0d34-0410-b5e6-96231b3b80d8
384 lines
12 KiB
C++
384 lines
12 KiB
C++
//===- lib/MC/MCObjectDisassembler.cpp ------------------------------------===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/MC/MCObjectDisassembler.h"
|
|
#include "llvm/ADT/SetVector.h"
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
#include "llvm/ADT/StringExtras.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/Twine.h"
|
|
#include "llvm/MC/MCAtom.h"
|
|
#include "llvm/MC/MCDisassembler.h"
|
|
#include "llvm/MC/MCFunction.h"
|
|
#include "llvm/MC/MCInstrAnalysis.h"
|
|
#include "llvm/MC/MCModule.h"
|
|
#include "llvm/MC/MCObjectSymbolizer.h"
|
|
#include "llvm/Object/MachO.h"
|
|
#include "llvm/Object/ObjectFile.h"
|
|
#include "llvm/Support/Debug.h"
|
|
#include "llvm/Support/MachO.h"
|
|
#include "llvm/Support/MemoryObject.h"
|
|
#include "llvm/Support/StringRefMemoryObject.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
#include <map>
|
|
#include <vector>
|
|
|
|
using namespace llvm;
|
|
using namespace object;
|
|
|
|
MCObjectDisassembler::MCObjectDisassembler(const ObjectFile &Obj,
|
|
const MCDisassembler &Dis,
|
|
const MCInstrAnalysis &MIA)
|
|
: Obj(Obj), Dis(Dis), MIA(MIA), MOS(0) {}
|
|
|
|
uint64_t MCObjectDisassembler::getEntrypoint() {
|
|
error_code ec;
|
|
for (symbol_iterator SI = Obj.begin_symbols(), SE = Obj.end_symbols();
|
|
SI != SE; SI.increment(ec)) {
|
|
if (ec)
|
|
break;
|
|
StringRef Name;
|
|
SI->getName(Name);
|
|
if (Name == "main" || Name == "_main") {
|
|
uint64_t Entrypoint;
|
|
SI->getAddress(Entrypoint);
|
|
return getEffectiveLoadAddr(Entrypoint);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
ArrayRef<uint64_t> MCObjectDisassembler::getStaticInitFunctions() {
|
|
return ArrayRef<uint64_t>();
|
|
}
|
|
|
|
ArrayRef<uint64_t> MCObjectDisassembler::getStaticExitFunctions() {
|
|
return ArrayRef<uint64_t>();
|
|
}
|
|
|
|
uint64_t MCObjectDisassembler::getEffectiveLoadAddr(uint64_t Addr) {
|
|
return Addr;
|
|
}
|
|
|
|
uint64_t MCObjectDisassembler::getOriginalLoadAddr(uint64_t Addr) {
|
|
return Addr;
|
|
}
|
|
|
|
MCModule *MCObjectDisassembler::buildEmptyModule() {
|
|
MCModule *Module = new MCModule;
|
|
Module->Entrypoint = getEntrypoint();
|
|
return Module;
|
|
}
|
|
|
|
MCModule *MCObjectDisassembler::buildModule(bool withCFG) {
|
|
MCModule *Module = buildEmptyModule();
|
|
|
|
buildSectionAtoms(Module);
|
|
if (withCFG)
|
|
buildCFG(Module);
|
|
return Module;
|
|
}
|
|
|
|
void MCObjectDisassembler::buildSectionAtoms(MCModule *Module) {
|
|
error_code ec;
|
|
for (section_iterator SI = Obj.begin_sections(),
|
|
SE = Obj.end_sections();
|
|
SI != SE;
|
|
SI.increment(ec)) {
|
|
if (ec) break;
|
|
|
|
bool isText; SI->isText(isText);
|
|
bool isData; SI->isData(isData);
|
|
if (!isData && !isText)
|
|
continue;
|
|
|
|
uint64_t StartAddr; SI->getAddress(StartAddr);
|
|
uint64_t SecSize; SI->getSize(SecSize);
|
|
if (StartAddr == UnknownAddressOrSize || SecSize == UnknownAddressOrSize)
|
|
continue;
|
|
StartAddr = getEffectiveLoadAddr(StartAddr);
|
|
|
|
StringRef Contents; SI->getContents(Contents);
|
|
StringRefMemoryObject memoryObject(Contents, StartAddr);
|
|
|
|
// We don't care about things like non-file-backed sections yet.
|
|
if (Contents.size() != SecSize || !SecSize)
|
|
continue;
|
|
uint64_t EndAddr = StartAddr + SecSize - 1;
|
|
|
|
StringRef SecName; SI->getName(SecName);
|
|
|
|
if (isText) {
|
|
MCTextAtom *Text = 0;
|
|
MCDataAtom *InvalidData = 0;
|
|
|
|
uint64_t InstSize;
|
|
for (uint64_t Index = 0; Index < SecSize; Index += InstSize) {
|
|
const uint64_t CurAddr = StartAddr + Index;
|
|
MCInst Inst;
|
|
if (Dis.getInstruction(Inst, InstSize, memoryObject, CurAddr, nulls(),
|
|
nulls())) {
|
|
if (!Text) {
|
|
Text = Module->createTextAtom(CurAddr, CurAddr);
|
|
Text->setName(SecName);
|
|
}
|
|
Text->addInst(Inst, InstSize);
|
|
InvalidData = 0;
|
|
} else {
|
|
if (!InvalidData) {
|
|
Text = 0;
|
|
InvalidData = Module->createDataAtom(CurAddr, EndAddr);
|
|
}
|
|
InvalidData->addData(Contents[Index]);
|
|
}
|
|
}
|
|
} else {
|
|
MCDataAtom *Data = Module->createDataAtom(StartAddr, EndAddr);
|
|
Data->setName(SecName);
|
|
for (uint64_t Index = 0; Index < SecSize; ++Index)
|
|
Data->addData(Contents[Index]);
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace {
|
|
struct BBInfo;
|
|
typedef SmallPtrSet<BBInfo*, 2> BBInfoSetTy;
|
|
|
|
struct BBInfo {
|
|
MCTextAtom *Atom;
|
|
MCBasicBlock *BB;
|
|
BBInfoSetTy Succs;
|
|
BBInfoSetTy Preds;
|
|
|
|
BBInfo() : Atom(0), BB(0) {}
|
|
|
|
void addSucc(BBInfo &Succ) {
|
|
Succs.insert(&Succ);
|
|
Succ.Preds.insert(this);
|
|
}
|
|
};
|
|
}
|
|
|
|
void MCObjectDisassembler::buildCFG(MCModule *Module) {
|
|
typedef std::map<uint64_t, BBInfo> BBInfoByAddrTy;
|
|
BBInfoByAddrTy BBInfos;
|
|
typedef std::vector<uint64_t> AddressSetTy;
|
|
AddressSetTy Splits;
|
|
AddressSetTy Calls;
|
|
|
|
error_code ec;
|
|
for (symbol_iterator SI = Obj.begin_symbols(), SE = Obj.end_symbols();
|
|
SI != SE; SI.increment(ec)) {
|
|
if (ec)
|
|
break;
|
|
SymbolRef::Type SymType;
|
|
SI->getType(SymType);
|
|
if (SymType == SymbolRef::ST_Function) {
|
|
uint64_t SymAddr;
|
|
SI->getAddress(SymAddr);
|
|
SymAddr = getEffectiveLoadAddr(SymAddr);
|
|
Calls.push_back(SymAddr);
|
|
Splits.push_back(SymAddr);
|
|
}
|
|
}
|
|
|
|
assert(Module->func_begin() == Module->func_end()
|
|
&& "Module already has a CFG!");
|
|
|
|
// First, determine the basic block boundaries and call targets.
|
|
for (MCModule::atom_iterator AI = Module->atom_begin(),
|
|
AE = Module->atom_end();
|
|
AI != AE; ++AI) {
|
|
MCTextAtom *TA = dyn_cast<MCTextAtom>(*AI);
|
|
if (!TA) continue;
|
|
Calls.push_back(TA->getBeginAddr());
|
|
BBInfos[TA->getBeginAddr()].Atom = TA;
|
|
for (MCTextAtom::const_iterator II = TA->begin(), IE = TA->end();
|
|
II != IE; ++II) {
|
|
if (MIA.isTerminator(II->Inst))
|
|
Splits.push_back(II->Address + II->Size);
|
|
uint64_t Target;
|
|
if (MIA.evaluateBranch(II->Inst, II->Address, II->Size, Target)) {
|
|
if (MIA.isCall(II->Inst))
|
|
Calls.push_back(Target);
|
|
Splits.push_back(Target);
|
|
}
|
|
}
|
|
}
|
|
|
|
std::sort(Splits.begin(), Splits.end());
|
|
Splits.erase(std::unique(Splits.begin(), Splits.end()), Splits.end());
|
|
|
|
std::sort(Calls.begin(), Calls.end());
|
|
Calls.erase(std::unique(Calls.begin(), Calls.end()), Calls.end());
|
|
|
|
// Split text atoms into basic block atoms.
|
|
for (AddressSetTy::const_iterator SI = Splits.begin(), SE = Splits.end();
|
|
SI != SE; ++SI) {
|
|
MCAtom *A = Module->findAtomContaining(*SI);
|
|
if (!A) continue;
|
|
MCTextAtom *TA = cast<MCTextAtom>(A);
|
|
if (TA->getBeginAddr() == *SI)
|
|
continue;
|
|
MCTextAtom *NewAtom = TA->split(*SI);
|
|
BBInfos[NewAtom->getBeginAddr()].Atom = NewAtom;
|
|
StringRef BBName = TA->getName();
|
|
BBName = BBName.substr(0, BBName.find_last_of(':'));
|
|
NewAtom->setName((BBName + ":" + utohexstr(*SI)).str());
|
|
}
|
|
|
|
// Compute succs/preds.
|
|
for (MCModule::atom_iterator AI = Module->atom_begin(),
|
|
AE = Module->atom_end();
|
|
AI != AE; ++AI) {
|
|
MCTextAtom *TA = dyn_cast<MCTextAtom>(*AI);
|
|
if (!TA) continue;
|
|
BBInfo &CurBB = BBInfos[TA->getBeginAddr()];
|
|
const MCDecodedInst &LI = TA->back();
|
|
if (MIA.isBranch(LI.Inst)) {
|
|
uint64_t Target;
|
|
if (MIA.evaluateBranch(LI.Inst, LI.Address, LI.Size, Target))
|
|
CurBB.addSucc(BBInfos[Target]);
|
|
if (MIA.isConditionalBranch(LI.Inst))
|
|
CurBB.addSucc(BBInfos[LI.Address + LI.Size]);
|
|
} else if (!MIA.isTerminator(LI.Inst))
|
|
CurBB.addSucc(BBInfos[LI.Address + LI.Size]);
|
|
}
|
|
|
|
|
|
// Create functions and basic blocks.
|
|
for (AddressSetTy::const_iterator CI = Calls.begin(), CE = Calls.end();
|
|
CI != CE; ++CI) {
|
|
BBInfo &BBI = BBInfos[*CI];
|
|
if (!BBI.Atom) continue;
|
|
|
|
MCFunction &MCFN = *Module->createFunction(BBI.Atom->getName());
|
|
|
|
// Create MCBBs.
|
|
SmallSetVector<BBInfo*, 16> Worklist;
|
|
Worklist.insert(&BBI);
|
|
for (size_t wi = 0; wi < Worklist.size(); ++wi) {
|
|
BBInfo *BBI = Worklist[wi];
|
|
if (!BBI->Atom)
|
|
continue;
|
|
BBI->BB = &MCFN.createBlock(*BBI->Atom);
|
|
// Add all predecessors and successors to the worklist.
|
|
for (BBInfoSetTy::iterator SI = BBI->Succs.begin(), SE = BBI->Succs.end();
|
|
SI != SE; ++SI)
|
|
Worklist.insert(*SI);
|
|
for (BBInfoSetTy::iterator PI = BBI->Preds.begin(), PE = BBI->Preds.end();
|
|
PI != PE; ++PI)
|
|
Worklist.insert(*PI);
|
|
}
|
|
|
|
// Set preds/succs.
|
|
for (size_t wi = 0; wi < Worklist.size(); ++wi) {
|
|
BBInfo *BBI = Worklist[wi];
|
|
MCBasicBlock *MCBB = BBI->BB;
|
|
if (!MCBB)
|
|
continue;
|
|
for (BBInfoSetTy::iterator SI = BBI->Succs.begin(), SE = BBI->Succs.end();
|
|
SI != SE; ++SI)
|
|
if ((*SI)->BB)
|
|
MCBB->addSuccessor((*SI)->BB);
|
|
for (BBInfoSetTy::iterator PI = BBI->Preds.begin(), PE = BBI->Preds.end();
|
|
PI != PE; ++PI)
|
|
if ((*PI)->BB)
|
|
MCBB->addPredecessor((*PI)->BB);
|
|
}
|
|
}
|
|
}
|
|
|
|
// MachO MCObjectDisassembler implementation.
|
|
|
|
MCMachOObjectDisassembler::MCMachOObjectDisassembler(
|
|
const MachOObjectFile &MOOF, const MCDisassembler &Dis,
|
|
const MCInstrAnalysis &MIA, uint64_t VMAddrSlide,
|
|
uint64_t HeaderLoadAddress)
|
|
: MCObjectDisassembler(MOOF, Dis, MIA), MOOF(MOOF),
|
|
VMAddrSlide(VMAddrSlide), HeaderLoadAddress(HeaderLoadAddress) {
|
|
|
|
error_code ec;
|
|
for (section_iterator SI = MOOF.begin_sections(), SE = MOOF.end_sections();
|
|
SI != SE; SI.increment(ec)) {
|
|
if (ec)
|
|
break;
|
|
StringRef Name;
|
|
SI->getName(Name);
|
|
// FIXME: We should use the S_ section type instead of the name.
|
|
if (Name == "__mod_init_func") {
|
|
DEBUG(dbgs() << "Found __mod_init_func section!\n");
|
|
SI->getContents(ModInitContents);
|
|
} else if (Name == "__mod_exit_func") {
|
|
DEBUG(dbgs() << "Found __mod_exit_func section!\n");
|
|
SI->getContents(ModExitContents);
|
|
}
|
|
}
|
|
}
|
|
|
|
// FIXME: Only do the translations for addresses actually inside the object.
|
|
uint64_t MCMachOObjectDisassembler::getEffectiveLoadAddr(uint64_t Addr) {
|
|
return Addr + VMAddrSlide;
|
|
}
|
|
|
|
uint64_t
|
|
MCMachOObjectDisassembler::getOriginalLoadAddr(uint64_t EffectiveAddr) {
|
|
return EffectiveAddr - VMAddrSlide;
|
|
}
|
|
|
|
uint64_t MCMachOObjectDisassembler::getEntrypoint() {
|
|
uint64_t EntryFileOffset = 0;
|
|
|
|
// Look for LC_MAIN.
|
|
{
|
|
uint32_t LoadCommandCount = MOOF.getHeader().NumLoadCommands;
|
|
MachOObjectFile::LoadCommandInfo Load = MOOF.getFirstLoadCommandInfo();
|
|
for (unsigned I = 0;; ++I) {
|
|
if (Load.C.Type == MachO::LoadCommandMain) {
|
|
EntryFileOffset =
|
|
((const MachO::entry_point_command *)Load.Ptr)->entryoff;
|
|
break;
|
|
}
|
|
|
|
if (I == LoadCommandCount - 1)
|
|
break;
|
|
else
|
|
Load = MOOF.getNextLoadCommandInfo(Load);
|
|
}
|
|
}
|
|
|
|
// If we didn't find anything, default to the common implementation.
|
|
// FIXME: Maybe we could also look at LC_UNIXTHREAD and friends?
|
|
if (EntryFileOffset)
|
|
return MCObjectDisassembler::getEntrypoint();
|
|
|
|
return EntryFileOffset + HeaderLoadAddress;
|
|
}
|
|
|
|
ArrayRef<uint64_t> MCMachOObjectDisassembler::getStaticInitFunctions() {
|
|
// FIXME: We only handle 64bit mach-o
|
|
assert(MOOF.is64Bit());
|
|
|
|
size_t EntrySize = 8;
|
|
size_t EntryCount = ModInitContents.size() / EntrySize;
|
|
return ArrayRef<uint64_t>(
|
|
reinterpret_cast<const uint64_t *>(ModInitContents.data()), EntryCount);
|
|
}
|
|
|
|
ArrayRef<uint64_t> MCMachOObjectDisassembler::getStaticExitFunctions() {
|
|
// FIXME: We only handle 64bit mach-o
|
|
assert(MOOF.is64Bit());
|
|
|
|
size_t EntrySize = 8;
|
|
size_t EntryCount = ModExitContents.size() / EntrySize;
|
|
return ArrayRef<uint64_t>(
|
|
reinterpret_cast<const uint64_t *>(ModExitContents.data()), EntryCount);
|
|
}
|