yetangitu/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2025-10-04 02:09:44 +02:00
Code Issues Releases Wiki Activity

Use context when determining if extension casts are hidden

Browse source
This commit is contained in:
caheckman 2020-02-20 14:05:55 -05:00
parent 163fa4af57
commit 36aebc2d9b
6 changed files with 117 additions and 115 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Ghidra/Features/Decompiler/src/decompile/cpp/op.hh
View file

@ -218,7 +218,6 @@ public:
PcodeOp *target(void) const; ///< Return starting op for instruction associated with this op PcodeOp *target(void) const; ///< Return starting op for instruction associated with this op
uintb getNZMaskLocal(bool cliploop) const; ///< Calculate known zero bits for output to this op uintb getNZMaskLocal(bool cliploop) const; ///< Calculate known zero bits for output to this op
int4 compareOrder(const PcodeOp *bop) const; ///< Compare the control-flow order of this and \e bop int4 compareOrder(const PcodeOp *bop) const; ///< Compare the control-flow order of this and \e bop
void push(PrintLanguage *lng) const { opcode->push(lng,this); } ///< Push this op as a display token
void printRaw(ostream &s) const { opcode->printRaw(s,this); } ///< Print raw info about this op to stream void printRaw(ostream &s) const { opcode->printRaw(s,this); } ///< Print raw info about this op to stream
const string &getOpName(void) const { return opcode->getName(); } ///< Return the name of this op const string &getOpName(void) const { return opcode->getName(); } ///< Return the name of this op
void printDebug(ostream &s) const; ///< Print debug description of this op to stream void printDebug(ostream &s) const; ///< Print debug description of this op to stream

71
Ghidra/Features/Decompiler/src/decompile/cpp/printc.cc
View file

