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