Skip to content

Ghidra is a software reverse engineering (SRE) framework

GP-6492 Adjustments to union scoring

caheckmane12d821d861e
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/constseq.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/constseq.cc
index 27304436d4..046f60f9d9 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/constseq.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/constseq.cc
@@ -205,7 +205,13 @@ StringSequence::StringSequence(Funcdata &fdata,Datatype *ct,SymbolEntry *ent,Pco
break;
arrayType = parentType;
lastOff = off;
- parentType = parentType->getSubType(off, &off);
+ if (parentType->needsResolution()) {
+ const TypeField *field = parentType->resolveTruncation(off, root, -1, off); // Resolve thru the specific COPY
+ if (field == (const TypeField *)0) break;
+ parentType = field->type;
+ }
+ else
+ parentType = parentType->getSubType(off, &off);
} while(parentType != (Datatype *)0);
if (parentType != ct || arrayType == (Datatype *)0 || arrayType->getMetatype() != TYPE_ARRAY)
return;
@@ -296,8 +302,20 @@ Varnode *StringSequence::constructTypedPointer(PcodeOp *insertPoint)
if (baseType->getMetatype() == TYPE_ARRAY)
elSize = ((TypeArray *)baseType)->getBase()->getAlignSize();
int8 newOff;
- baseType = baseType->getSubType(curOff, &newOff );
- if (baseType == (Datatype *)0) break;
+ if (baseType->needsResolution()) {
+ const TypeField *field = baseType->resolveTruncation(curOff, insertPoint, -1, newOff);
+ if (field != (const TypeField *)0) {
+ baseType = field->type;
+ curOff = newOff;
+ continue; // Do not create PTRSUB for union resolution here
+ }
+ else
+ break;
+ }
+ else {
+ baseType = baseType->getSubType(curOff, &newOff );
+ if (baseType == (Datatype *)0) break;
+ }
curOff -= newOff;
baseOff = AddrSpace::byteToAddress(curOff, spc->getWordSize());
if (elSize >= 0) {
@@ -318,6 +336,8 @@ Varnode *StringSequence::constructTypedPointer(PcodeOp *insertPoint)
data.opSetInput(ptrsub,data.newConstant(spacePtr->getSize(), baseOff), 1);
}
data.opSetInput(ptrsub,spacePtr,0);
+ if (curType->needsResolution())
+ data.inheritUnionFieldPtr(curType, ptrsub, 0, insertPoint, -1);
spacePtr = data.newUniqueOut(spacePtr->getSize(), ptrsub);
data.opInsertBefore(ptrsub, insertPoint);
curType = types->getTypePointerStripArray(spacePtr->getSize(), baseType, spc->getWordSize());
@@ -364,6 +384,8 @@ PcodeOp *StringSequence::buildStringCopy(void)
Varnode *destPtr = constructTypedPointer(insertPoint);
data.opSetInput(copyOp, destPtr, 1);
data.opSetInput(copyOp, srcPtr, 2);
+ if (destPtr->getType()->needsResolution())
+ data.inheritUnionFieldPtr(destPtr->getType(), copyOp, 1, insertPoint, -1);
Varnode *lenVn = data.newConstant(4,index);
lenVn->updateType(copyOp->inputTypeLocal(3));
data.opSetInput(copyOp, lenVn, 3);
@@ -460,12 +482,12 @@ bool StringSequence::transform(void)
return true;
}
-/// From a starting pointer, backtrack through PTRADDs and COPYs to a putative root Varnode pointer.
-/// \param initPtr is pointer Varnode into the root STORE
-void HeapSequence::findBasePointer(Varnode *initPtr)
+/// From a starting pointer to \b rootOp, backtrack through PTRADDs and COPYs to a putative root Varnode pointer.
+void HeapSequence::findBasePointer(void)
{
- basePointer = initPtr;
+ basePointer = rootOp->getIn(1);
+ immedRead = rootOp;
while(basePointer->isWritten()) {
PcodeOp *op = basePointer->getDef();
OpCode opc = op->code();
@@ -476,6 +498,7 @@ void HeapSequence::findBasePointer(Varnode *initPtr)
else if (opc != CPUI_COPY)
break;
basePointer = op->getIn(0);
+ immedRead = op;
}
}
@@ -745,6 +768,8 @@ PcodeOp *HeapSequence::buildStringCopy(void)
data.opSetInput(ptrAdd,data.newConstant(basePointer->getSize(), charType->getAlignSize()),2);
destPtr->updateType(charPtrType);
data.opInsertBefore(ptrAdd, insertPoint);
+ if (basePointer->getType()->needsResolution())
+ data.inheritUnionField(basePointer->getType(), ptrAdd, 0, immedRead, immedRead->getSlot(basePointer));
}
int4 index;
uint4 builtInId = selectStringCopyFunction(index);
@@ -758,6 +783,8 @@ PcodeOp *HeapSequence::buildStringCopy(void)
lenVn->updateType(copyOp->inputTypeLocal(3));
data.opSetInput(copyOp, lenVn, 3);
data.opInsertBefore(copyOp, insertPoint);
+ if (destPtr->getType()->needsResolution())
+ data.inheritUnionField(destPtr->getType(), copyOp, 1, immedRead, immedRead->getSlot(destPtr));
return copyOp;
}
@@ -910,7 +937,7 @@ HeapSequence::HeapSequence(Funcdata &fdata,Datatype *ct,PcodeOp *root)
baseOffset = 0;
storeSpace = root->getIn(0)->getSpaceFromConst();
ptrAddMult = AddrSpace::byteToAddressInt(charType->getAlignSize(), storeSpace->getWordSize());
- findBasePointer(rootOp->getIn(1));
+ findBasePointer();
if (!collectStoreOps())
return;
if (!checkInterference())
@@ -956,7 +983,7 @@ int4 RuleStringCopy::applyOp(PcodeOp *op,Funcdata &data)
{
if (!op->getIn(0)->isConstant()) return 0; // Constant
Varnode *outvn = op->getOut();
- Datatype *ct = outvn->getType();
+ Datatype *ct = outvn->getTypeDefFacing();
if (!ct->isCharPrint()) return 0; // Copied to a "char" data-type Varnode
if (ct->isOpaqueString()) return 0;
if (!outvn->isAddrTied()) return 0;
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/constseq.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/constseq.hh
index 5df6bf1b90..153c4d6d57 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/constseq.hh
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/constseq.hh
@@ -95,11 +95,12 @@ class HeapSequence : public ArraySequence {
static bool compareOutput(const IndirectPair *a,const IndirectPair *b); ///< Compare pairs by output storage
};
Varnode *basePointer; ///< Pointer that sequence is stored to
+ PcodeOp *immedRead; ///< Op immediately reading basePointer
uint8 baseOffset; ///< Offset relative to pointer to root STORE
AddrSpace *storeSpace; ///< Address space being STOREed to
int4 ptrAddMult; ///< Required multiplier for PTRADD ops
vector<Varnode *> nonConstAdds; ///< non-constant Varnodes being added into pointer calculation
- void findBasePointer(Varnode *initPtr); ///< Find the base pointer for the sequence
+ void findBasePointer(void); ///< Find the base pointer for the sequence
void findDuplicateBases(vector<Varnode *> &duplist); ///< Find any duplicates of \b basePointer
void findInitialStores(vector<PcodeOp *> &stores);
static uint8 calcAddElements(Varnode *vn,vector<Varnode *> &nonConst,int4 maxDepth);
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.cc
index f1664ac3a3..560f74b0f1 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.cc
@@ -2454,23 +2454,54 @@ bool ActionSetCasts::testStructOffset0(Datatype *reqtype,Datatype *curtype,CastS
return (castStrategy->castStandard(reqtype, curtype, true, true) == (Datatype *)0);
}
-/// \brief Try to adjust the input and output Varnodes to eliminate a CAST
+/// \brief Try to eliminate a CAST for a data-type needing resolution by matching the data-type needed by the p-code op
+///
+/// Merging can cause the high data-type to become unresolved even though the underlying data-type requires a specific
+/// resolution. This forces the resolution onto the high, if possible, in the context of the specific read or write.
+/// \param dt is the data-type needed by the p-code op
+/// \param op is the p-code op
+/// \param slot is the index of the slot to test for resolution (-1 for output, >= 0 for input)
+/// \return \b true if the resolution was successfully changed and a CAST is not needed
+bool ActionSetCasts::tryResolutionAdjustment(Datatype *dt,PcodeOp *op,int4 slot,Funcdata &data)
+
+{
+ if (dt->needsResolution()) return false;
+ Varnode *vn = (slot < 0) ? op->getOut() : op->getIn(slot);
+ Datatype *curType = vn->getHigh()->getType();
+ if (!curType->needsResolution()) return false;
+ if (slot < 0 && curType->getMetatype() == TYPE_PTR) return false; // Cannot take field of pointer during assignment
+ int4 fieldNum = curType->findCompatibleResolve(dt);
+ if (fieldNum < 0) return false;
+ TypeFactory *typegrp = data.getArch()->types;
+ ResolvedUnion resolve(curType,fieldNum,*typegrp);
+ if (!data.setUnionField(curType, op, slot, resolve))
+ return false;
+ if (slot >=0 && curType->getMetatype() == TYPE_PTR) {
+ if (vn->isWritten() && (vn->getDef()->code() != CPUI_PTRSUB || vn->getDef()->getIn(0)->getType() != curType)) {
+ // For pointers, if not already inserted, insert a PTRSUB representing the field access
+ PcodeOp *ptrsub = insertPtrsubZero(op,slot,resolve.getDatatype(),data);
+ data.setUnionField(curType, ptrsub,-1,resolve); // Attach the resolution to the PTRSUB
+ }
+ }
+ return true;
+}
+
+/// \brief Try to adjust the input and output Varnodes to a COPY, in order to eliminate a CAST
///
/// If input/output data-types are different, it may be due to late merges. For
/// unions, the CAST can sometimes be eliminated by adjusting the data-type resolutions
/// of the Varnodes relative to the PcodeOp
-/// \param op is the PcodeOp reading the input Varnode and writing the output Varnode
-/// \param slot is the index of the input Varnode
+/// \param op is the COPY
/// \param data is the function
/// \return \b true if an adjustment is made so that a CAST is no longer needed
-bool ActionSetCasts::tryResolutionAdjustment(PcodeOp *op,int4 slot,Funcdata &data)
+bool ActionSetCasts::tryResolutionCopy(PcodeOp *op,Funcdata &data)
{
Varnode *outvn = op->getOut();
if (outvn == (Varnode *)0)
return false;
Datatype *outType = outvn->getHigh()->getType();
- Datatype *inType = op->getIn(slot)->getHigh()->getType();
+ Datatype *inType = op->getIn(0)->getHigh()->getType();
if (!inType->needsResolution() && !outType->needsResolution()) return false;
int4 inResolve = -1;
int4 outResolve = -1;
@@ -2478,7 +2509,7 @@ bool ActionSetCasts::tryResolutionAdjustment(PcodeOp *op,int4 slot,Funcdata &dat
inResolve = inType->findCompatibleResolve(outType);
if (inResolve < 0) return false;
}
- if (outType->needsResolution()) {
+ if (outType->needsResolution() && outType->getMetatype() != TYPE_PTR) {
if (inResolve >= 0)
outResolve = outType->findCompatibleResolve(inType->getDepend(inResolve));
else
@@ -2487,12 +2518,12 @@ bool ActionSetCasts::tryResolutionAdjustment(PcodeOp *op,int4 slot,Funcdata &dat
}
TypeFactory *typegrp = data.getArch()->types;
- if (inType->needsResolution()) {
+ if (inResolve >= 0) {
ResolvedUnion resolve(inType,inResolve,*typegrp);
- if (!data.setUnionField(inType, op, slot, resolve))
+ if (!data.setUnionField(inType, op, 0, resolve))
return false;
}
- if (outType->needsResolution()) {
+ if (outResolve >= 0) {
ResolvedUnion resolve(outType,outResolve,*typegrp);
if (!data.setUnionField(outType, op, -1, resolve))
return false;
@@ -2537,10 +2568,12 @@ int4 ActionSetCasts::resolveUnion(PcodeOp *op,int4 slot,Funcdata &data,CastStrat
Datatype *dt = vn->getHigh()->getType();
if (!dt->needsResolution())
return 0;
- if (dt != vn->getType())
+ const ResolvedUnion *resUnion = data.getUnionField(dt, op, slot);
+ if (resUnion == (ResolvedUnion *)0) {
dt->resolveInFlow(op, slot); // Last chance to resolve data-type based on flow
- const ResolvedUnion *resUnion = data.getUnionField(dt, op,slot);
- if (resUnion != (ResolvedUnion*)0 && resUnion->getFieldNum() >= 0) {
+ resUnion = data.getUnionField(dt, op, slot);
+ }
+ if (resUnion != (ResolvedUnion *)0 && resUnion->getFieldNum() >= 0) {
if (dt->getMetatype() == TYPE_PTR) {
// Test if a cast is still needed even after resolution
Datatype *reqtype = vn->getTypeReadFacing(op);
@@ -2577,12 +2610,11 @@ int4 ActionSetCasts::castOutput(PcodeOp *op,Funcdata &data,CastStrategy *castStr
Datatype *outct,*ct,*tokenct;
Varnode *vn,*outvn;
PcodeOp *newop;
- Datatype *outHighType;
bool force=false;
tokenct = op->getOpcode()->getOutputToken(op,castStrategy);
outvn = op->getOut();
- outHighType = outvn->getHigh()->getType();
+ Datatype *outHighType = outvn->getHigh()->getType();
if (tokenct == outHighType) {
if (tokenct->needsResolution()) {
// operation copies directly to outvn AS a union
@@ -2592,12 +2624,7 @@ int4 ActionSetCasts::castOutput(PcodeOp *op,Funcdata &data,CastStrategy *castStr
// Short circuit more sophisticated casting tests. If they are the same type, there is no cast
return 0;
}
- Datatype *outHighResolve = outHighType;
- if (outHighType->needsResolution()) {
- if (outHighType != outvn->getType())
- outHighType->resolveInFlow(op, -1); // Last chance to resolve data-type based on flow
- outHighResolve = outHighType->findResolve(op, -1); // Finish fetching DefFacing data-type
- }
+ Datatype *outHighResolve = outvn->getHighTypeDefFacing();
if (outvn->isImplied()) {
// implied varnode must have parse type
if (outvn->isTypeLock()) {
@@ -2632,6 +2659,8 @@ int4 ActionSetCasts::castOutput(PcodeOp *op,Funcdata &data,CastStrategy *castStr
ct = castStrategy->castStandard(outct,tokenct,false,true);
if (ct == (Datatype *)0) return 0;
}
+ if (tryResolutionAdjustment(tokenct, op, -1, data))
+ return 0;
}
// Generate the cast op
vn = data.newUnique(outvn->getSize());
@@ -2652,7 +2681,7 @@ int4 ActionSetCasts::castOutput(PcodeOp *op,Funcdata &data,CastStrategy *castStr
if (tokenct->needsResolution())
data.forceFacingType(tokenct, -1, newop, 0);
if (outHighType->needsResolution())
- data.inheritResolution(outHighType, newop, -1, op, -1); // Inherit write resolution
+ data.inheritUnionField(outHighType, newop, -1, op, -1); // Inherit write resolution
return 1;
}
@@ -2735,10 +2764,12 @@ int4 ActionSetCasts::castInput(PcodeOp *op,int4 slot,Funcdata &data,CastStrategy
// Insert a PTRSUB(vn,#0) instead of a CAST
newop = insertPtrsubZero(op, slot, ct, data);
if (vn->getHigh()->getType()->needsResolution())
- data.inheritResolution(vn->getHigh()->getType(),newop, 0, op, slot);
+ data.inheritUnionField(vn->getHigh()->getType(),newop, 0, op, slot);
return 1;
}
- else if (tryResolutionAdjustment(op, slot, data)) {
+ else if (op->code() != CPUI_COPY && tryResolutionAdjustment(ct, op, slot, data))
+ return 1;
+ else if (op->code() == CPUI_COPY && tryResolutionCopy(op, data)) {
return 1;
}
newop = data.newOp(1,op->getAddr());
@@ -2756,7 +2787,7 @@ int4 ActionSetCasts::castInput(PcodeOp *op,int4 slot,Funcdata &data,CastStrategy
data.forceFacingType(ct, -1, newop, -1);
}
if (vn->getHigh()->getType()->needsResolution()) {
- data.inheritResolution(vn->getHigh()->getType(),newop, 0, op, slot);
+ data.inheritUnionField(vn->getHigh()->getType(),newop, 0, op, slot);
}
return 1;
}
@@ -2796,9 +2827,18 @@ int4 ActionSetCasts::apply(Funcdata &data)
data.opSetOpcode(op, CPUI_INT_ADD);
}
}
- // Do input casts first, as output may depend on input
+ // Allow unresolved high data-types to resolve
for(int4 i=0;i<op->numInput();++i) {
count += resolveUnion(op, i, data, castStrategy);
+ }
+ Varnode *vn = op->getOut();
+ if (vn != (Varnode *)0) {
+ Datatype *outHighType = vn->getHigh()->getType();
+ if (outHighType->needsResolution())
+ outHighType->resolveInFlow(op, -1); // Last chance to resolve data-type based on flow
+ }
+ // Do input casts first, as output may depend on input
+ for(int4 i=0;i<op->numInput();++i) {
count += castInput(op,i,data,castStrategy);
}
if (opc == CPUI_LOAD) {
@@ -2807,9 +2847,8 @@ int4 ActionSetCasts::apply(Funcdata &data)
else if (opc == CPUI_STORE) {
checkPointerIssues(op, op->getIn(2), data);
}
- Varnode *vn = op->getOut();
- if (vn == (Varnode *)0) continue;
- count += castOutput(op,data,castStrategy);
+ if (vn != (Varnode *)0)
+ count += castOutput(op,data,castStrategy);
}
}
return 0; // Indicate full completion
@@ -5127,13 +5166,15 @@ bool ActionInferTypes::propagateTypeEdge(TypeFactory *typegrp,PcodeOp *op,int4 i
{
Varnode *invn,*outvn;
+ if (inslot == outslot) return false; // don't backtrack
invn = (inslot==-1) ? op->getOut() : op->getIn(inslot);
Datatype *alttype = invn->getTempType();
if (alttype->needsResolution()) {
// Always give incoming data-type a chance to resolve, even if it would not otherwise propagate
- alttype = alttype->resolveInFlow(op, inslot);
+ Datatype *resType = alttype->resolveInFlow(op, inslot);
+ if (!op->isMarker())
+ alttype = resType;
}
- if (inslot == outslot) return false; // don't backtrack
if (outslot < 0)
outvn = op->getOut();
else {
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.hh
index d974875d7d..a9390971bf 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.hh
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/coreaction.hh
@@ -320,7 +320,8 @@ public:
class ActionSetCasts : public Action {
static void checkPointerIssues(PcodeOp *op,Varnode *vn,Funcdata &data);
static bool testStructOffset0(Datatype *reqtype,Datatype *curtype,CastStrategy *castStrategy);
- static bool tryResolutionAdjustment(PcodeOp *op,int4 slot,Funcdata &data);
+ static bool tryResolutionAdjustment(Datatype *dt,PcodeOp *op,int4 slot,Funcdata &data);
+ static bool tryResolutionCopy(PcodeOp *op,Funcdata &data);
static bool isOpIdentical(Datatype *ct1,Datatype *ct2);
static int4 resolveUnion(PcodeOp *op,int4 slot,Funcdata &data,CastStrategy *castStrategy);
static int4 castOutput(PcodeOp *op,Funcdata &data,CastStrategy *castStrategy);
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/database.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/database.cc
index c6529baea5..211e7daf6f 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/database.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/database.cc
@@ -688,11 +688,13 @@ void EquateSymbol::decode(Decoder &decoder)
/// \param nm is the name of the symbol
/// \param unionDt is the union data-type being forced
/// \param fldNum is the particular field to force (-1 indicates the whole union)
-UnionFacetSymbol::UnionFacetSymbol(Scope *sc,const string &nm,Datatype *unionDt,int4 fldNum)
+/// \param isAddr is \b true for facets that apply to all ops at the address
+UnionFacetSymbol::UnionFacetSymbol(Scope *sc,const string &nm,Datatype *unionDt,int4 fldNum,bool isAddr)
: Symbol(sc, nm, unionDt)
{
fieldNum = fldNum;
category = union_facet;
+ addrBased = isAddr;
}
void UnionFacetSymbol::encode(Encoder &encoder) const
@@ -701,6 +703,7 @@ void UnionFacetSymbol::encode(Encoder &encoder) const
encoder.openElement(ELEM_FACETSYMBOL);
encodeHeader(encoder);
encoder.writeSignedInteger(ATTRIB_FIELD, fieldNum);
+ encoder.writeBool(ATTRIB_ADDRTIED, true);
encodeBody(encoder);
encoder.closeElement(ELEM_FACETSYMBOL);
}
@@ -711,6 +714,7 @@ void UnionFacetSymbol::decode(Decoder &decoder)
uint4 elemId = decoder.openElement(ELEM_FACETSYMBOL);
decodeHeader(decoder);
fieldNum = decoder.readSignedInteger(ATTRIB_FIELD);
+ addrBased = decoder.readBool(ATTRIB_ADDRTIED);
decodeBody(decoder);
decoder.closeElement(elemId);
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/database.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/database.hh
index ab13b02522..dd24c7a331 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/database.hh
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/database.hh
@@ -318,10 +318,12 @@ public:
/// different symbols attached. The Symbol's associated data-type will be the desired \e union to force.
class UnionFacetSymbol : public Symbol {
int4 fieldNum; ///< Particular field to associate with Symbol access
+ bool addrBased; ///< Set to \b true if facet matches any PcodeOp at the address
public:
- UnionFacetSymbol(Scope *sc,const string &nm,Datatype *unionDt,int4 fldNum); ///< Constructor from components
- UnionFacetSymbol(Scope *sc) : Symbol(sc) { fieldNum = -1; category = union_facet; } ///< Constructor for decode
+ UnionFacetSymbol(Scope *sc,const string &nm,Datatype *unionDt,int4 fldNum,bool isAddr=false); ///< Constructor from components
+ UnionFacetSymbol(Scope *sc) : Symbol(sc) { fieldNum = -1; category = union_facet; addrBased = false; } ///< Constructor for decode
int4 getFieldNumber(void) const { return fieldNum; } ///< Get the particular field associate with \b this
+ bool isAddrBased(void) const { return addrBased; } ///< Return \b true if facet matches any PcodeOp at the address
virtual void encode(Encoder &encoder) const;
virtual void decode(Decoder &decoder);
};
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/float.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/float.cc
index 81df78ca91..d4632819f4 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/float.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/float.cc
@@ -222,6 +222,25 @@ void FloatFormat::calcPrecision(void)
decimalMaxPrecision = (int4)ceil((frac_size + 1) * 0.30103) + 1;
}
+/// \param encoding is the encoded floating-point value
+/// \return either \e zero, \e infinity, \e denormalized, \e nan, or \e normalized
+FloatFormat::floatclass FloatFormat::getClass(uintb encoding) const
+
+{
+ int4 exp = extractExponentCode(encoding);
+ if (exp == 0) {
+ if ( extractFractionalCode(encoding) == 0 )
+ return zero;
+ return denormalized;
+ }
+ if (exp == maxexponent) {
+ if ( extractFractionalCode(encoding) == 0 )
+ return infinity;
+ return nan;
+ }
+ return normalized;
+}
+
/// \param encoding is the encoding value
/// \param type points to the floating-point class, which is passed back
/// \return the equivalent double value
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/float.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/float.hh
index 06429dc7fa..44d5255634 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/float.hh
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/float.hh
@@ -64,6 +64,7 @@ private:
public:
FloatFormat(int4 sz); ///< Construct default IEEE 754 standard settings
int4 getSize(void) const { return size; } ///< Get the size of the encoding in bytes
+ floatclass getClass(uintb encoding) const; ///< Get the class of an encoding
double getHostFloat(uintb encoding,floatclass *type) const; ///< Convert an encoding into host's double
uintb getEncoding(double host) const; ///< Convert host's double into \b this encoding
uintb convertEncoding(uintb encoding,const FloatFormat *formin) const; ///< Convert between two different formats
@@ -71,6 +72,7 @@ public:
uintb extractFractionalCode(uintb x) const; ///< Extract the fractional part of the encoding
bool extractSign(uintb x) const; ///< Extract the sign bit from the encoding
int4 extractExponentCode(uintb x) const; ///< Extract the exponent from the encoding
+ int4 getExponent(uintb x) const { return extractExponentCode(x) - bias; } ///< Get the exponent of an encoding
string printDecimal(double host,bool forcesci) const; ///< Print given value as a decimal string
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata.cc
index f004922e9c..6ec19de290 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata.cc
@@ -907,44 +907,87 @@ void PcodeEmitFd::dump(const Address &addr,OpCode opc,VarnodeData *outvar,Varnod
}
}
-/// \brief Get the resolved union field associated with the given edge
+/// \brief Get the resolution (union field) associated with an unresolved data-type and the given edge
///
-/// If there is no field associated with the edge, null is returned
-/// \param parent is the data-type being resolved
+/// If there is no field associated with the edge, or the resolved data-type is not
+/// the same size as the given data-type, null is returned.
+/// \param unresType is the given data-type being resolved
/// \param op is the PcodeOp component of the given edge
/// \param slot is the slot component of the given edge
/// \return the associated field as a ResolvedUnion or null
-const ResolvedUnion *Funcdata::getUnionField(const Datatype *parent,const PcodeOp *op,int4 slot) const
+const ResolvedUnion *Funcdata::getUnionField(const Datatype *unresType,const PcodeOp *op,int4 slot) const
{
map<ResolveEdge,ResolvedUnion>::const_iterator iter;
- ResolveEdge edge(parent,op,slot);
+ ResolveEdge edge(unresType,op,slot);
+ iter = unionMap.find(edge);
+ if (iter != unionMap.end()) {
+ const ResolvedUnion *res = &(*iter).second;
+ Datatype *dt = res->getDatatype();
+ // Check that the Varnode size matches the data-type
+ if (unresType->getSize() == dt->getSize())
+ return res;
+ }
+ return (const ResolvedUnion *)0;
+}
+
+/// \brief Get the resolution (union field) associated with an unresolved data-type and the given edge
+///
+/// The size of the resolved data-type does not have to match the given data-type.
+/// If there is no field associated with the edge, null is returned.
+/// \param unresType is the unresolved data-type
+/// \param op is the PcodeOp component of the given edge
+/// \param slot is the slot component of the given edge
+/// \return the associated field as a ResolvedUnion or null
+const ResolvedUnion *Funcdata::getUnionResolution(const Datatype *unresType,const PcodeOp *op,int4 slot) const
+
+{
+ map<ResolveEdge,ResolvedUnion>::const_iterator iter;
+ ResolveEdge edge(unresType,op,slot);
+ iter = unionMap.find(edge);
+ if (iter != unionMap.end()) {
+ const ResolvedUnion *res = &(*iter).second;
+ return res;
+ }
+ return (const ResolvedUnion *)0;
+}
+
+/// \brief Get any resolution (union field) associated with an unresolved data-type and the given address
+///
+/// If there is no associated field, null is returned
+/// \param unresType is the unresolved data-type
+/// \param addr is the given address
+/// \param slot is the slot component the resolution matches
+/// \return the associated field as a ResolvedUnion or null
+const ResolvedUnion *Funcdata::getAddressBasedUnionField(const Datatype *unresType,const Address &addr,int4 slot) const
+
+{
+ map<ResolveEdge,ResolvedUnion>::const_iterator iter;
+ ResolveEdge edge(unresType,addr,slot);
iter = unionMap.find(edge);
if (iter != unionMap.end())
return &(*iter).second;
return (const ResolvedUnion *)0;
}
-/// \brief Associate a union field with the given edge
+/// \brief Associate a resolution (union field) with an unresolved data-type and the given edge
///
/// If there was a previous association, it is overwritten unless it was \e locked.
/// The method returns \b true except in this case where a previous locked association exists.
-/// \param parent is the parent union data-type
+/// \param unresType is the unresolved data-type
/// \param op is the PcodeOp component of the given edge
/// \param slot is the slot component of the given edge
/// \param resolve is the resolved union
-/// \return \b true unless there was a locked association
-bool Funcdata::setUnionField(const Datatype *parent,const PcodeOp *op,int4 slot,const ResolvedUnion &resolve)
+/// \return \b true unless the resolution was locked
+bool Funcdata::setUnionField(const Datatype *unresType,const PcodeOp *op,int4 slot,const ResolvedUnion &resolve)
{
- ResolveEdge edge(parent,op,slot);
+ ResolveEdge edge(unresType,op,slot);
pair<map<ResolveEdge,ResolvedUnion>::iterator,bool> res;
res = unionMap.emplace(edge,resolve);
if (!res.second) {
- if ((*res.first).second.isLocked()) {
- return false;
- }
- (*res.first).second = resolve;
+ if (!(*res.first).second.update(resolve))
+ return !(*res.first).second.isLocked();
}
if (op->code() == CPUI_MULTIEQUAL && slot >= 0) {
// Data-type propagation doesn't happen between MULTIEQUAL input slots holding the same Varnode
@@ -953,54 +996,124 @@ bool Funcdata::setUnionField(const Datatype *parent,const PcodeOp *op,int4 slot,
for(int4 i=0;i<op->numInput();++i) {
if (i == slot) continue;
if (op->getIn(i) != vn) continue; // Check that different input slot holds same Varnode
- ResolveEdge dupedge(parent,op,i);
+ ResolveEdge dupedge(unresType,op,i);
res = unionMap.emplace(dupedge,resolve);
if (!res.second) {
- if (!(*res.first).second.isLocked())
- (*res.first).second = resolve;
+ (*res.first).second.update(resolve);
}
}
}
return true;
}
-/// \brief Force a specific union field resolution for the given edge
+/// \brief Associate a resolution (union field) with an unresolved data-type and the given address
///
-/// The \b parent data-type is taken directly from the given Varnode.
-/// \param parent is the parent data-type
+/// If there was a previous association, it is overwritten unless it was \e locked.
+/// The method returns \b true except in this case where a previous locked association exists.
+/// \param unresType is the unresolved data-type
+/// \param addr is the given address
+/// \param slot is the slot component the resolution matches
+/// \param resolve is the resolved union
+/// \return \b true unless there was a locked association
+bool Funcdata::setAddressBasedUnionField(const Datatype *unresType,const Address &addr,int4 slot,const ResolvedUnion &resolve)
+
+{
+ ResolveEdge edge(unresType,addr,slot);
+ pair<map<ResolveEdge,ResolvedUnion>::iterator,bool> res;
+ res = unionMap.emplace(edge,resolve);
+ if (!res.second) {
+ if ((*res.first).second.isLocked()) {
+ return false;
+ }
+ (*res.first).second = resolve;
+ }
+ return true;
+}
+
+/// \brief Update the resolution data-type associated with an unresolved data-type for a given edge
+///
+/// If further resolution of the cached data-type has happened, update the cache with the new data-type.
+/// \param unresType is the unresolved data-type
+/// \param op is the PcodeOp component of the given edge
+/// \param slot is the slot component of the given edge
+/// \param resType is the new resolution data-type
+/// \return \b true unless there was a locked association
+bool Funcdata::updateUnionField(const Datatype *unresType,const PcodeOp *op,int4 slot,Datatype *resType)
+
+{
+ map<ResolveEdge,ResolvedUnion>::iterator iter;
+ ResolveEdge edge(unresType,op,slot);
+ iter = unionMap.find(edge);
+ if (iter != unionMap.end()) {
+ (*iter).second.setResolve(resType);
+ return true;
+ }
+ return false;
+}
+
+/// \brief Force a specific resolution (union field) resolution for an unresolved data-type and the given edge
+///
+/// \param unresType is the unresolved data-type
/// \param fieldNum is the index of the field to force
/// \param op is PcodeOp of the edge
/// \param slot is -1 for the write edge or >=0 indicating the particular read edge
-void Funcdata::forceFacingType(Datatype *parent,int4 fieldNum,PcodeOp *op,int4 slot)
+void Funcdata::forceFacingType(Datatype *unresType,int4 fieldNum,PcodeOp *op,int4 slot)
{
- Datatype *baseType = parent;
+ Datatype *baseType = unresType;
if (baseType->getMetatype() == TYPE_PTR)
baseType = ((TypePointer *)baseType)->getPtrTo();
- if (parent->isPointerRel()) {
+ if (unresType->isPointerRel()) {
// Don't associate a relative pointer with the resolution, but convert to a standard pointer
- parent = glb->types->getTypePointer(parent->getSize(), baseType, ((TypePointer *)parent)->getWordSize());
+ unresType = glb->types->getTypePointer(unresType->getSize(), baseType, ((TypePointer *)unresType)->getWordSize());
}
- ResolvedUnion resolve(parent,fieldNum,*glb->types);
- setUnionField(parent, op, slot, resolve);
+ ResolvedUnion resolve(unresType,fieldNum,*glb->types);
+ setUnionField(unresType, op, slot, resolve);
+}
+
+/// \brief Copy a read/write facing resolution for an unresolved data-type from one PcodeOp to another
+///
+/// \param unresType is the unresolved data-type
+/// \param op is the new reading PcodeOp
+/// \param slot is the new slot (-1 for write, >=0 for read)
+/// \param oldOp is the PcodeOp to inherit the resolution from
+/// \param oldSlot is the old slot (-1 for write, >=0 for read)
+/// \return the field number that was inherited
+int4 Funcdata::inheritUnionField(Datatype *unresType,const PcodeOp *op,int4 slot,PcodeOp *oldOp,int4 oldSlot)
+
+{
+ map<ResolveEdge,ResolvedUnion>::const_iterator iter;
+ if (slot < 0 && oldOp->isMarker())
+ slot = 0;
+ ResolveEdge edge(unresType,oldOp,oldSlot);
+ iter = unionMap.find(edge);
+ if (iter == unionMap.end())
+ return -1;
+ setUnionField(unresType,op,slot,(*iter).second);
+ return (*iter).second.getFieldNum();
}
-/// \brief Copy a read/write facing resolution for a specific data-type from one PcodeOp to another
+/// \brief Create a resolution for an unresolved pointer data-type based on earlier non-pointer resolution
///
-/// \param parent is the data-type that needs resolution
+/// \param unresPtr is the unresolved pointer data-type
/// \param op is the new reading PcodeOp
/// \param slot is the new slot (-1 for write, >=0 for read)
/// \param oldOp is the PcodeOp to inherit the resolution from
/// \param oldSlot is the old slot (-1 for write, >=0 for read)
-int4 Funcdata::inheritResolution(Datatype *parent,const PcodeOp *op,int4 slot,PcodeOp *oldOp,int4 oldSlot)
+/// \return the field number that was inherited
+int4 Funcdata::inheritUnionFieldPtr(Datatype *unresPtr,const PcodeOp *op,int4 slot,PcodeOp *oldOp,int4 oldSlot)
{
+ Datatype *parent = unresPtr->getDepend(0);
+ if (slot < 0 && oldOp->isMarker())
+ slot = 0;
map<ResolveEdge,ResolvedUnion>::const_iterator iter;
ResolveEdge edge(parent,oldOp,oldSlot);
iter = unionMap.find(edge);
if (iter == unionMap.end())
return -1;
- setUnionField(parent,op,slot,(*iter).second);
+ ResolvedUnion ptrres(unresPtr,(*iter).second.getFieldNum(),*glb->types);
+ setUnionField(unresPtr,op,slot,ptrres);
return (*iter).second.getFieldNum();
}
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata.hh
index db85597a12..90bcd18b06 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata.hh
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata.hh
@@ -529,11 +529,15 @@ public:
bool moveRespectingCover(PcodeOp *op,PcodeOp *lastOp); ///< Move given op past \e lastOp respecting covers if possible
- const ResolvedUnion *getUnionField(const Datatype *parent,const PcodeOp *op,int4 slot) const;
- bool setUnionField(const Datatype *parent,const PcodeOp *op,int4 slot,const ResolvedUnion &resolve);
- void forceFacingType(Datatype *parent,int4 fieldNum,PcodeOp *op,int4 slot);
- int4 inheritResolution(Datatype *parent,const PcodeOp *op,int4 slot,PcodeOp *oldOp,int4 oldSlot);
-
+ const ResolvedUnion *getUnionField(const Datatype *unresType,const PcodeOp *op,int4 slot) const;
+ const ResolvedUnion *getAddressBasedUnionField(const Datatype *unresType,const Address &addr,int4 slot) const;
+ const ResolvedUnion *getUnionResolution(const Datatype *unresType,const PcodeOp *op,int4 slot) const;
+ bool setUnionField(const Datatype *unresType,const PcodeOp *op,int4 slot,const ResolvedUnion &resolve);
+ bool setAddressBasedUnionField(const Datatype *unresType,const Address &addr,int4 slot,const ResolvedUnion &resolve);
+ bool updateUnionField(const Datatype *unresType,const PcodeOp *op,int4 slot,Datatype *resType);
+ void forceFacingType(Datatype *unresType,int4 fieldNum,PcodeOp *op,int4 slot);
+ int4 inheritUnionField(Datatype *unresType,const PcodeOp *op,int4 slot,PcodeOp *oldOp,int4 oldSlot);
+ int4 inheritUnionFieldPtr(Datatype *unresPtr,const PcodeOp *op,int4 slot,PcodeOp *oldOp,int4 oldSlot);
// Jumptable routines
JumpTable *linkJumpTable(PcodeOp *op); ///< Link jump-table with a given BRANCHIND
JumpTable *findJumpTable(const PcodeOp *op) const; ///< Find a jump-table associated with a given BRANCHIND
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata_varnode.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata_varnode.cc
index 2232a823d5..bd0b58d7db 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata_varnode.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/funcdata_varnode.cc
@@ -1656,15 +1656,40 @@ void Funcdata::coverVarnodes(SymbolEntry *entry,vector<Varnode *> &list)
bool Funcdata::applyUnionFacet(SymbolEntry *entry,DynamicHash &dhash)
{
- Symbol *sym = entry->getSymbol();
+ UnionFacetSymbol *sym = (UnionFacetSymbol *)entry->getSymbol();
+ if (sym->isAddrBased()) {
+ ResolvedUnion resolve(sym->getType(), sym->getFieldNumber(), *glb->types);
+ resolve.setLock(true);
+ int4 slot = DynamicHash::getSlotFromHash(entry->getHash());
+ return setAddressBasedUnionField(sym->getType(), entry->getFirstUseAddress(), slot, resolve);
+ }
PcodeOp *op = dhash.findOp(this, entry->getFirstUseAddress(), entry->getHash());
if (op == (PcodeOp *)0)
return false;
int4 slot = DynamicHash::getSlotFromHash(entry->getHash());
- int4 fldNum = ((UnionFacetSymbol *)sym)->getFieldNumber();
- ResolvedUnion resolve(sym->getType(), fldNum, *glb->types);
+ const ResolvedUnion *res = getUnionResolution(sym->getType(), op, slot);
+ if (res != (const ResolvedUnion *)0 && res->getFieldNum() == sym->getFieldNumber())
+ return false;
+ Varnode *vn = (slot < 0) ? op->getOut() : op->getIn(slot);
+ Datatype *unresType = sym->getType();
+ Datatype *dt = vn->getType();
+ if (dt->getMetatype() == TYPE_PTR) {
+ if (((TypePointer *)dt)->getPtrTo() == unresType) {
+ unresType = dt;
+ }
+ }
+ else if (dt->getMetatype() == TYPE_PARTIALSTRUCT) {
+ if (((TypePartialStruct *)dt)->getParent() == unresType)
+ unresType = dt;
+ }
+ else if (dt->getMetatype() == TYPE_PARTIALUNION) {
+ if (((TypePartialUnion *)dt)->getParentUnion() == unresType)
+ unresType = dt;
+ }
+ ResolvedUnion resolve(unresType,sym->getFieldNumber(), *glb->types);
resolve.setLock(true);
- return setUnionField(sym->getType(),op,slot,resolve);
+ setUnionField(unresType,op,slot,resolve);
+ return true;
}
/// Search for \e addrtied Varnodes whose storage falls in the global Scope, then
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/merge.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/merge.cc
index c416820055..c9023e8efb 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/merge.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/merge.cc
@@ -416,7 +416,7 @@ PcodeOp *Merge::allocateCopyTrim(Varnode *inVn,const Address &addr,PcodeOp *trim
Datatype *ct = inVn->getType();
if (ct->needsResolution()) { // If the data-type needs resolution
if (inVn->isWritten()) {
- int4 fieldNum = data.inheritResolution(ct, copyOp, -1, inVn->getDef(), -1);
+ int4 fieldNum = data.inheritUnionField(ct, copyOp, -1, inVn->getDef(), -1);
data.forceFacingType(ct, fieldNum, copyOp, 0);
}
else {
@@ -669,7 +669,7 @@ void Merge::trimOpOutput(PcodeOp *op)
copyop = data.newOp(1,op->getAddr());
data.opSetOpcode(copyop,CPUI_COPY);
if (ct->needsResolution()) {
- int4 fieldNum = data.inheritResolution(ct, copyop, -1, op, -1);
+ int4 fieldNum = data.inheritUnionField(ct, copyop, -1, op, -1);
data.forceFacingType(ct, fieldNum, copyop, 0);
if (ct->getMetatype() == TYPE_PARTIALUNION)
ct = vn->getTypeDefFacing();
@@ -871,7 +871,7 @@ void Merge::mergeIndirect(PcodeOp *indop)
PcodeOp *newop = allocateCopyTrim(invn0, indop->getAddr(), indop);
SymbolEntry *entry = outvn->getSymbolEntry();
if (entry != (SymbolEntry *)0 && entry->getSymbol()->getType()->needsResolution()) {
- data.inheritResolution(entry->getSymbol()->getType(), newop, -1, indop, -1);
+ data.inheritUnionField(entry->getSymbol()->getType(), newop, -1, indop, -1);
}
data.opSetInput(indop,newop->getOut(),0);
data.opInsertBefore(newop,indop);
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/ruleaction.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/ruleaction.cc
index 9b92b3e2fe..c516890c10 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/ruleaction.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/ruleaction.cc
@@ -6517,8 +6517,12 @@ void AddTreeState::buildTree(void)
// Create PTRADD portion of operation
if (multNode != (Varnode *)0) {
newop = data.newOpBefore(baseOp,CPUI_PTRADD,ptr,multNode,data.newConstant(ptrsize,size));
- if (ptr->getType()->needsResolution())
- data.inheritResolution(ptr->getType(),newop, 0, baseOp, baseSlot);
+ if (ptr->getType()->needsResolution()) {
+ if (((TypePointer *)ptr->getType())->getPtrTo()->getSize() == baseType->getSize())
+ data.forceFacingType(ptr->getType(),-1,newop, 0); // Force type not to resolve before the index is applied
+ else
+ data.inheritUnionField(ptr->getType(), newop, 0, baseOp, baseSlot);
+ }
if (data.isTypeRecoveryExceeded())
assignPropagatedType(newop);
multNode = newop->getOut();
@@ -6530,7 +6534,7 @@ void AddTreeState::buildTree(void)
if (isSubtype) {
newop = data.newOpBefore(baseOp,CPUI_PTRSUB,multNode,data.newConstant(ptrsize,offset));
if (multNode->getType()->needsResolution())
- data.inheritResolution(multNode->getType(),newop, 0, baseOp, baseSlot);
+ data.inheritUnionField(multNode->getType(),newop, 0, baseOp, baseSlot);
if (data.isTypeRecoveryExceeded())
assignPropagatedType(newop);
if (size != 0)
@@ -6731,7 +6735,7 @@ int4 RuleStructOffset0::applyOp(PcodeOp *op,Funcdata &data)
// Create pointer up to parent
PcodeOp *newop = data.newOpBefore(op,CPUI_PTRSUB,ptrVn,data.newConstant(ptrVn->getSize(),offset));
if (ptrVn->getType()->needsResolution())
- data.inheritResolution(ptrVn->getType(),newop, 0, op, 1);
+ data.inheritUnionField(ptrVn->getType(),newop, 0, op, 1);
newop->setStopTypePropagation();
if (newoff != 0) {
// Add newoff in to get back to zero total offset
@@ -6769,7 +6773,7 @@ int4 RuleStructOffset0::applyOp(PcodeOp *op,Funcdata &data)
PcodeOp *newop = data.newOpBefore(op,CPUI_PTRSUB,ptrVn,data.newConstant(ptrVn->getSize(),0));
if (ptrVn->getType()->needsResolution())
- data.inheritResolution(ptrVn->getType(),newop, 0, op, 1);
+ data.inheritUnionField(ptrVn->getType(),newop, 0, op, 1);
newop->setStopTypePropagation();
data.opSetInput(op,newop->getOut(),1);
return 1;
@@ -7100,10 +7104,11 @@ int8 RulePtrsubUndo::removeLocalAdds(Varnode *vn,Funcdata &data)
{
int8 extra = 0;
PcodeOp *op = vn->loneDescend();
+ Varnode *nextVn = vn;
while(op != (PcodeOp *)0) {
OpCode opc = op->code();
if (opc == CPUI_INT_ADD) {
- int4 slot = op->getSlot(vn);
+ int4 slot = op->getSlot(nextVn);
if (slot == 0 && op->getIn(1)->isConstant()) {
extra += (int8)op->getIn(1)->getOffset();
data.opRemoveInput(op, 1);
@@ -7120,7 +7125,7 @@ int8 RulePtrsubUndo::removeLocalAdds(Varnode *vn,Funcdata &data)
data.opSetOpcode(op, CPUI_COPY);
}
else if (opc == CPUI_PTRADD) {
- if (op->getIn(0) != vn) break;
+ if (op->getIn(0) != nextVn) break;
// The PTRADD should be converted to an INT_ADD or COPY
// as it is associated with the invalid PTRSUB
int8 ptraddmult = op->getIn(2)->getOffset();
@@ -7139,9 +7144,11 @@ int8 RulePtrsubUndo::removeLocalAdds(Varnode *vn,Funcdata &data)
else {
break;
}
- vn = op->getOut();
- op = vn->loneDescend();
+ nextVn = op->getOut();
+ op = nextVn->loneDescend();
}
+ if (nextVn != vn)
+ vn->updateType(nextVn->getType());
return extra;
}
@@ -7561,7 +7568,7 @@ bool RulePieceStructure::convertZextToPiece(PcodeOp *zext,Datatype *ct,int4 offs
data.opSetOpcode(zext, CPUI_PIECE);
data.opInsertInput(zext, zerovn, 0);
if (invn->getType()->needsResolution())
- data.inheritResolution(invn->getType(), zext, 1, zext, 0); // Transfer invn's resolution to slot 1
+ data.inheritUnionField(invn->getType(), zext, 1, zext, 0); // Transfer invn's resolution to slot 1
return true;
}
@@ -7692,7 +7699,7 @@ int4 RulePieceStructure::applyOp(PcodeOp *op,Funcdata &data)
data.opInsertBefore(copyOp, node.getOp());
if (vn->getType()->needsResolution()) {
// Inherit PIECE's read resolution for COPY's read
- data.inheritResolution(vn->getType(), copyOp, 0, node.getOp(), node.getSlot());
+ data.inheritUnionField(vn->getType(), copyOp, 0, node.getOp(), node.getSlot());
}
if (newType->needsResolution()) {
newType->resolveInFlow(copyOp, -1); // If the piece represents part of a union, resolve it
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/subflow.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/subflow.cc
index b191cdbd6b..d1e17ee800 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/subflow.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/subflow.cc
@@ -2141,7 +2141,7 @@ bool SplitDatatype::RootPointer::backUpPointer(Datatype *impliedBase)
/// \param op is the LOAD or STORE
/// \param valueType is the specific data-type to match
/// \return \b true if the root pointer is found
-bool SplitDatatype::RootPointer::find(PcodeOp *op,Datatype *valueType)
+bool SplitDatatype::RootPointer::find(PcodeOp *op,Datatype *valueType,ResolveCache &resolver)
{
Datatype *impliedBase = (Datatype *)0;
@@ -2151,12 +2151,14 @@ bool SplitDatatype::RootPointer::find(PcodeOp *op,Datatype *valueType)
valueType = ((TypeArray *)valueType)->getBase();
impliedBase = valueType; // we allow an implied array (pointer to element) as a match
}
+ int4 key = (op->code() == CPUI_LOAD) ? 0 : 1;
loadStore = op;
baseOffset = 0;
firstPointer = pointer = op->getIn(1);
Datatype *ct = pointer->getTypeReadFacing(op);
if (ct->getMetatype() != TYPE_PTR)
return false;
+ resolver.addResolution(key, pointer->getType(), op, 1);
ptrType = (TypePointer *)ct;
if (ptrType->getPtrTo() != valueType) {
if (impliedBase != (Datatype *)0)
@@ -2169,8 +2171,10 @@ bool SplitDatatype::RootPointer::find(PcodeOp *op,Datatype *valueType)
// The required pointer is found. We try to back up to pointers to containing structures or arrays
for(int4 i=0;i<3;++i) {
if (pointer->isAddrTied() || pointer->loneDescend() == (PcodeOp *)0) break;
+ Varnode *lastVn = pointer;
if (!backUpPointer(impliedBase))
break;
+ resolver.addResolution(key, pointer->getType(), lastVn->getDef(), 0);
}
return true;
}
@@ -2639,9 +2643,15 @@ void SplitDatatype::buildPointers(Varnode *rootVn,TypePointer *ptrType,int4 base
newOff = 0;
}
}
- if (tmpType == newType || tmpType->getMetatype() == TYPE_ARRAY) {
+ Datatype *resType;
+ if (newType->needsResolution())
+ resType = resolver.resolve(isInput ? 0 : 1, newType);
+ else
+ resType = newType;
+
+ if (tmpType == resType || tmpType->getMetatype() == TYPE_ARRAY) {
int8 finalOffset = curOff - newOff;
- int4 sz = newType->getSize(); // Element size in bytes
+ int4 sz = resType->getSize(); // Element size in bytes
finalOffset = finalOffset / sz; // Number of elements
sz = AddrSpace::byteToAddressInt(sz, ptrType->getWordSize());
newOp = data.newOp(3,followOp->getAddr());
@@ -2660,11 +2670,12 @@ void SplitDatatype::buildPointers(Varnode *rootVn,TypePointer *ptrType,int4 base
data.opSetInput(newOp, inPtr, 0);
data.opSetInput(newOp, data.newConstant(inPtr->getSize(), finalOffset), 1);
}
+ resolver.inheritResolution(isInput ? 0 : 1, inPtr, newOp, 0);
inPtr = data.newUniqueOut(inPtr->getSize(), newOp);
Datatype *tmpPtr = types->getTypePointerStripArray(ptrType->getSize(), newType, ptrType->getWordSize());
inPtr->updateType(tmpPtr);
data.opInsertBefore(newOp, followOp);
- tmpType = newType;
+ tmpType = resType;
curOff = newOff;
} while(tmpType->getSize() > matchType->getSize());
ptrVarnodes.push_back(inPtr);
@@ -2699,7 +2710,7 @@ bool SplitDatatype::isArithmeticOutput(Varnode *vn)
}
SplitDatatype::SplitDatatype(Funcdata &func)
- : data(func)
+ : data(func), resolver(func)
{
Architecture *glb = func.getArch();
types = glb->types;
@@ -2729,6 +2740,8 @@ bool SplitDatatype::splitCopy(PcodeOp *copyOp,Datatype *inType,Datatype *outType
return false;
vector<Varnode *> inVarnodes;
vector<Varnode *> outVarnodes;
+ Datatype *unresOutType = outVn->getType();
+ resolver.addResolution(0,unresOutType, copyOp, -1);
if (inVn->isConstant())
buildInConstants(inVn,inVarnodes,outVn->getSpace()->isBigEndian());
else
@@ -2741,6 +2754,7 @@ bool SplitDatatype::splitCopy(PcodeOp *copyOp,Datatype *inType,Datatype *outType
data.opSetInput(newCopyOp,inVarnodes[i],0);
data.opSetOutput(newCopyOp,outVarnodes[i]);
data.opInsertBefore(newCopyOp, copyOp);
+ resolver.inheritResolution(0,unresOutType, dataTypePieces[i].offset, outVarnodes[i], newCopyOp, -1);
}
data.opDestroy(copyOp);
return true;
@@ -2776,7 +2790,7 @@ bool SplitDatatype::splitLoad(PcodeOp *loadOp,Datatype *inType)
if (isArithmeticInput(outVn)) // Sanity check on output
return false;
RootPointer root;
- if (!root.find(loadOp,inType))
+ if (!root.find(loadOp,inType,resolver))
return false;
vector<Varnode *> ptrVarnodes;
vector<Varnode *> outVarnodes;
@@ -2839,12 +2853,12 @@ bool SplitDatatype::splitStore(PcodeOp *storeOp,Datatype *outType)
return false;
RootPointer storeRoot;
- if (!storeRoot.find(storeOp,outType))
+ if (!storeRoot.find(storeOp,outType,resolver))
return false;
RootPointer loadRoot;
if (loadOp != (PcodeOp *)0) {
- if (!loadRoot.find(loadOp,inType))
+ if (!loadRoot.find(loadOp,inType,resolver))
return false;
}
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/subflow.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/subflow.hh
index 6843eb77d8..1c87c941ed 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/subflow.hh
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/subflow.hh
@@ -20,6 +20,7 @@
#include "ruleaction.hh"
#include "transform.hh"
+#include "unionresolve.hh"
namespace ghidra {
@@ -277,13 +278,14 @@ class SplitDatatype {
int4 baseOffset; ///< Offset of the LOAD or STORE relative to root pointer
bool backUpPointer(Datatype *impliedBase); ///< Follow flow of \b pointer back thru INT_ADD or PTRSUB
public:
- bool find(PcodeOp *op,Datatype *valueType); ///< Locate root pointer for underlying LOAD or STORE
+ bool find(PcodeOp *op,Datatype *valueType,ResolveCache &resolver); ///< Locate root pointer for underlying LOAD or STORE
void duplicateToTemp(Funcdata &data,PcodeOp *followOp); ///< COPY the root varnode into a temp register
void freePointerChain(Funcdata &data); ///< Remove unused pointer calculations
};
Funcdata &data; ///< The containing function
TypeFactory *types; ///< The data-type container
vector<Component> dataTypePieces; ///< Sequence of all data-type pairs being copied
+ ResolveCache resolver; ///< Resolved data-types encountered
bool splitStructures; ///< Whether or not structures should be split
bool splitArrays; ///< Whether or not arrays should be split
bool isLoadStore; ///< True if trying to split LOAD or STORE
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/type.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/type.cc
index e3601d3a99..81cd2392fe 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/type.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/type.cc
@@ -1317,9 +1317,15 @@ Datatype *TypePointer::resolveInFlow(PcodeOp *op,int4 slot)
if (ptrto->getMetatype() == TYPE_UNION) {
Funcdata *fd = op->getParent()->getFuncdata();
const ResolvedUnion *res = fd->getUnionField(this,op,slot);
- if (res != (ResolvedUnion*)0)
+ if (res != (ResolvedUnion *)0)
return res->getDatatype();
- ScoreUnionFields scoreFields(*fd->getArch()->types,this,op,slot);
+ res = fd->getAddressBasedUnionField(this, op->getAddr(), slot);
+ if (res != (ResolvedUnion *)0) {
+ ResolvedUnion resolve(this,res->getFieldNum(),*fd->getArch()->types);
+ fd->setUnionField(this,op,slot,resolve);
+ return resolve.getDatatype();
+ }
+ ScoreUnionFields scoreFields(*fd,this,op,slot);
fd->setUnionField(this,op,slot,scoreFields.getResult());
return scoreFields.getResult().getDatatype();
}
@@ -1338,6 +1344,15 @@ Datatype* TypePointer::findResolve(const PcodeOp *op,int4 slot)
return this;
}
+int4 TypePointer::findCompatibleResolve(Datatype *ct) const
+
+{
+ if (ct->getMetatype() == TYPE_PTR) {
+ return ptrto->findCompatibleResolve(((TypePointer *)ct)->ptrto);
+ }
+ return -1;
+}
+
void TypeArray::printRaw(ostream &s) const
{
@@ -2530,7 +2545,13 @@ Datatype *TypeUnion::resolveInFlow(PcodeOp *op,int4 slot)
const ResolvedUnion *res = fd->getUnionField(this, op, slot);
if (res != (ResolvedUnion *)0)
return res->getDatatype();
- ScoreUnionFields scoreFields(*fd->getArch()->types,this,op,slot);
+ res = fd->getAddressBasedUnionField(this, op->getAddr(), slot);
+ if (res != (ResolvedUnion *)0) {
+ ResolvedUnion resolve(this,res->getFieldNum(),*fd->getArch()->types);
+ fd->setUnionField(this, op, slot, *res);
+ return resolve.getDatatype();
+ }
+ ScoreUnionFields scoreFields(*fd,this,op,slot);
fd->setUnionField(this, op, slot, scoreFields.getResult());
return scoreFields.getResult().getDatatype();
}
@@ -2549,7 +2570,13 @@ const TypeField *TypeUnion::resolveTruncation(int8 offset,PcodeOp *op,int4 slot,
{
Funcdata *fd = op->getParent()->getFuncdata();
- const ResolvedUnion *res = fd->getUnionField(this, op, slot);
+ const ResolvedUnion *res = fd->getUnionResolution(this, op, slot);
+ if (res == (ResolvedUnion *)0) {
+ res = fd->getAddressBasedUnionField(this, op->getAddr(), slot);
+ if (res != (ResolvedUnion *)0) {
+ fd->setUnionField(this, op, slot, *res);
+ }
+ }
if (res != (ResolvedUnion *)0) {
if (res->getFieldNum() >= 0) {
const TypeField *field = getField(res->getFieldNum());
@@ -2558,7 +2585,7 @@ const TypeField *TypeUnion::resolveTruncation(int8 offset,PcodeOp *op,int4 slot,
}
}
else if (op->code() == CPUI_SUBPIECE && slot == 1) { // The slot is artificial in this case
- ScoreUnionFields scoreFields(*fd->getArch()->types,this,offset,op);
+ ScoreUnionFields scoreFields(*fd,this,offset,op);
fd->setUnionField(this, op, slot, scoreFields.getResult());
if (scoreFields.getResult().getFieldNum() >= 0) {
newoff = 0;
@@ -2566,7 +2593,7 @@ const TypeField *TypeUnion::resolveTruncation(int8 offset,PcodeOp *op,int4 slot,
}
}
else {
- ScoreUnionFields scoreFields(*fd->getArch()->types,this,offset,op,slot);
+ ScoreUnionFields scoreFields(*fd,this,offset,op,slot);
fd->setUnionField(this, op, slot, scoreFields.getResult());
if (scoreFields.getResult().getFieldNum() >= 0) {
const TypeField *field = getField(scoreFields.getResult().getFieldNum());
@@ -2588,7 +2615,7 @@ const TypeField *TypeUnion::findTruncation(int8 offset,int4 sz,const PcodeOp *op
{
// No new scoring is done, but if a cached result is available, return it.
const Funcdata *fd = op->getParent()->getFuncdata();
- const ResolvedUnion *res = fd->getUnionField(this, op, slot);
+ const ResolvedUnion *res = fd->getUnionResolution(this, op, slot);
if (res != (ResolvedUnion *)0 && res->getFieldNum() >= 0) {
const TypeField *field = getField(res->getFieldNum());
newoff = offset - field->offset;
@@ -2908,38 +2935,50 @@ void TypePartialUnion::encode(Encoder &encoder) const
Datatype *TypePartialUnion::resolveInFlow(PcodeOp *op,int4 slot)
{
+ Funcdata *fd = op->getParent()->getFuncdata();
+ const ResolvedUnion *res = fd->getUnionField(this, op, slot);
+ if (res != (ResolvedUnion *)0)
+ return res->getDatatype();
Datatype *curType = container;
int8 curOff = offset;
while(curType != (Datatype *)0 && curType->getSize() > size) {
- if (curType->getMetatype() == TYPE_UNION) {
+ if (curType->getMetatype() == TYPE_PARTIALUNION) {
+ TypePartialUnion *curPartial = (TypePartialUnion *)curType;
+ curOff += curPartial->getOffset();
+ int8 newOff;
+ const TypeField *field = curPartial->getParentUnion()->resolveTruncation(curOff, op, slot, newOff);
+ Architecture *glb = op->getParent()->getFuncdata()->getArch();
+ curType = (Datatype *)0;
+ if (field != (const TypeField *)0)
+ curType = glb->types->getExactPiece(field->type, curOff, size);
+ curOff = 0;
+ }
+ else if (curType->getMetatype() == TYPE_UNION) {
const TypeField *field = curType->resolveTruncation(curOff, op, slot, curOff);
- curType = (field == (const TypeField *)0) ? (Datatype *)0 : field->type;
+ Architecture *glb = op->getParent()->getFuncdata()->getArch();
+ curType = (Datatype *)0;
+ if (field != (const TypeField *)0)
+ curType = glb->types->getExactPiece(field->type, curOff, size);
+ curOff = 0;
}
- else {
- curType = curType->getSubType(curOff, &curOff);
+ else { // Should never reach here
+ curType = (Datatype *)0;
+ break;
}
}
- if (curType != (Datatype *)0 && curType->getSize() == size)
- return curType;
- return stripped;
+ if (curType == (Datatype *)0 || curType->getSize() != size)
+ curType = stripped;
+ fd->updateUnionField(this, op, slot, curType);
+ return curType;
}
Datatype* TypePartialUnion::findResolve(const PcodeOp *op,int4 slot)
{
- Datatype *curType = container;
- int8 curOff = offset;
- while(curType != (Datatype *)0 && curType->getSize() > size) {
- if (curType->getMetatype() == TYPE_UNION) {
- Datatype *newType = curType->findResolve(op, slot);
- curType = (newType == curType) ? (Datatype *)0 : newType;
- }
- else {
- curType = curType->getSubType(curOff, &curOff);
- }
- }
- if (curType != (Datatype *)0 && curType->getSize() == size)
- return curType;
+ const Funcdata *fd = op->getParent()->getFuncdata();
+ const ResolvedUnion *res = fd->getUnionField(this, op, slot);
+ if (res != (ResolvedUnion *)0)
+ return res->getDatatype();
return stripped;
}
@@ -4535,9 +4574,6 @@ Datatype *TypeFactory::getExactPiece(Datatype *ct,int4 offset,int4 size)
}
if (ct->getSize() == size)
return ct; // Perfect size match
- if (ct->getMetatype() == TYPE_UNION) {
- return getTypePartialUnion((TypeUnion *)ct, curOff, size);
- }
lastType = ct;
lastOff = curOff;
ct = ct->getSubType(curOff,&curOff);
@@ -4547,6 +4583,12 @@ Datatype *TypeFactory::getExactPiece(Datatype *ct,int4 offset,int4 size)
type_metatype meta = lastType->getMetatype();
if (meta == TYPE_STRUCT || meta == TYPE_ARRAY || meta == TYPE_PARTIALSTRUCT)
return getTypePartialStruct(lastType, lastOff, size);
+ else if (meta == TYPE_UNION)
+ return getTypePartialUnion((TypeUnion *)lastType, lastOff, size);
+ else if (meta == TYPE_PARTIALUNION) { // Truncate to smaller partial union
+ TypePartialUnion *partial = (TypePartialUnion *)lastType;
+ return getTypePartialUnion(partial->getParentUnion(),lastOff + partial->getOffset(), size);
+ }
else if (lastType->isEnumType() && !lastType->hasStripped())
return getTypePartialEnum((TypeEnum *)lastType, lastOff, size);
}
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/type.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/type.hh
index a49726b0f4..591f724c65 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/type.hh
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/type.hh
@@ -293,7 +293,7 @@ public:
virtual int4 findCompatibleResolve(Datatype *ct) const; ///< Find a resolution compatible with the given data-type
virtual const TypeField *resolveTruncation(int8 offset,PcodeOp *op,int4 slot,int8 &newoff);
int4 typeOrder(const Datatype &op) const { if (this==&op) return 0; return compare(op,10); } ///< Order this with -op- datatype
- int4 typeOrderBool(const Datatype &op) const; ///< Order \b this with -op-, treating \e bool data-type as special
+ int4 typeOrderFormal(const Datatype &op) const; ///< Order \b this with \b op for selecting a formal high-level data-type
void encodeRef(Encoder &encoder) const; ///< Encode a reference of \b this to a stream
bool isPieceStructured(void) const; ///< Does \b this data-type consist of separate pieces?
bool isPrimitiveWhole(void) const; ///< Is \b this made up of a single primitive
@@ -479,6 +479,7 @@ public:
virtual bool isPtrsubMatching(int8 off,int8 extra,int8 multiplier) const;
virtual Datatype *resolveInFlow(PcodeOp *op,int4 slot);
virtual Datatype* findResolve(const PcodeOp *op,int4 slot);
+ virtual int4 findCompatibleResolve(Datatype *ct) const; ///< Find a resolution compatible with the given data-type
};
/// \brief Datatype object representing an array of elements
@@ -978,17 +979,19 @@ inline uint8 Datatype::getUnsizedId(void) const
return id;
}
-/// Order data-types, with special handling of the \e bool data-type. Data-types are compared
-/// using the normal ordering, but \e bool is ordered after all other data-types. A return value
-/// of 0 indicates the data-types are the same, -1 indicates that \b this is prefered (ordered earlier),
+/// Order data-types, preferring the most specialized, except deemphasize \e partial data-types,
+/// which can't be formal, and \e bool, which can be over specialized. A return value
+/// of 0 indicates the data-types are the same, -1 indicates that \b this is preferred (ordered earlier),
/// and 1 indicates \b this is ordered later.
/// \param op is the other data-type to compare with \b this
/// \return -1, 0, or 1
-inline int4 Datatype::typeOrderBool(const Datatype &op) const
+inline int4 Datatype::typeOrderFormal(const Datatype &op) const
{
if (this == &op) return 0;
- if (metatype == TYPE_BOOL) return 1; // Never prefer bool over other data-types
+ if (metatype == TYPE_PARTIALUNION) return 1; // Prefer partials the least
+ if (op.metatype == TYPE_PARTIALUNION) return -1;
+ if (metatype == TYPE_BOOL) return 1; // Prefer bool less than integers
if (op.metatype == TYPE_BOOL) return -1;
return compare(op,10);
}
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/unionresolve.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/unionresolve.cc
index 3076dce7a6..0d7edd1f81 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/unionresolve.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/unionresolve.cc
@@ -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.
@@ -18,62 +18,114 @@
namespace ghidra {
-/// The original parent must either be a union, a partial union, a structure with a single field,
+/// The original data-type must either be a union, a partial union, a structure with a single field,
/// an array with a single element, or a pointer to one of these data-types.
/// The object is set up initially to resolve to the parent.
-/// \param parent is the original parent data-type
-ResolvedUnion::ResolvedUnion(Datatype *parent)
+/// \param unresType is the original unresolved data-type
+ResolvedUnion::ResolvedUnion(Datatype *unresType)
{
- baseType = parent;
+ baseType = unresType;
if (baseType->getMetatype() == TYPE_PTR)
baseType = ((TypePointer *)baseType)->getPtrTo();
- resolve = parent;
+ else if (baseType->getMetatype() == TYPE_PARTIALUNION)
+ baseType = ((TypePartialUnion *)baseType)->getParentUnion();
+ resolve = unresType;
fieldNum = -1;
lock = false;
}
-/// The original parent must be a union or structure.
-/// \param parent is the original parent
-/// \param fldNum is the index of the particular field to resolve to (or -1 to resolve to parent)
+/// \param unresType is the data-type that needs resolution
+/// \param fldNum is the index of the particular field to resolve to (or -1 to resolve to \b unresType)
/// \param typegrp is a TypeFactory used to construct the resolved data-type of the field
-ResolvedUnion::ResolvedUnion(Datatype *parent,int4 fldNum,TypeFactory &typegrp)
+ResolvedUnion::ResolvedUnion(Datatype *unresType,int4 fldNum,TypeFactory &typegrp)
{
- if (parent->getMetatype() == TYPE_PARTIALUNION)
- parent = ((TypePartialUnion *)parent)->getParentUnion();
- baseType = parent;
+ baseType = unresType;
fieldNum = fldNum;
lock = false;
- if (fldNum < 0)
- resolve = parent;
- else {
- if (parent->getMetatype() == TYPE_PTR) {
- TypePointer *pointer = (TypePointer *)parent;
+ if (unresType->getMetatype() == TYPE_PARTIALUNION) {
+ TypePartialUnion *partial = (TypePartialUnion *)unresType;
+ baseType = partial->getParentUnion();
+ if (fldNum < 0)
+ resolve = unresType->getStripped();
+ else {
+ const TypeField *field = partial->getParentUnion()->getField(fldNum);
+ resolve = typegrp.getExactPiece(field->type, partial->getOffset(), partial->getSize());
+ if (resolve == (Datatype *)0)
+ resolve = partial->getStripped();
+ }
+ }
+ else if (unresType->getMetatype() == TYPE_PTR) {
+ TypePointer *pointer = (TypePointer *)unresType;
+ baseType = pointer->getPtrTo();
+ if (fldNum < 0)
+ resolve = unresType;
+ else {
Datatype *field = pointer->getPtrTo()->getDepend(fldNum);
- resolve = typegrp.getTypePointer(parent->getSize(),field,pointer->getWordSize());
+ resolve = typegrp.getTypePointerStripArray(unresType->getSize(),field,pointer->getWordSize());
}
+ }
+ else {
+ if (fldNum < 0)
+ resolve = unresType;
else
- resolve = parent->getDepend(fldNum);
+ resolve = unresType->getDepend(fldNum);
}
}
-/// \param parent is a parent data-type that needs to be resolved
-/// \param op is the PcodeOp reading/writing the \b parent data-type
-/// \param slot is the slot (>=0 for input, -1 for output) accessing the \b parent
-ResolveEdge::ResolveEdge(const Datatype *parent,const PcodeOp *op,int4 slot)
+ResolvedUnion::ResolvedUnion(const ResolvedUnion &op,Datatype *res)
+
+{
+ baseType = op.baseType;
+ fieldNum = op.fieldNum;
+ lock = op.lock;
+ resolve = res;
+}
+
+/// \param op is the new resolution
+/// \return \b true if any change is made
+bool ResolvedUnion::update(const ResolvedUnion &op)
+
+{
+ if (lock && fieldNum != op.fieldNum)
+ return false; // Lock protects the fieldNum resolution not the resolved data-type
+ if (fieldNum == op.fieldNum && resolve == op.resolve)
+ return false;
+ fieldNum = op.fieldNum;
+ resolve = op.resolve;
+ return true;
+}
+
+/// \param unresType is the data-type that needs to be resolved
+/// \param op is the PcodeOp reading/writing the data-type
+/// \param slot is the slot (>=0 for input, -1 for output) accessing the data-type
+ResolveEdge::ResolveEdge(const Datatype *unresType,const PcodeOp *op,int4 slot)
{
opTime = op->getTime();
encoding = slot;
- if (parent->getMetatype() == TYPE_PTR) {
- typeId = ((TypePointer *)parent)->getPtrTo()->getId(); // Strip pointer
+ if (unresType->getMetatype() == TYPE_PTR) {
+ typeId = ((TypePointer *)unresType)->getPtrTo()->getId(); // Strip pointer
encoding += 0x1000; // Encode the fact that a pointer is getting accessed
}
- else if (parent->getMetatype() == TYPE_PARTIALUNION)
- typeId = ((TypePartialUnion *)parent)->getParentUnion()->getId();
+ else if (unresType->getMetatype() == TYPE_PARTIALUNION)
+ typeId = ((TypePartialUnion *)unresType)->getParentUnion()->getId();
+ else
+ typeId = unresType->getId();
+}
+
+ResolveEdge::ResolveEdge(const Datatype *unresType,const Address &addr,int4 slot)
+
+{
+ opTime = addr.getOffset();
+ encoding = 0x2000;
+ if (unresType->getMetatype() == TYPE_PTR)
+ typeId = ((TypePointer *)unresType)->getPtrTo()->getId(); // Strip pointer
+ else if (unresType->getMetatype() == TYPE_PARTIALUNION)
+ typeId = ((TypePartialUnion *)unresType)->getParentUnion()->getId();
else
- typeId = parent->getId();
+ typeId = unresType->getId();
}
const int4 ScoreUnionFields::threshold = 256;
@@ -119,7 +171,7 @@ bool ScoreUnionFields::testArrayArithmetic(PcodeOp *op,int4 inslot)
bool ScoreUnionFields::testSimpleCases(PcodeOp *op,int4 inslot,Datatype *parent)
{
- if (op->isMarker())
+ if (op->isMarker() && inslot < 0)
return true; // Propagate raw union across MULTIEQUAL and INDIRECT
if (parent->getMetatype() == TYPE_PTR) {
if (inslot < 0)
@@ -127,13 +179,7 @@ bool ScoreUnionFields::testSimpleCases(PcodeOp *op,int4 inslot,Datatype *parent)
if (testArrayArithmetic(op, inslot))
return true;
}
- if (op->code() != CPUI_COPY)
- return false; // A more complicated case
- if (inslot < 0)
- return false; // Generally we don't want to propagate union backward thru COPY
- if (op->getOut()->isTypeLock())
- return false; // Do the full scoring
- return true; // Assume we don't have to extract a field if copying
+ return false;
}
/// A trial that encounters a locked data-type does not propagate through it but scores
@@ -175,20 +221,17 @@ int4 ScoreUnionFields::scoreLockedType(Datatype *ct,Datatype *lockType)
return score;
}
-/// Look up the call-specs for the given CALL. If the inputs are locked, find the corresponding
+/// For the given function prototype, if the inputs are locked, find the corresponding
/// parameter and score the trial data-type against it.
/// \param ct is the trial data-type
-/// \param callOp is the CALL
+/// \param proto is the function prototype (may be null)
/// \param paramSlot is the input slot of the trial data-type
/// \return the score
-int4 ScoreUnionFields::scoreParameter(Datatype *ct,const PcodeOp *callOp,int4 paramSlot)
+int4 ScoreUnionFields::scoreParameter(Datatype *ct,const FuncProto *proto,int4 paramSlot)
{
- const Funcdata *fd = callOp->getParent()->getFuncdata();
-
- FuncCallSpecs *fc = fd->getCallSpecs(callOp);
- if (fc != (FuncCallSpecs *)0 && fc->isInputLocked() && fc->numParams() > paramSlot) {
- return scoreLockedType(ct,fc->getParam(paramSlot)->getType());
+ if (proto != (const FuncProto *)0 && proto->isInputLocked() && proto->numParams() > paramSlot) {
+ return scoreLockedType(ct,proto->getParam(paramSlot)->getType());
}
type_metatype meta = ct->getMetatype();
if (meta == TYPE_ARRAY || meta == TYPE_STRUCT || meta == TYPE_UNION || meta == TYPE_CODE)
@@ -196,19 +239,15 @@ int4 ScoreUnionFields::scoreParameter(Datatype *ct,const PcodeOp *callOp,int4 pa
return 0;
}
-/// Look up the call-specs for the given CALL. If the output is locked,
-/// score the trial data-type against it.
+/// For the given function prototype, if the output is locked, score the trial data-type against it.
/// \param ct is the trial data-type
-/// \param callOp is the CALL
+/// \param proto is the function prototype (may be null)
/// \return the score
-int4 ScoreUnionFields::scoreReturnType(Datatype *ct,const PcodeOp *callOp)
+int4 ScoreUnionFields::scoreReturnType(Datatype *ct,const FuncProto *proto)
{
- const Funcdata *fd = callOp->getParent()->getFuncdata();
-
- FuncCallSpecs *fc = fd->getCallSpecs(callOp);
- if (fc != (FuncCallSpecs *)0 && fc->isOutputLocked()) {
- return scoreLockedType(ct,fc->getOutputType());
+ if (proto != (FuncProto *)0 && proto->isOutputLocked()) {
+ return scoreLockedType(ct,proto->getOutputType());
}
type_metatype meta = ct->getMetatype();
if (meta == TYPE_ARRAY || meta == TYPE_STRUCT || meta == TYPE_UNION || meta == TYPE_CODE)
@@ -224,46 +263,54 @@ int4 ScoreUnionFields::scoreReturnType(Datatype *ct,const PcodeOp *callOp)
/// \param vn is the Varnode holding the value being loaded or stored
/// \param score is used to pass back the score
/// \return the data-type of the value or null
-Datatype *ScoreUnionFields::derefPointer(Datatype *ct,Varnode *vn,int4 &score)
+Datatype *ScoreUnionFields::derefPointer(const Trial &trial,Varnode *vn,int4 &score)
{
- Datatype *resType = (Datatype *)0;
score = 0;
- if (ct->getMetatype() == TYPE_PTR) {
- Datatype *ptrto = ((TypePointer *)ct)->getPtrTo();
- while(ptrto != (Datatype *)0 && ptrto->getSize() > vn->getSize()) {
+ if (trial.fitType->getMetatype() == TYPE_PTR) {
+ Datatype *ptrto = ((TypePointer *)trial.fitType)->getPtrTo();
+ Datatype *subType = ptrto;
+ while(subType != (Datatype *)0 && subType->getSize() > vn->getSize()) {
int8 newoff;
- ptrto = ptrto->getSubType(0, &newoff);
+ subType = subType->getSubType(0, &newoff);
}
- if (ptrto != (Datatype *)0 && ptrto->getSize() == vn->getSize()) {
+ if (subType != (Datatype *)0 && subType->getSize() == vn->getSize()) {
score = 10;
- resType = ptrto;
+ return subType;
+ }
+ if (trial.maxLength != 0 && (vn->getSize() % ptrto->getSize()) == 0) {
+ score = -4; // Doesn't fit but could be multiple values at once
+ return typegrp.getTypeArray(vn->getSize() / ptrto->getSize(), ptrto);
}
+ score = -5; // Score to something but it doesn't fit
}
else
- score = -10;
- return resType;
+ score = -10; // Derefencing something that isn't even a pointer
+ return (Datatype *)0;
}
/// If the Varnode has already been visited, no new trials are created
/// \param vn is the given Varnode
/// \param ct is the data-type to associate with the trial
/// \param scoreIndex is the field index to score the trial against
-/// \param isArray is \b true if the data-type to fit is a pointer to an array
-void ScoreUnionFields::newTrialsDown(Varnode *vn,Datatype *ct,int4 scoreIndex,bool isArray)
+/// \param max is the biggest offset that can be added to the data-type as a pointer
+void ScoreUnionFields::newTrialsDown(Varnode *vn,Datatype *ct,int4 scoreIndex,int4 max)
{
VisitMark mark(vn,scoreIndex);
if (!visited.insert(mark).second)
return; // Already visited this Varnode
if (vn->isTypeLock()) {
- scores[scoreIndex] += scoreLockedType(ct, vn->getType());
- return; // Don't propagate through locked Varnode
+ Datatype *lockType = vn->getTypeDefFacing();
+ if (!lockType->needsResolution()) {
+ scores[scoreIndex] += scoreLockedType(ct, lockType);
+ return; // Don't propagate through locked Varnode
+ }
}
list<PcodeOp*>::const_iterator piter;
for(piter = vn->beginDescend();piter != vn->endDescend();++piter) {
PcodeOp *op = *piter;
- trialNext.emplace_back(op,op->getSlot(vn),ct,scoreIndex,isArray);
+ trialNext.emplace_back(op,op->getSlot(vn),ct,scoreIndex,max);
}
}
@@ -272,8 +319,8 @@ void ScoreUnionFields::newTrialsDown(Varnode *vn,Datatype *ct,int4 scoreIndex,bo
/// \param slot is the index of the given input slot
/// \param ct is the data-type to associate with the trial
/// \param scoreIndex is the field index to score the trial against
-/// \param isArray is \b true if the data-type to fit is a pointer to an array
-void ScoreUnionFields::newTrials(PcodeOp *op,int4 slot,Datatype *ct,int4 scoreIndex,bool isArray)
+/// \param max is the biggest offset that can be added to the data-type as a pointer
+void ScoreUnionFields::newTrials(PcodeOp *op,int4 slot,Datatype *ct,int4 scoreIndex,int4 max)
{
Varnode *vn = op->getIn(slot);
@@ -281,17 +328,20 @@ void ScoreUnionFields::newTrials(PcodeOp *op,int4 slot,Datatype *ct,int4 scoreIn
if (!visited.insert(mark).second)
return; // Already visited this Varnode
if (vn->isTypeLock()) {
- scores[scoreIndex] += scoreLockedType(ct, vn->getType());
- return; // Don't propagate through locked Varnode
+ Datatype *lockType = vn->getTypeReadFacing(op);
+ if (!lockType->needsResolution()) {
+ scores[scoreIndex] += scoreLockedType(ct, lockType);
+ return; // Don't propagate through locked Varnode
+ }
}
- trialNext.emplace_back(vn,ct,scoreIndex,isArray); // Try to fit up
+ trialNext.emplace_back(vn,ct,scoreIndex,max); // Try to fit up
list<PcodeOp *>::const_iterator iter;
for(iter=vn->beginDescend();iter!=vn->endDescend();++iter) {
PcodeOp *readOp = *iter;
int4 inslot = readOp->getSlot(vn);
if (readOp == op && inslot == slot)
continue; // Don't go down PcodeOp we came from
- trialNext.emplace_back(readOp,inslot,ct, scoreIndex,isArray);
+ trialNext.emplace_back(readOp,inslot,ct, scoreIndex,max);
}
}
@@ -308,6 +358,7 @@ void ScoreUnionFields::scoreTrialDown(const Trial &trial,bool lastLevel)
if (trial.direction == Trial::fit_up)
return; // Trial doesn't push in this direction
Datatype *resType = (Datatype *)0; // Assume by default we don't propagate
+ int4 maxLength = 0;
type_metatype meta = trial.fitType->getMetatype();
int4 score = 0;
switch(trial.op->code()) {
@@ -315,23 +366,30 @@ void ScoreUnionFields::scoreTrialDown(const Trial &trial,bool lastLevel)
case CPUI_MULTIEQUAL:
case CPUI_INDIRECT:
resType = trial.fitType; // No score, but we can propagate
+ maxLength = trial.maxLength;
break;
case CPUI_LOAD:
- resType = derefPointer(trial.fitType, trial.op->getOut(), score);
+ resType = derefPointer(trial, trial.op->getOut(), score);
break;
case CPUI_STORE:
if (trial.inslot == 1) {
- Datatype *ptrto = derefPointer(trial.fitType,trial.op->getIn(2),score);
+ Datatype *ptrto = derefPointer(trial,trial.op->getIn(2),score);
if (ptrto != (Datatype*)0) {
if (!lastLevel)
- newTrials(trial.op,2,ptrto,trial.scoreIndex,trial.array); // Propagate to value being STOREd
+ newTrials(trial.op,2,ptrto,trial.scoreIndex,0); // Propagate to value being STOREd
}
}
else if (trial.inslot == 2) {
if (meta == TYPE_CODE)
score = -5;
- else
+ else {
+ Datatype *storePtr = trial.op->getIn(1)->getTypeReadFacing(trial.op);
+ if (!lastLevel && storePtr->getMetatype() == TYPE_PTR) {
+ Datatype *ptr = typegrp.getTypePointerStripArray(storePtr->getSize(), trial.fitType, ((TypePointer *)storePtr)->getWordSize());
+ newTrials(trial.op,1,ptr,trial.scoreIndex,trial.fitType->getSize());
+ }
score = 1;
+ }
}
break;
case CPUI_CBRANCH:
@@ -350,7 +408,7 @@ void ScoreUnionFields::scoreTrialDown(const Trial &trial,bool lastLevel)
case CPUI_CALL:
case CPUI_CALLOTHER:
if (trial.inslot > 0)
- score = scoreParameter(trial.fitType, trial.op, trial.inslot-1);
+ score = scoreParameter(trial.fitType, data.getCallSpecs(trial.op), trial.inslot-1);
break;
case CPUI_CALLIND:
if (trial.inslot == 0) {
@@ -365,13 +423,11 @@ void ScoreUnionFields::scoreTrialDown(const Trial &trial,bool lastLevel)
}
}
else {
- score = scoreParameter(trial.fitType, trial.op, trial.inslot-1);
+ score = scoreParameter(trial.fitType, data.getCallSpecs(trial.op), trial.inslot-1);
}
break;
case CPUI_RETURN:
- // We could check for locked return data-type
- if (meta == TYPE_ARRAY || meta == TYPE_STRUCT || meta == TYPE_UNION || meta == TYPE_CODE)
- score = -1;
+ score = scoreReturnType(trial.fitType, &data.getFuncProto());
break;
case CPUI_INT_EQUAL:
case CPUI_INT_NOTEQUAL:
@@ -429,15 +485,28 @@ void ScoreUnionFields::scoreTrialDown(const Trial &trial,bool lastLevel)
Varnode *vn = trial.op->getIn(1-trial.inslot);
if (vn->isConstant()) {
TypePointer *baseType = (TypePointer *)trial.fitType;
- int8 off = vn->getOffset();
- int8 parOff;
- TypePointer *par;
- resType = baseType->downChain(off,par,parOff,trial.array,typegrp);
- if (resType != (Datatype*)0)
+ int8 off = sign_extend(vn->getOffset(),vn->getSize()*8-1);
+ if (trial.maxLength != 0) {
+ if (off < 0 || off >= trial.maxLength) {
+ baseType = (TypePointer *)0;
+ score = -1; // Offset doesn't land in allowed range
+ }
+ else
+ maxLength = trial.maxLength;
+ }
+ while(off != 0 && baseType != (Datatype *)0) {
+ int8 parOff;
+ TypePointer *par;
+ baseType = baseType->downChain(off,par,parOff,true,typegrp);
+ }
+ if (baseType != (Datatype*)0) {
+ resType = baseType;
+ maxLength = baseType->getPtrTo()->getSize();
score = 5;
+ }
}
else {
- if (trial.array) {
+ if (trial.maxLength != 0) {
score = 1;
int4 elSize = 1;
if (vn->isWritten()) {
@@ -450,8 +519,12 @@ void ScoreUnionFields::scoreTrialDown(const Trial &trial,bool lastLevel)
}
TypePointer *baseType = (TypePointer *)trial.fitType;
if (baseType->getPtrTo()->getAlignSize() == elSize) {
- score = 5;
+ if (elSize == trial.maxLength)
+ score = 2; // Only one element available, but variable index
+ else
+ score = 5;
resType = trial.fitType;
+ maxLength = trial.maxLength;
}
}
else
@@ -459,10 +532,14 @@ void ScoreUnionFields::scoreTrialDown(const Trial &trial,bool lastLevel)
}
}
}
- else if (meta == TYPE_ARRAY || meta == TYPE_STRUCT || meta == TYPE_UNION || meta == TYPE_CODE || meta == TYPE_FLOAT)
- score = -5;
- else
+ else if (meta == TYPE_INT || meta == TYPE_UINT || meta == TYPE_UNKNOWN) {
score = 1;
+ resType = trial.fitType;
+ }
+ else if (meta == TYPE_BOOL)
+ score = -3;
+ else // TYPE_ARRAY TYPE_STRUCT TYPE_UNION TYPE_CODE TYPE_FLOAT
+ score = -5;
break;
case CPUI_INT_2COMP:
if (meta == TYPE_ARRAY || meta == TYPE_STRUCT || meta == TYPE_UNION || meta == TYPE_CODE || meta == TYPE_FLOAT)
@@ -636,7 +713,7 @@ void ScoreUnionFields::scoreTrialDown(const Trial &trial,bool lastLevel)
}
scores[trial.scoreIndex] += score;
if (resType != (Datatype *)0 && !lastLevel)
- newTrialsDown(trial.op->getOut(), resType, trial.scoreIndex, trial.array);
+ newTrialsDown(trial.op->getOut(), resType, trial.scoreIndex, maxLength);
}
void ScoreUnionFields::scoreTrialUp(const Trial &trial,bool lastLevel)
@@ -651,6 +728,7 @@ void ScoreUnionFields::scoreTrialUp(const Trial &trial,bool lastLevel)
return; // Nothing to propagate up through
}
Datatype *resType = (Datatype *)0; // Assume by default we don't propagate
+ int4 maxLength = 0;
int4 newslot = 0;
type_metatype meta = trial.fitType->getMetatype();
PcodeOp *def = trial.vn->getDef();
@@ -659,16 +737,18 @@ void ScoreUnionFields::scoreTrialUp(const Trial &trial,bool lastLevel)
case CPUI_MULTIEQUAL:
case CPUI_INDIRECT:
resType = trial.fitType; // No score, but we can propagate
+ maxLength = trial.maxLength;
newslot = 0;
break;
case CPUI_LOAD:
- resType = typegrp.getTypePointer(def->getIn(1)->getSize(),trial.fitType,1);
+ resType = typegrp.getTypePointerStripArray(def->getIn(1)->getSize(),trial.fitType,1);
+ maxLength = trial.fitType->getSize();
newslot = 1; // No score, but we can propagate
break;
case CPUI_CALL:
case CPUI_CALLOTHER:
case CPUI_CALLIND:
- score = scoreReturnType(trial.fitType, def);
+ score = scoreReturnType(trial.fitType, data.getCallSpecs(def));
break;
case CPUI_INT_EQUAL:
case CPUI_INT_NOTEQUAL:
@@ -699,11 +779,19 @@ void ScoreUnionFields::scoreTrialUp(const Trial &trial,bool lastLevel)
case CPUI_INT_SUB:
case CPUI_PTRSUB:
if (meta == TYPE_PTR) {
+ score = 5;
+ if (trial.maxLength == 0 && def->getIn(1)->isConstant()) {
+ Datatype *ptrto = ((TypePointer *)trial.fitType)->getPtrTo();
+ if (ptrto->getAlignSize() == (int4)def->getIn(1)->getOffset())
+ score += 1;
+ }
+ }
+ else if (meta == TYPE_INT || meta == TYPE_UINT) {
score = 5; // Don't try to back up further
}
else if (meta == TYPE_ARRAY || meta == TYPE_STRUCT || meta == TYPE_UNION || meta == TYPE_CODE || meta == TYPE_FLOAT)
score = -5;
- else
+ else // BOOL UNKNOWN
score = 1;
break;
case CPUI_INT_2COMP:
@@ -828,7 +916,7 @@ void ScoreUnionFields::scoreTrialUp(const Trial &trial,bool lastLevel)
}
scores[trial.scoreIndex] += score;
if (resType != (Datatype *)0 && !lastLevel) {
- newTrials(def, newslot, resType, trial.scoreIndex, trial.array);
+ newTrials(def, newslot, resType, trial.scoreIndex, maxLength);
}
}
@@ -869,6 +957,16 @@ Datatype *ScoreUnionFields::scoreTruncation(Datatype *ct,Varnode *vn,int4 offset
break;
}
}
+ else if (ct->getMetatype() == TYPE_ARRAY) {
+ Datatype *elType = ct->getDepend(0);
+ if (elType->getAlignSize() < vn->getSize()) {
+ if ((curOff + vn->getSize()) % elType->getAlignSize() != 0)
+ score = -5; // Varnode is unaligned with array elements
+ else
+ score = 1; // Varnode covers array elements
+ break;
+ }
+ }
ct = ct->getSubType(curOff,&curOff);
}
if (ct == (Datatype *)0)
@@ -895,9 +993,14 @@ void ScoreUnionFields::scoreConstantFit(const Trial &trial)
score = -1;
const FloatFormat *format = typegrp.getArch()->translate->getFloatFormat(size);
if (format != (const FloatFormat *)0) {
- int4 exp = format->extractExponentCode(val);
- if (exp < 7 && exp > -4) // Check for common exponent range
+ FloatFormat::floatclass fClass = format->getClass(val);
+ if (fClass == FloatFormat::zero)
score = 2;
+ else if (fClass == FloatFormat::normalized) {
+ int4 exp = format->getExponent(val);
+ if (exp < 7 && exp > -4) // Check for common exponent range
+ score = 2;
+ }
}
}
else if (meta == TYPE_INT || meta == TYPE_UINT || meta == TYPE_PTR) {
@@ -920,6 +1023,8 @@ void ScoreUnionFields::scoreConstantFit(const Trial &trial)
}
}
}
+ else if (meta == TYPE_ARRAY)
+ score = 0; // Could be multiple values from an array
else
score = -2;
scores[trial.scoreIndex] += score;
@@ -983,12 +1088,12 @@ void ScoreUnionFields::run(void)
///
/// The data-type must either be a union or a pointer to union.
/// Set up the initial set of trials based on the given data-flow edge (PcodeOp and slot).
-/// \param tgrp is the TypeFactory owning the data-types
+/// \param fd is the function containing the data-flow
/// \param parentType is the given data-type to score
/// \param op is PcodeOp of the given data-flow edge
/// \param slot is slot of the given data-flow edge
-ScoreUnionFields::ScoreUnionFields(TypeFactory &tgrp,Datatype *parentType,PcodeOp *op,int4 slot)
- : typegrp(tgrp), result(parentType)
+ScoreUnionFields::ScoreUnionFields(Funcdata &fd,Datatype *parentType,PcodeOp *op,int4 slot)
+ : data(fd), typegrp(*fd.getArch()->types), result(parentType)
{
if (testSimpleCases(op, slot, parentType))
return;
@@ -1002,32 +1107,38 @@ ScoreUnionFields::ScoreUnionFields(TypeFactory &tgrp,Datatype *parentType,PcodeO
if (vn->getSize() != parentType->getSize())
scores[0] -= 10; // Data-type does not even match size of Varnode
else
- trialCurrent.emplace_back(vn,parentType,0,false);
+ trialCurrent.emplace_back(vn,parentType,0,0);
}
else {
vn = op->getIn(slot);
if (vn->getSize() != parentType->getSize())
scores[0] -= 10;
else
- trialCurrent.emplace_back(op,slot,parentType,0,false);
+ trialCurrent.emplace_back(op,slot,parentType,0,0);
}
fields[0] = parentType;
+ OpCode opc = op->code();
+ // If the varnode is not a pointer or is not used in pointer arithmetic
+ if (wordSize == 0 || opc == CPUI_INT_ADD || opc == CPUI_PTRADD || opc == CPUI_PTRSUB || opc == CPUI_STORE || opc == CPUI_LOAD)
+ scores[0] -= 1; // Without any other information, prefer a resolution from a specific field
visited.insert(VisitMark(vn,0));
for(int4 i=0;i<numFields;++i) {
Datatype *fieldType = result.baseType->getDepend(i);
- bool isArray = false;
- if (wordSize != 0) {
- if (fieldType->getMetatype() == TYPE_ARRAY)
- isArray = true;
- fieldType = typegrp.getTypePointerStripArray(parentType->getSize(),fieldType,wordSize);
+ int4 maxLength = 0;
+ if (wordSize != 0) { // If this is a pointer
+ if (fieldType->getMetatype() == TYPE_ARRAY) // Array gets stripped
+ maxLength = fieldType->getSize(); // Keep track of original array size
+ else if (fieldType->getSize() < result.baseType->getSize())
+ maxLength = fieldType->getSize();
+ fieldType = typegrp.getTypePointerStripArray(parentType->getSize(),fieldType,wordSize); // Create pointer to field type
}
if (vn->getSize() != fieldType->getSize())
scores[i+1] -= 10; // Data-type does not even match size of Varnode, don't create trial
else if (slot < 0) {
- trialCurrent.emplace_back(vn,fieldType,i+1,isArray);
+ trialCurrent.emplace_back(vn,fieldType,i+1,maxLength);
}
else {
- trialCurrent.emplace_back(op,slot,fieldType,i+1,isArray);
+ trialCurrent.emplace_back(op,slot,fieldType,i+1,maxLength);
}
fields[i+1] = fieldType;
visited.insert(VisitMark(vn,i+1));
@@ -1043,12 +1154,12 @@ ScoreUnionFields::ScoreUnionFields(TypeFactory &tgrp,Datatype *parentType,PcodeO
/// If there is a good fit, the scoring for that field recurses into the given data-flow edge.
/// This is only used where there is a SUBPIECE and the base scoring indicates the whole union is
/// the best match for the input.
-/// \param tgrp is the TypeFactory owning the data-types
+/// \param fd is the function containing the data-flow
/// \param unionType is the data-type to score, which must be a TypeUnion
/// \param offset is the given starting offset of the truncation
/// \param op is the SUBPIECE op
-ScoreUnionFields::ScoreUnionFields(TypeFactory &tgrp,TypeUnion *unionType,int4 offset,PcodeOp *op)
- :typegrp(tgrp), result(unionType)
+ScoreUnionFields::ScoreUnionFields(Funcdata &fd,TypeUnion *unionType,int4 offset,PcodeOp *op)
+ : data(fd), typegrp(*fd.getArch()->types), result(unionType)
{
Varnode *vn = op->getOut();
int numFields = unionType->numDepend();
@@ -1063,26 +1174,29 @@ ScoreUnionFields::ScoreUnionFields(TypeFactory &tgrp,TypeUnion *unionType,int4 o
scores[i+1] = -10;
continue;
}
- newTrialsDown(vn, unionField->type, i+1, false);
+ newTrialsDown(vn, unionField->type, i+1, 0);
}
trialCurrent.swap(trialNext);
if (trialCurrent.size() > 1)
run();
computeBestIndex();
+ result.resolve = typegrp.getExactPiece(result.resolve, offset, vn->getSize());
}
/// \brief Score a union data-type against data-flow, where there is an implied truncation
///
/// A truncation is fit to each union field before doing the fit against data-flow, starting with
/// the given PcodeOp and input slot.
-/// \param tgrp is the TypeFactory owning the data-types
+/// \param fd is the function containing the data-flow
/// \param unionType is the data-type to score, which must be a TypeUnion
/// \param offset is the given starting offset of the truncation
/// \param op is the PcodeOp initially reading/writing the union
/// \param slot is the -1 if the op is writing, >= 0 if reading
-ScoreUnionFields::ScoreUnionFields(TypeFactory &tgrp,TypeUnion *unionType,int4 offset,PcodeOp *op,int4 slot)
- :typegrp(tgrp), result(unionType)
+ScoreUnionFields::ScoreUnionFields(Funcdata &fd,TypeUnion *unionType,int4 offset,PcodeOp *op,int4 slot)
+ :data(fd), typegrp(*fd.getArch()->types), result(unionType)
{
+ if (testSimpleCases(op, slot, unionType))
+ return;
Varnode *vn = (slot < 0) ? op->getOut() : op->getIn(slot);
int numFields = unionType->numDepend();
scores.resize(numFields + 1, 0);
@@ -1096,15 +1210,84 @@ ScoreUnionFields::ScoreUnionFields(TypeFactory &tgrp,TypeUnion *unionType,int4 o
Datatype *ct = scoreTruncation(unionField->type,vn,offset-unionField->offset,i+1);
if (ct != (Datatype *)0) {
if (slot < 0)
- trialCurrent.emplace_back(vn,ct,i+1,false); // Try to flow backward
+ trialCurrent.emplace_back(vn,ct,i+1,0); // Try to flow backward
else
- trialCurrent.emplace_back(op,slot,ct,i+1,false); // Flow downward
+ trialCurrent.emplace_back(op,slot,ct,i+1,0); // Flow downward
visited.insert(VisitMark(vn,i+1));
}
}
if (trialCurrent.size() > 1)
run();
computeBestIndex();
+ result.resolve = typegrp.getExactPiece(result.resolve, offset, vn->getSize());
+}
+
+/// If a resolution for the data-type exists along the given edge, it is cached. Otherwise there is no change.
+/// \param key is the context id associated with the resolution
+/// \param dt is the data-type needing resolution
+/// \param op is the PcodeOp reading/writing the resolved data-type
+/// \param slot is the edge index of the resolution
+void ResolveCache::addResolution(int4 key,Datatype *dt,PcodeOp *op,int4 slot)
+
+{
+ if (!dt->needsResolution()) return;
+ const ResolvedUnion *res = data.getUnionResolution(dt, op, slot);
+ if (res == (const ResolvedUnion *)0) return;
+ Datatype *parent = res->getBase();
+ resolveList.emplace_back(key,parent,res->getFieldNum());
+}
+
+/// If the resolved data-type is in \b this cache, it is returned.
+/// Otherwise the original data-type is returned.
+/// \param key is the context id
+/// \param dt is the given data-type needing resolution
+/// \return the resolved form of the data-type
+Datatype *ResolveCache::resolve(int4 key,Datatype *dt) const
+
+{
+ list<Record>::const_iterator iter;
+ for(iter=resolveList.begin();iter!=resolveList.end();++iter) {
+ if ((*iter).match(key,dt)) {
+ if ((*iter).fieldNum < 0)
+ return dt;
+ return dt->getDepend((*iter).fieldNum);
+ }
+ }
+ return dt;
+}
+
+/// \brief Associate a cached resolution with a new Varnode and read/write edge
+///
+/// The data-type \b dt can either be the current data-type of the Varnode or it
+/// can be a parent data-type, with \b off corresponding to the offset of the Varnode within the parent.
+/// \param key is the context id
+/// \param dt is the data-type needing resolution
+/// \param off is the offset within the data-type of the Varnode
+/// \param vn is the new Varnode inheriting the resolution
+/// \param op is the PcodeOp reading/writing the Varnode
+/// \param slot is the read/write edge
+void ResolveCache::inheritResolution(int4 key,Datatype *dt,int4 off,Varnode *vn,PcodeOp *op,int4 slot) const
+
+{
+ if (!dt->needsResolution()) return;
+ Datatype *parent = dt;
+ if (parent->getMetatype() == TYPE_PARTIALUNION)
+ parent = ((TypePartialUnion *)parent)->getParentUnion();
+ else if (parent->getMetatype() == TYPE_PTR)
+ parent = ((TypePointer *)parent)->getPtrTo();
+ list<Record>::const_iterator iter;
+ for(iter=resolveList.begin();iter!=resolveList.end();++iter) {
+ if ((*iter).match(key,parent)) {
+ TypeFactory *typegrp = data.getArch()->types;
+ dt = typegrp->getExactPiece(dt, off, vn->getSize());
+ if (dt != (Datatype *)0) {
+ ResolvedUnion newRes(dt,(*iter).fieldNum,*typegrp);
+ data.setUnionField(dt, op, slot, newRes);
+ vn->updateType(dt);
+ }
+ return;
+ }
+ }
}
} // End namespace ghidra
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/unionresolve.hh b/Ghidra/Features/Decompiler/src/decompile/cpp/unionresolve.hh
index 8ceca302ba..b01db68c52 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/unionresolve.hh
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/unionresolve.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.
@@ -39,16 +39,19 @@ namespace ghidra {
class ResolvedUnion {
friend class ScoreUnionFields;
Datatype *resolve; ///< The resolved data-type
- Datatype *baseType; ///< Union or Structure being resolved
+ Datatype *baseType; ///< Union or Structure being resolved (pointers and partials stripped)
int4 fieldNum; ///< Index of field referenced by \b resolve
bool lock; ///< If \b true, resolution cannot be overridden
public:
- ResolvedUnion(Datatype *parent); ///< Construct a data-type that resolves to itself
- ResolvedUnion(Datatype *parent,int4 fldNum,TypeFactory &typegrp); ///< Construct a reference to a field
+ ResolvedUnion(Datatype *unresType); ///< Construct a data-type that resolves to itself
+ ResolvedUnion(Datatype *unresType,int4 fldNum,TypeFactory &typegrp); ///< Construct a resolution with a specific field number
+ ResolvedUnion(const ResolvedUnion &op,Datatype *res); ///< Copy constructor with updated resolve data-type
Datatype *getDatatype(void) const { return resolve; } ///< Get the resolved data-type
Datatype *getBase(void) const { return baseType; } ///< Get the union or structure being referenced
int4 getFieldNum(void) const { return fieldNum; } ///< Get the index of the resolved field or -1
- bool isLocked(void) const { return lock; } ///< Is \b this locked against overrides
+ bool isLocked(void) const { return lock; } ///< Return \b true if the field resolution is locked
+ bool update(const ResolvedUnion &op); ///< Update a resolution with a new data-type
+ void setResolve(Datatype *res) { resolve = res; } ///< Update the resolution data-type (without changing field resolution)
void setLock(bool val) { lock = val; } ///< Set whether \b this resolution is locked against overrides
};
@@ -62,7 +65,8 @@ class ResolveEdge {
uintm opTime; ///< Id of PcodeOp edge
int4 encoding; ///< Encoding of the slot and pointer-ness
public:
- ResolveEdge(const Datatype *parent,const PcodeOp *op,int4 slot); ///< Construct from components
+ ResolveEdge(const Datatype *unresType,const PcodeOp *op,int4 slot); ///< Construct from components
+ ResolveEdge(const Datatype *unresType,const Address &addr,int4 slot); ///< Construct address based resolve
bool operator<(const ResolveEdge &op2) const; ///< Compare two edges
};
@@ -92,7 +96,7 @@ class ScoreUnionFields {
PcodeOp *op; ///< The PcodeOp reading the Varnode (or null)
int4 inslot; ///< The slot reading the Varnode (or -1)
dir_type direction; ///< Direction to push fit. 0=down 1=up
- bool array; ///< Field can be accessed as an array
+ int4 maxLength; ///< Maximum byte offset that can be added to \b fitType as a pointer
Datatype *fitType; ///< The putative data-type of the Varnode
int4 scoreIndex; ///< The original field being scored by \b this trial
public:
@@ -102,18 +106,18 @@ class ScoreUnionFields {
/// \param slot is the input slot being read
/// \param ct is the trial data-type to fit
/// \param index is the scoring index
- /// \param isArray is \b true if the data-type to fit is a pointer to an array
- Trial(PcodeOp *o,int4 slot,Datatype *ct,int4 index,bool isArray) {
- op = o; inslot = slot; direction = fit_down; fitType = ct; scoreIndex = index; vn = o->getIn(slot); array=isArray; }
+ /// \param max is the biggest offset that can be added to this data-type as a pointer (or 0 if there is no known restriction)
+ Trial(PcodeOp *o,int4 slot,Datatype *ct,int4 index,int4 max) {
+ op = o; inslot = slot; direction = fit_down; fitType = ct; scoreIndex = index; vn = o->getIn(slot); maxLength = max; }
/// \brief Construct an upward trial for a Varnode
///
/// \param v is the Varnode to fit
/// \param ct is the trial data-type to fit
/// \param index is the scoring index
- /// \param isArray is \b true if the data-type to fit is a pointer to an array
- Trial(Varnode *v,Datatype *ct,int4 index,bool isArray) {
- vn = v; op = (PcodeOp *)0; inslot=-1; direction = fit_up; fitType = ct; scoreIndex = index; array=isArray; }
+ /// \param max is the biggest offset that can be added to this data-type as a pointer (or 0 if there is no known restriction)
+ Trial(Varnode *v,Datatype *ct,int4 index,int4 max) {
+ vn = v; op = (PcodeOp *)0; inslot=-1; direction = fit_up; fitType = ct; scoreIndex = index; maxLength = max; }
};
/// \brief A mark accumulated when a given Varnode is visited with a specific field index
@@ -133,6 +137,7 @@ class ScoreUnionFields {
return (index < op2.index);
}
};
+ Funcdata &data; ///< Function containing data-flow being scored
TypeFactory &typegrp; ///< The factory containing data-types
vector<int4> scores; ///< Score for each field, indexed by fieldNum + 1 (whole union is index=0)
vector<Datatype *> fields; ///< Field corresponding to each score
@@ -147,11 +152,11 @@ class ScoreUnionFields {
bool testArrayArithmetic(PcodeOp *op,int4 inslot); ///< Check if given PcodeOp is operating on array with union elements
bool testSimpleCases(PcodeOp *op,int4 inslot,Datatype *parent); ///< Preliminary checks before doing full scoring
int4 scoreLockedType(Datatype *ct,Datatype *lockType); ///< Score trial data-type against a locked data-type
- int4 scoreParameter(Datatype *ct,const PcodeOp *callOp,int4 paramSlot); ///< Score trial data-type against a parameter
- int4 scoreReturnType(Datatype *ct,const PcodeOp *callOp); ///< Score trial data-type against return data-type of function
- Datatype *derefPointer(Datatype *ct,Varnode *vn,int4 &score); ///< Score trial data-type as a pointer to LOAD/STORE
- void newTrialsDown(Varnode *vn,Datatype *ct,int4 scoreIndex,bool isArray); ///< Create new trials based an reads of given Varnode
- void newTrials(PcodeOp *op,int4 slot,Datatype *ct,int4 scoreIndex,bool isArray); ///< Create new trials based on given input slot
+ int4 scoreParameter(Datatype *ct,const FuncProto *proto,int4 paramSlot); ///< Score trial data-type against a parameter
+ int4 scoreReturnType(Datatype *ct,const FuncProto *proto); ///< Score trial data-type against return data-type of function
+ Datatype *derefPointer(const Trial &trial,Varnode *vn,int4 &score); ///< Score trial as a pointer to LOAD/STORE
+ void newTrialsDown(Varnode *vn,Datatype *ct,int4 scoreIndex,int4 max); ///< Create new trials based an reads of given Varnode
+ void newTrials(PcodeOp *op,int4 slot,Datatype *ct,int4 scoreIndex,int4 max); ///< Create new trials based on given input slot
void scoreTrialDown(const Trial &trial,bool lastLevel); ///< Try to fit the given trial following data-flow down
void scoreTrialUp(const Trial &trial,bool lastLevel); ///< Try to fit the given trial following data-flow up
Datatype *scoreTruncation(Datatype *ct,Varnode *vn,int4 offset,int4 scoreIndex); ///< Score a truncation in the data-flow
@@ -160,12 +165,47 @@ class ScoreUnionFields {
void computeBestIndex(void); ///< Assuming scoring is complete, compute the best index
void run(void); ///< Calculate best fitting field
public:
- ScoreUnionFields(TypeFactory &tgrp,Datatype *parentType,PcodeOp *op,int4 slot);
- ScoreUnionFields(TypeFactory &tgrp,TypeUnion *unionType,int4 offset,PcodeOp *op);
- ScoreUnionFields(TypeFactory &tgrp,TypeUnion *unionType,int4 offset,PcodeOp *op,int4 slot);
+ ScoreUnionFields(Funcdata &fd,Datatype *parentType,PcodeOp *op,int4 slot);
+ ScoreUnionFields(Funcdata &fd,TypeUnion *unionType,int4 offset,PcodeOp *op);
+ ScoreUnionFields(Funcdata &fd,TypeUnion *unionType,int4 offset,PcodeOp *op,int4 slot);
const ResolvedUnion &getResult(void) const { return result; } ///< Get the resulting best field resolution
};
+/// \brief A collection of specific union data-type and how they resolve in a given context
+///
+/// Union resolutions are collected before a transform via addResolution(). Then afterwards Varnodes
+/// can inherit the the same resolutions via the inheritResolution() methods.
+/// Resolutions for multiple contexts can stored and retrieved by providing an id for the context
+/// in the \b key parameter.
+class ResolveCache {
+ /// \brief A specific resolution of a union data-type
+ class Record {
+ public:
+ Datatype *baseType; ///< The union or structure needing resolution (pointers and partials stripped)
+ int4 fieldNum; ///< Index of the specific resolution
+ int4 key; ///< Context key
+ Record(int4 k,Datatype *dt,int4 fldNum) { baseType = dt; fieldNum = fldNum; key = k; } ///< Constructor
+ bool match(int4 k,Datatype *dt) const { return (key == k && baseType == dt); } ///< Does the given data-type match \b this record
+ };
+ Funcdata &data; ///< Function to which resolutions apply
+ list<Record> resolveList; ///< List of known resolutions
+public:
+ ResolveCache(Funcdata &fd) : data(fd) {} ///< Constructor
+ void addResolution(int4 key,Datatype *dt,PcodeOp *op,int4 slot); ///< Add a specific resolution to the cache
+ Datatype *resolve(int4 key,Datatype *dt) const; ///< Look up the in context resolution for the given data-type
+ void inheritResolution(int4 key,Datatype *dt,int4 off,Varnode *vn,PcodeOp *op,int4 slot) const;
+
+ /// \brief Associate a cached resolution with a Varnode and its new read/write edge
+ ///
+ /// \param key is the context id
+ /// \param vn is the new Varnode inheriting the resolution
+ /// \param op is the PcodeOp reading/writing the Varnode
+ /// \param slot is the read/write edge
+ void inheritResolution(int4 key,Varnode *vn,PcodeOp *op,int4 slot) const {
+ inheritResolution(key,vn->getType(),0,vn,op,slot);
+ }
+};
+
/// Compare based on the data-type, the \b slot, and the PcodeOp's unique id.
/// \param op2 is the other edge to compare with \b this
/// \return \b true if \b this should be ordered before the other edge
diff --git a/Ghidra/Features/Decompiler/src/decompile/cpp/variable.cc b/Ghidra/Features/Decompiler/src/decompile/cpp/variable.cc
index 3c955754a9..93c19fe1ec 100644
--- a/Ghidra/Features/Decompiler/src/decompile/cpp/variable.cc
+++ b/Ghidra/Features/Decompiler/src/decompile/cpp/variable.cc
@@ -389,7 +389,7 @@ Varnode *HighVariable::getTypeRepresentative(void) const
if (vn->isTypeLock())
rep = vn;
}
- else if (0>vn->getType()->typeOrderBool(*rep->getType()))
+ else if (0>vn->getType()->typeOrderFormal(*rep->getType()))
rep = vn;
}
return rep;
diff --git a/Ghidra/Features/Decompiler/src/main/java/ghidra/app/decompiler/ClangFieldToken.java b/Ghidra/Features/Decompiler/src/main/java/ghidra/app/decompiler/ClangFieldToken.java
index 9ae3127742..1bcfce8e45 100644
--- a/Ghidra/Features/Decompiler/src/main/java/ghidra/app/decompiler/ClangFieldToken.java
+++ b/Ghidra/Features/Decompiler/src/main/java/ghidra/app/decompiler/ClangFieldToken.java
@@ -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.
@@ -47,6 +47,11 @@ public class ClangFieldToken extends ClangToken {
return offset;
}
+ @Override
+ public Varnode getVarnode() {
+ return op.getOutput();
+ }
+
@Override
public PcodeOp getPcodeOp() {
return op;
diff --git a/Ghidra/Features/Decompiler/src/main/java/ghidra/app/plugin/core/decompile/actions/ForceUnionAction.java b/Ghidra/Features/Decompiler/src/main/java/ghidra/app/plugin/core/decompile/actions/ForceUnionAction.java
index 587097562c..dde3abb63e 100644
--- a/Ghidra/Features/Decompiler/src/main/java/ghidra/app/plugin/core/decompile/actions/ForceUnionAction.java
+++ b/Ghidra/Features/Decompiler/src/main/java/ghidra/app/plugin/core/decompile/actions/ForceUnionAction.java
@@ -55,6 +55,40 @@ public class ForceUnionAction extends AbstractDecompilerAction {
// setKeyBindingData(new KeyBindingData(KeyEvent.VK_L, 0));
}
+ /**
+ * Find any union data-type associated with the token and return it. Otherwise return null.
+ * @param tokenAtCursor is the decompiler token
+ * @return the union data-type or null
+ */
+ private static Union findUnion(ClangToken tokenAtCursor) {
+ if (tokenAtCursor instanceof ClangFieldToken) {
+ Composite composite = getCompositeDataType(tokenAtCursor);
+ if (composite instanceof Union) {
+ return (Union) composite;
+ }
+ }
+ Varnode vn = tokenAtCursor.getVarnode();
+ if (vn != null) {
+ DataType dt = vn.getHigh().getDataType();
+ if (dt instanceof TypeDef) {
+ dt = ((TypeDef) dt).getBaseDataType();
+ }
+ if (dt instanceof Pointer) {
+ dt = ((Pointer) dt).getDataType();
+ }
+ else if (dt instanceof PartialUnion) {
+ dt = ((PartialUnion) dt).getParent();
+ }
+ if (dt instanceof TypeDef) {
+ dt = ((TypeDef) dt).getBaseDataType();
+ }
+ if (dt instanceof Union)
+ return (Union) dt;
+ }
+ return null;
+
+ }
+
@Override
protected boolean isEnabledForDecompilerContext(DecompilerActionContext context) {
Function function = context.getFunction();
@@ -63,11 +97,7 @@ public class ForceUnionAction extends AbstractDecompilerAction {
}
ClangToken tokenAtCursor = context.getTokenAtCursor();
- if (!(tokenAtCursor instanceof ClangFieldToken)) {
- return false;
- }
- Composite composite = getCompositeDataType(tokenAtCursor);
- return (composite instanceof Union);
+ return findUnion(tokenAtCursor) != null;
}
/**
@@ -147,26 +177,39 @@ public class ForceUnionAction extends AbstractDecompilerAction {
}
return;
}
- }
- else {
- parentDt = null;
- for (accessSlot = 0; accessSlot < accessOp.getNumInputs(); ++accessSlot) {
- accessVn = accessOp.getInput(accessSlot);
- parentDt = typeIsUnionRelated(accessVn);
- if (parentDt != null) {
- break;
- }
- }
+ parentDt = typeIsUnionRelated(accessOp.getOutput()); // Its possible the output of PTRSUB is the union
if (parentDt != null) {
- if (opcode == PcodeOp.SUBPIECE && accessSlot == 0 &&
- !(parentDt instanceof Pointer)) {
- // SUBPIECE acts directly as resolution operator
- // Choose field based on output varnode, even though it isn't the union data-type
- accessSlot = -1;
- accessVn = accessOp.getOutput();
+ accessVn = accessOp.getOutput();
+ accessSlot = -1;
+ PcodeOp readOp = accessVn.getLoneDescend();
+ if (readOp != null && readOp.getOpcode() != PcodeOp.MULTIEQUAL &&
+ readOp.getOpcode() != PcodeOp.INDIRECT) {
+ accessOp = readOp;
+ accessSlot = accessOp.getSlot(accessVn); // Transfer to lone reading Op
+ return;
}
return;
}
+ accessOp = null; // Give up. Could not find union type.
+ return;
+ }
+ parentDt = null;
+ for (accessSlot = 0; accessSlot < accessOp.getNumInputs(); ++accessSlot) {
+ accessVn = accessOp.getInput(accessSlot);
+ parentDt = typeIsUnionRelated(accessVn);
+ if (parentDt != null) {
+ break;
+ }
+ }
+ if (parentDt != null) {
+ if (opcode == PcodeOp.SUBPIECE && accessSlot == 0 &&
+ !(parentDt instanceof Pointer)) {
+ // SUBPIECE acts directly as resolution operator
+ // Choose field based on output varnode, even though it isn't the union data-type
+ accessSlot = -1;
+ accessVn = accessOp.getOutput();
+ }
+ return;
}
accessSlot = -1;
accessVn = accessOp.getOutput();
@@ -262,7 +305,7 @@ public class ForceUnionAction extends AbstractDecompilerAction {
Program program = context.getProgram();
ClangToken tokenAtCursor = context.getTokenAtCursor();
HighFunction highFunction = context.getHighFunction();
- unionDt = (Union) getCompositeDataType(tokenAtCursor);
+ unionDt = findUnion(tokenAtCursor);
determineFacet(tokenAtCursor);
if (accessOp == null || accessVn == null) {
Msg.showError(this, null, "Force Union failed", "Could not recover p-code op");
@@ -280,7 +323,7 @@ public class ForceUnionAction extends AbstractDecompilerAction {
int transaction = program.startTransaction("Force Union");
try {
HighFunctionDBUtil.writeUnionFacet(function, parentDt, fieldNumber, pcAddr,
- dhash.getHash(), SourceType.USER_DEFINED);
+ dhash.getHash(), true, SourceType.USER_DEFINED);
}
catch (DuplicateNameException e) {
Msg.showError(this, null, "Force Union failed", e.getMessage());
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/HighFunctionDBUtil.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/HighFunctionDBUtil.java
index 5e40a6390d..ca5dcf1fed 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/HighFunctionDBUtil.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/HighFunctionDBUtil.java
@@ -877,42 +877,53 @@ public class HighFunctionDBUtil {
/**
* Write a union facet to the database (UnionFacetSymbol). Parameters provide the
* pieces for building the dynamic LocalVariable. This method clears out any preexisting
- * union facet with the same dynamic hash and firstUseOffset.
+ * union facet with the same dynamic hash and firstUseOffset. The new facet can optionally
+ * be "address based", meaning that all reads/writes of the union at the address are
+ * controlled by this single facet.
* @param function is the function affected by the union facet
* @param dt is the parent data-type; a union, a pointer to a union, or a partial union
* @param fieldNum is the ordinal of the desired union field
* @param addr is the first use address of the facet
* @param hash is the dynamic hash
+ * @param isAddr is true if the new facet is address based
* @param source is the SourceType for the LocalVariable
* @throws InvalidInputException if the LocalVariable cannot be created
* @throws DuplicateNameException if the (auto-generated) name is used elsewhere
*/
public static void writeUnionFacet(Function function, DataType dt, int fieldNum, Address addr,
- long hash, SourceType source) throws InvalidInputException, DuplicateNameException {
- if (dt instanceof PartialUnion) {
- dt = ((PartialUnion) dt).getParent();
- }
+ long hash, boolean isAddr, SourceType source)
+ throws InvalidInputException, DuplicateNameException {
int firstUseOffset = (int) addr.subtract(function.getEntryPoint());
- String symbolName = UnionFacetSymbol.buildSymbolName(fieldNum, addr);
boolean nameCollision = false;
Variable[] localVariables =
function.getLocalVariables(VariableFilter.UNIQUE_VARIABLE_FILTER);
- // Clean out any facet symbols with bad data-types
for (int i = 0; i < localVariables.length; ++i) {
Variable var = localVariables[i];
if (var.getName().startsWith(UnionFacetSymbol.BASENAME)) {
- if (!UnionFacetSymbol.isUnionType(var.getDataType())) {
+ if (!UnionFacetSymbol.isUnionType(var.getDataType())) { // Clean out any facet symbols with bad data-types
function.removeVariable(var);
localVariables[i] = null;
}
}
+ else {
+ localVariables[i] = null; // Ignore symbols that aren't facets
+ }
}
+ String symbolName = UnionFacetSymbol.buildSymbolName(fieldNum, addr, isAddr);
Variable preexistingVar = null;
for (Variable var : localVariables) {
if (var == null) {
continue;
}
- if (var.getFirstUseOffset() == firstUseOffset &&
+ if (isAddr && var.getFirstUseOffset() == firstUseOffset) {
+ if (preexistingVar == null) {
+ preexistingVar = var;
+ }
+ else {
+ function.removeVariable(var); // Address based facets override all other facets at the same address
+ }
+ }
+ else if (!isAddr && var.getFirstUseOffset() == firstUseOffset &&
var.getFirstStorageVarnode().getOffset() == hash) {
preexistingVar = var;
}
@@ -920,6 +931,12 @@ public class HighFunctionDBUtil {
nameCollision = true;
}
}
+ if (dt instanceof PartialUnion) {
+ dt = ((PartialUnion) dt).getParent();
+ }
+ if (isAddr && dt instanceof Pointer) {
+ dt = ((Pointer) dt).getDataType();
+ }
if (nameCollision) { // Uniquify the name if necessary
symbolName = symbolName + '_' + Integer.toHexString(DynamicHash.getComparable(hash));
}
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/LocalSymbolMap.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/LocalSymbolMap.java
index 9209d212d1..516717daf5 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/LocalSymbolMap.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/LocalSymbolMap.java
@@ -461,8 +461,7 @@ public class LocalSymbolMap {
}
HighSymbol sym;
if (DynamicHash.getMethodFromHash(hash) > 3 && UnionFacetSymbol.isUnionType(dt)) {
- int fieldNum = UnionFacetSymbol.extractFieldNumber(nm);
- sym = new UnionFacetSymbol(id, nm, dt, fieldNum, func);
+ sym = new UnionFacetSymbol(id, nm, dt, func);
}
else {
sym = new HighSymbol(id, nm, dt, func);
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/UnionFacetSymbol.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/UnionFacetSymbol.java
index 884ca384f2..5101cbb1b6 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/UnionFacetSymbol.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/UnionFacetSymbol.java
@@ -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.
@@ -35,11 +35,13 @@ import ghidra.program.model.data.*;
public class UnionFacetSymbol extends HighSymbol {
public static String BASENAME = "unionfacet";
private int fieldNumber; // Ordinal of field within union being selected
+ private boolean isAddrBased; // Controls facets for any op at the address
- public UnionFacetSymbol(long uniqueId, String nm, DataType dt, int fldNum, HighFunction func) {
+ public UnionFacetSymbol(long uniqueId, String nm, DataType dt, HighFunction func) {
super(uniqueId, nm, dt, func);
category = 2;
- fieldNumber = fldNum;
+ fieldNumber = extractFieldNumber(nm);
+ isAddrBased = extractAddressBased(nm);
}
@Override
@@ -47,6 +49,7 @@ public class UnionFacetSymbol extends HighSymbol {
encoder.openElement(ELEM_FACETSYMBOL);
encodeHeader(encoder);
encoder.writeSignedInteger(ATTRIB_FIELD, fieldNumber);
+ encoder.writeBool(ATTRIB_ADDRTIED, isAddrBased);
dtmanage.encodeTypeRef(encoder, type, getSize());
encoder.closeElement(ELEM_FACETSYMBOL);
}
@@ -55,11 +58,16 @@ public class UnionFacetSymbol extends HighSymbol {
* Generate an automatic symbol name, given a field number and address
* @param fldNum is the field number
* @param addr is the Address
+ * @param isAddr is true if the facet should be address based
* @return the name
*/
- public static String buildSymbolName(int fldNum, Address addr) {
+ public static String buildSymbolName(int fldNum, Address addr, boolean isAddr) {
StringBuilder buffer = new StringBuilder();
- buffer.append(BASENAME).append(fldNum + 1).append('_');
+ buffer.append(BASENAME);
+ if (isAddr) {
+ buffer.append('a');
+ }
+ buffer.append(fldNum + 1).append('_');
buffer.append(Long.toHexString(addr.getOffset()));
return buffer.toString();
}
@@ -74,11 +82,28 @@ public class UnionFacetSymbol extends HighSymbol {
if (pos < 0) {
return -1;
}
+ pos += BASENAME.length();
+ if (nm.length() > pos && nm.charAt(pos) == 'a') {
+ pos = pos + 1;
+ }
int endpos = nm.indexOf('_', pos);
if (endpos < 0) {
return -1;
}
- return Integer.decode(nm.substring(pos + BASENAME.length(), endpos)) - 1;
+ return Integer.decode(nm.substring(pos, endpos)) - 1;
+ }
+
+ /**
+ * First character of 'a' after BASENAME indicates an address based facet
+ * @param nm is the symbol name
+ * @return true if the facet is address based
+ */
+ public static boolean extractAddressBased(String nm) {
+ int pos = nm.indexOf(BASENAME);
+ if (pos < 0 || nm.length() <= pos) {
+ return false;
+ }
+ return nm.charAt(pos + BASENAME.length()) == 'a';
}
/**