llvm-6502/tools/edis/EDMain.cpp

294 lines
6.8 KiB
C++
Raw Normal View History

//===-EDMain.cpp - LLVM Enhanced Disassembly C API ------------------------===//
//
// 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 enhanced disassembler's public C API.
//
//===----------------------------------------------------------------------===//
#include "EDDisassembler.h"
#include "EDInst.h"
#include "EDOperand.h"
#include "EDToken.h"
#include "llvm-c/EnhancedDisassembly.h"
int EDGetDisassembler(EDDisassemblerRef *disassembler,
const char *triple,
EDAssemblySyntax_t syntax) {
EDDisassembler::initialize();
EDDisassemblerRef ret = EDDisassembler::getDisassembler(triple,
syntax);
if (ret) {
*disassembler = ret;
return 0;
}
else {
return -1;
}
}
int EDGetRegisterName(const char** regName,
EDDisassemblerRef disassembler,
unsigned regID) {
const char* name = disassembler->nameWithRegisterID(regID);
if(!name)
return -1;
*regName = name;
return 0;
}
int EDRegisterIsStackPointer(EDDisassemblerRef disassembler,
unsigned regID) {
return disassembler->registerIsStackPointer(regID) ? 1 : 0;
}
int EDRegisterIsProgramCounter(EDDisassemblerRef disassembler,
unsigned regID) {
return disassembler->registerIsProgramCounter(regID) ? 1 : 0;
}
unsigned int EDCreateInsts(EDInstRef *insts,
unsigned int count,
EDDisassemblerRef disassembler,
EDByteReaderCallback byteReader,
uint64_t address,
void *arg) {
unsigned int index;
for (index = 0; index < count; index++) {
EDInst *inst = disassembler->createInst(byteReader, address, arg);
if(!inst)
return index;
insts[index] = inst;
address += inst->byteSize();
}
return count;
}
void EDReleaseInst(EDInstRef inst) {
delete inst;
}
int EDInstByteSize(EDInstRef inst) {
return inst->byteSize();
}
int EDGetInstString(const char **buf,
EDInstRef inst) {
return inst->getString(*buf);
}
int EDInstID(unsigned *instID, EDInstRef inst) {
*instID = inst->instID();
return 0;
}
int EDInstIsBranch(EDInstRef inst) {
return inst->isBranch();
}
int EDInstIsMove(EDInstRef inst) {
return inst->isMove();
}
int EDBranchTargetID(EDInstRef inst) {
return inst->branchTargetID();
}
int EDMoveSourceID(EDInstRef inst) {
return inst->moveSourceID();
}
int EDMoveTargetID(EDInstRef inst) {
return inst->moveTargetID();
}
int EDNumTokens(EDInstRef inst) {
return inst->numTokens();
}
int EDGetToken(EDTokenRef *token,
EDInstRef inst,
int index) {
return inst->getToken(*token, index);
}
int EDGetTokenString(const char **buf,
EDTokenRef token) {
return token->getString(*buf);
}
int EDOperandIndexForToken(EDTokenRef token) {
return token->operandID();
}
int EDTokenIsWhitespace(EDTokenRef token) {
if(token->type() == EDToken::kTokenWhitespace)
return 1;
else
return 0;
}
int EDTokenIsPunctuation(EDTokenRef token) {
if(token->type() == EDToken::kTokenPunctuation)
return 1;
else
return 0;
}
int EDTokenIsOpcode(EDTokenRef token) {
if(token->type() == EDToken::kTokenOpcode)
return 1;
else
return 0;
}
int EDTokenIsLiteral(EDTokenRef token) {
if(token->type() == EDToken::kTokenLiteral)
return 1;
else
return 0;
}
int EDTokenIsRegister(EDTokenRef token) {
if(token->type() == EDToken::kTokenRegister)
return 1;
else
return 0;
}
int EDTokenIsNegativeLiteral(EDTokenRef token) {
if(token->type() != EDToken::kTokenLiteral)
return -1;
return token->literalSign();
}
int EDLiteralTokenAbsoluteValue(uint64_t *value,
EDTokenRef token) {
if(token->type() != EDToken::kTokenLiteral)
return -1;
return token->literalAbsoluteValue(*value);
}
int EDRegisterTokenValue(unsigned *registerID,
EDTokenRef token) {
if(token->type() != EDToken::kTokenRegister)
return -1;
return token->registerID(*registerID);
}
int EDNumOperands(EDInstRef inst) {
return inst->numOperands();
}
int EDGetOperand(EDOperandRef *operand,
EDInstRef inst,
int index) {
return inst->getOperand(*operand, index);
}
int EDOperandIsRegister(EDOperandRef operand) {
return operand->isRegister();
}
int EDOperandIsImmediate(EDOperandRef operand) {
return operand->isImmediate();
}
int EDOperandIsMemory(EDOperandRef operand) {
return operand->isMemory();
}
int EDRegisterOperandValue(unsigned *value,
EDOperandRef operand) {
if(!operand->isRegister())
return -1;
*value = operand->regVal();
return 0;
}
int EDImmediateOperandValue(uint64_t *value,
EDOperandRef operand) {
if(!operand->isImmediate())
return -1;
*value = operand->immediateVal();
return 0;
}
int EDEvaluateOperand(uint64_t *result,
EDOperandRef operand,
EDRegisterReaderCallback regReader,
void *arg) {
return operand->evaluate(*result, regReader, arg);
}
#ifdef __BLOCKS__
struct ByteReaderWrapper {
EDByteBlock_t byteBlock;
};
static int readerWrapperCallback(uint8_t *byte,
uint64_t address,
void *arg) {
struct ByteReaderWrapper *wrapper = (struct ByteReaderWrapper *)arg;
return wrapper->byteBlock(byte, address);
}
unsigned int EDBlockCreateInsts(EDInstRef *insts,
int count,
EDDisassemblerRef disassembler,
EDByteBlock_t byteBlock,
uint64_t address) {
struct ByteReaderWrapper wrapper;
wrapper.byteBlock = byteBlock;
return EDCreateInsts(insts,
count,
disassembler,
readerWrapperCallback,
address,
(void*)&wrapper);
}
int EDBlockEvaluateOperand(uint64_t *result,
EDOperandRef operand,
EDRegisterBlock_t regBlock) {
return operand->evaluate(*result, regBlock);
}
int EDBlockVisitTokens(EDInstRef inst,
EDTokenVisitor_t visitor) {
return inst->visitTokens(visitor);
}
#else
extern "C" unsigned int EDBlockCreateInsts() {
return 0;
}
extern "C" int EDBlockEvaluateOperand() {
return -1;
}
extern "C" int EDBlockVisitTokens() {
return -1;
}
#endif