@ -591,11 +591,11 @@ void PrintC::opReturn(const PcodeOp *op)
pushAtom(Atom("",blanktoken,EmitXml::no_color)); pushAtom(Atom("",blanktoken,EmitXml::no_color));
} }
void PrintC::opIntZext(const PcodeOp *op) void PrintC::opIntZext(const PcodeOp *op,const PcodeOp *readOp)
{ {
if (castStrategy->isZextCast(op->getOut()->getHigh()->getType(),op->getIn(0)->getHigh()->getType())) { if (castStrategy->isZextCast(op->getOut()->getHigh()->getType(),op->getIn(0)->getHigh()->getType())) {
if (isExtensionCastImplied(op)) if (isExtensionCastImplied(op,readOp))
opHiddenFunc(op); opHiddenFunc(op);
else else
opTypeCast(op); opTypeCast(op);
@ -604,11 +604,11 @@ void PrintC::opIntZext(const PcodeOp *op)
opFunc(op); opFunc(op);
} }
void PrintC::opIntSext(const PcodeOp *op) void PrintC::opIntSext(const PcodeOp *op,const PcodeOp *readOp)
{ {
if (castStrategy->isSextCast(op->getOut()->getHigh()->getType(),op->getIn(0)->getHigh()->getType())) { if (castStrategy->isSextCast(op->getOut()->getHigh()->getType(),op->getIn(0)->getHigh()->getType())) {
if (isExtensionCastImplied(op)) if (isExtensionCastImplied(op,readOp))
opHiddenFunc(op); opHiddenFunc(op);
else else
opTypeCast(op); opTypeCast(op);
@ -1288,8 +1288,9 @@ bool PrintC::printCharacterConstant(ostream &s,const Address &addr,int4 charsize
/// Sometimes such a cast is implied by the expression its in, and the cast itself /// Sometimes such a cast is implied by the expression its in, and the cast itself
/// doesn't need to be printed. /// doesn't need to be printed.
/// \param op is the given ZEXT or SEXT PcodeOp /// \param op is the given ZEXT or SEXT PcodeOp
/// \param readOp is the PcodeOp consuming the output of the extensions (or null)
/// \return \b true if the op as a cast does not need to be printed /// \return \b true if the op as a cast does not need to be printed
bool PrintC::isExtensionCastImplied(const PcodeOp *op) const bool PrintC::isExtensionCastImplied(const PcodeOp *op,const PcodeOp *readOp) const
{ {
if (!option_hide_exts) if (!option_hide_exts)
@ -1299,37 +1300,37 @@ bool PrintC::isExtensionCastImplied(const PcodeOp *op) const
} }
else { else {
if (readOp == (PcodeOp *) 0)
return false;
type_metatype metatype = outVn->getHigh()->getType()->getMetatype(); type_metatype metatype = outVn->getHigh()->getType()->getMetatype();
list<PcodeOp *>::const_iterator iter; const Varnode *otherVn;
for(iter=outVn->beginDescend();iter!=outVn->endDescend();++iter) { int4 slot;
PcodeOp *expOp = *iter; switch (readOp->code()) {
Varnode *otherVn; case CPUI_PTRADD:
int4 slot; break;
switch(expOp->code()) { case CPUI_INT_ADD:
case CPUI_PTRADD: case CPUI_INT_SUB:
break; case CPUI_INT_MULT:
case CPUI_INT_ADD: case CPUI_INT_DIV:
case CPUI_INT_SUB: case CPUI_INT_AND:
case CPUI_INT_MULT: case CPUI_INT_OR:
case CPUI_INT_DIV: case CPUI_INT_XOR:
case CPUI_INT_AND: case CPUI_INT_EQUAL:
case CPUI_INT_OR: case CPUI_INT_NOTEQUAL:
case CPUI_INT_XOR: case CPUI_INT_LESS:
case CPUI_INT_LESS: case CPUI_INT_LESSEQUAL:
case CPUI_INT_LESSEQUAL: case CPUI_INT_SLESS:
case CPUI_INT_SLESS: case CPUI_INT_SLESSEQUAL:
case CPUI_INT_SLESSEQUAL: slot = readOp->getSlot(outVn);
slot = expOp->getSlot(outVn); otherVn = readOp->getIn(1 - slot);
otherVn = expOp->getIn(1-slot); // Check if the expression involves an explicit variable of the right integer type
// Check if the expression involves an explicit variable of the right integer type if (!otherVn->isExplicit() && !otherVn->isConstant())
if (!otherVn->isExplicit())
return false;
if (otherVn->getHigh()->getType()->getMetatype() != metatype)
return false;
break;
default:
return false; return false;
} if (otherVn->getHigh()->getType()->getMetatype() != metatype)
return false;
break;
default:
return false;
} }
return true; // Everything is integer promotion return true; // Everything is integer promotion
} }
@ -2153,7 +2154,7 @@ void PrintC::emitExpression(const PcodeOp *op)
// If BRANCHIND, print switch( ) // If BRANCHIND, print switch( )
// If CALL, CALLIND, CALLOTHER print call // If CALL, CALLIND, CALLOTHER print call
// If RETURN, print return ( ) // If RETURN, print return ( )
op->push(this); op->getOpcode()->push(this,op,(PcodeOp *)0);
recurse(); recurse();
} }

6
Ghidra/Features/Decompiler/src/decompile/cpp/printc.hh
View file

@ -159,7 +159,7 @@ protected:
void opHiddenFunc(const PcodeOp *op); ///< Push the given p-code op as a hidden token void opHiddenFunc(const PcodeOp *op); ///< Push the given p-code op as a hidden token
static bool hasCharTerminator(uint1 *buffer,int4 size,int4 charsize); static bool hasCharTerminator(uint1 *buffer,int4 size,int4 charsize);
bool printCharacterConstant(ostream &s,const Address &addr,int4 charsize) const; bool printCharacterConstant(ostream &s,const Address &addr,int4 charsize) const;
bool isExtensionCastImplied(const PcodeOp *op) const; bool isExtensionCastImplied(const PcodeOp *op,const PcodeOp *readOp) const;
virtual void pushConstant(uintb val,const Datatype *ct, virtual void pushConstant(uintb val,const Datatype *ct,
const Varnode *vn,const PcodeOp *op); const Varnode *vn,const PcodeOp *op);
virtual bool pushEquate(uintb val,int4 sz,const EquateSymbol *sym, virtual bool pushEquate(uintb val,int4 sz,const EquateSymbol *sym,
@ -238,8 +238,8 @@ public:
virtual void opIntSlessEqual(const PcodeOp *op) { opBinary(&less_equal,op); } virtual void opIntSlessEqual(const PcodeOp *op) { opBinary(&less_equal,op); }
virtual void opIntLess(const PcodeOp *op) { opBinary(&less_than,op); } virtual void opIntLess(const PcodeOp *op) { opBinary(&less_than,op); }
virtual void opIntLessEqual(const PcodeOp *op) { opBinary(&less_equal,op); } virtual void opIntLessEqual(const PcodeOp *op) { opBinary(&less_equal,op); }
virtual void opIntZext(const PcodeOp *op); virtual void opIntZext(const PcodeOp *op,const PcodeOp *readOp);
virtual void opIntSext(const PcodeOp *op); virtual void opIntSext(const PcodeOp *op,const PcodeOp *readOp);
virtual void opIntAdd(const PcodeOp *op) { opBinary(&binary_plus,op); } virtual void opIntAdd(const PcodeOp *op) { opBinary(&binary_plus,op); }
virtual void opIntSub(const PcodeOp *op) { opBinary(&binary_minus,op); } virtual void opIntSub(const PcodeOp *op) { opBinary(&binary_minus,op); }
virtual void opIntCarry(const PcodeOp *op) { opFunc(op); } virtual void opIntCarry(const PcodeOp *op) { opFunc(op); }

6
Ghidra/Features/Decompiler/src/decompile/cpp/printlanguage.cc
View file

@ -648,8 +648,10 @@ void PrintLanguage::recurse(void)
mods = nodepend.back().vnmod; mods = nodepend.back().vnmod;
nodepend.pop_back(); nodepend.pop_back();
pending -= 1; pending -= 1;
if (vn->isImplied()) if (vn->isImplied()) {
vn->getDef()->push(this); const PcodeOp *defOp = vn->getDef();
defOp->getOpcode()->push(this,defOp,op);
}
else else
pushVnExplicit(vn,op); pushVnExplicit(vn,op);
pending = nodepend.size(); pending = nodepend.size();

4
Ghidra/Features/Decompiler/src/decompile/cpp/printlanguage.hh
View file

@ -486,8 +486,8 @@ public:
virtual void opIntSlessEqual(const PcodeOp *op)=0; ///< Emit a INT_SLESSEQUAL operator virtual void opIntSlessEqual(const PcodeOp *op)=0; ///< Emit a INT_SLESSEQUAL operator
virtual void opIntLess(const PcodeOp *op)=0; ///< Emit a INT_LESS operator virtual void opIntLess(const PcodeOp *op)=0; ///< Emit a INT_LESS operator
virtual void opIntLessEqual(const PcodeOp *op)=0; ///< Emit a INT_LESSEQUAL operator virtual void opIntLessEqual(const PcodeOp *op)=0; ///< Emit a INT_LESSEQUAL operator
virtual void opIntZext(const PcodeOp *op)=0; ///< Emit a INT_ZEXT operator virtual void opIntZext(const PcodeOp *op,const PcodeOp *readOp)=0; ///< Emit a INT_ZEXT operator
virtual void opIntSext(const PcodeOp *op)=0; ///< Emit a INT_SEXT operator virtual void opIntSext(const PcodeOp *op,const PcodeOp *readOp)=0; ///< Emit a INT_SEXT operator
virtual void opIntAdd(const PcodeOp *op)=0; ///< Emit a INT_ADD operator virtual void opIntAdd(const PcodeOp *op)=0; ///< Emit a INT_ADD operator
virtual void opIntSub(const PcodeOp *op)=0; ///< Emit a INT_SUB operator virtual void opIntSub(const PcodeOp *op)=0; ///< Emit a INT_SUB operator
virtual void opIntCarry(const PcodeOp *op)=0; ///< Emit a INT_CARRY operator virtual void opIntCarry(const PcodeOp *op)=0; ///< Emit a INT_CARRY operator

144
Ghidra/Features/Decompiler/src/decompile/cpp/typeop.hh
View file

@ -123,7 +123,7 @@ public:
/// Given a specific language and PcodeOp, emit the expression rooted at the operation. /// Given a specific language and PcodeOp, emit the expression rooted at the operation.
/// \param lng is the PrintLanguage to emit /// \param lng is the PrintLanguage to emit
/// \param op is the specific PcodeOp /// \param op is the specific PcodeOp
virtual void push(PrintLanguage *lng,const PcodeOp *op) const=0; virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const=0;
/// \brief Print (for debugging purposes) \b this specific PcodeOp to the stream /// \brief Print (for debugging purposes) \b this specific PcodeOp to the stream
/// ///
@ -207,7 +207,7 @@ public:
TypeOpCopy(TypeFactory *t); ///< Constructor TypeOpCopy(TypeFactory *t); ///< Constructor
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opCopy(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCopy(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -218,7 +218,7 @@ public:
// virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; // virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opLoad(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opLoad(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -228,7 +228,7 @@ public:
TypeOpStore(TypeFactory *t); ///< Constructor TypeOpStore(TypeFactory *t); ///< Constructor
// virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; // virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opStore(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opStore(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -236,7 +236,7 @@ public:
class TypeOpBranch : public TypeOp { class TypeOpBranch : public TypeOp {
public: public:
TypeOpBranch(TypeFactory *t); ///< Constructor TypeOpBranch(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opBranch(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBranch(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -245,7 +245,7 @@ class TypeOpCbranch : public TypeOp {
public: public:
TypeOpCbranch(TypeFactory *t); ///< Constructor TypeOpCbranch(TypeFactory *t); ///< Constructor
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opCbranch(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCbranch(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -253,7 +253,7 @@ public:
class TypeOpBranchind : public TypeOp { class TypeOpBranchind : public TypeOp {
public: public:
TypeOpBranchind(TypeFactory *t); ///< Constructor TypeOpBranchind(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opBranchind(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBranchind(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -261,7 +261,7 @@ public:
class TypeOpCall : public TypeOp { class TypeOpCall : public TypeOp {
public: public:
TypeOpCall(TypeFactory *t); ///< Constructor TypeOpCall(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opCall(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCall(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual Datatype *getOutputLocal(const PcodeOp *op) const; virtual Datatype *getOutputLocal(const PcodeOp *op) const;
@ -271,7 +271,7 @@ public:
class TypeOpCallind : public TypeOp { class TypeOpCallind : public TypeOp {
public: public:
TypeOpCallind(TypeFactory *t); ///< Constructor TypeOpCallind(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opCallind(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCallind(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual Datatype *getOutputLocal(const PcodeOp *op) const; virtual Datatype *getOutputLocal(const PcodeOp *op) const;
@ -281,7 +281,7 @@ public:
class TypeOpCallother : public TypeOp { class TypeOpCallother : public TypeOp {
public: public:
TypeOpCallother(TypeFactory *t); ///< Constructor TypeOpCallother(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opCallother(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCallother(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
virtual string getOperatorName(const PcodeOp *op) const; virtual string getOperatorName(const PcodeOp *op) const;
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
@ -292,7 +292,7 @@ public:
class TypeOpReturn : public TypeOp { class TypeOpReturn : public TypeOp {
public: public:
TypeOpReturn(TypeFactory *t); ///< Constructor TypeOpReturn(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opReturn(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opReturn(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
}; };
@ -301,7 +301,7 @@ public:
class TypeOpEqual : public TypeOpBinary { class TypeOpEqual : public TypeOpBinary {
public: public:
TypeOpEqual(TypeFactory *t); ///< Constructor TypeOpEqual(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntEqual(op); } 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; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -309,7 +309,7 @@ public:
class TypeOpNotEqual : public TypeOpBinary { class TypeOpNotEqual : public TypeOpBinary {
public: public:
TypeOpNotEqual(TypeFactory *t); ///< Constructor TypeOpNotEqual(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntNotEqual(op); } 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; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -317,7 +317,7 @@ public:
class TypeOpIntSless : public TypeOpBinary { class TypeOpIntSless : public TypeOpBinary {
public: public:
TypeOpIntSless(TypeFactory *t); ///< Constructor TypeOpIntSless(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntSless(op); } 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; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -325,7 +325,7 @@ public:
class TypeOpIntSlessEqual : public TypeOpBinary { class TypeOpIntSlessEqual : public TypeOpBinary {
public: public:
TypeOpIntSlessEqual(TypeFactory *t); ///< Constructor TypeOpIntSlessEqual(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntSlessEqual(op); } 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; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -333,7 +333,7 @@ public:
class TypeOpIntLess : public TypeOpBinary { class TypeOpIntLess : public TypeOpBinary {
public: public:
TypeOpIntLess(TypeFactory *t); ///< Constructor TypeOpIntLess(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntLess(op); } 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; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -341,7 +341,7 @@ public:
class TypeOpIntLessEqual : public TypeOpBinary { class TypeOpIntLessEqual : public TypeOpBinary {
public: public:
TypeOpIntLessEqual(TypeFactory *t); ///< Constructor TypeOpIntLessEqual(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntLessEqual(op); } 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; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -349,7 +349,7 @@ public:
class TypeOpIntZext : public TypeOpFunc { class TypeOpIntZext : public TypeOpFunc {
public: public:
TypeOpIntZext(TypeFactory *t); ///< Constructor TypeOpIntZext(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntZext(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntZext(op,readOp); }
virtual string getOperatorName(const PcodeOp *op) const; virtual string getOperatorName(const PcodeOp *op) const;
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -358,7 +358,7 @@ public:
class TypeOpIntSext : public TypeOpFunc { class TypeOpIntSext : public TypeOpFunc {
public: public:
TypeOpIntSext(TypeFactory *t); ///< Constructor TypeOpIntSext(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntSext(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSext(op,readOp); }
virtual string getOperatorName(const PcodeOp *op) const; virtual string getOperatorName(const PcodeOp *op) const;
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -367,7 +367,7 @@ public:
class TypeOpIntAdd : public TypeOpBinary { class TypeOpIntAdd : public TypeOpBinary {
public: public:
TypeOpIntAdd(TypeFactory *t); ///< Constructor TypeOpIntAdd(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntAdd(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntAdd(op); }
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
}; };
@ -375,7 +375,7 @@ public:
class TypeOpIntSub : public TypeOpBinary { class TypeOpIntSub : public TypeOpBinary {
public: public:
TypeOpIntSub(TypeFactory *t); ///< Constructor TypeOpIntSub(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntSub(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSub(op); }
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
}; };
@ -383,7 +383,7 @@ public:
class TypeOpIntCarry : public TypeOpFunc { class TypeOpIntCarry : public TypeOpFunc {
public: public:
TypeOpIntCarry(TypeFactory *t); ///< Constructor TypeOpIntCarry(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntCarry(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntCarry(op); }
virtual string getOperatorName(const PcodeOp *op) const; virtual string getOperatorName(const PcodeOp *op) const;
}; };
@ -391,7 +391,7 @@ public:
class TypeOpIntScarry : public TypeOpFunc { class TypeOpIntScarry : public TypeOpFunc {
public: public:
TypeOpIntScarry(TypeFactory *t); ///< Constructor TypeOpIntScarry(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntScarry(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntScarry(op); }
virtual string getOperatorName(const PcodeOp *op) const; virtual string getOperatorName(const PcodeOp *op) const;
}; };
@ -399,7 +399,7 @@ public:
class TypeOpIntSborrow : public TypeOpFunc { class TypeOpIntSborrow : public TypeOpFunc {
public: public:
TypeOpIntSborrow(TypeFactory *t); ///< Constructor TypeOpIntSborrow(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntSborrow(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSborrow(op); }
virtual string getOperatorName(const PcodeOp *op) const; virtual string getOperatorName(const PcodeOp *op) const;
}; };
@ -407,7 +407,7 @@ public:
class TypeOpInt2Comp : public TypeOpUnary { class TypeOpInt2Comp : public TypeOpUnary {
public: public:
TypeOpInt2Comp(TypeFactory *t); ///< Constructor TypeOpInt2Comp(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opInt2Comp(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opInt2Comp(op); }
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
}; };
@ -415,7 +415,7 @@ public:
class TypeOpIntNegate : public TypeOpUnary { class TypeOpIntNegate : public TypeOpUnary {
public: public:
TypeOpIntNegate(TypeFactory *t); ///< Constructor TypeOpIntNegate(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntNegate(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntNegate(op); }
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
}; };
@ -423,7 +423,7 @@ public:
class TypeOpIntXor : public TypeOpBinary { class TypeOpIntXor : public TypeOpBinary {
public: public:
TypeOpIntXor(TypeFactory *t); ///< Constructor TypeOpIntXor(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntXor(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntXor(op); }
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
}; };
@ -431,7 +431,7 @@ public:
class TypeOpIntAnd : public TypeOpBinary { class TypeOpIntAnd : public TypeOpBinary {
public: public:
TypeOpIntAnd(TypeFactory *t); ///< Constructor TypeOpIntAnd(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntAnd(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntAnd(op); }
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
}; };
@ -439,7 +439,7 @@ public:
class TypeOpIntOr : public TypeOpBinary { class TypeOpIntOr : public TypeOpBinary {
public: public:
TypeOpIntOr(TypeFactory *t); ///< Constructor TypeOpIntOr(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntOr(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntOr(op); }
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
}; };
@ -447,7 +447,7 @@ public:
class TypeOpIntLeft : public TypeOpBinary { class TypeOpIntLeft : public TypeOpBinary {
public: public:
TypeOpIntLeft(TypeFactory *t); ///< Constructor TypeOpIntLeft(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntLeft(op); } 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 *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
}; };
@ -456,7 +456,7 @@ public:
class TypeOpIntRight : public TypeOpBinary { class TypeOpIntRight : public TypeOpBinary {
public: public:
TypeOpIntRight(TypeFactory *t); ///< Constructor TypeOpIntRight(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntRight(op); } 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 *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
@ -466,7 +466,7 @@ public:
class TypeOpIntSright : public TypeOpBinary { class TypeOpIntSright : public TypeOpBinary {
public: public:
TypeOpIntSright(TypeFactory *t); ///< Constructor TypeOpIntSright(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntSright(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntSright(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
@ -477,7 +477,7 @@ public:
class TypeOpIntMult : public TypeOpBinary { class TypeOpIntMult : public TypeOpBinary {
public: public:
TypeOpIntMult(TypeFactory *t); ///< Constructor TypeOpIntMult(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntMult(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIntMult(op); }
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
}; };
@ -485,7 +485,7 @@ public:
class TypeOpIntDiv : public TypeOpBinary { class TypeOpIntDiv : public TypeOpBinary {
public: public:
TypeOpIntDiv(TypeFactory *t); ///< Constructor TypeOpIntDiv(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntDiv(op); } 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; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -493,7 +493,7 @@ public:
class TypeOpIntSdiv : public TypeOpBinary { class TypeOpIntSdiv : public TypeOpBinary {
public: public:
TypeOpIntSdiv(TypeFactory *t); ///< Constructor TypeOpIntSdiv(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntSdiv(op); } 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; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -501,7 +501,7 @@ public:
class TypeOpIntRem : public TypeOpBinary { class TypeOpIntRem : public TypeOpBinary {
public: public:
TypeOpIntRem(TypeFactory *t); ///< Constructor TypeOpIntRem(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntRem(op); } 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; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -509,7 +509,7 @@ public:
class TypeOpIntSrem : public TypeOpBinary { class TypeOpIntSrem : public TypeOpBinary {
public: public:
TypeOpIntSrem(TypeFactory *t); ///< Constructor TypeOpIntSrem(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIntSrem(op); } 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; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
}; };
@ -517,161 +517,161 @@ public:
class TypeOpBoolNegate : public TypeOpUnary { class TypeOpBoolNegate : public TypeOpUnary {
public: public:
TypeOpBoolNegate(TypeFactory *t); ///< Constructor TypeOpBoolNegate(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opBoolNegate(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBoolNegate(op); }
}; };
/// \brief Information about the BOOL_XOR op-code /// \brief Information about the BOOL_XOR op-code
class TypeOpBoolXor : public TypeOpBinary { class TypeOpBoolXor : public TypeOpBinary {
public: public:
TypeOpBoolXor(TypeFactory *t); ///< Constructor TypeOpBoolXor(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opBoolXor(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBoolXor(op); }
}; };
/// \brief Information about the BOOL_AND op-code /// \brief Information about the BOOL_AND op-code
class TypeOpBoolAnd : public TypeOpBinary { class TypeOpBoolAnd : public TypeOpBinary {
public: public:
TypeOpBoolAnd(TypeFactory *t); ///< Constructor TypeOpBoolAnd(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opBoolAnd(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBoolAnd(op); }
}; };
/// \brief Information about the BOOL_OR op-code /// \brief Information about the BOOL_OR op-code
class TypeOpBoolOr : public TypeOpBinary { class TypeOpBoolOr : public TypeOpBinary {
public: public:
TypeOpBoolOr(TypeFactory *t); ///< Constructor TypeOpBoolOr(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opBoolOr(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opBoolOr(op); }
}; };
/// \brief Information about the FLOAT_EQUAL op-code /// \brief Information about the FLOAT_EQUAL op-code
class TypeOpFloatEqual : public TypeOpBinary { class TypeOpFloatEqual : public TypeOpBinary {
public: public:
TypeOpFloatEqual(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatEqual(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatEqual(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatEqual(op); }
}; };
/// \brief Information about the FLOAT_NOTEQUAL op-code /// \brief Information about the FLOAT_NOTEQUAL op-code
class TypeOpFloatNotEqual : public TypeOpBinary { class TypeOpFloatNotEqual : public TypeOpBinary {
public: public:
TypeOpFloatNotEqual(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatNotEqual(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatNotEqual(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatNotEqual(op); }
}; };
/// \brief Information about the FLOAT_LESS op-code /// \brief Information about the FLOAT_LESS op-code
class TypeOpFloatLess : public TypeOpBinary { class TypeOpFloatLess : public TypeOpBinary {
public: public:
TypeOpFloatLess(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatLess(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatLess(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatLess(op); }
}; };
/// \brief Information about the FLOAT_LESSEQUAL op-code /// \brief Information about the FLOAT_LESSEQUAL op-code
class TypeOpFloatLessEqual : public TypeOpBinary { class TypeOpFloatLessEqual : public TypeOpBinary {
public: public:
TypeOpFloatLessEqual(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatLessEqual(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatLessEqual(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatLessEqual(op); }
}; };
/// \brief Information about the FLOAT_NAN op-code /// \brief Information about the FLOAT_NAN op-code
class TypeOpFloatNan : public TypeOpFunc { class TypeOpFloatNan : public TypeOpFunc {
public: public:
TypeOpFloatNan(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatNan(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatNan(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatNan(op); }
}; };
/// \brief Information about the FLOAT_ADD op-code /// \brief Information about the FLOAT_ADD op-code
class TypeOpFloatAdd : public TypeOpBinary { class TypeOpFloatAdd : public TypeOpBinary {
public: public:
TypeOpFloatAdd(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatAdd(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatAdd(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatAdd(op); }
}; };
/// \brief Information about the FLOAT_DIV op-code /// \brief Information about the FLOAT_DIV op-code
class TypeOpFloatDiv : public TypeOpBinary { class TypeOpFloatDiv : public TypeOpBinary {
public: public:
TypeOpFloatDiv(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatDiv(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatDiv(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatDiv(op); }
}; };
/// \brief Information about the FLOAT_MULT op-code /// \brief Information about the FLOAT_MULT op-code
class TypeOpFloatMult : public TypeOpBinary { class TypeOpFloatMult : public TypeOpBinary {
public: public:
TypeOpFloatMult(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatMult(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatMult(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatMult(op); }
}; };
/// \brief Information about the FLOAT_SUB op-code /// \brief Information about the FLOAT_SUB op-code
class TypeOpFloatSub : public TypeOpBinary { class TypeOpFloatSub : public TypeOpBinary {
public: public:
TypeOpFloatSub(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatSub(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatSub(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatSub(op); }
}; };
/// \brief Information about the FLOAT_NEG op-code /// \brief Information about the FLOAT_NEG op-code
class TypeOpFloatNeg : public TypeOpUnary { class TypeOpFloatNeg : public TypeOpUnary {
public: public:
TypeOpFloatNeg(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatNeg(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatNeg(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatNeg(op); }
}; };
/// \brief Information about the FLOAT_ABS op-code /// \brief Information about the FLOAT_ABS op-code
class TypeOpFloatAbs : public TypeOpFunc { class TypeOpFloatAbs : public TypeOpFunc {
public: public:
TypeOpFloatAbs(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatAbs(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatAbs(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatAbs(op); }
}; };
/// \brief Information about the FLOAT_SQRT op-code /// \brief Information about the FLOAT_SQRT op-code
class TypeOpFloatSqrt : public TypeOpFunc { class TypeOpFloatSqrt : public TypeOpFunc {
public: public:
TypeOpFloatSqrt(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatSqrt(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatSqrt(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatSqrt(op); }
}; };
/// \brief Information about the FLOAT_INT2FLOAT op-code /// \brief Information about the FLOAT_INT2FLOAT op-code
class TypeOpFloatInt2Float : public TypeOpFunc { class TypeOpFloatInt2Float : public TypeOpFunc {
public: public:
TypeOpFloatInt2Float(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatInt2Float(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatInt2Float(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatInt2Float(op); }
}; };
/// \brief Information about the FLOAT_FLOAT2FLOAT op-code /// \brief Information about the FLOAT_FLOAT2FLOAT op-code
class TypeOpFloatFloat2Float : public TypeOpFunc { class TypeOpFloatFloat2Float : public TypeOpFunc {
public: public:
TypeOpFloatFloat2Float(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatFloat2Float(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatFloat2Float(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatFloat2Float(op); }
}; };
/// \brief Information about the FLOAT_TRUNC op-code /// \brief Information about the FLOAT_TRUNC op-code
class TypeOpFloatTrunc : public TypeOpFunc { class TypeOpFloatTrunc : public TypeOpFunc {
public: public:
TypeOpFloatTrunc(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatTrunc(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatTrunc(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatTrunc(op); }
}; };
/// \brief Information about the FLOAT_CEIL op-code /// \brief Information about the FLOAT_CEIL op-code
class TypeOpFloatCeil : public TypeOpFunc { class TypeOpFloatCeil : public TypeOpFunc {
public: public:
TypeOpFloatCeil(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatCeil(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatCeil(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatCeil(op); }
}; };
/// \brief Information about the FLOAT_FLOOR op-code /// \brief Information about the FLOAT_FLOOR op-code
class TypeOpFloatFloor : public TypeOpFunc { class TypeOpFloatFloor : public TypeOpFunc {
public: public:
TypeOpFloatFloor(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatFloor(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatFloor(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatFloor(op); }
}; };
/// \brief Information about the FLOAT_ROUND op-code /// \brief Information about the FLOAT_ROUND op-code
class TypeOpFloatRound : public TypeOpFunc { class TypeOpFloatRound : public TypeOpFunc {
public: public:
TypeOpFloatRound(TypeFactory *t,const Translate *trans); ///< Constructor TypeOpFloatRound(TypeFactory *t,const Translate *trans); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opFloatRound(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatRound(op); }
}; };
/// \brief Information about the MULTIEQUAL op-code /// \brief Information about the MULTIEQUAL op-code
class TypeOpMulti : public TypeOp { class TypeOpMulti : public TypeOp {
public: public:
TypeOpMulti(TypeFactory *t); ///< Constructor TypeOpMulti(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opMultiequal(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opMultiequal(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -680,7 +680,7 @@ class TypeOpIndirect : public TypeOp {
public: public:
TypeOpIndirect(TypeFactory *t); ///< Constructor TypeOpIndirect(TypeFactory *t); ///< Constructor
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opIndirect(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opIndirect(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -690,7 +690,7 @@ public:
TypeOpPiece(TypeFactory *t); ///< Constructor TypeOpPiece(TypeFactory *t); ///< Constructor
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
virtual string getOperatorName(const PcodeOp *op) const; virtual string getOperatorName(const PcodeOp *op) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opPiece(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opPiece(op); }
}; };
/// \brief Information about the SUBPIECE op-code /// \brief Information about the SUBPIECE op-code
@ -701,7 +701,7 @@ public:
// virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; // virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
virtual string getOperatorName(const PcodeOp *op) const; virtual string getOperatorName(const PcodeOp *op) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opSubpiece(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opSubpiece(op); }
}; };
/// \brief Information about the CAST op-code /// \brief Information about the CAST op-code
@ -710,7 +710,7 @@ public:
TypeOpCast(TypeFactory *t); ///< Constructor TypeOpCast(TypeFactory *t); ///< Constructor
// We don't care what types are cast // We don't care what types are cast
// So no input and output requirements // So no input and output requirements
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opCast(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCast(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -722,7 +722,7 @@ public:
virtual Datatype *getOutputLocal(const PcodeOp *op) const; virtual Datatype *getOutputLocal(const PcodeOp *op) const;
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opPtradd(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opPtradd(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -734,7 +734,7 @@ public:
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opPtrsub(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opPtrsub(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -753,7 +753,7 @@ public:
// virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; // virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const; virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const; virtual Datatype *getOutputToken(const PcodeOp *op,CastStrategy *castStrategy) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opSegmentOp(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opSegmentOp(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -765,7 +765,7 @@ public:
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const { return (Datatype *)0; } // Never needs casting 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 *getOutputLocal(const PcodeOp *op) const;
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opCpoolRefOp(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opCpoolRefOp(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -774,7 +774,7 @@ class TypeOpNew : public TypeOp {
public: public:
TypeOpNew(TypeFactory *t); ///< Constructor TypeOpNew(TypeFactory *t); ///< Constructor
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const { return (Datatype *)0; } // Never needs casting 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 { lng->opNewOp(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opNewOp(op); }
virtual void printRaw(ostream &s,const PcodeOp *op); virtual void printRaw(ostream &s,const PcodeOp *op);
}; };
@ -783,7 +783,7 @@ class TypeOpInsert : public TypeOpFunc {
public: public:
TypeOpInsert(TypeFactory *t); ///< Constructor TypeOpInsert(TypeFactory *t); ///< Constructor
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opInsertOp(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opInsertOp(op); }
}; };
/// \brief Information about the EXTRACT op-code /// \brief Information about the EXTRACT op-code
@ -791,14 +791,14 @@ class TypeOpExtract : public TypeOpFunc {
public: public:
TypeOpExtract(TypeFactory *t); ///< Constructor TypeOpExtract(TypeFactory *t); ///< Constructor
virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const; virtual Datatype *getInputLocal(const PcodeOp *op,int4 slot) const;
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opExtractOp(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opExtractOp(op); }
}; };
/// \brief Information about the POPCOUNT op-code /// \brief Information about the POPCOUNT op-code
class TypeOpPopcount : public TypeOpFunc { class TypeOpPopcount : public TypeOpFunc {
public: public:
TypeOpPopcount(TypeFactory *t); ///< Constructor TypeOpPopcount(TypeFactory *t); ///< Constructor
virtual void push(PrintLanguage *lng,const PcodeOp *op) const { lng->opPopcountOp(op); } virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opPopcountOp(op); }
}; };
#endif #endif