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 EDEvaluateOperand(uint64_t *result,
 205                       EDOperandRef operand,
 206                       EDRegisterReaderCallback regReader,
 207                       void *arg) {
 208   return operand->evaluate(*result, regReader, arg);
 209 }
 210
 211 #ifdef __BLOCKS__
 212
 213 struct ByteReaderWrapper {
 214   EDByteBlock_t byteBlock;
 215 };
 216
 217 static int readerWrapperCallback(uint8_t *byte,
 218                           uint64_t address,
 219                           void *arg) {
 220   struct ByteReaderWrapper *wrapper = (struct ByteReaderWrapper *)arg;
 221   return wrapper->byteBlock(byte, address);
 222 }
 223
 224 unsigned int EDBlockCreateInsts(EDInstRef *insts,
 225                                 int count,
 226                                 EDDisassemblerRef disassembler,
 227                                 EDByteBlock_t byteBlock,
 228                                 uint64_t address) {
 229   struct ByteReaderWrapper wrapper;
 230   wrapper.byteBlock = byteBlock;
 231
 232   return EDCreateInsts(insts,
 233                        count,
 234                        disassembler,
 235                        readerWrapperCallback,
 236                        address,
 237                        (void*)&wrapper);
 238 }
 239
 240 int EDBlockEvaluateOperand(uint64_t *result,
 241                            EDOperandRef operand,
 242                            EDRegisterBlock_t regBlock) {
 243   return operand->evaluate(*result, regBlock);
 244 }
 245
 246 int EDBlockVisitTokens(EDInstRef inst,
 247                        EDTokenVisitor_t visitor) {
 248   return inst->visitTokens(visitor);
 249 }
 250
 251 #else
 252
 253 extern "C" unsigned int EDBlockCreateInsts() {
 254   return 0;
 255 }
 256
 257 extern "C" int EDBlockEvaluateOperand() {
 258   return -1;
 259 }
 260
 261 extern "C" int EDBlockVisitTokens() {
 262   return -1;
 263 }
 264
 265 #endif