lib/MC/MCDisassembler/EDMain.cpp

   1 //===-- EDMain.cpp - LLVM Enhanced Disassembly C API ----------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file implements the enhanced disassembler's public C API.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "EDDisassembler.h"
  15 #include "EDInst.h"
  16 #include "EDOperand.h"
  17 #include "EDToken.h"
  18 #include "llvm-c/EnhancedDisassembly.h"
  19 using namespace llvm;
  20
  21 int EDGetDisassembler(EDDisassemblerRef *disassembler,
  22                       const char *triple,
  23                       EDAssemblySyntax_t syntax) {
  24   EDDisassembler::AssemblySyntax Syntax;
  25   switch (syntax) {
  26   default: llvm_unreachable("Unknown assembly syntax!");
  27   case kEDAssemblySyntaxX86Intel:
  28     Syntax = EDDisassembler::kEDAssemblySyntaxX86Intel;
  29     break;
  30   case kEDAssemblySyntaxX86ATT:
  31     Syntax = EDDisassembler::kEDAssemblySyntaxX86ATT;
  32     break;
  33   case kEDAssemblySyntaxARMUAL:
  34     Syntax = EDDisassembler::kEDAssemblySyntaxARMUAL;
  35     break;
  36   }
  37
  38   EDDisassemblerRef ret = EDDisassembler::getDisassembler(triple, Syntax);
  39
  40   if (!ret)
  41     return -1;
  42   *disassembler = ret;
  43   return 0;
  44 }
  45
  46 int EDGetRegisterName(const char** regName,
  47                       EDDisassemblerRef disassembler,
  48                       unsigned regID) {
  49   const char *name = ((EDDisassembler*)disassembler)->nameWithRegisterID(regID);
  50   if (!name)
  51     return -1;
  52   *regName = name;
  53   return 0;
  54 }
  55
  56 int EDRegisterIsStackPointer(EDDisassemblerRef disassembler,
  57                              unsigned regID) {
  58   return ((EDDisassembler*)disassembler)->registerIsStackPointer(regID) ? 1 : 0;
  59 }
  60
  61 int EDRegisterIsProgramCounter(EDDisassemblerRef disassembler,
  62                                unsigned regID) {
  63   return ((EDDisassembler*)disassembler)->registerIsProgramCounter(regID) ? 1:0;
  64 }
  65
  66 unsigned int EDCreateInsts(EDInstRef *insts,
  67                            unsigned int count,
  68                            EDDisassemblerRef disassembler,
  69                            ::EDByteReaderCallback byteReader,
  70                            uint64_t address,
  71                            void *arg) {
  72   unsigned int index;
  73
  74   for (index = 0; index < count; ++index) {
  75     EDInst *inst = ((EDDisassembler*)disassembler)->createInst(byteReader,
  76                                                                address, arg);
  77
  78     if (!inst)
  79       return index;
  80
  81     insts[index] = inst;
  82     address += inst->byteSize();
  83   }
  84
  85   return count;
  86 }
  87
  88 void EDReleaseInst(EDInstRef inst) {
  89   delete ((EDInst*)inst);
  90 }
  91
  92 int EDInstByteSize(EDInstRef inst) {
  93   return ((EDInst*)inst)->byteSize();
  94 }
  95
  96 int EDGetInstString(const char **buf,
  97                     EDInstRef inst) {
  98   return ((EDInst*)inst)->getString(*buf);
  99 }
 100
 101 int EDInstID(unsigned *instID, EDInstRef inst) {
 102   *instID = ((EDInst*)inst)->instID();
 103   return 0;
 104 }
 105
 106 int EDInstIsBranch(EDInstRef inst) {
 107   return ((EDInst*)inst)->isBranch();
 108 }
 109
 110 int EDInstIsMove(EDInstRef inst) {
 111   return ((EDInst*)inst)->isMove();
 112 }
 113
 114 int EDBranchTargetID(EDInstRef inst) {
 115   return ((EDInst*)inst)->branchTargetID();
 116 }
 117
 118 int EDMoveSourceID(EDInstRef inst) {
 119   return ((EDInst*)inst)->moveSourceID();
 120 }
 121
 122 int EDMoveTargetID(EDInstRef inst) {
 123   return ((EDInst*)inst)->moveTargetID();
 124 }
 125
 126 int EDNumTokens(EDInstRef inst) {
 127   return ((EDInst*)inst)->numTokens();
 128 }
 129
 130 int EDGetToken(EDTokenRef *token,
 131                EDInstRef inst,
 132                int index) {
 133   return ((EDInst*)inst)->getToken(*(EDToken**)token, index);
 134 }
 135
 136 int EDGetTokenString(const char **buf,
 137                      EDTokenRef token) {
 138   return ((EDToken*)token)->getString(*buf);
 139 }
 140
 141 int EDOperandIndexForToken(EDTokenRef token) {
 142   return ((EDToken*)token)->operandID();
 143 }
 144
 145 int EDTokenIsWhitespace(EDTokenRef token) {
 146   return ((EDToken*)token)->type() == EDToken::kTokenWhitespace;
 147 }
 148
 149 int EDTokenIsPunctuation(EDTokenRef token) {
 150   return ((EDToken*)token)->type() == EDToken::kTokenPunctuation;
 151 }
 152
 153 int EDTokenIsOpcode(EDTokenRef token) {
 154   return ((EDToken*)token)->type() == EDToken::kTokenOpcode;
 155 }
 156
 157 int EDTokenIsLiteral(EDTokenRef token) {
 158   return ((EDToken*)token)->type() == EDToken::kTokenLiteral;
 159 }
 160
 161 int EDTokenIsRegister(EDTokenRef token) {
 162   return ((EDToken*)token)->type() == EDToken::kTokenRegister;
 163 }
 164
 165 int EDTokenIsNegativeLiteral(EDTokenRef token) {
 166   if (((EDToken*)token)->type() != EDToken::kTokenLiteral)
 167     return -1;
 168
 169   return ((EDToken*)token)->literalSign();
 170 }
 171
 172 int EDLiteralTokenAbsoluteValue(uint64_t *value, EDTokenRef token) {
 173   if (((EDToken*)token)->type() != EDToken::kTokenLiteral)
 174     return -1;
 175
 176   return ((EDToken*)token)->literalAbsoluteValue(*value);
 177 }
 178
 179 int EDRegisterTokenValue(unsigned *registerID,
 180                          EDTokenRef token) {
 181   if (((EDToken*)token)->type() != EDToken::kTokenRegister)
 182     return -1;
 183
 184   return ((EDToken*)token)->registerID(*registerID);
 185 }
 186
 187 int EDNumOperands(EDInstRef inst) {
 188   return ((EDInst*)inst)->numOperands();
 189 }
 190
 191 int EDGetOperand(EDOperandRef *operand,
 192                  EDInstRef inst,
 193                  int index) {
 194   return ((EDInst*)inst)->getOperand(*(EDOperand**)operand, index);
 195 }
 196
 197 int EDOperandIsRegister(EDOperandRef operand) {
 198   return ((EDOperand*)operand)->isRegister();
 199 }
 200
 201 int EDOperandIsImmediate(EDOperandRef operand) {
 202   return ((EDOperand*)operand)->isImmediate();
 203 }
 204
 205 int EDOperandIsMemory(EDOperandRef operand) {
 206   return ((EDOperand*)operand)->isMemory();
 207 }
 208
 209 int EDRegisterOperandValue(unsigned *value, EDOperandRef operand) {
 210   if (!((EDOperand*)operand)->isRegister())
 211     return -1;
 212   *value = ((EDOperand*)operand)->regVal();
 213   return 0;
 214 }
 215
 216 int EDImmediateOperandValue(uint64_t *value, EDOperandRef operand) {
 217   if (!((EDOperand*)operand)->isImmediate())
 218     return -1;
 219   *value = ((EDOperand*)operand)->immediateVal();
 220   return 0;
 221 }
 222
 223 int EDEvaluateOperand(uint64_t *result, EDOperandRef operand,
 224                       ::EDRegisterReaderCallback regReader, void *arg) {
 225   return ((EDOperand*)operand)->evaluate(*result, regReader, arg);
 226 }
 227
 228 #ifdef __BLOCKS__
 229
 230 struct ByteReaderWrapper {
 231   EDByteBlock_t byteBlock;
 232 };
 233
 234 static int readerWrapperCallback(uint8_t *byte,
 235                           uint64_t address,
 236                           void *arg) {
 237   struct ByteReaderWrapper *wrapper = (struct ByteReaderWrapper *)arg;
 238   return wrapper->byteBlock(byte, address);
 239 }
 240
 241 unsigned int EDBlockCreateInsts(EDInstRef *insts,
 242                                 int count,
 243                                 EDDisassemblerRef disassembler,
 244                                 EDByteBlock_t byteBlock,
 245                                 uint64_t address) {
 246   struct ByteReaderWrapper wrapper;
 247   wrapper.byteBlock = byteBlock;
 248
 249   return EDCreateInsts(insts, count, disassembler, readerWrapperCallback,
 250                        address, (void*)&wrapper);
 251 }
 252
 253 int EDBlockEvaluateOperand(uint64_t *result, EDOperandRef operand,
 254                            EDRegisterBlock_t regBlock) {
 255   return ((EDOperand*)operand)->evaluate(*result, regBlock);
 256 }
 257
 258 int EDBlockVisitTokens(EDInstRef inst, ::EDTokenVisitor_t visitor) {
 259   return ((EDInst*)inst)->visitTokens((llvm::EDTokenVisitor_t)visitor);
 260 }
 261
 262 #else
 263
 264 extern "C" unsigned int EDBlockCreateInsts() {
 265   return 0;
 266 }
 267
 268 extern "C" int EDBlockEvaluateOperand() {
 269   return -1;
 270 }
 271
 272 extern "C" int EDBlockVisitTokens() {
 273   return -1;
 274 }
 275
 276 #endif