typeop.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_TYPEOP__
#define __CPUI_TYPEOP__

#include "cpool.hh"
#include "variable.hh"
#include "opbehavior.hh"
#include "printlanguage.hh"

class PcodeOp;
class Translate;

class TypeOp {
public:
  enum {
    inherits_sign = 1,      
    inherits_sign_zero = 2  
  };
protected:
  TypeFactory *tlst;        
  OpCode opcode;        
  uint4 opflags;        
  uint4 addlflags;      
  string name;          
  OpBehavior *behave;       
  virtual void setMetatypeIn(type_metatype val) {}  
  virtual void setMetatypeOut(type_metatype val) {} 
  virtual void setSymbol(const string &nm) { name = nm; }   
public:
  TypeOp(TypeFactory *t,OpCode opc,const string &n);    
  virtual ~TypeOp(void);                
  const string &getName(void) const { return name; }    
  OpCode getOpcode(void) const { return opcode; }   
  uint4 getFlags(void) const { return opflags; }    
  OpBehavior *getBehavior(void) const { return behave; }    
  bool markExplicitUnsigned(PcodeOp *op,int4 slot) const;   

  uintb evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const {
    return behave->evaluateUnary(sizeout,sizein,in1); }

  uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const {
    return behave->evaluateBinary(sizeout,sizein,in1,in2); }

  uintb recoverInputBinary(int4 slot,int4 sizeout,uintb out,int4 sizein,uintb in) const {
    return behave->recoverInputBinary(slot,sizeout,out,sizein,in); }

  uintb recoverInputUnary(int4 sizeout,uintb out,int4 sizein) const {
    return behave->recoverInputUnary(sizeout,out,sizein); }

  bool isCommutative(void) const;       

  bool inheritsSign(void) const { return ((addlflags & inherits_sign)!=0); }

  virtual Datatype *getOutputLocal(const PcodeOp *op) const;

  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;

  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;

  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;

  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const=0;

  virtual void printRaw(ostream &s,const PcodeOp *op)=0;

  virtual string getOperatorName(const PcodeOp *op) const { return name; }

  static void registerInstructions(vector<TypeOp *> &inst,TypeFactory *tlst,
                   const Translate *trans);

  static void selectJavaOperators(vector<TypeOp *> &inst,bool val);
};

// Major classes of operations

