};
/// Constructor - Performs initial setup for the disassembler.
- MCDisassembler(const MCSubtargetInfo &STI) : STI(STI), Symbolizer(0),
+ MCDisassembler(const MCSubtargetInfo &STI) : GetOpInfo(0), SymbolLookUp(0),
+ DisInfo(0), Ctx(0),
+ STI(STI), Symbolizer(0),
CommentStream(0) {}
virtual ~MCDisassembler();
uint64_t address,
raw_ostream &vStream,
raw_ostream &cStream) const = 0;
+private:
+ //
+ // Hooks for symbolic disassembly via the public 'C' interface.
+ //
+ // The function to get the symbolic information for operands.
+ LLVMOpInfoCallback GetOpInfo;
+ // The function to lookup a symbol name.
+ LLVMSymbolLookupCallback SymbolLookUp;
+ // The pointer to the block of symbolic information for above call back.
+ void *DisInfo;
+ // The assembly context for creating symbols and MCExprs in place of
+ // immediate operands when there is symbolic information.
+ MCContext *Ctx;
protected:
// Subtarget information, for instruction decoding predicates if required.
const MCSubtargetInfo &STI;
-
-private:
OwningPtr<MCSymbolizer> Symbolizer;
public:
MCContext *Ctx,
OwningPtr<MCRelocationInfo> &RelInfo);
+ LLVMOpInfoCallback getLLVMOpInfoCallback() const { return GetOpInfo; }
+ LLVMSymbolLookupCallback getLLVMSymbolLookupCallback() const {
+ return SymbolLookUp;
+ }
+ void *getDisInfoBlock() const { return DisInfo; }
+ MCContext *getMCContext() const { return Ctx; }
+
// Marked mutable because we cache it inside the disassembler, rather than
// having to pass it around as an argument through all the autogenerated code.
mutable raw_ostream *CommentStream;
#include "llvm/ADT/Triple.h"
#include "llvm/Support/CodeGen.h"
+#include "llvm-c/Disassembler.h"
#include <cassert>
#include <string>
class MCRegisterInfo;
class MCStreamer;
class MCSubtargetInfo;
+ class MCSymbolizer;
class MCRelocationInfo;
class MCTargetAsmParser;
class TargetMachine;
MCAsmBackend *TAB,
bool ShowInst);
- MCRelocationInfo *createMCRelocationInfo(MCContext &Ctx);
+ MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx);
+
+ MCSymbolizer *createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,
+ LLVMSymbolLookupCallback SymbolLookUp,
+ void *DisInfo,
+ MCContext *Ctx,
+ MCRelocationInfo *RelInfo);
/// Target - Wrapper for Target specific information.
///
bool ShowInst);
typedef MCRelocationInfo *(*MCRelocationInfoCtorTy)(StringRef TT,
MCContext &Ctx);
+ typedef MCSymbolizer *(*MCSymbolizerCtorTy)(StringRef TT,
+ LLVMOpInfoCallback GetOpInfo,
+ LLVMSymbolLookupCallback SymbolLookUp,
+ void *DisInfo,
+ MCContext *Ctx,
+ MCRelocationInfo *RelInfo);
private:
/// Next - The next registered target in the linked list, maintained by the
/// MCRelocationInfo, if registered (default = llvm::createMCRelocationInfo)
MCRelocationInfoCtorTy MCRelocationInfoCtorFn;
+ /// MCSymbolizerCtorFn - Construction function for this target's
+ /// MCSymbolizer, if registered (default = llvm::createMCSymbolizer)
+ MCSymbolizerCtorTy MCSymbolizerCtorFn;
+
public:
- Target() : AsmStreamerCtorFn(llvm::createAsmStreamer) {}
+ Target() : AsmStreamerCtorFn(llvm::createAsmStreamer),
+ MCRelocationInfoCtorFn(llvm::createMCRelocationInfo),
+ MCSymbolizerCtorFn(llvm::createMCSymbolizer) {}
/// @name Target Information
/// @{
/// \param Ctx The target context.
MCRelocationInfo *
createMCRelocationInfo(StringRef TT, MCContext &Ctx) const {
- // MCRelocationInfoCtorFn defaults to createMCRelocationInfo
return MCRelocationInfoCtorFn(TT, Ctx);
}
+ /// createMCSymbolizer - Create a target specific MCSymbolizer.
+ ///
+ /// \param TT The target triple.
+ /// \param GetOpInfo The function to get the symbolic information for operands.
+ /// \param SymbolLookUp The function to lookup a symbol name.
+ /// \param DisInfo The pointer to the block of symbolic information for above call
+ /// back.
+ /// \param Ctx The target context.
+ /// \param RelInfo The relocation information for this target. Takes ownership.
+ MCSymbolizer *
+ createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,
+ LLVMSymbolLookupCallback SymbolLookUp,
+ void *DisInfo,
+ MCContext *Ctx, MCRelocationInfo *RelInfo) const {
+ return MCSymbolizerCtorFn(TT, GetOpInfo, SymbolLookUp, DisInfo,
+ Ctx, RelInfo);
+ }
+
/// @}
};
/// @param Fn - A function to construct an MCRelocationInfo for the target.
static void RegisterMCRelocationInfo(Target &T,
Target::MCRelocationInfoCtorTy Fn) {
- if (!T.MCRelocationInfoCtorFn)
+ if (T.MCRelocationInfoCtorFn == llvm::createMCRelocationInfo)
T.MCRelocationInfoCtorFn = Fn;
}
+ /// RegisterMCSymbolizer - Register an MCSymbolizer
+ /// implementation for the given target.
+ ///
+ /// Clients are responsible for ensuring that registration doesn't occur
+ /// while another thread is attempting to access the registry. Typically
+ /// this is done by initializing all targets at program startup.
+ ///
+ /// @param T - The target being registered.
+ /// @param Fn - A function to construct an MCSymbolizer for the target.
+ static void RegisterMCSymbolizer(Target &T,
+ Target::MCSymbolizerCtorTy Fn) {
+ if (T.MCSymbolizerCtorFn == llvm::createMCSymbolizer)
+ T.MCSymbolizerCtorFn = Fn;
+ }
+
/// @}
};
void *DisInfo,
MCContext *Ctx,
OwningPtr<MCRelocationInfo> &RelInfo) {
+ this->GetOpInfo = GetOpInfo;
+ this->SymbolLookUp = SymbolLookUp;
+ this->DisInfo = DisInfo;
+ this->Ctx = Ctx;
assert(Ctx != 0 && "No MCContext given for symbolic disassembly");
- Symbolizer.reset(new MCExternalSymbolizer(*Ctx, RelInfo, GetOpInfo,
- SymbolLookUp, DisInfo));
+ if (!Symbolizer)
+ Symbolizer.reset(new MCExternalSymbolizer(*Ctx, RelInfo, GetOpInfo,
+ SymbolLookUp, DisInfo));
}
bool MCDisassembler::tryAddingSymbolicOperand(MCInst &Inst, int64_t Value,
#include "llvm/MC/MCRegisterInfo.h"
#include "llvm/MC/MCRelocationInfo.h"
#include "llvm/MC/MCSubtargetInfo.h"
+#include "llvm/MC/MCSymbolizer.h"
#include "llvm/Support/ErrorHandling.h"
#include "llvm/Support/MemoryObject.h"
#include "llvm/Support/TargetRegistry.h"
if (!RelInfo)
return 0;
+ OwningPtr<MCSymbolizer> Symbolizer(
+ TheTarget->createMCSymbolizer(Triple, GetOpInfo, SymbolLookUp, DisInfo,
+ Ctx, RelInfo.take()));
+ DisAsm->setSymbolizer(Symbolizer);
DisAsm->setupForSymbolicDisassembly(GetOpInfo, SymbolLookUp, DisInfo,
Ctx, RelInfo);
-
// Set up the instruction printer.
int AsmPrinterVariant = MAI->getAssemblerDialect();
MCInstPrinter *IP = TheTarget->createMCInstPrinter(AsmPrinterVariant,
cStream << "literal pool for: " << ReferenceName;
}
}
+
+namespace llvm {
+MCSymbolizer *createMCSymbolizer(StringRef TT, LLVMOpInfoCallback GetOpInfo,
+ LLVMSymbolLookupCallback SymbolLookUp,
+ void *DisInfo,
+ MCContext *Ctx,
+ MCRelocationInfo *RelInfo) {
+ assert(Ctx != 0 && "No MCContext given for symbolic disassembly");
+
+ OwningPtr<MCRelocationInfo> RelInfoOwingPtr(RelInfo);
+ return new MCExternalSymbolizer(*Ctx, RelInfoOwingPtr, GetOpInfo,
+ SymbolLookUp, DisInfo);
+}
+}
return SubExpr;
}
-MCRelocationInfo *llvm::createMCRelocationInfo(MCContext &Ctx) {
+MCRelocationInfo *llvm::createMCRelocationInfo(StringRef TT, MCContext &Ctx) {
return new MCRelocationInfo(Ctx);
}
return 0;
}
-static MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) {
+static MCRelocationInfo *createARMMCRelocationInfo(StringRef TT,
+ MCContext &Ctx) {
Triple TheTriple(TT);
if (TheTriple.isEnvironmentMachO())
return createARMMachORelocationInfo(Ctx);
// Default to the stock relocation info.
- return llvm::createMCRelocationInfo(Ctx);
+ return llvm::createMCRelocationInfo(TT, Ctx);
}
namespace {
// Register the MC relocation info.
TargetRegistry::RegisterMCRelocationInfo(TheARMTarget,
- createMCRelocationInfo);
+ createARMMCRelocationInfo);
TargetRegistry::RegisterMCRelocationInfo(TheThumbTarget,
- createMCRelocationInfo);
+ createARMMCRelocationInfo);
}
return 0;
}
-static MCRelocationInfo *createMCRelocationInfo(StringRef TT, MCContext &Ctx) {
+static MCRelocationInfo *createX86MCRelocationInfo(StringRef TT,
+ MCContext &Ctx) {
Triple TheTriple(TT);
if (TheTriple.isEnvironmentMachO() && TheTriple.getArch() == Triple::x86_64)
return createX86_64MachORelocationInfo(Ctx);
else if (TheTriple.isOSBinFormatELF())
return createX86_64ELFRelocationInfo(Ctx);
// Default to the stock relocation info.
- return llvm::createMCRelocationInfo(Ctx);
+ return llvm::createMCRelocationInfo(TT, Ctx);
}
static MCInstrAnalysis *createX86MCInstrAnalysis(const MCInstrInfo *Info) {
// Register the MC relocation info.
TargetRegistry::RegisterMCRelocationInfo(TheX86_32Target,
- createMCRelocationInfo);
+ createX86MCRelocationInfo);
TargetRegistry::RegisterMCRelocationInfo(TheX86_64Target,
- createMCRelocationInfo);
+ createX86MCRelocationInfo);
}