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