class TypeOpBinary : public TypeOp {
  type_metatype metaout;    
  type_metatype metain;     
  virtual void setMetatypeIn(type_metatype val) { metain = val; }
  virtual void setMetatypeOut(type_metatype val) { metaout = val; }
public:
  TypeOpBinary(TypeFactory *t,OpCode opc,const string &n,type_metatype mout,type_metatype min)
    : TypeOp(t,opc,n) { metaout = mout; metain = min; } 
  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpUnary : public TypeOp {
  type_metatype metaout;    
  type_metatype metain;     
  virtual void setMetatypeIn(type_metatype val) { metain = val; }
  virtual void setMetatypeOut(type_metatype val) { metaout = val; }
public:
  TypeOpUnary(TypeFactory *t,OpCode opc,const string &n,type_metatype mout,type_metatype min)
    : TypeOp(t,opc,n) { metaout = mout; metain = min; } 
  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpFunc : public TypeOp {
  type_metatype metaout;    
  type_metatype metain;     
  virtual void setMetatypeIn(type_metatype val) { metain = val; }
  virtual void setMetatypeOut(type_metatype val) { metaout = val; }
public:
  TypeOpFunc(TypeFactory *t,OpCode opc,const string &n,type_metatype mout,type_metatype min)
    : TypeOp(t,opc,n) { metaout = mout; metain = min; }     
  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

// A class for each op-code

class TypeOpCopy : public TypeOp {
public:
  TypeOpCopy(TypeFactory *t);           
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCopy(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpLoad : public TypeOp {
public:
  TypeOpLoad(TypeFactory *t);           
  //  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opLoad(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpStore : public TypeOp {
public:
  TypeOpStore(TypeFactory *t);          
  //  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opStore(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpBranch : public TypeOp {
public:
  TypeOpBranch(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBranch(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpCbranch : public TypeOp {
public:
  TypeOpCbranch(TypeFactory *t);            
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCbranch(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpBranchind : public TypeOp {
public:
  TypeOpBranchind(TypeFactory *t);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBranchind(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpCall : public TypeOp {
public:
  TypeOpCall(TypeFactory *t);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCall(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
};

class TypeOpCallind : public TypeOp {
public:
  TypeOpCallind(TypeFactory *t);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCallind(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
};

class TypeOpCallother : public TypeOp {
public:
  TypeOpCallother(TypeFactory *t);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCallother(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
  virtual string getOperatorName(const PcodeOp *op) const;
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
};

class TypeOpReturn : public TypeOp {
public:
  TypeOpReturn(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opReturn(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
};

class TypeOpEqual : public TypeOpBinary {
public:
  TypeOpEqual(TypeFactory *t);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntEqual(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpNotEqual : public TypeOpBinary {
public:
  TypeOpNotEqual(TypeFactory *t);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntNotEqual(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpIntSless : public TypeOpBinary {
public:
  TypeOpIntSless(TypeFactory *t);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSless(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpIntSlessEqual : public TypeOpBinary {
public:
  TypeOpIntSlessEqual(TypeFactory *t);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSlessEqual(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpIntLess : public TypeOpBinary {
public:
  TypeOpIntLess(TypeFactory *t);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntLess(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpIntLessEqual : public TypeOpBinary {
public:
  TypeOpIntLessEqual(TypeFactory *t);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntLessEqual(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpIntZext : public TypeOpFunc {
public:
  TypeOpIntZext(TypeFactory *t);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntZext(op,readOp); }
  virtual string getOperatorName(const PcodeOp *op) const;
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpIntSext : public TypeOpFunc {
public:
  TypeOpIntSext(TypeFactory *t);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSext(op,readOp); }
  virtual string getOperatorName(const PcodeOp *op) const;
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpIntAdd : public TypeOpBinary {
public:
  TypeOpIntAdd(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntAdd(op); }
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntSub : public TypeOpBinary {
public:
  TypeOpIntSub(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSub(op); }
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntCarry : public TypeOpFunc {
public:
  TypeOpIntCarry(TypeFactory *t);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntCarry(op); }
  virtual string getOperatorName(const PcodeOp *op) const;
};

class TypeOpIntScarry : public TypeOpFunc {
public:
  TypeOpIntScarry(TypeFactory *t);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntScarry(op); }
  virtual string getOperatorName(const PcodeOp *op) const;
};

class TypeOpIntSborrow : public TypeOpFunc {
public:
  TypeOpIntSborrow(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSborrow(op); }
  virtual string getOperatorName(const PcodeOp *op) const;
};

class TypeOpInt2Comp : public TypeOpUnary {
public:
  TypeOpInt2Comp(TypeFactory *t);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opInt2Comp(op); }
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntNegate : public TypeOpUnary {
public:
  TypeOpIntNegate(TypeFactory *t);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntNegate(op); }
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntXor : public TypeOpBinary {
public:
  TypeOpIntXor(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntXor(op); }
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntAnd : public TypeOpBinary {
public:
  TypeOpIntAnd(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntAnd(op); }
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntOr : public TypeOpBinary {
public:
  TypeOpIntOr(TypeFactory *t);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntOr(op); }
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntLeft : public TypeOpBinary {
public:
  TypeOpIntLeft(TypeFactory *t);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntLeft(op); }
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntRight : public TypeOpBinary {
public:
  TypeOpIntRight(TypeFactory *t);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntRight(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntSright : public TypeOpBinary {
public:
  TypeOpIntSright(TypeFactory *t);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSright(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntMult : public TypeOpBinary {
public:
  TypeOpIntMult(TypeFactory *t);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntMult(op); }
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
};

class TypeOpIntDiv : public TypeOpBinary {
public:
  TypeOpIntDiv(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntDiv(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpIntSdiv : public TypeOpBinary {
public:
  TypeOpIntSdiv(TypeFactory *t);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSdiv(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpIntRem : public TypeOpBinary {
public:
  TypeOpIntRem(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntRem(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpIntSrem : public TypeOpBinary {
public:
  TypeOpIntSrem(TypeFactory *t);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSrem(op); }
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
};

class TypeOpBoolNegate : public TypeOpUnary {
public:
  TypeOpBoolNegate(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBoolNegate(op); }
};
  
class TypeOpBoolXor : public TypeOpBinary {
public:
  TypeOpBoolXor(TypeFactory *t);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBoolXor(op); }
};
  
class TypeOpBoolAnd : public TypeOpBinary {
public:
  TypeOpBoolAnd(TypeFactory *t);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBoolAnd(op); }
};
  
class TypeOpBoolOr : public TypeOpBinary {
public:
  TypeOpBoolOr(TypeFactory *t);         
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBoolOr(op); }
};
  
class TypeOpFloatEqual : public TypeOpBinary {
public:
  TypeOpFloatEqual(TypeFactory *t,const Translate *trans);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatEqual(op); }
};
  
class TypeOpFloatNotEqual : public TypeOpBinary {
public:
  TypeOpFloatNotEqual(TypeFactory *t,const Translate *trans);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatNotEqual(op); }
};
  
class TypeOpFloatLess : public TypeOpBinary {
public:
  TypeOpFloatLess(TypeFactory *t,const Translate *trans);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatLess(op); }
};
  
class TypeOpFloatLessEqual : public TypeOpBinary {
public:
  TypeOpFloatLessEqual(TypeFactory *t,const Translate *trans);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatLessEqual(op); }
};
  
class TypeOpFloatNan : public TypeOpFunc {
public:
  TypeOpFloatNan(TypeFactory *t,const Translate *trans);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatNan(op); }
};

class TypeOpFloatAdd : public TypeOpBinary {
public:
  TypeOpFloatAdd(TypeFactory *t,const Translate *trans);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatAdd(op); }
};
  
class TypeOpFloatDiv : public TypeOpBinary {
public:
  TypeOpFloatDiv(TypeFactory *t,const Translate *trans);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatDiv(op); }
};

class TypeOpFloatMult : public TypeOpBinary {
public:
  TypeOpFloatMult(TypeFactory *t,const Translate *trans);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatMult(op); }
};
  
class TypeOpFloatSub : public TypeOpBinary {
public:
  TypeOpFloatSub(TypeFactory *t,const Translate *trans);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatSub(op); }
};
  
class TypeOpFloatNeg : public TypeOpUnary {
public:
  TypeOpFloatNeg(TypeFactory *t,const Translate *trans);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatNeg(op); }
};

class TypeOpFloatAbs : public TypeOpFunc {
public:
  TypeOpFloatAbs(TypeFactory *t,const Translate *trans);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatAbs(op); }
};

class TypeOpFloatSqrt : public TypeOpFunc {
public:
  TypeOpFloatSqrt(TypeFactory *t,const Translate *trans);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatSqrt(op); }
};

class TypeOpFloatInt2Float : public TypeOpFunc {
public:
  TypeOpFloatInt2Float(TypeFactory *t,const Translate *trans);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatInt2Float(op); }
};

class TypeOpFloatFloat2Float : public TypeOpFunc {
public:
  TypeOpFloatFloat2Float(TypeFactory *t,const Translate *trans);            
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatFloat2Float(op); }
};

class TypeOpFloatTrunc : public TypeOpFunc {
public:
  TypeOpFloatTrunc(TypeFactory *t,const Translate *trans);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatTrunc(op); }
};

class TypeOpFloatCeil : public TypeOpFunc {
public:
  TypeOpFloatCeil(TypeFactory *t,const Translate *trans);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatCeil(op); }
};

class TypeOpFloatFloor : public TypeOpFunc {
public:
  TypeOpFloatFloor(TypeFactory *t,const Translate *trans);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatFloor(op); }
};

class TypeOpFloatRound : public TypeOpFunc {
public:
  TypeOpFloatRound(TypeFactory *t,const Translate *trans);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatRound(op); }
};

class TypeOpMulti : public TypeOp {
public:
  TypeOpMulti(TypeFactory *t);          
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opMultiequal(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpIndirect : public TypeOp {
public:
  TypeOpIndirect(TypeFactory *t);           
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIndirect(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpPiece : public TypeOpFunc {
public:
  TypeOpPiece(TypeFactory *t);          
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
  virtual string getOperatorName(const PcodeOp *op) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opPiece(op); }
};

class TypeOpSubpiece : public TypeOpFunc {
public:
  TypeOpSubpiece(TypeFactory *t);           
  //  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
  //  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
  virtual string getOperatorName(const PcodeOp *op) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opSubpiece(op); }
};

class TypeOpCast : public TypeOp {
public:
  TypeOpCast(TypeFactory *t);           
                // We don't care what types are cast
                // So no input and output requirements
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCast(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};
  
class TypeOpPtradd : public TypeOp {
public:
  TypeOpPtradd(TypeFactory *t);         
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opPtradd(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpPtrsub : public TypeOp {
public:
  TypeOpPtrsub(TypeFactory *t);         
  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opPtrsub(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpSegment : public TypeOp {
public:
  TypeOpSegment(TypeFactory *t);            
  //  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
  //  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
  virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opSegmentOp(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpCpoolref : public TypeOp {
  ConstantPool *cpool;                  
public:
  TypeOpCpoolref(TypeFactory *t);           
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const { return (Datatype *)0; }  // Never needs casting
  virtual Datatype *getOutputLocal(const PcodeOp *op) const;
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCpoolRefOp(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpNew : public TypeOp {
public:
  TypeOpNew(TypeFactory *t);            
  virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const { return (Datatype *)0; }  // Never needs casting
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opNewOp(op); }
  virtual void printRaw(ostream &s,const PcodeOp *op);
};

class TypeOpInsert : public TypeOpFunc {
public:
  TypeOpInsert(TypeFactory *t);         
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opInsertOp(op); }
};

class TypeOpExtract : public TypeOpFunc {
public:
  TypeOpExtract(TypeFactory *t);            
  virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opExtractOp(op); }
};

class TypeOpPopcount : public TypeOpFunc {
public:
  TypeOpPopcount(TypeFactory *t);           
  virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opPopcountOp(op); }
};

#endif