Skip to content

Ghidra is a software reverse engineering (SRE) framework

Add custom printRaw implementation for TypeOps with ambiguous printRaw This adds a `printRaw` implementation to 13 TypeOps, similar in implementation to `TypeOpIntSright::printRaw`.

Luke Serné12806006b5e0
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.cc
index 025b843019..c688db2a5d 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.cc
@@ -1022,6 +1022,16 @@ TypeOpIntSless::TypeOpIntSless(TypeFactory *t)
behave = new OpBehaviorIntSless();
}
+void TypeOpIntSless::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " s< ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
Datatype *TypeOpIntSless::getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const
{
@@ -1048,6 +1058,16 @@ TypeOpIntSlessEqual::TypeOpIntSlessEqual(TypeFactory *t)
behave = new OpBehaviorIntSlessEqual();
}
+void TypeOpIntSlessEqual::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " s<= ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
Datatype *TypeOpIntSlessEqual::getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const
{
@@ -1670,6 +1690,16 @@ Datatype *TypeOpIntSdiv::getInputCast(const PcodeOp *op,int4 slot,const CastStra
return castStrategy->castStandard(reqtype,curtype,true,true);
}
+void TypeOpIntSdiv::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " s/ ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
TypeOpIntRem::TypeOpIntRem(TypeFactory *t)
: TypeOpBinary(t,CPUI_INT_REM,"%",TYPE_UINT,TYPE_UINT)
{
@@ -1698,6 +1728,16 @@ TypeOpIntSrem::TypeOpIntSrem(TypeFactory *t)
behave = new OpBehaviorIntSrem();
}
+void TypeOpIntSrem::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " s% ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
Datatype *TypeOpIntSrem::getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const
{
@@ -1750,6 +1790,16 @@ TypeOpFloatEqual::TypeOpFloatEqual(TypeFactory *t,const Translate *trans)
behave = new OpBehaviorFloatEqual(trans);
}
+void TypeOpFloatEqual::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " f== ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
TypeOpFloatNotEqual::TypeOpFloatNotEqual(TypeFactory *t,const Translate *trans)
: TypeOpBinary(t,CPUI_FLOAT_NOTEQUAL,"!=",TYPE_BOOL,TYPE_FLOAT)
{
@@ -1758,6 +1808,16 @@ TypeOpFloatNotEqual::TypeOpFloatNotEqual(TypeFactory *t,const Translate *trans)
behave = new OpBehaviorFloatNotEqual(trans);
}
+void TypeOpFloatNotEqual::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " f!= ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
TypeOpFloatLess::TypeOpFloatLess(TypeFactory *t,const Translate *trans)
: TypeOpBinary(t,CPUI_FLOAT_LESS,"<",TYPE_BOOL,TYPE_FLOAT)
{
@@ -1766,6 +1826,16 @@ TypeOpFloatLess::TypeOpFloatLess(TypeFactory *t,const Translate *trans)
behave = new OpBehaviorFloatLess(trans);
}
+void TypeOpFloatLess::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " f< ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
TypeOpFloatLessEqual::TypeOpFloatLessEqual(TypeFactory *t,const Translate *trans)
: TypeOpBinary(t,CPUI_FLOAT_LESSEQUAL,"<=",TYPE_BOOL,TYPE_FLOAT)
{
@@ -1774,6 +1844,16 @@ TypeOpFloatLessEqual::TypeOpFloatLessEqual(TypeFactory *t,const Translate *trans
behave = new OpBehaviorFloatLessEqual(trans);
}
+void TypeOpFloatLessEqual::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " f<= ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
TypeOpFloatNan::TypeOpFloatNan(TypeFactory *t,const Translate *trans)
: TypeOpFunc(t,CPUI_FLOAT_NAN,"NAN",TYPE_BOOL,TYPE_FLOAT)
{
@@ -1790,6 +1870,16 @@ TypeOpFloatAdd::TypeOpFloatAdd(TypeFactory *t,const Translate *trans)
behave = new OpBehaviorFloatAdd(trans);
}
+void TypeOpFloatAdd::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " f+ ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
TypeOpFloatDiv::TypeOpFloatDiv(TypeFactory *t,const Translate *trans)
: TypeOpBinary(t,CPUI_FLOAT_DIV,"/",TYPE_FLOAT,TYPE_FLOAT)
{
@@ -1798,6 +1888,16 @@ TypeOpFloatDiv::TypeOpFloatDiv(TypeFactory *t,const Translate *trans)
behave = new OpBehaviorFloatDiv(trans);
}
+void TypeOpFloatDiv::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " f/ ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
TypeOpFloatMult::TypeOpFloatMult(TypeFactory *t,const Translate *trans)
: TypeOpBinary(t,CPUI_FLOAT_MULT,"*",TYPE_FLOAT,TYPE_FLOAT)
{
@@ -1806,6 +1906,16 @@ TypeOpFloatMult::TypeOpFloatMult(TypeFactory *t,const Translate *trans)
behave = new OpBehaviorFloatMult(trans);
}
+void TypeOpFloatMult::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " f* ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
TypeOpFloatSub::TypeOpFloatSub(TypeFactory *t,const Translate *trans)
: TypeOpBinary(t,CPUI_FLOAT_SUB,"-",TYPE_FLOAT,TYPE_FLOAT)
{
@@ -1814,6 +1924,16 @@ TypeOpFloatSub::TypeOpFloatSub(TypeFactory *t,const Translate *trans)
behave = new OpBehaviorFloatSub(trans);
}
+void TypeOpFloatSub::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = ";
+ Varnode::printRaw(s,op->getIn(0));
+ s << " f- ";
+ Varnode::printRaw(s,op->getIn(1));
+}
+
TypeOpFloatNeg::TypeOpFloatNeg(TypeFactory *t,const Translate *trans)
: TypeOpUnary(t,CPUI_FLOAT_NEG,"-",TYPE_FLOAT,TYPE_FLOAT)
{
@@ -1822,6 +1942,14 @@ TypeOpFloatNeg::TypeOpFloatNeg(TypeFactory *t,const Translate *trans)
behave = new OpBehaviorFloatNeg(trans);
}
+void TypeOpFloatNeg::printRaw(ostream &s,const PcodeOp *op)
+
+{
+ Varnode::printRaw(s,op->getOut());
+ s << " = f- ";
+ Varnode::printRaw(s,op->getIn(0));
+}
+
TypeOpFloatAbs::TypeOpFloatAbs(TypeFactory *t,const Translate *trans)
: TypeOpFunc(t,CPUI_FLOAT_ABS,"ABS",TYPE_FLOAT,TYPE_FLOAT)
{
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.hh
index 5a5fd1d5a9..f919d6b4e5 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.hh
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.hh
@@ -378,6 +378,7 @@ public:
class TypeOpIntSless : public TypeOpBinary {
public:
TypeOpIntSless(TypeFactory *t); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
virtual Datatype *propagateType(Datatype *alttype,PcodeOp *op,Varnode *invn,Varnode *outvn,
int4 inslot,int4 outslot);
@@ -388,6 +389,7 @@ public:
class TypeOpIntSlessEqual : public TypeOpBinary {
public:
TypeOpIntSlessEqual(TypeFactory *t); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual Datatype *getInputCast(const PcodeOp *op,int4 slot,const CastStrategy *castStrategy) const;
virtual Datatype *propagateType(Datatype *alttype,PcodeOp *op,Varnode *invn,Varnode *outvn,
int4 inslot,int4 outslot);
@@ -572,6 +574,7 @@ public:
class TypeOpIntSdiv : public TypeOpBinary {
public:
TypeOpIntSdiv(TypeFactory *t); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *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;
};
@@ -588,6 +591,7 @@ public:
class TypeOpIntSrem : public TypeOpBinary {
public:
TypeOpIntSrem(TypeFactory *t); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *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;
};
@@ -624,6 +628,7 @@ public:
class TypeOpFloatEqual : public TypeOpBinary {
public:
TypeOpFloatEqual(TypeFactory *t,const Translate *trans); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatEqual(op); }
};
@@ -631,6 +636,7 @@ public:
class TypeOpFloatNotEqual : public TypeOpBinary {
public:
TypeOpFloatNotEqual(TypeFactory *t,const Translate *trans); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatNotEqual(op); }
};
@@ -638,6 +644,7 @@ public:
class TypeOpFloatLess : public TypeOpBinary {
public:
TypeOpFloatLess(TypeFactory *t,const Translate *trans); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatLess(op); }
};
@@ -645,6 +652,7 @@ public:
class TypeOpFloatLessEqual : public TypeOpBinary {
public:
TypeOpFloatLessEqual(TypeFactory *t,const Translate *trans); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatLessEqual(op); }
};
@@ -659,6 +667,7 @@ public:
class TypeOpFloatAdd : public TypeOpBinary {
public:
TypeOpFloatAdd(TypeFactory *t,const Translate *trans); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatAdd(op); }
};
@@ -666,6 +675,7 @@ public:
class TypeOpFloatDiv : public TypeOpBinary {
public:
TypeOpFloatDiv(TypeFactory *t,const Translate *trans); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatDiv(op); }
};
@@ -673,6 +683,7 @@ public:
class TypeOpFloatMult : public TypeOpBinary {
public:
TypeOpFloatMult(TypeFactory *t,const Translate *trans); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatMult(op); }
};
@@ -680,6 +691,7 @@ public:
class TypeOpFloatSub : public TypeOpBinary {
public:
TypeOpFloatSub(TypeFactory *t,const Translate *trans); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatSub(op); }
};
@@ -687,6 +699,7 @@ public:
class TypeOpFloatNeg : public TypeOpUnary {
public:
TypeOpFloatNeg(TypeFactory *t,const Translate *trans); ///< Constructor
+ virtual void printRaw(ostream &s,const PcodeOp *op);
virtual void push(PrintLanguage *lng,const PcodeOp *op,const PcodeOp *readOp) const { lng->opFloatNeg(op); }
};