1 //===-EDMain.cpp - LLVM Enhanced Disassembly C API ------------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the enhanced disassembler's public C API.
12 //===----------------------------------------------------------------------===//
14 #include "EDDisassembler.h"
16 #include "EDOperand.h"
19 #include "llvm-c/EnhancedDisassembly.h"
21 int EDGetDisassembler(EDDisassemblerRef *disassembler,
23 EDAssemblySyntax_t syntax) {
24 EDDisassembler::initialize();
26 EDDisassemblerRef ret = EDDisassembler::getDisassembler(triple,
37 int EDGetRegisterName(const char** regName,
38 EDDisassemblerRef disassembler,
40 const char* name = disassembler->nameWithRegisterID(regID);
47 int EDRegisterIsStackPointer(EDDisassemblerRef disassembler,
49 return disassembler->registerIsStackPointer(regID) ? 1 : 0;
52 int EDRegisterIsProgramCounter(EDDisassemblerRef disassembler,
54 return disassembler->registerIsProgramCounter(regID) ? 1 : 0;
57 unsigned int EDCreateInsts(EDInstRef *insts,
59 EDDisassemblerRef disassembler,
60 EDByteReaderCallback byteReader,
65 for (index = 0; index < count; ++index) {
66 EDInst *inst = disassembler->createInst(byteReader, address, arg);
72 address += inst->byteSize();
78 void EDReleaseInst(EDInstRef inst) {
82 int EDInstByteSize(EDInstRef inst) {
83 return inst->byteSize();
86 int EDGetInstString(const char **buf,
88 return inst->getString(*buf);
91 int EDInstID(unsigned *instID, EDInstRef inst) {
92 *instID = inst->instID();
96 int EDInstIsBranch(EDInstRef inst) {
97 return inst->isBranch();
100 int EDInstIsMove(EDInstRef inst) {
101 return inst->isMove();
104 int EDBranchTargetID(EDInstRef inst) {
105 return inst->branchTargetID();
108 int EDMoveSourceID(EDInstRef inst) {
109 return inst->moveSourceID();
112 int EDMoveTargetID(EDInstRef inst) {
113 return inst->moveTargetID();
116 int EDNumTokens(EDInstRef inst) {
117 return inst->numTokens();
120 int EDGetToken(EDTokenRef *token,
123 return inst->getToken(*token, index);
126 int EDGetTokenString(const char **buf,
128 return token->getString(*buf);
131 int EDOperandIndexForToken(EDTokenRef token) {
132 return token->operandID();
135 int EDTokenIsWhitespace(EDTokenRef token) {
136 if (token->type() == EDToken::kTokenWhitespace)
142 int EDTokenIsPunctuation(EDTokenRef token) {
143 if (token->type() == EDToken::kTokenPunctuation)
149 int EDTokenIsOpcode(EDTokenRef token) {
150 if (token->type() == EDToken::kTokenOpcode)
156 int EDTokenIsLiteral(EDTokenRef token) {
157 if (token->type() == EDToken::kTokenLiteral)
163 int EDTokenIsRegister(EDTokenRef token) {
164 if (token->type() == EDToken::kTokenRegister)
170 int EDTokenIsNegativeLiteral(EDTokenRef token) {
171 if (token->type() != EDToken::kTokenLiteral)
174 return token->literalSign();
177 int EDLiteralTokenAbsoluteValue(uint64_t *value,
179 if (token->type() != EDToken::kTokenLiteral)
182 return token->literalAbsoluteValue(*value);
185 int EDRegisterTokenValue(unsigned *registerID,
187 if (token->type() != EDToken::kTokenRegister)
190 return token->registerID(*registerID);
193 int EDNumOperands(EDInstRef inst) {
194 return inst->numOperands();
197 int EDGetOperand(EDOperandRef *operand,
200 return inst->getOperand(*operand, index);
203 int EDOperandIsRegister(EDOperandRef operand) {
204 return operand->isRegister();
207 int EDOperandIsImmediate(EDOperandRef operand) {
208 return operand->isImmediate();
211 int EDOperandIsMemory(EDOperandRef operand) {
212 return operand->isMemory();
215 int EDRegisterOperandValue(unsigned *value,
216 EDOperandRef operand) {
217 if (!operand->isRegister())
219 *value = operand->regVal();
223 int EDImmediateOperandValue(uint64_t *value,
224 EDOperandRef operand) {
225 if (!operand->isImmediate())
227 *value = operand->immediateVal();
231 int EDEvaluateOperand(uint64_t *result,
232 EDOperandRef operand,
233 EDRegisterReaderCallback regReader,
235 return operand->evaluate(*result, regReader, arg);
240 struct ByteReaderWrapper {
241 EDByteBlock_t byteBlock;
244 static int readerWrapperCallback(uint8_t *byte,
247 struct ByteReaderWrapper *wrapper = (struct ByteReaderWrapper *)arg;
248 return wrapper->byteBlock(byte, address);
251 unsigned int EDBlockCreateInsts(EDInstRef *insts,
253 EDDisassemblerRef disassembler,
254 EDByteBlock_t byteBlock,
256 struct ByteReaderWrapper wrapper;
257 wrapper.byteBlock = byteBlock;
259 return EDCreateInsts(insts,
262 readerWrapperCallback,
267 int EDBlockEvaluateOperand(uint64_t *result,
268 EDOperandRef operand,
269 EDRegisterBlock_t regBlock) {
270 return operand->evaluate(*result, regBlock);
273 int EDBlockVisitTokens(EDInstRef inst,
274 EDTokenVisitor_t visitor) {
275 return inst->visitTokens(visitor);
280 extern "C" unsigned int EDBlockCreateInsts() {
284 extern "C" int EDBlockEvaluateOperand() {
288 extern "C" int EDBlockVisitTokens() {