Ghidra is a software reverse engineering (SRE) framework
GP-5950 Add support for multipath conditional constants
caheckmane412f13b30b5
diff --git a/Ghidra/Features/Decompiler/certification.manifest b/Ghidra/Features/Decompiler/certification.manifestindex e3d0538c50..3ff8179a61 100644--- a/Ghidra/Features/Decompiler/certification.manifest+++ b/Ghidra/Features/Decompiler/certification.manifest@@ -17,6 +17,8 @@ src/decompile/datatests/ccmp.xml||GHIDRA||||END|src/decompile/datatests/concat.xml||GHIDRA||||END|src/decompile/datatests/concatsplit.xml||GHIDRA||||END|src/decompile/datatests/condconst.xml||GHIDRA||||END|+src/decompile/datatests/condconst2.xml||GHIDRA||||END|+src/decompile/datatests/condconstsub.xml||GHIDRA||||END|src/decompile/datatests/condexesub.xml||GHIDRA||||END|src/decompile/datatests/condmulti.xml||GHIDRA||||END|src/decompile/datatests/convert.xml||GHIDRA||||END|diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.ccindex 2a4b1afa77..f21c0f823b 100644--- a/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.cc+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.cc@@ -4248,6 +4248,40 @@ void ActionConditionalConst::placeMultipleConstants(vector<PcodeOpNode> &phiNode}}+/// \brief Try to push the constant at the front point through to the output of the given PcodeOp+///+/// If successful, create a ConstPoint to search for reads of this new constant.+/// \param points is the set of points with the current point at the front+/// \param op is p-code op to push the constant through+void ActionConditionalConst::pushConstant(list<ConstPoint> &points,PcodeOp *op)++{+ if ((op->getEvalType() & PcodeOp::special) != 0) return;+ if (op->getOpcode()->isFloatingPointOp()) return;+ Varnode *outvn = op->getOut();+ if (outvn->getSize() > sizeof(uintb)) return;+ Varnode *vn = points.front().vn;+ int4 slot = op->getSlot(vn);+ uintb in[3];+ for(int4 i=0;i<op->numInput();++i) {+ if (i == slot)+ in[i] = points.front().value;+ else {+ Varnode *inVn = op->getIn(i);+ if (inVn->getSize() > sizeof(uintb)) return;+ if (inVn->isConstant())+ in[i] = op->getIn(i)->getOffset();+ else+ return; // Not all inputs are constant+ }+ }+ bool evalError;+ uintb outval = op->executeSimple(in,evalError);+ if (evalError)+ return;+ points.emplace_back(outvn,outval,points.front().constBlock,points.front().inSlot,points.front().blockIsDom);+}+/// \brief Replace MULTIEQUAL edges with constant if there is no alternate flow////// A given Varnode is known to be constant along a set of MULTIEQUAL edges. If these edges are excised from the@@ -4297,57 +4331,107 @@ void ActionConditionalConst::handlePhiNodes(Varnode *varVn,Varnode *constVn,vect}}-/// \brief Replace reads of a given Varnode with a constant.+/// \brief Test if we can reach the given Varnode via a path other than through the immediate edge///-/// For each read op, check that is in or dominated by a specific block we known-/// the Varnode is constant in.-/// \param varVn is the given Varnode-/// \param constVn is the constant Varnode to replace with (may be null)-/// \param constVal is the constant value being propagated-/// \param constBlock is the block which dominates ops reading the constant value+/// The given Varnode is an input to a MULTIEQUAL through a specific input slot. If we can reach the+/// same Varnode backtracking through one of the other slots, return \b true. We can backtrack+/// through MULTIEQUALs up to a given depth and possibly a final INT_ADD.+/// \param vn is the given Varnode+/// \param op is the MULTIEQUAL reading \b vn+/// \param slot is the input index of \b vn+/// \param depth is the maximum depth to backtrack+/// \return \b true if an alternate path to the Varnode is found+bool ActionConditionalConst::testAlternatePath(Varnode *vn,PcodeOp *op,int4 slot,int4 depth)++{+ for(int4 i=0;i<op->numInput();++i) {+ if (i == slot) continue;+ Varnode *inVn = op->getIn(i);+ if (inVn == vn) return true;+ if (inVn->isWritten()) {+ PcodeOp *curOp = inVn->getDef();+ OpCode opc = curOp->code();+ if (opc == CPUI_INT_ADD || opc == CPUI_PTRSUB || opc == CPUI_PTRADD) {+ if (curOp->getIn(0) == vn || curOp->getIn(1) == vn)+ return true;+ }+ else if (opc == CPUI_MULTIEQUAL) {+ if (depth == 0) continue;+ if (testAlternatePath(vn,curOp,-1,depth-1))+ return true;+ }+ }+ }+ return false;+}++/// \brief At each ConstPoint, replace reads of the Varnode down the constant path with a constant Varnode+///+/// Process ConstPoints from the front of the list.+/// For each read op of current point's Varnode, check if it is in the constant path.+/// If it is, replace the read with a new constant Varnode.+/// If not in the constant path, attempt to make the output Varnode into a new ConstPoint that may have+/// have reads in the constant path.+/// \param points is the list of ConstPoints/// \param useMultiequal is \b true if conditional constants can be applied to MULTIEQUAL ops/// \param data is the function being analyzed-void ActionConditionalConst::propagateConstant(Varnode *varVn,Varnode *constVn,uintb constVal,- FlowBlock *constBlock,bool useMultiequal,Funcdata &data)+void ActionConditionalConst::propagateConstant(list<ConstPoint> &points,bool useMultiequal,Funcdata &data){vector<PcodeOpNode> phiNodeEdges;- list<PcodeOp *>::const_iterator iter,enditer;- iter = varVn->beginDescend();- enditer = varVn->endDescend();- while(iter != enditer) {- PcodeOp *op = *iter;- while(iter != enditer && *iter == op)- ++iter; // Advance iterator off of current op, as this descendant may be erased- OpCode opc = op->code();- if (opc == CPUI_INDIRECT) // Don't propagate constant into these- continue;- else if (opc == CPUI_MULTIEQUAL) {- if (!useMultiequal)- continue;- if (varVn->isAddrTied() && varVn->getAddr() == op->getOut()->getAddr())+ while(!points.empty()) {+ ConstPoint &point(points.front());+ Varnode *varVn = point.vn;+ Varnode *constVn = point.constVn;+ FlowBlock *constBlock = point.constBlock;+ list<PcodeOp *>::const_iterator iter = varVn->beginDescend();+ list<PcodeOp *>::const_iterator enditer = varVn->endDescend();+ while(iter != enditer) {+ PcodeOp *op = *iter;+ while(iter != enditer && *iter == op)+ ++iter; // Advance iterator off of current op, as this descendant may be erased+ OpCode opc = op->code();+ if (opc == CPUI_INDIRECT) // Don't propagate constant into thesecontinue;- FlowBlock *bl = op->getParent();- for(int4 slot=0;slot<op->numInput();++slot) {- if (op->getIn(slot) == varVn) {- if (constBlock->dominates(bl->getIn(slot))) {- phiNodeEdges.emplace_back(op,slot);+ else if (opc == CPUI_MULTIEQUAL) {+ if (!useMultiequal)+ continue;+ if (varVn->isAddrTied() && varVn->getAddr() == op->getOut()->getAddr())+ continue;+ FlowBlock *bl = op->getParent();+ if (bl == constBlock) { // The immediate edge from the conditional block, coming into a MULTIEQUAL+ if (op->getIn(point.inSlot) == varVn) {+ // Its possible the compiler still intends the constant value to be the same variable+ // Test for conditions when this is likely so we don't unnecessarily create a new variable+ if (point.value > 1) continue;+ if (op->getOut()->isAddrTied()) continue;+ if (testAlternatePath(varVn, op, point.inSlot, 2)) continue;+ phiNodeEdges.emplace_back(op,point.inSlot);+ }+ }+ else if (point.blockIsDom) {+ for(int4 slot=0;slot<op->numInput();++slot) {+ if (op->getIn(slot) == varVn) {+ if (constBlock->dominates(bl->getIn(slot))) {+ phiNodeEdges.emplace_back(op,slot);+ }+ }}}+ continue;}- continue;- }- else if (opc == CPUI_COPY) { // Don't propagate into COPY unless...- PcodeOp *followOp = op->getOut()->loneDescend();- if (followOp == (PcodeOp *)0) continue;- if (followOp->isMarker()) continue;- if (followOp->code() == CPUI_COPY) continue;+ else if (opc == CPUI_COPY) { // Don't propagate into COPY unless...+ PcodeOp *followOp = op->getOut()->loneDescend();+ if (followOp == (PcodeOp *)0) continue;+ if (followOp->isMarker()) continue;+ if (followOp->code() == CPUI_COPY) continue;// ...unless COPY is into something more interesting- }- if (constBlock->dominates(op->getParent())) {- if (constVn == (Varnode *)0)- constVn = data.newConstant(varVn->getSize(), constVal);- if (opc == CPUI_RETURN){+ }+ if (!point.blockIsDom) continue;+ if (constBlock->dominates(op->getParent())) {+ if (constVn == (Varnode *)0)+ constVn = data.newConstant(varVn->getSize(), point.value);+ if (opc == CPUI_RETURN) {// CPUI_RETURN ops can't directly take constants// as inputsPcodeOp *copyBeforeRet = data.newOp(1, op->getAddr());@@ -4356,19 +4440,70 @@ void ActionConditionalConst::propagateConstant(Varnode *varVn,Varnode *constVn,udata.newVarnodeOut(varVn->getSize(),varVn->getAddr(),copyBeforeRet);data.opSetInput(op,copyBeforeRet->getOut(),1);data.opInsertBefore(copyBeforeRet,op);+ }+ else {+ int4 slot = op->getSlot(varVn);+ data.opSetInput(op,constVn,slot); // Replace ref with constant!+ }+ count += 1; // We made a change}else {- int4 slot = op->getSlot(varVn);- data.opSetInput(op,constVn,slot); // Replace ref with constant!+ pushConstant(points, op);}- count += 1; // We made a change}+ if (!phiNodeEdges.empty()) {+ if (constVn == (Varnode *)0)+ constVn = data.newConstant(varVn->getSize(), point.value);+ handlePhiNodes(varVn, constVn, phiNodeEdges, data);+ phiNodeEdges.clear();+ }+ points.pop_front();}- if (!phiNodeEdges.empty()) {- if (constVn == (Varnode *)0)- constVn = data.newConstant(varVn->getSize(), constVal);- handlePhiNodes(varVn, constVn, phiNodeEdges, data);- }+}++/// \brief Find a Varnode being compared to a constant creating the given CBRANCH boolean+///+/// If the boolean is created by comparing a Varnode to a constant, create a ConstPoint record+/// indicating the path down which the Varnode can be considered constant.+/// \param points will hold any new ConstPoint+/// \param boolVn is the given CBRANCH boolean+/// \param bl is the block constaining the CBRANCH+/// \param blockDom is an array of booleans indicating along which out edges a constant could be pushed+/// \param flipEdge is \b true if the meaning of the CBRANCH has been flipped+void ActionConditionalConst::findConstCompare(list<ConstPoint> &points,Varnode *boolVn,FlowBlock *bl,+ bool *blockDom,bool flipEdge)+{+ if (!boolVn->isWritten()) return;+ PcodeOp *compOp = boolVn->getDef();+ OpCode opc = compOp->code();+ if (opc == CPUI_BOOL_NEGATE) {+ flipEdge = !flipEdge;+ boolVn = compOp->getIn(0);+ if (!boolVn->isWritten()) return;+ compOp = boolVn->getDef();+ opc = compOp->code();+ }+ int4 constEdge; // Out edge where value is constant+ if (opc == CPUI_INT_EQUAL)+ constEdge = 1;+ else if (opc == CPUI_INT_NOTEQUAL)+ constEdge = 0;+ else+ return;+ // Find the variable and verify that it is compared to a constant+ Varnode *varVn = compOp->getIn(0);+ Varnode *constVn = compOp->getIn(1);+ if (!constVn->isConstant()) {+ if (!varVn->isConstant())+ return;+ Varnode *tmp = constVn;+ constVn = varVn;+ varVn = tmp;+ }+ if (varVn->loneDescend() != (PcodeOp *)0) return;+ if (flipEdge)+ constEdge = 1 - constEdge;+ points.emplace_back(varVn,constVn,bl->getOut(constEdge),bl->getOutRevIndex(constEdge),blockDom[constEdge]);}int4 ActionConditionalConst::apply(Funcdata &data)@@ -4384,55 +4519,23 @@ int4 ActionConditionalConst::apply(Funcdata &data)useMultiequal = false; // Don't propagate into MULTIEQUAL}const BlockGraph &blockGraph(data.getBasicBlocks());- bool blockdom[2];+ bool blockDom[2];+ list<ConstPoint> points;for(int4 i=0;i<blockGraph.getSize();++i) {FlowBlock *bl = blockGraph.getBlock(i);PcodeOp *cBranch = bl->lastOp();if (cBranch == (PcodeOp *)0 || cBranch->code() != CPUI_CBRANCH) continue;Varnode *boolVn = cBranch->getIn(1);- blockdom[0] = bl->getOut(0)->restrictedByConditional(bl); // Make sure boolean constant holds down false branch- blockdom[1] = bl->getOut(1)->restrictedByConditional(bl);- if (!blockdom[0] && !blockdom[1]) continue;+ blockDom[0] = bl->getOut(0)->restrictedByConditional(bl); // Make sure boolean constant holds down false branch+ blockDom[1] = bl->getOut(1)->restrictedByConditional(bl);bool flipEdge = cBranch->isBooleanFlip();if (boolVn->loneDescend() == (PcodeOp *)0) { // If the boolean is read more than once// Search for implied constants, bool=0 down false branch, bool=1 down true branch- if (blockdom[0])- propagateConstant(boolVn, (Varnode *)0, flipEdge ? 1 : 0, bl->getFalseOut(), useMultiequal, data);- if (blockdom[1])- propagateConstant(boolVn, (Varnode *)0, flipEdge ? 0 : 1, bl->getTrueOut(), useMultiequal, data);- }- if (!boolVn->isWritten()) continue;- PcodeOp *compOp = boolVn->getDef();- OpCode opc = compOp->code();- if (opc == CPUI_BOOL_NEGATE) {- flipEdge = !flipEdge;- boolVn = compOp->getIn(0);- if (!boolVn->isWritten()) continue;- compOp = boolVn->getDef();- opc = compOp->code();- }- int4 constEdge; // Out edge where value is constant- if (opc == CPUI_INT_EQUAL)- constEdge = 1;- else if (opc == CPUI_INT_NOTEQUAL)- constEdge = 0;- else- continue;- // Find the variable and verify that it is compared to a constant- Varnode *varVn = compOp->getIn(0);- Varnode *constVn = compOp->getIn(1);- if (!constVn->isConstant()) {- if (!varVn->isConstant())- continue;- Varnode *tmp = constVn;- constVn = varVn;- varVn = tmp;- }- if (varVn->loneDescend() != (PcodeOp *)0) continue;- if (flipEdge)- constEdge = 1 - constEdge;- if (!blockdom[constEdge]) continue; // Make sure condition holds- propagateConstant(varVn,constVn,0,bl->getOut(constEdge),useMultiequal,data);+ points.emplace_back(boolVn, flipEdge ? 1 : 0, bl->getFalseOut(),bl->getOutRevIndex(0),blockDom[0]);+ points.emplace_back(boolVn, flipEdge ? 0 : 1, bl->getTrueOut(),bl->getOutRevIndex(1),blockDom[1]);+ }+ findConstCompare(points, boolVn, bl, blockDom, flipEdge);+ propagateConstant(points, useMultiequal, data);}return 0;}diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.hhindex 3b1a41456e..d484facb7c 100644--- a/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.hh+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.hh@@ -567,14 +567,30 @@ public:/// \brief Propagate conditional constantsclass ActionConditionalConst : public Action {+ /// \brief Description of a point in control-flow where a Varnode can propagate as a constant down a conditional branch+ struct ConstPoint {+ Varnode *vn; ///< Varnode that is constant for some reads+ Varnode *constVn; ///< Representative of the constant (may be null)+ uintb value; ///< The constant value+ FlowBlock *constBlock; ///< Block that dominates all reads where vn is constant+ int4 inSlot; ///< Input edge from condition block+ bool blockIsDom; ///< Is \b true if block is dominated by constant path+ ConstPoint(Varnode *v,Varnode *c,FlowBlock *bl,int4 slot,bool isDom) {+ vn = v; constVn = c; value = c->getOffset(); constBlock = bl; inSlot = slot; blockIsDom = isDom; } ///< Construct from constant Varnode+ ConstPoint(Varnode *v,uintb val,FlowBlock *bl,int4 slot,bool isDom) {+ vn = v; constVn = (Varnode *)0; value = val; constBlock = bl; inSlot = slot; blockIsDom = isDom; } ///< Construct from constant value+ };static void clearMarks(const vector<PcodeOp *> &opList);static void collectReachable(Varnode *vn,vector<PcodeOpNode> &phiNodeEdges,vector<PcodeOp *> &reachable);static bool flowToAlternatePath(PcodeOp *op);static bool flowTogether(const vector<PcodeOpNode> &edges,int4 i,vector<int4> &result);static Varnode *placeCopy(PcodeOp *op,BlockBasic *bl,Varnode *constVn,Funcdata &data);+ static void findConstCompare(list<ConstPoint> &points,Varnode *boolVn,FlowBlock *bl,bool *blockDom,bool flipEdge);+ static void pushConstant(list<ConstPoint> &points,PcodeOp *op);static void placeMultipleConstants(vector<PcodeOpNode> &phiNodeEdges,vector<int4> &marks,Varnode *constVn,Funcdata &data);void handlePhiNodes(Varnode *varVn,Varnode *constVn,vector<PcodeOpNode> &phiNodeEdges,Funcdata &data);- void propagateConstant(Varnode *varVn,Varnode *constVn,uintb constVal,FlowBlock *constBlock,bool useMultiequal,Funcdata &data);+ bool testAlternatePath(Varnode *vn,PcodeOp *op,int4 slot,int4 depth);+ void propagateConstant(list<ConstPoint> &points,bool useMultiequal,Funcdata &data);public:ActionConditionalConst(const string &g) : Action(0,"condconst",g) {} ///< Constructorvirtual Action *clone(const ActionGroupList &grouplist) const {diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/double.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/double.ccindex b56f08658c..858b64b499 100644--- a/Ghidra/Features/Decompiler/src/decompile/cpp/double.cc+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/double.cc@@ -2169,6 +2169,7 @@ bool LessThreeWay::normalizeHi(void)}hiconstform = false;if (vnhil2->isConstant()) {+ if (in.getSize() > sizeof(uintb)) return false; // Must have enough precision for constanthiconstform = true;hival = vnhil2->getOffset();SplitVarnode::getTrueFalse(hilessbool,hiflip,hilesstrue,hilessfalse);diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/op.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/op.ccindex cc7e46033f..dcf7553fd3 100644--- a/Ghidra/Features/Decompiler/src/decompile/cpp/op.cc+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/op.cc@@ -471,6 +471,32 @@ uintb PcodeOp::collapse(bool &markedInput) const {throw LowlevelError("Invalid constant collapse");}+/// The p-code op must be \e special, or an exception is thrown. The operation is performed+/// and if there is no evaluation error, the result is returned and \b evalError is set to \b false.+/// \param in is an array of input values+/// \return the result of applying \b this operation to the input values+uintb PcodeOp::executeSimple(uintb *in,bool &evalError) const++{+ uint4 evalType = getEvalType();+ uintb res;+ try {+ if (evalType == PcodeOp::unary)+ res = opcode->evaluateUnary(output->getSize(),inrefs[0]->getSize(),in[0]);+ else if (evalType == PcodeOp::binary)+ res = opcode->evaluateBinary(output->getSize(),inrefs[0]->getSize(),in[0],in[1]);+ else if (evalType == PcodeOp::ternary)+ res = opcode->evaluateTernary(output->getSize(),inrefs[0]->getSize(),in[0],in[1],in[2]);+ else+ throw LowlevelError("Cannot perform simple execution of "+(string)get_opname(code()));+ } catch(EvaluationError &err) {+ evalError = true;+ return 0;+ }+ evalError = false;+ return res;+}+/// Knowing that \b this PcodeOp has collapsed its constant inputs, one of which has/// symbol content, figure out if the symbol should propagate to the new given output constant./// \param newConst is the given output constantdiff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/op.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/op.hhindex 3111e8c8b4..7e516fdf57 100644--- a/Ghidra/Features/Decompiler/src/decompile/cpp/op.hh+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/op.hh@@ -233,6 +233,7 @@ public:OpCode code(void) const { return opcode->getOpcode(); } ///< Get the opcode id (enum) for this opbool isCommutative(void) const { return ((flags & PcodeOp::commutative)!=0); } ///< Return \b true if inputs commuteuintb collapse(bool &markedInput) const; ///< Calculate the constant output produced by this op+ uintb executeSimple(uintb *in,bool &evalError) const; ///< Execute \b this operation on the given input valuesvoid collapseConstantSymbol(Varnode *newConst) const; ///< Propagate constant symbol from inputs to given outputPcodeOp *nextOp(void) const; ///< Return the next op in the control-flow from this or \e nullPcodeOp *previousOp(void) const; ///< Return the previous op within this op's basic block or \e nulldiff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/opbehavior.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/opbehavior.ccindex 390dbea084..ab23e94b83 100644--- a/Ghidra/Features/Decompiler/src/decompile/cpp/opbehavior.cc+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/opbehavior.cc@@ -129,7 +129,20 @@ uintb OpBehavior::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) cstring name(get_opname(opcode));throw LowlevelError("Binary emulation unimplemented for "+name);}-++/// \param sizeout is the size of the output in bytes+/// \param sizein is the size of the inputs in bytes+/// \param in1 is the first input value+/// \param in2 is the second input value+/// \param in3 is the third input value+/// \return the output value+uintb OpBehavior::evaluateTernary(int4 sizeout,int4 sizein,uintb in1,uintb in2,uintb in3) const++{+ string name(get_opname(opcode));+ throw LowlevelError("Ternary emulation unimplemented for "+name);+}+/// If the output value is known, recover the input value./// \param sizeout is the size of the output in bytes/// \param out is the output value@@ -752,6 +765,20 @@ uintb OpBehaviorSubpiece::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintreturn res;}+uintb OpBehaviorPtradd::evaluateTernary(int4 sizeout,int4 sizein,uintb in1,uintb in2,uintb in3) const++{+ uintb res = (in1 + in2 * in3) & calc_mask(sizeout);+ return res;+}++uintb OpBehaviorPtrsub::evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const++{+ uintb res = (in1 + in2) & calc_mask(sizeout);+ return res;+}+uintb OpBehaviorPopcount::evaluateUnary(int4 sizeout,int4 sizein,uintb in1) const{diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/opbehavior.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/opbehavior.hhindex 2eb9752bac..d1733c7ac2 100644--- a/Ghidra/Features/Decompiler/src/decompile/cpp/opbehavior.hh+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/opbehavior.hh@@ -4,9 +4,9 @@* 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.@@ -66,7 +66,10 @@ public:/// \brief Emulate the binary op-code on input valuesvirtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;-++ /// \brief Emulate the ternary op-code on input values+ virtual uintb evaluateTernary(int4 sizeout,int4 sizein,uintb in1,uintb in2,uintb in3) const;+/// \brief Reverse the binary op-code operation, recovering an input valuevirtual uintb recoverInputBinary(int4 slot,int4 sizeout,uintb out,int4 sizein,uintb in) const;@@ -506,6 +509,20 @@ public:virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;};+/// CPUI_PTRADD behavior+class OpBehaviorPtradd : public OpBehavior {+public:+ OpBehaviorPtradd(void) : OpBehavior(CPUI_PTRADD,false) {} ///< Constructor+ virtual uintb evaluateTernary(int4 sizeout,int4 sizein,uintb in1,uintb in2,uintb in3) const;+};++/// CPUI_PTRSUB behavior+class OpBehaviorPtrsub : public OpBehavior {+public:+ OpBehaviorPtrsub(void) : OpBehavior(CPUI_PTRSUB,false) {} ///< Constructor+ virtual uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const;+};+/// CPUI_POPCOUNT behaviorclass OpBehaviorPopcount : public OpBehavior {public:diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.ccindex bb12d46769..549b10e824 100644--- a/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.cc+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.cc@@ -2226,7 +2226,7 @@ TypeOpPtradd::TypeOpPtradd(TypeFactory *t) : TypeOp(t,CPUI_PTRADD,"+"){opflags = PcodeOp::ternary | PcodeOp::nocollapse;addlflags = arithmetic_op;- behave = new OpBehavior(CPUI_PTRADD,false); // Dummy behavior+ behave = new OpBehaviorPtradd();}Datatype *TypeOpPtradd::getInputLocal(const PcodeOp *op,int4 slot) const@@ -2296,7 +2296,7 @@ TypeOpPtrsub::TypeOpPtrsub(TypeFactory *t) : TypeOp(t,CPUI_PTRSUB,"->")// allow this to be commutative.opflags = PcodeOp::binary|PcodeOp::nocollapse;addlflags = arithmetic_op;- behave = new OpBehavior(CPUI_PTRSUB,false); // Dummy behavior+ behave = new OpBehaviorPtrsub();}Datatype *TypeOpPtrsub::getOutputLocal(const PcodeOp *op) constdiff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.hhindex 51b20cc7e8..90ac4ed351 100644--- a/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.hh+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/typeop.hh@@ -91,6 +91,17 @@ public:uintb evaluateBinary(int4 sizeout,int4 sizein,uintb in1,uintb in2) const {return behave->evaluateBinary(sizeout,sizein,in1,in2); }+ /// \brief Emulate the ternary op-code on an input value+ ///+ /// \param sizeout is the size of the output in bytes+ /// \param sizein is the size of the inputs in bytes+ /// \param in1 is the first input value+ /// \param in2 is the second input value+ /// \param in3 is the third input value+ /// \return the output value+ uintb evaluateTernary(int4 sizeout,int4 sizein,uintb in1,uintb in2,uintb in3) const {+ return behave->evaluateTernary(sizeout,sizein,in1,in2,in3); }+/// \brief Reverse the binary op-code operation, recovering a constant input value////// If the output value and one of the input values is known, recover the valuediff --git a/Ghidra/Features/Decompiler/src/decompile/datatests/condconst2.xml b/Ghidra/Features/Decompiler/src/decompile/datatests/condconst2.xmlnew file mode 100644index 0000000000..b065d8b81b--- /dev/null+++ b/Ghidra/Features/Decompiler/src/decompile/datatests/condconst2.xml@@ -0,0 +1,45 @@+<decompilertest>+<binaryimage arch="ARM:LE:32:v8:default">+<!--+ Examples of conditional constants being immediately passed to MULTIEQUAL after the branch+-->+<bytechunk space="ram" offset="0x4022871a">+ 00b970478160+6120fbe7+</bytechunk>+<bytechunk space="ram" offset="0x40228728">+ 0b4601b107330360+7047+</bytechunk>+<bytechunk space="ram" offset="0x40228736">+ 087a613818bf01207047+</bytechunk>+<symbol space="ram" offset="0x4022871a" name="zeroprop"/>+<symbol space="ram" offset="0x40228728" name="throughadd"/>+<symbol space="ram" offset="0x40228736" name="condmove"/>+<symbol space="ram" offset="0x40228758" name="myfunc"/>+</binaryimage>+<script>+ <com>set context TMode 1 [ram,0x4022871a] [ram,0x40228800]</com>+ <com>parse line extern char zeroprop(int4 *ptrint,int4 val);</com>+ <com>parse line extern void throughadd(int4 *tadd,int4 tval);</com>+ <com>parse line extern bool condmove(int4 cval,char *cptr);</com>+ <com>lo fu zeroprop</com>+ <com>decompile</com>+ <com>print C</com>+ <com>lo fu throughadd</com>+ <com>decompile</com>+ <com>print C</com>+ <com>lo fu condmove</com>+ <com>decompile</com>+ <com>print C</com>+</script>+<stringmatch name="Immediate Conditional #1" min="0" max="0">\(char\)ptrint</stringmatch>+<stringmatch name="Immediate Conditional #2" min="1" max="1">return cVar1;</stringmatch>+<stringmatch name="Immediate Conditional #3" min="1" max="1">cVar1 = '\\0';</stringmatch>+<stringmatch name="Immediate Conditional #4" min="1" max="1">cVar1 = 'a';</stringmatch>+<stringmatch name="Immediate Conditional #5" min="1" max="1">\*tadd = tval;</stringmatch>+<stringmatch name="Immediate Conditional #6" min="1" max="1">tval = tval \+ 7;</stringmatch>+<stringmatch name="Immediate Conditional #7" min="1" max="1">return cptr\[8\] != 'a';</stringmatch>+<stringmatch name="Immediate Conditional #8" min="0" max="0">SUB</stringmatch>+</decompilertest>diff --git a/Ghidra/Features/Decompiler/src/decompile/datatests/condconstsub.xml b/Ghidra/Features/Decompiler/src/decompile/datatests/condconstsub.xmlnew file mode 100644index 0000000000..c188de8196--- /dev/null+++ b/Ghidra/Features/Decompiler/src/decompile/datatests/condconstsub.xml@@ -0,0 +1,23 @@+<decompilertest>+<binaryimage arch="AARCH64:LE:64:v8A:default">+<!--+ Example of conditional constant operated on prior to branch+-->+<bytechunk space="ram" offset="0x110320" readonly="true">+400000b40b000014c0035fd6+</bytechunk>+</binaryimage>+<script>+ <com>map fun r0x110320 foo</com>+ <com>override flow r0x110324 callreturn</com>+ <com>map fun r0x110350 otherfunc</com>+ <com>parse line extern int4 foo(void *ptr);</com>+ <com>lo fu foo</com>+ <com>decompile</com>+ <com>print C</com>+</script>+<stringmatch name="Modified conditional constant #1" min="1" max="1">return 0;</stringmatch>+<stringmatch name="Modified conditional constant #2" min="1" max="1">iVar1 = otherfunc\(\);</stringmatch>+<stringmatch name="Modified conditional constant #3" min="1" max="1">return iVar1;</stringmatch>+<stringmatch name="Modified conditional constant #4" min="0" max="0">\(int4\)ptr</stringmatch>+</decompilertest>