opbehavior.hh

Go to the documentation of this file.

/* ###
 * IP: GHIDRA
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#ifndef __CPUI_OPBEHAVIOR__
#define __CPUI_OPBEHAVIOR__
 
#include "error.hh"
#include "opcodes.hh"
 
class Translate;        // Forward declaration
 
struct EvaluationError : public LowlevelError {
  EvaluationError(const string &s) : LowlevelError(s) {} 
};
 
class OpBehavior {
  OpCode opcode;        
  bool isunary;         
  bool isspecial;       
public:
  OpBehavior(OpCode opc,bool isun); 
 
  OpBehavior(OpCode opc,bool isun,bool isspec); 
 
  virtual ~OpBehavior(void) {}
 
  OpCode getOpcode(void) const;
 
  bool isSpecial(void) const;
 
  bool isUnary(void) const;
 
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
  
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
  
  virtual uintb recoverInputBinary(int4 slot,int4 sizeout,uintb out,int4 sizein,uintb in) const;
  
  virtual uintb recoverInputUnary(int4 sizeout,uintb out,int4 sizein) const;
 
  static void registerInstructions(vector<OpBehavior *> &inst,const Translate *trans); 
};
 
inline OpBehavior::OpBehavior(OpCode opc,bool isun)
 
{
  opcode = opc;
  isunary = isun;
  isspecial = false;
}
 
inline OpBehavior::OpBehavior(OpCode opc,bool isun,bool isspec)
 
{
  opcode = opc;
  isunary = isun;
  isspecial = isspec;
}
 
inline OpCode OpBehavior::getOpcode(void) const {
  return opcode;
}
 
inline bool OpBehavior::isSpecial(void) const {
  return isspecial;
}
 
inline bool OpBehavior::isUnary(void) const {
  return isunary;
}
 
// A class for each opcode
 
class OpBehaviorCopy : public OpBehavior {
public:
  OpBehaviorCopy(void) : OpBehavior(CPUI_COPY,true) {}  
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
  virtual uintb recoverInputUnary(int4 sizeout,uintb out,int4 sizein) const;
};
 
class OpBehaviorEqual : public OpBehavior {
public:
  OpBehaviorEqual(void) : OpBehavior(CPUI_INT_EQUAL,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorNotEqual : public OpBehavior {
public:
  OpBehaviorNotEqual(void) : OpBehavior(CPUI_INT_NOTEQUAL,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntSless : public OpBehavior {
public:
  OpBehaviorIntSless(void) : OpBehavior(CPUI_INT_SLESS,false) {}    
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntSlessEqual : public OpBehavior {
public:
  OpBehaviorIntSlessEqual(void) : OpBehavior(CPUI_INT_SLESSEQUAL,false) {}  
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntLess : public OpBehavior {
public:
  OpBehaviorIntLess(void) : OpBehavior(CPUI_INT_LESS,false) {}  
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntLessEqual : public OpBehavior {
public:
  OpBehaviorIntLessEqual(void): OpBehavior(CPUI_INT_LESSEQUAL,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntZext : public OpBehavior {
public:
  OpBehaviorIntZext(void): OpBehavior(CPUI_INT_ZEXT,true) {}    
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
  virtual uintb recoverInputUnary(int4 sizeout,uintb out,int4 sizein) const;
};
 
class OpBehaviorIntSext : public OpBehavior {
public:
  OpBehaviorIntSext(void): OpBehavior(CPUI_INT_SEXT,true) {}    
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
  virtual uintb recoverInputUnary(int4 sizeout,uintb out,int4 sizein) const;
};
 
class OpBehaviorIntAdd : public OpBehavior {
public:
  OpBehaviorIntAdd(void): OpBehavior(CPUI_INT_ADD,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
  virtual uintb recoverInputBinary(int4 slot,int4 sizeout,uintb out,int4 sizein,uintb in) const;
};
 
class OpBehaviorIntSub : public OpBehavior {
public:
  OpBehaviorIntSub(void): OpBehavior(CPUI_INT_SUB,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
  virtual uintb recoverInputBinary(int4 slot,int4 sizeout,uintb out,int4 sizein,uintb in) const;
};
 
class OpBehaviorIntCarry : public OpBehavior {
public:
  OpBehaviorIntCarry(void): OpBehavior(CPUI_INT_CARRY,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntScarry : public OpBehavior {
public:
  OpBehaviorIntScarry(void): OpBehavior(CPUI_INT_SCARRY,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntSborrow : public OpBehavior {
public:
  OpBehaviorIntSborrow(void): OpBehavior(CPUI_INT_SBORROW,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorInt2Comp : public OpBehavior {
public:
  OpBehaviorInt2Comp(void): OpBehavior(CPUI_INT_2COMP,true) {}  
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorIntNegate : public OpBehavior {
public:
  OpBehaviorIntNegate(void): OpBehavior(CPUI_INT_NEGATE,true) {}    
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorIntXor : public OpBehavior {
public:
  OpBehaviorIntXor(void): OpBehavior(CPUI_INT_XOR,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntAnd : public OpBehavior {
public:
  OpBehaviorIntAnd(void): OpBehavior(CPUI_INT_AND,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntOr : public OpBehavior {
public:
  OpBehaviorIntOr(void): OpBehavior(CPUI_INT_OR,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntLeft : public OpBehavior {
public:
  OpBehaviorIntLeft(void): OpBehavior(CPUI_INT_LEFT,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
  virtual uintb recoverInputBinary(int4 slot,int4 sizeout,uintb out,int4 sizein,uintb in) const;
};
 
class OpBehaviorIntRight : public OpBehavior {
public:
  OpBehaviorIntRight(void): OpBehavior(CPUI_INT_RIGHT,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
  virtual uintb recoverInputBinary(int4 slot,int4 sizeout,uintb out,int4 sizein,uintb in) const;
};
 
class OpBehaviorIntSright : public OpBehavior {
public:
  OpBehaviorIntSright(void): OpBehavior(CPUI_INT_SRIGHT,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
  virtual uintb recoverInputBinary(int4 slot,int4 sizeout,uintb out,int4 sizein,uintb in) const;
};
 
class OpBehaviorIntMult : public OpBehavior {
public:
  OpBehaviorIntMult(void): OpBehavior(CPUI_INT_MULT,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntDiv : public OpBehavior {
public:
  OpBehaviorIntDiv(void): OpBehavior(CPUI_INT_DIV,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntSdiv : public OpBehavior {
public:
  OpBehaviorIntSdiv(void): OpBehavior(CPUI_INT_SDIV,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntRem : public OpBehavior {
public:
  OpBehaviorIntRem(void): OpBehavior(CPUI_INT_REM,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorIntSrem : public OpBehavior {
public:
  OpBehaviorIntSrem(void): OpBehavior(CPUI_INT_SREM,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorBoolNegate : public OpBehavior {
public:
  OpBehaviorBoolNegate(void): OpBehavior(CPUI_BOOL_NEGATE,true) {}  
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorBoolXor : public OpBehavior {
public:
  OpBehaviorBoolXor(void): OpBehavior(CPUI_BOOL_XOR,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorBoolAnd : public OpBehavior {
public:
  OpBehaviorBoolAnd(void): OpBehavior(CPUI_BOOL_AND,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorBoolOr : public OpBehavior {
public:
  OpBehaviorBoolOr(void): OpBehavior(CPUI_BOOL_OR,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorFloatEqual : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatEqual(const Translate *trans): OpBehavior(CPUI_FLOAT_EQUAL,false) { translate = trans; }   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorFloatNotEqual : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatNotEqual(const Translate *trans): OpBehavior(CPUI_FLOAT_NOTEQUAL,false) { translate = trans; } 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorFloatLess : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatLess(const Translate *trans) : OpBehavior(CPUI_FLOAT_LESS,false) { translate = trans; }    
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorFloatLessEqual : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatLessEqual(const Translate *trans) : OpBehavior(CPUI_FLOAT_LESSEQUAL,false) { translate = trans; }  
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorFloatNan : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatNan(const Translate *trans) : OpBehavior(CPUI_FLOAT_NAN,true) { translate = trans; }   
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorFloatAdd : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatAdd(const Translate *trans) : OpBehavior(CPUI_FLOAT_ADD,false) { translate = trans; }  
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorFloatDiv : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatDiv(const Translate *trans) : OpBehavior(CPUI_FLOAT_DIV,false) { translate = trans; }  
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorFloatMult : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatMult(const Translate *trans) : OpBehavior(CPUI_FLOAT_MULT,false) { translate = trans; }    
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorFloatSub : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatSub(const Translate *trans) : OpBehavior(CPUI_FLOAT_SUB,false) { translate = trans; }  
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorFloatNeg : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatNeg(const Translate *trans) : OpBehavior(CPUI_FLOAT_NEG,true) { translate = trans; }   
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorFloatAbs : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatAbs(const Translate *trans) : OpBehavior(CPUI_FLOAT_ABS,true) { translate = trans; }   
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorFloatSqrt : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatSqrt(const Translate *trans) : OpBehavior(CPUI_FLOAT_SQRT,true) { translate = trans; } 
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorFloatInt2Float : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatInt2Float(const Translate *trans) : OpBehavior(CPUI_FLOAT_INT2FLOAT,true) { translate = trans; }   
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorFloatFloat2Float : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatFloat2Float(const Translate *trans) : OpBehavior(CPUI_FLOAT_FLOAT2FLOAT,true) { translate = trans; }   
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorFloatTrunc : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatTrunc(const Translate *trans) : OpBehavior(CPUI_FLOAT_TRUNC,true) { translate = trans; }   
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorFloatCeil : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatCeil(const Translate *trans) : OpBehavior(CPUI_FLOAT_CEIL,true) { translate = trans; } 
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorFloatFloor : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatFloor(const Translate *trans) : OpBehavior(CPUI_FLOAT_FLOOR,true) { translate = trans; }   
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorFloatRound : public OpBehavior {
  const Translate *translate;   
public:
  OpBehaviorFloatRound(const Translate *trans) : OpBehavior(CPUI_FLOAT_ROUND,true) { translate = trans; }   
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
class OpBehaviorPiece : public OpBehavior {
public:
  OpBehaviorPiece(void) : OpBehavior(CPUI_PIECE,false) {}   
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorSubpiece : public OpBehavior {
public:
  OpBehaviorSubpiece(void) : OpBehavior(CPUI_SUBPIECE,false) {} 
  virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;
};
 
class OpBehaviorPopcount : public OpBehavior {
public:
  OpBehaviorPopcount(void) : OpBehavior(CPUI_POPCOUNT,true) {}  
  virtual uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const;
};
 
#endif