dataflowAPI/src/RoseInsnFactory.C

   1 /*
   2  * See the dyninst/COPYRIGHT file for copyright information.
   3  *
   4  * We provide the Paradyn Tools (below described as "Paradyn")
   5  * on an AS IS basis, and do not warrant its validity or performance.
   6  * We reserve the right to update, modify, or discontinue this
   7  * software at any time.  We shall have no obligation to supply such
   8  * updates or modifications or any other form of support to you.
   9  *
  10  * By your use of Paradyn, you understand and agree that we (or any
  11  * other person or entity with proprietary rights in Paradyn) are
  12  * under no obligation to provide either maintenance services,
  13  * update services, notices of latent defects, or correction of
  14  * defects for Paradyn.
  15  *
  16  * This library is free software; you can redistribute it and/or
  17  * modify it under the terms of the GNU Lesser General Public
  18  * License as published by the Free Software Foundation; either
  19  * version 2.1 of the License, or (at your option) any later version.
  20  *
  21  * This library is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  24  * Lesser General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU Lesser General Public
  27  * License along with this library; if not, write to the Free Software
  28  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  29  */
  30 #include "RoseInsnFactory.h"
  31 //#include "../rose/x86InstructionSemantics.h"
  32 //#include "../rose/powerpcInstructionSemantics.h"
  33
  34 #include "Instruction.h"
  35 #include "Operand.h"
  36 #include "Expression.h"
  37 #include "Dereference.h"
  38 #include "Immediate.h"
  39 #include <vector>
  40
  41 #include "../rose/SgAsmInstruction.h"
  42 #include "../rose/SgAsmPowerpcInstruction.h"
  43 #include "../rose/SgAsmx86Instruction.h"
  44 #include "../rose/SgAsmExpression.h"
  45
  46 #include "ExpressionConversionVisitor.h"
  47
  48 using namespace Dyninst;
  49 using namespace InstructionAPI;
  50 using namespace DataflowAPI;
  51
  52 SgAsmInstruction *RoseInsnFactory::convert(const InstructionAPI::Instruction::Ptr &insn, uint64_t addr) {
  53   SgAsmInstruction *rinsn = createInsn();
  54
  55   rinsn->set_address(addr);
  56   rinsn->set_mnemonic(insn->format());
  57   setOpcode(rinsn, insn->getOperation().getID(), insn->getOperation().getPrefixID(), insn->getOperation().format());
  58
  59   // semantics don't support 64-bit code
  60   setSizes(rinsn);
  61
  62   //rinsn->set_operandSize(x86_insnsize_32);
  63   //rinsn->set_addressSize(x86_insnsize_32);
  64
  65   std::vector<unsigned char> rawBytes;
  66   for (unsigned i = 0; i < insn->size(); ++i) rawBytes.push_back(insn->rawByte(i));
  67   rinsn->set_raw_bytes(rawBytes);
  68
  69   // operand list
  70   SgAsmOperandList *roperands = new SgAsmOperandList;
  71
  72 //   std::cerr << "Converting " << insn->format(addr) << " @" << std::hex << addr << std::dec << std::endl;
  73
  74 //   std::cerr << "checking instruction: " << insn->format(addr) << " for special handling" << std::endl;
  75   if (handleSpecialCases(insn->getOperation().getID(), rinsn, roperands)) {
  76       rinsn->set_operandList(roperands);
  77       return rinsn;
  78   }
  79
  80 //   std::cerr << "no special handling by opcode, checking if we should mangle operands..." << std::endl;
  81   std::vector<InstructionAPI::Operand> operands;
  82   insn->getOperands(operands);
  83 //   std::cerr << "\t " << operands.size() << " operands" << std::endl;
  84   massageOperands(insn, operands);
  85   int i = 0;
  86 //   std::cerr << "converting insn " << insn->format(addr) << std::endl;
  87   for (std::vector<InstructionAPI::Operand>::iterator opi = operands.begin();
  88        opi != operands.end();
  89        ++opi, ++i) {
  90       InstructionAPI::Operand &currOperand = *opi;
  91 //       std::cerr << "Converting operand " << currOperand.format(arch(), addr) << std::endl;
  92       roperands->append_operand(convertOperand(currOperand.getValue(), addr, insn->size()));
  93   }
  94   rinsn->set_operandList(roperands);
  95   return rinsn;
  96 }
  97
  98 SgAsmExpression *RoseInsnFactory::convertOperand(const Expression::Ptr expression, int64_t addr, size_t insnSize) {
  99   if(!expression) return NULL;
 100   ExpressionConversionVisitor visitor(arch(), addr, insnSize);
 101   expression->apply(&visitor);
 102   return visitor.getRoseExpression();
 103 }
 104
 105 ///////////// X86 //////////////////
 106
 107 SgAsmInstruction *RoseInsnX86Factory::createInsn() {
 108   return new SgAsmx86Instruction;
 109 }
 110
 111 // Note: convertKind is defined in convertOpcodes.C
 112
 113 void RoseInsnX86Factory::setOpcode(SgAsmInstruction *insn, entryID opcode, prefixEntryID prefix, std::string) {
 114   SgAsmx86Instruction *tmp = static_cast<SgAsmx86Instruction *>(insn);
 115
 116   tmp->set_kind(convertKind(opcode, prefix));
 117 }
 118
 119 void RoseInsnX86Factory::setSizes(SgAsmInstruction *insn) {
 120   SgAsmx86Instruction *tmp = static_cast<SgAsmx86Instruction *>(insn);
 121   if (a == Arch_x86_64) {
 122       tmp->set_operandSize(x86_insnsize_64);
 123       tmp->set_addressSize(x86_insnsize_64);
 124   } else {
 125       tmp->set_operandSize(x86_insnsize_32);
 126       tmp->set_addressSize(x86_insnsize_32);
 127   }
 128 }
 129
 130 bool RoseInsnX86Factory::handleSpecialCases(entryID, SgAsmInstruction *, SgAsmOperandList *) {
 131   // Does nothing?
 132
 133   return false;
 134 }
 135
 136 void RoseInsnX86Factory::massageOperands(const InstructionAPI::Instruction::Ptr &insn,
 137                                          std::vector<InstructionAPI::Operand> &operands) {
 138   switch (insn->getOperation().getID()) {
 139   case e_lea: {
 140     // ROSE expects there to be a "memory reference" statement wrapping the
 141     // address calculation. It then unwraps it.
 142     Dereference::Ptr tmp = Dereference::Ptr(new Dereference(operands[1].getValue(), u32));
 143     operands[1] = Operand(tmp, operands[1].isRead(), operands[1].isWritten());
 144     operands.resize(2);
 145     break;
 146   }
 147   case e_push:
 148   case e_pop:
 149     operands.resize(1);
 150     break;
 151   case e_cmpxch:
 152     operands.resize(2);
 153     break;
 154   case e_movsb:
 155   case e_movsd:
 156   case e_movsw:
 157     // No operands
 158     operands.clear();
 159     break;
 160   case e_cmpsb:
 161   case e_cmpsw:
 162   case e_cmpsd:
 163     // No operands
 164     operands.clear();
 165     break;
 166   case e_scasb:
 167   case e_scasd:
 168   case e_scasw:
 169     // Same here
 170     operands.clear();
 171     break;
 172   case e_stosb:
 173   case e_stosd:
 174   case e_stosw:
 175     // Also, no operands
 176     operands.clear();
 177     break;
 178   case e_jcxz_jec:
 179     operands.resize(1);
 180     break;
 181   case e_cbw:
 182   case e_cwde:
 183   case e_cdq:
 184     // Nada
 185     operands.clear();
 186     break;
 187   case e_popad:
 188   case e_pushfd:
 189     operands.clear();
 190     break;
 191   case e_lodsd:
 192   case e_lodsb:
 193   case e_lodsw:
 194       operands.clear();
 195       break;
 196   case e_pushad:
 197       operands.clear();
 198       break;
 199   case e_loop:
 200   case e_loope:
 201   case e_loopn:
 202       operands.resize(1);
 203       break;
 204   case e_ret_far:
 205   case e_ret_near:
 206           if (operands.size() == 2) {
 207                   operands[0]=operands[1];
 208           }
 209           operands.resize(1);
 210           break;
 211   case e_aaa:
 212   case e_aas:
 213           // ROSE does not expect implicit operand rax/eax to be treated as an operand
 214           operands.clear();
 215           break;
 216   case e_aad:
 217   case e_aam: {
 218           // ROSE does not expect implicit operand rax/eax to be treated as an operand
 219           std::set<RegisterAST::Ptr> regs;
 220           operands[0].getReadSet(regs);
 221           operands[0].getWriteSet(regs);
 222           if (!regs.empty()) {
 223                       operands[0] = operands[1];
 224           }
 225           operands.resize(1);
 226           break;
 227   }
 228   default:
 229     break;
 230   }
 231 }
 232
 233
 234 //////////// PPC ///////////////////
 235 // Note: convertKind is defined in convertOpcodes.C
 236
 237 SgAsmInstruction *RoseInsnPPCFactory::createInsn() {
 238   return new SgAsmPowerpcInstruction;
 239 }
 240
 241 void RoseInsnPPCFactory::setOpcode(SgAsmInstruction *insn, entryID opcode, prefixEntryID /*prefix*/, std::string mnem) {
 242   SgAsmPowerpcInstruction *tmp = static_cast<SgAsmPowerpcInstruction *>(insn);
 243   kind = convertKind(opcode, mnem);
 244   tmp->set_kind(kind);
 245 }
 246
 247
 248 void RoseInsnPPCFactory::setSizes(SgAsmInstruction *) {
 249 }
 250
 251
 252 bool RoseInsnPPCFactory::handleSpecialCases(entryID iapi_opcode,
 253                                             SgAsmInstruction *insn,
 254                                             SgAsmOperandList *rose_operands) {
 255   SgAsmPowerpcInstruction *rose_insn = static_cast<SgAsmPowerpcInstruction *>(insn);
 256
 257   switch(iapi_opcode) {
 258   case power_op_b:
 259   case power_op_bc:
 260   case power_op_bcctr:
 261   case power_op_bclr: {
 262     unsigned int raw = 0;
 263     int branch_target = 0;
 264     unsigned int bo = 0, bi = 0;
 265     std::vector<unsigned char> bytes = rose_insn->get_raw_bytes();
 266     for(unsigned i = 0; i < bytes.size(); i++) {
 267       raw = raw << 8;
 268       raw |= bytes[i];
 269     }
 270     bool isAbsolute = (bool)(raw & 0x00000002);
 271     bool isLink = (bool)(raw & 0x00000001);
 272     rose_insn->set_kind(makeRoseBranchOpcode(iapi_opcode, isAbsolute, isLink));
 273     if(power_op_b == iapi_opcode) {
 274       branch_target = ((raw >> 2) & 0x00FFFFFF) << 2;
 275       branch_target = (branch_target << 8) >> 8;
 276     } else {
 277       if(power_op_bc == iapi_opcode) {
 278         branch_target = ((raw >> 2) & 0x00003FFF) << 2;
 279         branch_target = (branch_target << 18) >> 18;
 280         //cerr << "14-bit branch target: " << branch_target << endl;
 281       }
 282       bo = ((raw >> 21) & 0x0000001F);
 283       bi = ((raw >> 16) & 0x0000001F);
 284       rose_operands->append_operand(new SgAsmByteValueExpression(bo));
 285       rose_operands->append_operand(new SgAsmPowerpcRegisterReferenceExpression(powerpc_regclass_cr, bi,
 286                                                                                 powerpc_condreggranularity_bit));
 287     }
 288     if(branch_target) {
 289       rose_operands->append_operand(new SgAsmDoubleWordValueExpression(branch_target));
 290     } else if(power_op_bcctr == iapi_opcode) {
 291       rose_operands->append_operand(new SgAsmPowerpcRegisterReferenceExpression(powerpc_regclass_spr, powerpc_spr_ctr));
 292     } else {
 293       assert(power_op_bclr == iapi_opcode);
 294       rose_operands->append_operand(new SgAsmPowerpcRegisterReferenceExpression(powerpc_regclass_spr, powerpc_spr_lr));
 295     }
 296     return true;
 297   }
 298     break;
 299   case power_op_sc:
 300   case power_op_svcs: {
 301     //cerr << "special-casing syscall insn" << endl;
 302     unsigned int raw = 0;
 303     std::vector<unsigned char> bytes = rose_insn->get_raw_bytes();
 304     for(unsigned i = 0; i < bytes.size(); i++) {
 305       raw = raw << 8;
 306       raw |= bytes[i];
 307     }
 308     unsigned int lev = (raw >> 5) & 0x7F;
 309     rose_operands->append_operand(new SgAsmByteValueExpression(lev));
 310     //cerr << "LEV = " << lev << endl;
 311     return true;
 312   }
 313   default:
 314     return false;
 315   }
 316
 317 }
 318
 319 void RoseInsnPPCFactory::massageOperands(const InstructionAPI::Instruction::Ptr &insn,
 320                                          std::vector<InstructionAPI::Operand> &operands) {
 321   /*
 322   if(insn->writesMemory())
 323     std::swap(operands[0], operands[1]);
 324   */
 325   entryID opcode = insn->getOperation().getID();
 326   // Anything that's writing RA, ROSE expects in RA, RS, RB/immediates form.
 327   // Any store, however, ROSE expects in RS, RA, RB/displacement form.  Very confusing,
 328   // but we handle it cleanly here.
 329   if(!operands[0].isWritten() && operands.size() >= 2 &&
 330      operands[1].isWritten() && !operands[1].writesMemory()) {
 331     //std::cerr << "swapping RS and RA in " << insn->format() << std::endl;
 332     std::swap(operands[0], operands[1]);
 333   }
 334   if(opcode == power_op_cmp ||
 335      opcode == power_op_cmpl ||
 336      opcode == power_op_cmpi ||
 337      opcode == power_op_cmpli) {
 338     operands.push_back(Operand(Immediate::makeImmediate(Result(u8, 1)), false, false));
 339     std::swap(operands[2], operands[3]);
 340     std::swap(operands[1], operands[2]);
 341   }
 342   if(insn->getOperation().format().find(".") != std::string::npos &&
 343      insn->getOperation().getID() != power_op_stwcx_rc) {
 344     operands.pop_back();
 345   }
 346
 347   // Convert to ROSE so we can use numeric greater than/less than
 348
 349   if(kind >= powerpc_lbz && kind <= powerpc_lwzx) {
 350     operands.resize(2);
 351   }
 352   if(kind >= powerpc_stb && kind <= powerpc_stwx) {
 353     operands.resize(2);
 354   }
 355
 356   return;
 357 }
 358