static bool PrintInsts(const MCDisassembler &DisAsm,
MCInstPrinter &Printer, const ByteArrayTy &Bytes,
SourceMgr &SM) {
// Wrap the vector in a MemoryObject.
VectorMemoryObject memoryObject(Bytes);
// Disassemble it to strings.
uint64_t Size;
uint64_t Index;
for (Index = 0; Index < Bytes.size(); Index += Size) {
MCInst Inst;
if (DisAsm.getInstruction(Inst, Size, memoryObject, Index,
/*REMOVE*/ nulls())) {
Printer.printInst(&Inst, outs());
outs() << "\n";
} else {
SM.PrintMessage(SMLoc::getFromPointer(Bytes[Index].second),
"invalid instruction encoding", "warning");
if (Size == 0)
Size = 1; // skip illegible bytes
}
}
return false;
}
void llvmutil_disassemblefunction(void * data, size_t numBytes, size_t numInst) {
InitializeNativeTargetDisassembler();
std::string Error;
#if LLVM_VERSION >= 33
std::string TripleName = llvm::sys::getProcessTriple();
#else
std::string TripleName = llvm::sys::getDefaultTargetTriple();
#endif
std::string CPU = llvm::sys::getHostCPUName();
const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
assert(TheTarget && "Unable to create target!");
const MCAsmInfo *MAI = TheTarget->createMCAsmInfo(
#if LLVM_VERSION >= 34
*TheTarget->createMCRegInfo(TripleName),
#endif
TripleName);
assert(MAI && "Unable to create target asm info!");
const MCInstrInfo *MII = TheTarget->createMCInstrInfo();
assert(MII && "Unable to create target instruction info!");
const MCRegisterInfo *MRI = TheTarget->createMCRegInfo(TripleName);
assert(MRI && "Unable to create target register info!");
std::string FeaturesStr;
const MCSubtargetInfo *STI = TheTarget->createMCSubtargetInfo(TripleName, CPU,
FeaturesStr);
assert(STI && "Unable to create subtarget info!");
#if LLVM_VERSION >= 35
MCContext Ctx(MAI,MRI, NULL);
MCDisassembler *DisAsm = TheTarget->createMCDisassembler(*STI,Ctx);
#else
MCDisassembler *DisAsm = TheTarget->createMCDisassembler(*STI);
#endif
assert(DisAsm && "Unable to create disassembler!");
int AsmPrinterVariant = MAI->getAssemblerDialect();
MCInstPrinter *IP = TheTarget->createMCInstPrinter(AsmPrinterVariant,
*MAI, *MII, *MRI, *STI);
assert(IP && "Unable to create instruction printer!");
SimpleMemoryObject SMO;
uint64_t addr = (uint64_t)data;
uint64_t Size;
fflush(stdout);
raw_fd_ostream Out(fileno(stdout), false);
for(size_t i = 0, b = 0; b < numBytes || i < numInst; i++, b += Size) {
MCInst Inst;
MCDisassembler::DecodeStatus S = DisAsm->getInstruction(Inst, Size, SMO,addr + b, nulls(), Out);
if(MCDisassembler::Fail == S || MCDisassembler::SoftFail == S)
break;
Out << (void*) ((uintptr_t)data + b) << "(+" << b << ")" << ":\t";
IP->printInst(&Inst,Out,"");
Out << "\n";
}
Out.flush();
delete MAI; delete MRI; delete STI; delete MII; delete DisAsm; delete IP;
}
void llvmutil_disassemblefunction(void * data, size_t numBytes) {
InitializeNativeTargetDisassembler();
std::string Error;
std::string TripleName = llvm::sys::getDefaultTargetTriple();
const Target *TheTarget = TargetRegistry::lookupTarget(TripleName, Error);
assert(TheTarget && "Unable to create target!");
const MCAsmInfo *MAI = TheTarget->createMCAsmInfo(TripleName);
assert(MAI && "Unable to create target asm info!");
const MCInstrInfo *MII = TheTarget->createMCInstrInfo();
assert(MII && "Unable to create target instruction info!");
const MCRegisterInfo *MRI = TheTarget->createMCRegInfo(TripleName);
assert(MRI && "Unable to create target register info!");
std::string FeaturesStr;
std::string CPU;
const MCSubtargetInfo *STI = TheTarget->createMCSubtargetInfo(TripleName, CPU,
FeaturesStr);
assert(STI && "Unable to create subtarget info!");
MCDisassembler *DisAsm = TheTarget->createMCDisassembler(*STI);
assert(DisAsm && "Unable to create disassembler!");
int AsmPrinterVariant = MAI->getAssemblerDialect();
MCInstPrinter *IP = TheTarget->createMCInstPrinter(AsmPrinterVariant,
*MAI, *MII, *MRI, *STI);
assert(IP && "Unable to create instruction printer!");
printf("assembly for function at address %p\n",data);
SimpleMemoryObject SMO;
SMO.Bytes = (uint8_t*)data;
SMO.Size = numBytes;
uint64_t Size;
fflush(stdout);
raw_fd_ostream Out(fileno(stdout), false);
for(int i = 0; i < numBytes; i += Size) {
MCInst Inst;
MCDisassembler::DecodeStatus S = DisAsm->getInstruction(Inst, Size, SMO, 0, nulls(), Out);
if(MCDisassembler::Fail == S || MCDisassembler::SoftFail == S)
break;
Out << i << ":\t";
IP->printInst(&Inst,Out,"");
Out << "\n";
SMO.Size -= Size; SMO.Bytes += Size;
}
Out.flush();
delete MAI; delete MRI; delete STI; delete MII; delete DisAsm; delete IP;
}
static bool PrintInsts(const MCDisassembler &DisAsm,
const ByteArrayTy &Bytes,
SourceMgr &SM, raw_ostream &Out,
MCStreamer &Streamer, bool InAtomicBlock,
const MCSubtargetInfo &STI) {
ArrayRef<uint8_t> Data(Bytes.first.data(), Bytes.first.size());
// Disassemble it to strings.
uint64_t Size;
uint64_t Index;
for (Index = 0; Index < Bytes.first.size(); Index += Size) {
MCInst Inst;
MCDisassembler::DecodeStatus S;
S = DisAsm.getInstruction(Inst, Size, Data.slice(Index), Index,
/*REMOVE*/ nulls(), nulls());
switch (S) {
case MCDisassembler::Fail:
SM.PrintMessage(SMLoc::getFromPointer(Bytes.second[Index]),
SourceMgr::DK_Warning,
"invalid instruction encoding");
// Don't try to resynchronise the stream in a block
if (InAtomicBlock)
return true;
if (Size == 0)
Size = 1; // skip illegible bytes
break;
case MCDisassembler::SoftFail:
SM.PrintMessage(SMLoc::getFromPointer(Bytes.second[Index]),
SourceMgr::DK_Warning,
"potentially undefined instruction encoding");
LLVM_FALLTHROUGH;
case MCDisassembler::Success:
Streamer.EmitInstruction(Inst, STI);
break;
}
}
return false;
}
static bool PrintInsts(const MCDisassembler &DisAsm,
const ByteArrayTy &Bytes,
SourceMgr &SM, raw_ostream &Out,
MCStreamer &Streamer) {
// Wrap the vector in a MemoryObject.
VectorMemoryObject memoryObject(Bytes);
// Disassemble it to strings.
uint64_t Size;
uint64_t Index;
for (Index = 0; Index < Bytes.size(); Index += Size) {
MCInst Inst;
MCDisassembler::DecodeStatus S;
S = DisAsm.getInstruction(Inst, Size, memoryObject, Index,
/*REMOVE*/ nulls(), nulls());
switch (S) {
case MCDisassembler::Fail:
SM.PrintMessage(SMLoc::getFromPointer(Bytes[Index].second),
SourceMgr::DK_Warning,
"invalid instruction encoding");
if (Size == 0)
Size = 1; // skip illegible bytes
break;
case MCDisassembler::SoftFail:
SM.PrintMessage(SMLoc::getFromPointer(Bytes[Index].second),
SourceMgr::DK_Warning,
"potentially undefined instruction encoding");
// Fall through
case MCDisassembler::Success:
Streamer.EmitInstruction(Inst);
break;
}
}
return false;
}