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