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