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