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

Merge remote-tracking branch 'origin/GP-4356_ghintern_avr8_cspec--SQUASHED'

Browse source
This commit is contained in:
Ryan Kurtz 2025-07-17 06:19:47 -04:00
commit 88bfdeb429
17 changed files with 564 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

23
Ghidra/Features/Decompiler/src/decompile/cpp/fspec.cc
View file

@ -773,14 +773,19 @@ void ParamListStandard::assignMap(const PrototypePieces &proto,TypeFactory &type
if (res.size() == 2) { // Check for hidden parameters defined by the output list
Datatype *dt = res.back().type;
type_class store;
if ((res.back().flags & ParameterPieces::hiddenretparm) != 0)
store = TYPECLASS_HIDDENRET;
else
store = metatype2typeclass(dt->getMetatype());
// Reserve first param for hidden return pointer
if (assignAddressFallback(store,dt,false,status,res.back()) == AssignAction::fail)
if ((res.back().flags & ParameterPieces::hiddenretparm) != 0) {
// Need to pull from registers marked as hiddenret
if (assignAddressFallback(TYPECLASS_HIDDENRET,dt,false,status,res.back()) == AssignAction::fail) {
throw ParamUnassignedError("Cannot assign parameter address for " + res.back().type->getName());
}
}
else {
// Assign as a regular first input pointer parameter
if (assignAddress(dt,proto,0,typefactory,status,res.back()) == AssignAction::fail) {
throw ParamUnassignedError("Cannot assign parameter address for " + res.back().type->getName());
}
}
res.back().flags |= ParameterPieces::hiddenretparm;
}
for(int4 i=0;i<proto.intypes.size();++i) {
@ -1573,9 +1578,11 @@ void ParamListStandardOut::assignMap(const PrototypePieces &proto,TypeFactory &t
res.back().type = typefactory.getTypeVoid();
}
else {
if (assignAddressFallback(TYPECLASS_PTR,pointertp,false,status,res.back()) == AssignAction::fail)
res.back().type = pointertp;
if (assignAddress(pointertp,proto,-1,typefactory,status,res.back()) == AssignAction::fail) {
throw ParamUnassignedError("Cannot assign return value as a pointer");
}
}
res.back().flags = ParameterPieces::indirectstorage;
res.emplace_back(); // Add extra storage location in the input params

5
Ghidra/Features/Decompiler/src/decompile/cpp/marshal.cc
View file

@ -1254,8 +1254,7 @@ AttributeId ATTRIB_WORDSIZE = AttributeId("wordsize",26);
AttributeId ATTRIB_STORAGE = AttributeId("storage",149);
AttributeId ATTRIB_STACKSPILL = AttributeId("stackspill",150);
AttributeId ATTRIB_UNKNOWN = AttributeId("XMLunknown",154); // Number serves as next open index
AttributeId ATTRIB_UNKNOWN = AttributeId("XMLunknown",156); // Number serves as next open index
ElementId ELEM_DATA = ElementId("data",1);
ElementId ELEM_INPUT = ElementId("input",2);
@ -1268,6 +1267,6 @@ ElementId ELEM_VAL = ElementId("val",8);
ElementId ELEM_VALUE = ElementId("value",9);
ElementId ELEM_VOID = ElementId("void",10);
ElementId ELEM_UNKNOWN = ElementId("XMLunknown",288); // Number serves as next open index
ElementId ELEM_UNKNOWN = ElementId("XMLunknown",289); // Number serves as next open index
} // End namespace ghidra

109
Ghidra/Features/Decompiler/src/decompile/cpp/modelrules.cc
View file

@ -20,6 +20,8 @@ namespace ghidra {
AttributeId ATTRIB_SIZES = AttributeId("sizes",151);
AttributeId ATTRIB_MAX_PRIMITIVES = AttributeId("maxprimitives", 153);
AttributeId ATTRIB_REVERSESIGNIF = AttributeId("reversesignif", 154);
AttributeId ATTRIB_MATCHSIZE = AttributeId("matchsize", 155);
ElementId ELEM_DATATYPE = ElementId("datatype",273);
ElementId ELEM_CONSUME = ElementId("consume",274);
@ -34,6 +36,7 @@ ElementId ELEM_HIDDEN_RETURN = ElementId("hidden_return",282);
ElementId ELEM_JOIN_PER_PRIMITIVE = ElementId("join_per_primitive",283);
ElementId ELEM_JOIN_DUAL_CLASS = ElementId("join_dual_class",285);
ElementId ELEM_EXTRA_STACK = ElementId("extra_stack",287);
ElementId ELEM_CONSUME_REMAINING = ElementId("consume_remaining",288);
/// \brief Check that a big Primitive properly overlaps smaller Primitives
///
@ -619,6 +622,29 @@ AssignAction *AssignAction::decodeAction(Decoder &decoder,const ParamListStandar
return action;
}
/// \brief Read the next model rule precondition element from the stream
///
/// Allocate the precondition object corresponding to the element and configure it.
/// If the next element is not a precondition, return null.
/// \param decoder is the stream decoder
/// \param res is the resource set for the new precondition
/// \return the new precondition, or null if no more preconditions are in the stream
AssignAction *AssignAction::decodePrecondition(Decoder &decoder,const ParamListStandard *res)
{
AssignAction *action;
uint4 elemId = decoder.peekElement();
if (elemId == ELEM_CONSUME_EXTRA) {
action = new ConsumeExtra(res);
}
else {
return (AssignAction *)0;
}
action->decode(decoder);
return action;
}
/// \brief Read the next model rule sideeffect element from the stream
///
/// Allocate the sideeffect object corresponding to the element and configure it.
@ -638,6 +664,9 @@ AssignAction *AssignAction::decodeSideeffect(Decoder &decoder,const ParamListSta
else if (elemId == ELEM_EXTRA_STACK) {
action = new ExtraStack(res,0);
}
else if (elemId == ELEM_CONSUME_REMAINING) {
action = new ConsumeRemaining(res);
}
else
throw DecoderError("Expecting model rule sideeffect");
action->decode(decoder);
@ -913,6 +942,10 @@ void MultiSlotAssign::decode(Decoder &decoder)
if (decoder.readBool())
justifyRight = !justifyRight;
}
else if (attribId == ATTRIB_REVERSESIGNIF) {
if (decoder.readBool())
consumeMostSig = !consumeMostSig;
}
else if (attribId == ATTRIB_STORAGE) {
resourceType = string2typeclass(decoder.readString());
}
@ -1218,6 +1251,10 @@ void MultiSlotDualAssign::decode(Decoder &decoder)
if (decoder.readBool())
justifyRight = !justifyRight;
}
else if (attribId == ATTRIB_REVERSESIGNIF) {
if (decoder.readBool())
consumeMostSig = !consumeMostSig;
}
else if (attribId == ATTRIB_STORAGE || attribId == ATTRIB_A) {
baseType = string2typeclass(decoder.readString());
}
@ -1353,6 +1390,61 @@ void ConsumeExtra::decode(Decoder &decoder)
{
uint4 elemId = decoder.openElement(ELEM_CONSUME_EXTRA);
for(;;) {
uint4 attribId = decoder.getNextAttributeId();
if (attribId == 0) break;
else if (attribId == ATTRIB_STORAGE) {
resourceType = string2typeclass(decoder.readString());
}
else if (attribId == ATTRIB_MATCHSIZE) {
matchSize = decoder.readBool();
}
}
decoder.closeElement(elemId);
initializeEntries();
}
/// Find the first ParamEntry matching the \b resourceType.
void ConsumeRemaining::initializeEntries(void)
{
resource->extractTiles(tiles,resourceType);
if (tiles.size() == 0)
throw LowlevelError("Could not find matching resources for action: consume_remaining");
}
ConsumeRemaining::ConsumeRemaining(const ParamListStandard *res)
: AssignAction(res)
{
resourceType = TYPECLASS_GENERAL;
}
ConsumeRemaining::ConsumeRemaining(type_class store,const ParamListStandard *res)
: AssignAction(res)
{
resourceType = store;
initializeEntries();
}
uint4 ConsumeRemaining::assignAddress(Datatype *dt,const PrototypePieces &proto,int4 pos,TypeFactory &tlist,
vector<int4> &status,ParameterPieces &res) const
{
int4 iter = 0;
while(iter != tiles.size()) {
const ParamEntry *entry = tiles[iter];
++iter;
if (status[entry->getGroup()] != 0)
continue; // Already consumed
status[entry->getGroup()] = -1; // Consume the slot/register
}
return success;
}
void ConsumeRemaining::decode(Decoder &decoder)
{
uint4 elemId = decoder.openElement(ELEM_CONSUME_REMAINING);
resourceType = string2typeclass(decoder.readString(ATTRIB_STORAGE));
decoder.closeElement(elemId);
initializeEntries();
@ -1416,6 +1508,8 @@ ModelRule::ModelRule(const ModelRule &op2,const ParamListStandard *res)
assign = op2.assign->clone(res);
else
assign = (AssignAction *)0;
for (int4 i=0;i<op2.preconditions.size();++i)
preconditions.push_back(op2.preconditions[i]->clone(res));
for(int4 i=0;i<op2.sideeffects.size();++i)
sideeffects.push_back(op2.sideeffects[i]->clone(res));
}
@ -1441,6 +1535,8 @@ ModelRule::~ModelRule(void)
delete qualifier;
if (assign != (AssignAction *)0)
delete assign;
for(int4 i=0;i<preconditions.size();++i)
delete preconditions[i];
for(int4 i=0;i<sideeffects.size();++i)
delete sideeffects[i];
}
@ -1467,8 +1563,13 @@ uint4 ModelRule::assignAddress(Datatype *dt,const PrototypePieces &proto,int4 po
if (qualifier != (QualifierFilter *)0 && !qualifier->filter(proto,pos)) {
return AssignAction::fail;
}
uint4 response = assign->assignAddress(dt,proto,pos,tlist,status,res);
vector<int4> tmpStatus = status;
for(int4 i =0;i<preconditions.size();++i) {
preconditions[i]->assignAddress(dt,proto,pos,tlist,tmpStatus,res);
}
uint4 response = assign->assignAddress(dt,proto,pos,tlist,tmpStatus,res);
if (response != AssignAction::fail) {
status = tmpStatus;
for(int4 i=0;i<sideeffects.size();++i) {
sideeffects[i]->assignAddress(dt,proto,pos,tlist,status,res);
}
@ -1499,6 +1600,12 @@ void ModelRule::decode(Decoder &decoder,const ParamListStandard *res)
else {
qualifier = new AndFilter(qualifiers);
}
for (;;) {
AssignAction *precond = AssignAction::decodePrecondition(decoder, res);
if (precond == (AssignAction *)0)
break;
preconditions.push_back(precond);
}
assign = AssignAction::decodeAction(decoder, res);
while(decoder.peekElement() != 0) {
sideeffects.push_back(AssignAction::decodeSideeffect(decoder,res));

25
Ghidra/Features/Decompiler/src/decompile/cpp/modelrules.hh
View file

@ -30,6 +30,8 @@ class ParamActive;
extern AttributeId ATTRIB_SIZES; ///< Marshaling attribute "sizes"
extern AttributeId ATTRIB_MAX_PRIMITIVES; ///< Marshaling attribute "maxprimitives"
extern AttributeId ATTRIB_REVERSESIGNIF; ///< Marshaling attribute "reversesignif"
extern AttributeId ATTRIB_MATCHSIZE; ///< Marshaling attribute "matchsize"
extern ElementId ELEM_DATATYPE; ///< Marshaling element \<datatype>
extern ElementId ELEM_CONSUME; ///< Marshaling element \<consume>
@ -44,6 +46,7 @@ extern ElementId ELEM_HIDDEN_RETURN; ///< Marshaling element \<hidden_return>
extern ElementId ELEM_JOIN_PER_PRIMITIVE; ///< Marshaling element \<join_per_primitive>
extern ElementId ELEM_JOIN_DUAL_CLASS; ///< Marshaling element \<join_dual_class>
extern ElementId ELEM_EXTRA_STACK; ///< Marshaling element \<extra_stack>
extern ElementId ELEM_CONSUME_REMAINING; ///< Marshaling element \<consume_remaining>
/// \brief Class for extracting primitive elements of a data-type
///
@ -311,6 +314,7 @@ public:
/// \param decoder is the given stream decoder
virtual void decode(Decoder &decoder)=0;
static AssignAction *decodeAction(Decoder &decoder,const ParamListStandard *res);
static AssignAction *decodePrecondition(Decoder &decoder, const ParamListStandard *res);
static AssignAction *decodeSideeffect(Decoder &decoder,const ParamListStandard *res);
};
@ -492,6 +496,26 @@ public:
virtual void decode(Decoder &decoder);
};
/// \brief Consume all the remaining registers from a given resource list
///
/// This action is a side-effect and doesn't assign an address for the current parameter.
/// The resource list, resourceType, is specified. If the side-effect is triggered, all register
/// resources from this list are consumed, until no registers remain. If all registers are already
/// consumed, no action is taken.
class ConsumeRemaining : public AssignAction {
type_class resourceType; ///< The other resource list to consume from
vector<const ParamEntry *> tiles; ///< List of registers that can be consumed
void initializeEntries(void); ///< Cache specific ParamEntry needed by the action
public:
ConsumeRemaining(const ParamListStandard *res); ///< Constructor for use with decode
ConsumeRemaining(type_class store, const ParamListStandard *res); ///< Constructor
virtual AssignAction *clone(const ParamListStandard *newResource) const {
return new ConsumeRemaining(resourceType,newResource); }
virtual uint4 assignAddress(Datatype *dt,const PrototypePieces &proto,int4 pos,TypeFactory &tlist,
vector<int4> &status,ParameterPieces &res) const;
virtual void decode(Decoder &decoder);
};
/// \brief A rule controlling how parameters are assigned addresses
///
/// Rules are applied to a parameter in the context of a full function prototype.
@ -502,6 +526,7 @@ class ModelRule {
DatatypeFilter *filter; ///< Which data-types \b this rule applies to
QualifierFilter *qualifier; ///< Additional qualifiers for when the rule should apply (if non-null)
AssignAction *assign; ///< How the Address should be assigned
vector<AssignAction *> preconditions; ///< Extra actions that happen before assignment, discarded on failure
vector<AssignAction *> sideeffects; ///< Extra actions that happen on success
public:
ModelRule(void) {

30
Ghidra/Framework/SoftwareModeling/data/languages/compiler_spec.rxg
View file

@ -379,6 +379,16 @@
</element>
</zeroOrMore>
</interleave>
<zeroOrMore>
<element name="consume_extra">
<attribute name="storage"/>
<optional>
<attribute name="matchsize">
<ref name="boolean_type"/>
</attribute>
</optional>
</element>
</zeroOrMore>
<choice>
<element name="consume">
<attribute name="storage"/>
@ -395,6 +405,11 @@
<ref name="boolean_type"/>
</attribute>
</optional>
<optional>
<attribute name="reversesignif">
<ref name="boolean_type"/>
</attribute>
</optional>
<optional>
<attribute name="align">
<ref name="boolean_type"/>
@ -430,6 +445,11 @@
<ref name="boolean_type"/>
</attribute>
</optional>
<optional>
<attribute name="reversesignif">
<ref name="boolean_type"/>
</attribute>
</optional>
<optional>
<attribute name="storage"/>
</optional>
@ -444,6 +464,16 @@
<zeroOrMore>
<element name="consume_extra">
<attribute name="storage"/>
<optional>
<attribute name="matchsize">
<ref name="boolean_type"/>
</attribute>
</optional>
</element>
</zeroOrMore>
<zeroOrMore>
<element name="consume_remaining">
<attribute name="storage"/>
</element>
</zeroOrMore>
<zeroOrMore>

8
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/ParamListStandard.java
View file

@ -177,14 +177,14 @@ public class ParamListStandard implements ParamList {
if (addAutoParams && res.size() == 2) { // Check for hidden parameters defined by the output list
ParameterPieces last = res.get(res.size() - 1);
StorageClass store;
if (last.hiddenReturnPtr) {
store = StorageClass.HIDDENRET;
// Need to pull from registers marked as hiddenret
assignAddressFallback(StorageClass.HIDDENRET, last.type, false, status, last);
}
else {
store = ParamEntry.getBasicTypeClass(last.type);
// Assign as a regular first input pointer parameter
assignAddress(last.type, proto, 0, dtManager, status, last);
}
assignAddressFallback(store, last.type, false, status, last);
last.hiddenReturnPtr = true;
}
for (int i = 0; i < proto.intypes.size(); ++i) {

3
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/ParamListStandardOut.java
View file

@ -64,9 +64,10 @@ public class ParamListStandardOut extends ParamListStandard {
store.type = VoidDataType.dataType;
}
else {
assignAddressFallback(StorageClass.PTR, pointerType, false, status, store);
store.type = pointerType;
assignAddress(pointerType, proto, -1, dtManager, status, store);
}
store.isIndirect = true; // Signal that there is a hidden return
if (addAutoParams) {
ParameterPieces hiddenRet = new ParameterPieces();

28
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/protorules/AssignAction.java
View file

@ -157,10 +157,38 @@ public abstract class AssignAction {
else if (nm.equals(ELEM_EXTRA_STACK.name())) {
action = new ExtraStack(res, 0);
}
else if (nm.equals(ELEM_CONSUME_REMAINING.name())) {
action = new ConsumeRemaining(res);
}
else {
throw new XmlParseException("Unknown model rule sideeffect: " + nm);
}
action.restoreXml(parser);
return action;
}
/**
* Read the next precondition element from the stream, if it exists. Return the new configured
* AssignAction object. If the next element is not a precondition, return null.
* @param parser is the stream parser
* @param res is the resource set for the new precondition
* @return the new precondition, or null if no more preconditions are in the stream
* @throws XmlParseException if the precondition XML is malformed
*/
static public AssignAction restorePreconditionXml(XmlPullParser parser, ParamListStandard res)
throws XmlParseException {
AssignAction action;
XmlElement elemId = parser.peek();
String nm = elemId.getName();
if (nm.equals(ELEM_CONSUME_EXTRA.name())) {
action = new ConsumeExtra(res);
}
else {
return null;
}
action.restoreXml(parser);
return action;
}
}

13
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/protorules/ConsumeExtra.java
View file

@ -19,12 +19,14 @@ import static ghidra.program.model.pcode.AttributeId.*;
import static ghidra.program.model.pcode.ElementId.*;
import java.io.IOException;
import java.util.Map.Entry;
import ghidra.program.model.data.DataType;
import ghidra.program.model.data.DataTypeManager;
import ghidra.program.model.lang.*;
import ghidra.program.model.pcode.Encoder;
import ghidra.util.exception.InvalidInputException;
import ghidra.util.xml.SpecXmlUtils;
import ghidra.xml.*;
/**
@ -119,13 +121,22 @@ public class ConsumeExtra extends AssignAction {
public void encode(Encoder encoder) throws IOException {
encoder.openElement(ELEM_CONSUME_EXTRA);
encoder.writeString(ATTRIB_STORAGE, resourceType.toString());
encoder.writeBool(ATTRIB_MATCHSIZE, matchSize);
encoder.closeElement(ELEM_CONSUME_EXTRA);
}
@Override
public void restoreXml(XmlPullParser parser) throws XmlParseException {
XmlElement elem = parser.start(ELEM_CONSUME_EXTRA.name());
resourceType = StorageClass.getClass(elem.getAttribute(ATTRIB_STORAGE.name()));
for (Entry<String, String> attrib : elem.getAttributes().entrySet()) {
String name = attrib.getKey();
if (name.equals(ATTRIB_STORAGE.name())) {
resourceType = StorageClass.getClass(attrib.getValue());
}
else if (name.equals(ATTRIB_MATCHSIZE.name())) {
matchSize = SpecXmlUtils.decodeBoolean(attrib.getValue());
}
}
parser.end(elem);
try {
initializeEntries();

128
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/protorules/ConsumeRemaining.java Normal file
View file

@ -0,0 +1,128 @@
/* ###
* IP: GHIDRA
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package ghidra.program.model.lang.protorules;
import static ghidra.program.model.pcode.AttributeId.*;
import static ghidra.program.model.pcode.ElementId.*;
import java.io.IOException;
import ghidra.program.model.data.DataType;
import ghidra.program.model.data.DataTypeManager;
import ghidra.program.model.lang.*;
import ghidra.program.model.pcode.Encoder;
import ghidra.util.exception.InvalidInputException;
import ghidra.xml.*;
/**
* Consume all the remaining registers from a given resource list
*
* This action is a side-effect and doesn't assign an address for the current parameter.
* The resource list, resourceType, is specified. If the side-effect is triggered, all register
* resources from this list are consumed, until no registers remain. If all registers are already
* consumed, no action is taken.
*/
public class ConsumeRemaining extends AssignAction {
private StorageClass resourceType; // The resource list to consume from
private ParamEntry[] tiles; // Registers that can be consumed
/**
* Cache specific ParamEntry needed by the action
* Find the first ParamEntry matching the resourceType
* @throws InvalidInputException if it cannot find the configured ParamEntry objects
*/
private void initializeEntries() throws InvalidInputException {
tiles = resource.extractTiles(resourceType);
if (tiles.length == 0) {
throw new InvalidInputException(
"Could not find matching resources for action: consume_remaining");
}
}
protected ConsumeRemaining(ParamListStandard res) {
super(res);
resourceType = StorageClass.GENERAL;
}
public ConsumeRemaining(StorageClass store, ParamListStandard res)
throws InvalidInputException {
super(res);
resourceType = store;
initializeEntries();
}
@Override
public AssignAction clone(ParamListStandard newResource) throws InvalidInputException {
return new ConsumeRemaining(resourceType, newResource);
}
@Override
public boolean isEquivalent(AssignAction op) {
if (this.getClass() != op.getClass()) {
return false;
}
ConsumeRemaining otherAction = (ConsumeRemaining) op;
if (resourceType != otherAction.resourceType) {
return false;
}
if (tiles.length != otherAction.tiles.length) {
return false;
}
for (int i = 0; i < tiles.length; ++i) {
if (!tiles[i].isEquivalent(otherAction.tiles[i])) {
return false;
}
}
return true;
}
@Override
public int assignAddress(DataType dt, PrototypePieces proto, int pos, DataTypeManager dtManager,
int[] status, ParameterPieces res) {
int iter = 0;
while (iter != tiles.length) {
ParamEntry entry = tiles[iter];
++iter;
if (status[entry.getGroup()] != 0) {
continue; // Already consumed
}
status[entry.getGroup()] = -1;
}
return SUCCESS;
}
@Override
public void encode(Encoder encoder) throws IOException {
encoder.openElement(ELEM_CONSUME_REMAINING);
encoder.writeString(ATTRIB_STORAGE, resourceType.toString());
encoder.closeElement(ELEM_CONSUME_REMAINING);
}
@Override
public void restoreXml(XmlPullParser parser) throws XmlParseException {
XmlElement elem = parser.start(ELEM_CONSUME_REMAINING.name());
resourceType = StorageClass.getClass(elem.getAttribute(ATTRIB_STORAGE.name()));
parser.end(elem);
try {
initializeEntries();
}
catch (InvalidInputException e) {
throw new XmlParseException(e.getMessage());
}
}
}

38
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/protorules/ModelRule.java
View file

@ -39,6 +39,7 @@ public class ModelRule {
private DatatypeFilter filter; // Which data-types this rule applies to
private QualifierFilter qualifier; // Additional qualifiers for when the rule should apply (if non-null)
private AssignAction assign; // How the Address should be assigned
private AssignAction[] preconditions; // Extra actions that happen before assignment, discarded on failure
private AssignAction[] sideeffects; // Extra actions that happen on success
public ModelRule() {
@ -72,6 +73,12 @@ public class ModelRule {
else {
assign = null;
}
preconditions = new AssignAction[op2.preconditions.length];
for (int i = 0; i < op2.preconditions.length; ++i) {
preconditions[i] = op2.preconditions[i].clone(res);
}
sideeffects = new AssignAction[op2.sideeffects.length];
for (int i = 0; i < op2.sideeffects.length; ++i) {
sideeffects[i] = op2.sideeffects[i].clone(res);
@ -94,6 +101,7 @@ public class ModelRule {
filter = typeFilter.clone();
qualifier = null;
assign = action.clone(res);
preconditions = new AssignAction[0];
sideeffects = new AssignAction[0];
}
@ -131,6 +139,14 @@ public class ModelRule {
else {
return false;
}
if (preconditions.length != op.preconditions.length) {
return false;
}
for (int i = 0; i < preconditions.length; ++i) {
if (!preconditions[i].isEquivalent(op.preconditions[i])) {
return false;
}
}
if (sideeffects.length != op.sideeffects.length) {
return false;
}
@ -165,8 +181,15 @@ public class ModelRule {
if (qualifier != null && !qualifier.filter(proto, pos)) {
return AssignAction.FAIL;
}
int response = assign.assignAddress(dt, proto, pos, dtManager, status, res);
int[] tmpStatus = status.clone();
for (int i = 0; i < preconditions.length; ++i) {
preconditions[i].assignAddress(dt, proto, pos, dtManager, tmpStatus, res);
}
int response = assign.assignAddress(dt, proto, pos, dtManager, tmpStatus, res);
if (response != AssignAction.FAIL) {
System.arraycopy(tmpStatus, 0, status, 0, tmpStatus.length);
for (int i = 0; i < sideeffects.length; ++i) {
sideeffects[i].assignAddress(dt, proto, pos, dtManager, status, res);
}
@ -185,6 +208,9 @@ public class ModelRule {
if (qualifier != null) {
qualifier.encode(encoder);
}
for (int i = 0; i < preconditions.length; ++i) {
preconditions[i].encode(encoder);
}
assign.encode(encoder);
for (int i = 0; i < sideeffects.length; ++i) {
sideeffects[i].encode(encoder);
@ -222,6 +248,16 @@ public class ModelRule {
else {
qualifier = new AndFilter(qualifierList);
}
ArrayList<AssignAction> preList = new ArrayList<>();
for (;;) {
AssignAction preAction = AssignAction.restorePreconditionXml(parser, res);
if (preAction == null) {
break;
}
preList.add(preAction);
}
preconditions = new AssignAction[preList.size()];
preList.toArray(preconditions);
assign = AssignAction.restoreActionXml(parser, res);
ArrayList<AssignAction> sideList = new ArrayList<>();
for (;;) {

8
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/protorules/MultiSlotAssign.java
View file

@ -267,6 +267,9 @@ public class MultiSlotAssign extends AssignAction {
if (resource.getEntry(0).isBigEndian() != justifyRight) {
encoder.writeBool(ATTRIB_REVERSEJUSTIFY, true);
}
if (resource.getEntry(0).isBigEndian() != consumeMostSig) {
encoder.writeBool(ATTRIB_REVERSESIGNIF, true);
}
if (resourceType != StorageClass.GENERAL) {
encoder.writeString(ATTRIB_STORAGE, resourceType.toString());
}
@ -286,6 +289,11 @@ public class MultiSlotAssign extends AssignAction {
justifyRight = !justifyRight;
}
}
else if (name.equals(ATTRIB_REVERSESIGNIF.name())) {
if (SpecXmlUtils.decodeBoolean(attrib.getValue())) {
consumeMostSig = !consumeMostSig;
}
}
else if (name.equals(ATTRIB_STORAGE.name())) {
resourceType = StorageClass.getClass(attrib.getValue());
}

8
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/lang/protorules/MultiSlotDualAssign.java
View file

@ -262,6 +262,9 @@ public class MultiSlotDualAssign extends AssignAction {
if (resource.getEntry(0).isBigEndian() != justifyRight) {
encoder.writeBool(ATTRIB_REVERSEJUSTIFY, true);
}
if (resource.getEntry(0).isBigEndian() != consumeMostSig) {
encoder.writeBool(ATTRIB_REVERSESIGNIF, true);
}
if (baseType != StorageClass.GENERAL) {
encoder.writeString(ATTRIB_STORAGE, baseType.toString());
}
@ -281,6 +284,11 @@ public class MultiSlotDualAssign extends AssignAction {
justifyRight = !justifyRight;
}
}
else if (name.equals(ATTRIB_REVERSESIGNIF.name())) {
if (SpecXmlUtils.decodeBoolean(attrib.getValue())) {
consumeMostSig = !consumeMostSig;
}
}
else if (name.equals(ATTRIB_STORAGE.name()) || name.equals(ATTRIB_A.name())) {
baseType = StorageClass.getClass(attrib.getValue());
}

4
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/AttributeId.java
View file

@ -249,6 +249,8 @@ public record AttributeId(String name, int id) {
public static final AttributeId ATTRIB_BACKFILL = new AttributeId("backfill", 152);
public static final AttributeId ATTRIB_MAX_PRIMITIVES = new AttributeId("maxprimitives", 153);
public static final AttributeId ATTRIB_REVERSESIGNIF = new AttributeId("reversesignif", 154);
public static final AttributeId ATTRIB_MATCHSIZE = new AttributeId("matchsize", 155);
public static final AttributeId ATTRIB_UNKNOWN = new AttributeId("XMLunknown", 154);
public static final AttributeId ATTRIB_UNKNOWN = new AttributeId("XMLunknown", 156);
}

3
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/pcode/ElementId.java
View file

@ -457,6 +457,7 @@ public record ElementId(String name, int id) {
new ElementId("join_per_primitive", 283);
public static final ElementId ELEM_JOIN_DUAL_CLASS = new ElementId("join_dual_class", 285);
public static final ElementId ELEM_EXTRA_STACK = new ElementId("extra_stack", 287);
public static final ElementId ELEM_CONSUME_REMAINING = new ElementId("consume_remaining", 288);
public static final ElementId ELEM_UNKNOWN = new ElementId("XMLunknown", 288);
public static final ElementId ELEM_UNKNOWN = new ElementId("XMLunknown", 289);
}

143
Ghidra/Processors/Atmel/data/languages/avr8gcc.cspec
View file

@ -40,49 +40,140 @@
<default_proto>
<prototype name="__stdcall" extrapop="2" stackshift="2">
<input>
<pentry minsize="1" maxsize="2">
<register name="R25R24"/>
<pentry minsize="1" maxsize="1">
<register name="R25"/>
</pentry>
<pentry minsize="1" maxsize="2">
<register name="R23R22"/>
<pentry minsize="1" maxsize="1">
<register name="R24"/>
</pentry>
<pentry minsize="1" maxsize="2">
<register name="R21R20"/>
<pentry minsize="1" maxsize="1">
<register name="R23"/>
</pentry>
<pentry minsize="1" maxsize="2">
<register name="R19R18"/>
<pentry minsize="1" maxsize="1">
<register name="R22"/>
</pentry>
<pentry minsize="1" maxsize="2">
<register name="R17R16"/>
<pentry minsize="1" maxsize="1">
<register name="R21"/>
</pentry>
<pentry minsize="1" maxsize="2">
<register name="R15R14"/>
<pentry minsize="1" maxsize="1">
<register name="R20"/>
</pentry>
<pentry minsize="1" maxsize="2">
<register name="R13R12"/>
<pentry minsize="1" maxsize="1">
<register name="R19"/>
</pentry>
<pentry minsize="1" maxsize="2">
<register name="R11R10"/>
<pentry minsize="1" maxsize="1">
<register name="R18"/>
</pentry>
<pentry minsize="1" maxsize="2">
<register name="R9R8"/>
<pentry minsize="1" maxsize="1">
<register name="R17"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R16"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R15"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R14"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R13"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R12"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R11"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R10"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R9"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R8"/>
</pentry>
<!-- Currently messes up parameter allocation, for known data types bigger than 2 -->
<!-- strategy="packreg" planned to mitigate this problem -->
<pentry minsize="1" maxsize="500" align="1">
<addr offset="3" space="stack"/>
</pentry>
<!-- In a varargs function, everything is unconditionally on the stack -->
<rule>
<datatype name="any"/>
<varargs/>
<goto_stack/>
</rule>
<!-- Arguments are passed entirely in registers if possible, else entirely on stack -->
<!-- Odd-sized types are rounded to the next even register number for assignment -->
<rule>
<datatype name="any" sizes="1,3,5,7,9,11,13,15,17"/>
<consume_extra storage="general" matchsize="false"/>
<join stackspill="false" reversesignif="true"/>
</rule>
<rule>
<datatype name="any"/>
<join stackspill="false" reversesignif="true"/>
</rule>
<!-- Once any argument is passed on the stack, do not return to register allocation -->
<rule>
<datatype name="any"/>
<goto_stack/>
<consume_remaining storage="general"/>
</rule>
</input>
<output>
<pentry minsize="1" maxsize="2">
<register name="R25R24"/>
<pentry minsize="1" maxsize="1">
<register name="R25"/>
</pentry>
<pentry minsize="3" maxsize="4">
<addr space="join" piece1="R25R24" piece2="R23R22"/>
<pentry minsize="1" maxsize="1">
<register name="R24"/>
</pentry>
<pentry minsize="5" maxsize="8">
<addr space="join" piece1="R25R24" piece2="R23R22" piece3="R21R20" piece4="R19R18"/>
<pentry minsize="1" maxsize="1">
<register name="R23"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R22"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R21"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R20"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R19"/>
</pentry>
<pentry minsize="1" maxsize="1">
<register name="R18"/>
</pentry>
<!-- return value sizes are padded up to the nearest power of two -->
<rule>
<datatype name="any" sizes="1,3,7"/>
<consume_extra storage="general" matchsize="false"/>
<join reversesignif="true"/>
</rule>
<rule>
<datatype name="any" minsize="5" maxsize="5"/>
<consume_extra storage="general" matchsize="false"/>
<consume_extra storage="general" matchsize="false"/>
<consume_extra storage="general" matchsize="false"/>
<join reversesignif="true"/>
</rule>
<rule>
<datatype name="any" minsize="6" maxsize="6"/>
<consume_extra storage="general" matchsize="false"/>
<consume_extra storage="general" matchsize="false"/>
<join reversesignif="true"/>
</rule>
<rule>
<datatype name="any"/>
<join reversesignif="true"/>
</rule>
</output>
<unaffected>
<register name="SP"/>

19
Ghidra/Processors/Atmel/src/main/java/ghidra/app/util/bin/format/elf/extend/AVR8_ElfExtension.java
View file

@ -16,6 +16,7 @@
package ghidra.app.util.bin.format.elf.extend;
import ghidra.app.util.bin.format.elf.*;
import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressSpace;
import ghidra.program.model.lang.Language;
@ -74,4 +75,22 @@ public class AVR8_ElfExtension extends ElfExtension {
return elfOffset;
}
@Override
public Address evaluateElfSymbol(ElfLoadHelper elfLoadHelper, ElfSymbol elfSymbol,
Address address, boolean isExternal) {
if (!address.getAddressSpace().getName().equals("code")) {
return address;
}
if (isExternal) {
return address;
}
// st_value should be the byte offset into the code space, not word offset
// address - (st_value * 2) is the base address of symbols in the code space
return address.getAddressSpace()
.getAddress(address.subtract(elfSymbol.getValue() << 1).getOffset() +
elfSymbol.getValue());
}
}