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

Merge remote-tracking branch 'origin/patch'

Browse source
This commit is contained in:
Ryan Kurtz 2023-08-04 16:29:16 -04:00
commit d8f61fc7b2
7 changed files with 75 additions and 27 deletions
Download patch file Download diff file Expand all files Collapse all files

23
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumDB.java
View file

@ -112,12 +112,16 @@ class EnumDB extends DataTypeDB implements Enum {
long minValue = valueMap.firstKey();
long maxValue = valueMap.lastKey();
if (maxValue > getMaxPossibleValue(length, true)) {
if (minValue < 0) {
return INVALID;
}
return UNSIGNED;
}
if (minValue < 0) {
return SIGNED;
}
if (maxValue > getMaxPossibleValue(length, true)) {
return UNSIGNED;
}
return NONE; // we have no negatives and no large unsigned values
}
@ -874,6 +878,19 @@ class EnumDB extends DataTypeDB implements Enum {
}
}
@Override
public EnumSignedState getSignedState() {
lock.acquire();
try {
checkIsValid();
initializeIfNeeded();
return signedState;
}
finally {
lock.release();
}
}
@Override
public int getMinimumPossibleLength() {
lock.acquire();

11
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/EnumSignedState.java
View file

@ -18,13 +18,14 @@ package ghidra.program.database.data;
/**
* Keeps track of the signed state of an enum datatype. Enum are fundamentally either signed or
* unsigned, but sometimes you can't tell based on the values they contain. Once a negative value
* is added, then the enum becomes locked as signed, preventing high unsigned values from being
* added. Once a high value unsigned value is added, then it becomes locked as unsigned value. If
* neither a negative value or high unsigned value has been added, then the enum is not locked as
* either signed or unsigned.
* is added, then the enum becomes locked as signed, preventing high unsigned values (those values
* that are too big for signed value of the enum size) from being added. Once a high value unsigned
* value is added, then it becomes locked as unsigned value. If neither a negative value or high
* unsigned value has been added, then the enum is not locked as either signed or unsigned.
*/
public enum EnumSignedState {
SIGNED, // Enum contains at least 1 negative value, preventing high unsigned values
UNSIGNED, // Enum contains at least 1 high unsigned value, preventing negative values
NONE // Enum contains neither a negative or a high unsigned value, so can go either way
NONE, // Enum contains neither a negative or a high unsigned value, so can go either way
INVALID // Enum contains both negative and high unsigned values; can happen with old types
}

7
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/Enum.java
View file

@ -19,6 +19,7 @@ import java.math.BigInteger;
import java.util.NoSuchElementException;
import ghidra.docking.settings.Settings;
import ghidra.program.database.data.EnumSignedState;
public interface Enum extends DataType {
@ -133,6 +134,12 @@ public interface Enum extends DataType {
*/
public boolean isSigned();
/**
* Returns the signed state.
* @return the signed state.
*/
public EnumSignedState getSignedState();
/**
* Returns the maximum value that this enum can represent based on its size and signedness.
* @return the maximum value that this enum can represent based on its size and signedness.

26
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/EnumDataType.java
View file

@ -148,6 +148,11 @@ public class EnumDataType extends GenericDataType implements Enum {
@Override
public void add(String valueName, long value, String comment) {
doAdd(valueName, value, comment);
signedState = computeSignedness();
}
private void doAdd(String valueName, long value, String comment) {
bitGroups = null;
checkValue(value);
if (nameMap.containsKey(valueName)) {
@ -161,8 +166,6 @@ public class EnumDataType extends GenericDataType implements Enum {
if (!StringUtils.isBlank(comment)) {
commentMap.put(valueName, comment);
}
signedState = computeSignedness();
}
private EnumSignedState computeSignedness() {
@ -172,12 +175,16 @@ public class EnumDataType extends GenericDataType implements Enum {
long minValue = valueMap.firstKey();
long maxValue = valueMap.lastKey();
if (maxValue > getMaxPossibleValue(length, true)) {
if (minValue < 0) {
return INVALID;
}
return UNSIGNED;
}
if (minValue < 0) {
return SIGNED;
}
if (maxValue > getMaxPossibleValue(length, true)) {
return UNSIGNED;
}
return NONE; // we have no negatives and no large unsigned values
}
@ -277,6 +284,11 @@ public class EnumDataType extends GenericDataType implements Enum {
return signedState == SIGNED;
}
@Override
public EnumSignedState getSignedState() {
return signedState;
}
@Override
public long getMinPossibleValue() {
return getMinPossibleValue(length, signedState != UNSIGNED);
@ -503,10 +515,10 @@ public class EnumDataType extends GenericDataType implements Enum {
commentMap = new HashMap<>();
setLength(enumm.getLength());
String[] names = enumm.getNames();
signedState = enumm.getSignedState();
for (String valueName : names) {
add(valueName, enumm.getValue(valueName), enumm.getComment(valueName));
doAdd(valueName, enumm.getValue(valueName), enumm.getComment(valueName));
}
computeSignedness();
}
@Override