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,
38 int EDGetRegisterName(const char** regName,
39 EDDisassemblerRef disassembler,
41 const char* name = disassembler->nameWithRegisterID(regID);
48 int EDRegisterIsStackPointer(EDDisassemblerRef disassembler,
50 return disassembler->registerIsStackPointer(regID) ? 1 : 0;
53 int EDRegisterIsProgramCounter(EDDisassemblerRef disassembler,
55 return disassembler->registerIsProgramCounter(regID) ? 1 : 0;
58 unsigned int EDCreateInsts(EDInstRef *insts,
60 EDDisassemblerRef disassembler,
61 EDByteReaderCallback byteReader,
66 for (index = 0; index < count; index++) {
67 EDInst *inst = disassembler->createInst(byteReader, address, arg);
73 address += inst->byteSize();
79 void EDReleaseInst(EDInstRef inst) {
83 int EDInstByteSize(EDInstRef inst) {
84 return inst->byteSize();
87 int EDGetInstString(const char **buf,
89 return inst->getString(*buf);
92 int EDInstID(unsigned *instID, EDInstRef inst) {
93 *instID = inst->instID();
97 int EDInstIsBranch(EDInstRef inst) {
98 return inst->isBranch();
101 int EDInstIsMove(EDInstRef inst) {
102 return inst->isMove();
105 int EDBranchTargetID(EDInstRef inst) {
106 return inst->branchTargetID();
109 int EDMoveSourceID(EDInstRef inst) {
110 return inst->moveSourceID();
113 int EDMoveTargetID(EDInstRef inst) {
114 return inst->moveTargetID();
117 int EDNumTokens(EDInstRef inst) {
118 return inst->numTokens();
121 int EDGetToken(EDTokenRef *token,
124 return inst->getToken(*token, index);
127 int EDGetTokenString(const char **buf,
129 return token->getString(*buf);
132 int EDOperandIndexForToken(EDTokenRef token) {
133 return token->operandID();
136 int EDTokenIsWhitespace(EDTokenRef token) {
137 if(token->type() == EDToken::kTokenWhitespace)
143 int EDTokenIsPunctuation(EDTokenRef token) {
144 if(token->type() == EDToken::kTokenPunctuation)
150 int EDTokenIsOpcode(EDTokenRef token) {
151 if(token->type() == EDToken::kTokenOpcode)
157 int EDTokenIsLiteral(EDTokenRef token) {
158 if(token->type() == EDToken::kTokenLiteral)
164 int EDTokenIsRegister(EDTokenRef token) {
165 if(token->type() == EDToken::kTokenRegister)
171 int EDTokenIsNegativeLiteral(EDTokenRef token) {
172 if(token->type() != EDToken::kTokenLiteral)
175 return token->literalSign();
178 int EDLiteralTokenAbsoluteValue(uint64_t *value,
180 if(token->type() != EDToken::kTokenLiteral)
183 return token->literalAbsoluteValue(*value);
186 int EDRegisterTokenValue(unsigned *registerID,
188 if(token->type() != EDToken::kTokenRegister)
191 return token->registerID(*registerID);
194 int EDNumOperands(EDInstRef inst) {
195 return inst->numOperands();
198 int EDGetOperand(EDOperandRef *operand,
201 return inst->getOperand(*operand, index);
204 int EDEvaluateOperand(uint64_t *result,
205 EDOperandRef operand,
206 EDRegisterReaderCallback regReader,
208 return operand->evaluate(*result, regReader, arg);
213 struct ByteReaderWrapper {
214 EDByteBlock_t byteBlock;
217 static int readerWrapperCallback(uint8_t *byte,
220 struct ByteReaderWrapper *wrapper = (struct ByteReaderWrapper *)arg;
221 return wrapper->byteBlock(byte, address);
224 unsigned int EDBlockCreateInsts(EDInstRef *insts,
226 EDDisassemblerRef disassembler,
227 EDByteBlock_t byteBlock,
229 struct ByteReaderWrapper wrapper;
230 wrapper.byteBlock = byteBlock;
232 return EDCreateInsts(insts,
235 readerWrapperCallback,
240 int EDBlockEvaluateOperand(uint64_t *result,
241 EDOperandRef operand,
242 EDRegisterBlock_t regBlock) {
243 return operand->evaluate(*result, regBlock);
246 int EDBlockVisitTokens(EDInstRef inst,
247 EDTokenVisitor_t visitor) {
248 return inst->visitTokens(visitor);
253 extern "C" unsigned int EDBlockCreateInsts() {
257 extern "C" int EDBlockEvaluateOperand() {
261 extern "C" int EDBlockVisitTokens() {