lib/MC/MCDisassembler/EDInst.cpp

   1 //===-EDInst.cpp - LLVM Enhanced Disassembler -----------------------------===//
   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 Disassembly library's instruction class.
  11 // The instruction is responsible for vending the string representation,
  12 // individual tokens, and operands for a single instruction.
  13 //
  14 //===----------------------------------------------------------------------===//
  15
  16 #include "EDInst.h"
  17 #include "EDDisassembler.h"
  18 #include "EDOperand.h"
  19 #include "EDToken.h"
  20
  21 #include "llvm/MC/EDInstInfo.h"
  22 #include "llvm/MC/MCInst.h"
  23
  24 using namespace llvm;
  25
  26 EDInst::EDInst(llvm::MCInst *inst,
  27                uint64_t byteSize,
  28                EDDisassembler &disassembler,
  29                const llvm::EDInstInfo *info) :
  30   Disassembler(disassembler),
  31   Inst(inst),
  32   ThisInstInfo(info),
  33   ByteSize(byteSize),
  34   BranchTarget(-1),
  35   MoveSource(-1),
  36   MoveTarget(-1) {
  37   OperandOrder = ThisInstInfo->operandOrders[Disassembler.llvmSyntaxVariant()];
  38 }
  39
  40 EDInst::~EDInst() {
  41   unsigned int index;
  42   unsigned int numOperands = Operands.size();
  43
  44   for (index = 0; index < numOperands; ++index)
  45     delete Operands[index];
  46
  47   unsigned int numTokens = Tokens.size();
  48
  49   for (index = 0; index < numTokens; ++index)
  50     delete Tokens[index];
  51
  52   delete Inst;
  53 }
  54
  55 uint64_t EDInst::byteSize() {
  56   return ByteSize;
  57 }
  58
  59 int EDInst::stringify() {
  60   if (StringifyResult.valid())
  61     return StringifyResult.result();
  62
  63   if (Disassembler.printInst(String, *Inst))
  64     return StringifyResult.setResult(-1);
  65
  66   String.push_back('\n');
  67
  68   return StringifyResult.setResult(0);
  69 }
  70
  71 int EDInst::getString(const char*& str) {
  72   if (stringify())
  73     return -1;
  74
  75   str = String.c_str();
  76
  77   return 0;
  78 }
  79
  80 unsigned EDInst::instID() {
  81   return Inst->getOpcode();
  82 }
  83
  84 bool EDInst::isBranch() {
  85   if (ThisInstInfo)
  86     return
  87       ThisInstInfo->instructionType == kInstructionTypeBranch ||
  88       ThisInstInfo->instructionType == kInstructionTypeCall;
  89   else
  90     return false;
  91 }
  92
  93 bool EDInst::isMove() {
  94   if (ThisInstInfo)
  95     return ThisInstInfo->instructionType == kInstructionTypeMove;
  96   else
  97     return false;
  98 }
  99
 100 int EDInst::parseOperands() {
 101   if (ParseResult.valid())
 102     return ParseResult.result();
 103
 104   if (!ThisInstInfo)
 105     return ParseResult.setResult(-1);
 106
 107   unsigned int opIndex;
 108   unsigned int mcOpIndex = 0;
 109
 110   for (opIndex = 0; opIndex < ThisInstInfo->numOperands; ++opIndex) {
 111     if (isBranch() &&
 112         (ThisInstInfo->operandFlags[opIndex] & kOperandFlagTarget)) {
 113       BranchTarget = opIndex;
 114     }
 115     else if (isMove()) {
 116       if (ThisInstInfo->operandFlags[opIndex] & kOperandFlagSource)
 117         MoveSource = opIndex;
 118       else if (ThisInstInfo->operandFlags[opIndex] & kOperandFlagTarget)
 119         MoveTarget = opIndex;
 120     }
 121
 122     EDOperand *operand = new EDOperand(Disassembler, *this, opIndex, mcOpIndex);
 123
 124     Operands.push_back(operand);
 125   }
 126
 127   return ParseResult.setResult(0);
 128 }
 129
 130 int EDInst::branchTargetID() {
 131   if (parseOperands())
 132     return -1;
 133   return BranchTarget;
 134 }
 135
 136 int EDInst::moveSourceID() {
 137   if (parseOperands())
 138     return -1;
 139   return MoveSource;
 140 }
 141
 142 int EDInst::moveTargetID() {
 143   if (parseOperands())
 144     return -1;
 145   return MoveTarget;
 146 }
 147
 148 int EDInst::numOperands() {
 149   if (parseOperands())
 150     return -1;
 151   return Operands.size();
 152 }
 153
 154 int EDInst::getOperand(EDOperand *&operand, unsigned int index) {
 155   if (parseOperands())
 156     return -1;
 157
 158   if (index >= Operands.size())
 159     return -1;
 160
 161   operand = Operands[index];
 162   return 0;
 163 }
 164
 165 int EDInst::tokenize() {
 166   if (TokenizeResult.valid())
 167     return TokenizeResult.result();
 168
 169   if (ThisInstInfo == NULL)
 170     return TokenizeResult.setResult(-1);
 171
 172   if (stringify())
 173     return TokenizeResult.setResult(-1);
 174
 175   return TokenizeResult.setResult(EDToken::tokenize(Tokens,
 176                                                     String,
 177                                                     OperandOrder,
 178                                                     Disassembler));
 179
 180 }
 181
 182 int EDInst::numTokens() {
 183   if (tokenize())
 184     return -1;
 185   return Tokens.size();
 186 }
 187
 188 int EDInst::getToken(EDToken *&token, unsigned int index) {
 189   if (tokenize())
 190     return -1;
 191   token = Tokens[index];
 192   return 0;
 193 }
 194
 195 #ifdef __BLOCKS__
 196 int EDInst::visitTokens(EDTokenVisitor_t visitor) {
 197   if (tokenize())
 198     return -1;
 199
 200   tokvec_t::iterator iter;
 201
 202   for (iter = Tokens.begin(); iter != Tokens.end(); ++iter) {
 203     int ret = visitor(*iter);
 204     if (ret == 1)
 205       return 0;
 206     if (ret != 0)
 207       return -1;
 208   }
 209
 210   return 0;
 211 }
 212 #endif