Ghidra is a software reverse engineering (SRE) framework
GP-7307 Corrected data type merge conflict fixup
ghidra16c6f274d91fa
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/merge/datatypes/DataTypeMergeManager.java b/Ghidra/Features/Base/src/main/java/ghidra/app/merge/datatypes/DataTypeMergeManager.javaindex 05d6ca7113..472dfbb50f 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/merge/datatypes/DataTypeMergeManager.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/merge/datatypes/DataTypeMergeManager.java@@ -529,7 +529,7 @@ public class DataTypeMergeManager implements MergeResolver {}sb.append(dt.getDisplayName());sb.append(", ");- if (info.resultOrdinal < 0) {+ if (info.resultIndex < 0) {if (dt instanceof FunctionDefinition) {sb.append("return-type");}@@ -540,25 +540,25 @@ public class DataTypeMergeManager implements MergeResolver {else {if (dt instanceof FunctionDefinition) {sb.append("param-");- sb.append(info.resultOrdinal);+ sb.append(info.resultIndex);}else if (dt instanceof Union) {sb.append("component-");- sb.append(info.resultOrdinal);+ sb.append(info.resultIndex);}else if (dt instanceof Structure) {Structure resultStruct = (Structure) info.ht.get(info.id);- sb.append("component-");- sb.append(info.resultOrdinal);+ sb.append("defined-component-");+ sb.append(info.resultIndex);if (!resultStruct.isPackingEnabled()) {- sb.append(", offset-");+ sb.append(", source-offset-");sb.append("0x");sb.append(Integer.toHexString(info.offset));}}else {- sb.append("resultOrdinal-"); // unknown use case- sb.append(info.resultOrdinal);+ sb.append("resultIndex-"); // unknown use case+ sb.append(info.resultIndex);}}@@ -1234,6 +1234,38 @@ public class DataTypeMergeManager implements MergeResolver {return nextOrdinal;}+ /**+ * Get the index of a defined component in the structure's defined-component sequence.+ * Unlike its ordinal, this index is unaffected by changes to implicit undefined bytes.+ * @param struct destination structure+ * @param component newly inserted defined component+ * @return index in the destination's defined-component sequence+ */+ private static int getDefinedComponentIndex(Structure struct, DataTypeComponent component) {+ if (component.getDataType() == DataType.DEFAULT) {+ throw new IllegalArgumentException("Expected defined component");+ }+ int ordinal = component.getOrdinal();+ int low = 0;+ int high = struct.getNumDefinedComponents() - 1;+ // Defined components have unique, increasing ordinals even when offsets overlap.+ while (low <= high) {+ int mid = low + (high - low) / 2;+ int midOrdinal = struct.getDefinedComponent(mid).getOrdinal();+ if (midOrdinal < ordinal) {+ low = mid + 1;+ }+ else if (midOrdinal > ordinal) {+ high = mid - 1;+ }+ else {+ return mid;+ }+ }+ throw new AssertException(+ "Expected defined component at ordinal " + ordinal + " in " + struct.getPathName());+ }+private void updateStructure(long sourceDtID, Structure sourceDt, Structure destStruct,MyIdentityHashMap<Long, DataType> resolvedDataTypes) {@@ -1434,15 +1466,14 @@ public class DataTypeMergeManager implements MergeResolver {}}else if (packed) {- // Add fixup placeholder to prevent the ordinal values and component sizes from- // changing. Nothing we can do about packing which may be affected.- // These should get fixed-up later.+ // Preserve a defined component for later fixup. Packing and dependency size+ // changes may alter its offset and ordinal, but not its defined-component index.resultComp = destStruct.add(BadDataType.dataType, sourceComp.getLength(),sourceComp.getFieldName(), comment);}else {- // Add fixup placeholder to prevent the ordinal values and component sizes from- // changing. These should get fixed-up later.+ // Preserve a defined component and its reserved space for later fixup.+ // Changes to preceding undefined bytes may alter its ordinal.resultComp = destStruct.insertAtOffset(sourceComp.getOffset(), BadDataType.dataType,sourceComp.getLength(), sourceComp.getFieldName(), comment);}@@ -1450,7 +1481,7 @@ public class DataTypeMergeManager implements MergeResolver {if (fixupRequired) {// Component datatype has not been added/resolved yet, put an entry in the fixup listfixUpList.add(new FixUpInfo(sourceDtID, sourceComponentID,- resultComp.getOrdinal(), sourceComp, resolvedDataTypes));+ getDefinedComponentIndex(destStruct, resultComp), sourceComp, resolvedDataTypes));fixUpIDSet.add(sourceDtID);}}@@ -1607,7 +1638,7 @@ public class DataTypeMergeManager implements MergeResolver {}}else {- // Add fixup placeholder to prevent the ordinal values and component sizes from+ // Add fixup placeholder to prevent the ordinal values and component sizes from// changing. Nothing we can do about packing which may be affected.// These should get fixed-up later.destUnion.add(BadDataType.dataType, sourceComp.getLength(),@@ -2470,7 +2501,7 @@ public class DataTypeMergeManager implements MergeResolver {/*** NOTE: It is important that fixups for a Structure are processed bottom-up- * (i.e., last-ordinal to first-ordinal) to ensure that subsequent fixup ordinal+ * (i.e., last defined-component index to first) to ensure that subsequent fixup* indexes remain valid even after components are removed as a result of processing* a Structure fixup.*/@@ -2542,22 +2573,22 @@ public class DataTypeMergeManager implements MergeResolver {long lastChangeTime = fd.getLastChangeTime(); // Don't let the time change.try {if (dt != null) {- if (info.resultOrdinal < 0) { // -1 for return type+ if (info.resultIndex < 0) { // -1 for return typefd.setReturnType(dt);}else {ParameterDefinition[] args = fd.getArguments();- args[info.resultOrdinal].setDataType(dt);+ args[info.resultIndex].setDataType(dt);}return true;}- if (info.resultOrdinal < 0) { // -1 for return type+ if (info.resultIndex < 0) { // -1 for return type// nowhere to set error comment}else {ParameterDefinition[] args = fd.getArguments();- ParameterDefinition arg = args[info.resultOrdinal];+ ParameterDefinition arg = args[info.resultIndex];String comment =buildDataTypeFailureComment(info.componentDataType, null, arg.getComment());arg.setComment(comment);@@ -2577,16 +2608,8 @@ public class DataTypeMergeManager implements MergeResolver {* @return false if component not found, else true*/private boolean fixUpPackedStructureComponent(FixUpInfo info, Structure struct, DataType dt) {- int ordinal = info.resultOrdinal;-- DataTypeComponent dtc;- if (ordinal >= 0 || ordinal < struct.getNumComponents()) {- dtc = struct.getComponent(ordinal);- }- else {- throw new AssertException(- "Expected fixup component at ordinal " + ordinal + " in " + struct.getPathName());- }+ DataTypeComponent dtc = getStructureFixupComponent(info, struct);+ int ordinal = dtc.getOrdinal();long lastChangeTime = struct.getLastChangeTime(); // Don't let the time change.try {@@ -2674,16 +2697,8 @@ public class DataTypeMergeManager implements MergeResolver {private boolean fixUpNonPackedStructureComponent(FixUpInfo info, Structure struct,DataType dt) {- int ordinal = info.resultOrdinal;-- DataTypeComponent dtc;- if (ordinal >= 0 || ordinal < struct.getNumComponents()) {- dtc = struct.getComponent(ordinal);- }- else {- throw new AssertException(- "Expected fixup component at ordinal " + ordinal + " in " + struct.getPathName());- }+ DataTypeComponent dtc = getStructureFixupComponent(info, struct);+ int ordinal = dtc.getOrdinal();long lastChangeTime = struct.getLastChangeTime(); // Don't let the time change.try {@@ -2760,6 +2775,21 @@ public class DataTypeMergeManager implements MergeResolver {return true;}+ /**+ * Locate a fixup after dependency resolution, which may have changed the structure's layout.+ * Do not retain component instances or ordinals across fixups or packing changes.+ * @param info fixup identifying a defined component+ * @param struct current result structure+ * @return current component to fix up+ */+ private static DataTypeComponent getStructureFixupComponent(FixUpInfo info, Structure struct) {+ if (info.resultIndex < 0 || info.resultIndex >= struct.getNumDefinedComponents()) {+ throw new AssertException("Expected fixup component at defined-component index " ++ info.resultIndex + " in " + struct.getPathName());+ }+ return struct.getDefinedComponent(info.resultIndex);+ }+/*** Fix up the structure using the fix up info for a component.* @param info fixup info@@ -2780,10 +2810,11 @@ public class DataTypeMergeManager implements MergeResolver {String loc;if (struct.isPackingEnabled()) {- loc = "ordinal " + info.resultOrdinal;+ loc = "defined-component index " + info.resultIndex;}else {- loc = "offset 0x" + Integer.toHexString(info.offset);+ loc = "defined-component index " + info.resultIndex + " (source offset 0x" ++ Integer.toHexString(info.offset) + ")";}Msg.warn(this, "Structure Merge: Failed to resolve data type '" +info.componentDataType.getName() + "' at " + loc + " in " + struct.getPathName());@@ -2794,7 +2825,7 @@ public class DataTypeMergeManager implements MergeResolver {DataType compDt = resolve(info.compID, info.getDataTypeManager(), info.ht);- int ordinal = info.resultOrdinal;+ int ordinal = info.resultIndex;DataTypeComponent dtc = null;if (ordinal >= 0 && ordinal <= union.getNumComponents()) {@@ -2865,7 +2896,7 @@ public class DataTypeMergeManager implements MergeResolver {}Msg.warn(this,"Union Merge: Failed to resolve data type '" + info.componentDataType.getName() +- "' at ordinal " + info.resultOrdinal + " in " + union.getPathName());+ "' at ordinal " + info.resultIndex + " in " + union.getPathName());return false;}@@ -2889,7 +2920,7 @@ public class DataTypeMergeManager implements MergeResolver {FixUpInfo info = fixUpList.get(i); // assume info applies to unionif (!fixUpUnionComponent(union, info)) {Msg.warn(this, "Union Merge: Failed to apply data type at ordinal " +- info.resultOrdinal + " in " + union.getPathName());+ info.resultIndex + " in " + union.getPathName());unresolvedFixups.add(info);}}@@ -3427,10 +3458,12 @@ public class DataTypeMergeManager implements MergeResolver {final long compID; // Source datatype ID for componentfinal DataType componentDataType; // Source component datatype- // Result ordinal when id represents a container such as a structure/union or- // function definition. In such cases, 'compID' corresponds to the component datatype.- // A -1 may be used when not applicable.- final int resultOrdinal;+ // Result defined-component index for a structure, component ordinal for a union,+ // or parameter index for a function definition. A -1 denotes a return type or+ // a dependency without a component index. Structure indexes exclude implicit+ // undefined bytes and survive layout changes, but must be regenerated when the+ // selected definition is rebuilt (see removeFixUps).+ final int resultIndex;final MyIdentityHashMap<Long, DataType> ht;@@ -3449,16 +3482,16 @@ public class DataTypeMergeManager implements MergeResolver {* @param id source data type ID needing to be fixed up* @param compID source datatype ID of either param/component or bitfield base type* @param componentDataType source component/dependency datatype- * @param resultOrdinal the result ordinal into a structure/union; or- * parameter/return ordinal; or -1 for other cases where index is not used+ * @param resultIndex result defined-component index for a structure, union component+ * ordinal, function parameter index, or -1 for a return type/other dependency* @param resolvedDataTypes hashtable used for resolving the data type*/- FixUpInfo(long id, long compID, DataType componentDataType, int resultOrdinal,+ FixUpInfo(long id, long compID, DataType componentDataType, int resultIndex,MyIdentityHashMap<Long, DataType> resolvedDataTypes) {this.id = id;this.compID = compID;this.componentDataType = componentDataType;- this.resultOrdinal = resultOrdinal;+ this.resultIndex = resultIndex;this.ht = resolvedDataTypes;if (componentDataType instanceof BitFieldDataType) {@@ -3472,13 +3505,13 @@ public class DataTypeMergeManager implements MergeResolver {* or components were resolved.* @param id id of data type needing to be fixed up* @param compID datatype ID of either param/component or bitfield base type- * @param resultOrdinal component ordinal within result composite+ * @param resultIndex defined-component index within a result structure or ordinal in a union* @param sourceDtc associated composite datatype component* @param resolvedDataTypes hashtable used for resolving the data type*/- FixUpInfo(long id, long compID, int resultOrdinal, DataTypeComponent sourceDtc,+ FixUpInfo(long id, long compID, int resultIndex, DataTypeComponent sourceDtc,MyIdentityHashMap<Long, DataType> resolvedDataTypes) {- this(id, compID, getDataType(sourceDtc), resultOrdinal, resolvedDataTypes);+ this(id, compID, getDataType(sourceDtc), resultIndex, resolvedDataTypes);offset = sourceDtc.getOffset();if (sourceDtc.isBitFieldComponent()) {BitFieldDataType bfDt = (BitFieldDataType) sourceDtc.getDataType();@@ -3497,11 +3530,11 @@ public class DataTypeMergeManager implements MergeResolver {@Overridepublic int compareTo(FixUpInfo o) {- // Compare such that items are grouped by id and sort such that the greatest resultOrdinal+ // Compare such that items are grouped by id and sort such that the greatest resultIndex// is first within that group.long c = id - o.id;if (c == 0) {- c = Integer.toUnsignedLong(o.resultOrdinal) - Integer.toUnsignedLong(resultOrdinal);+ c = Integer.toUnsignedLong(o.resultIndex) - Integer.toUnsignedLong(resultIndex);}if (c == 0) {return 0;@@ -3527,7 +3560,7 @@ public class DataTypeMergeManager implements MergeResolver {}return "\n" + "ID = " + Long.toHexString(id) + ",\ndt = " + dtm.getDataType(id) +",\ncomponent ID = " + Long.toHexString(compID) + ",\ncomponent dt = " +- dtm.getDataType(compID) + ",\nresultOrdinal = " + resultOrdinal + ",\n" + bitInfo ++ dtm.getDataType(compID) + ",\nresultIndex = " + resultIndex + ",\n" + bitInfo +"ht = " +htStr + "\n";}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/stackeditor/StackFrameDataType.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/stackeditor/StackFrameDataType.javaindex 4e2746bbde..cb6f2b47b3 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/stackeditor/StackFrameDataType.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/stackeditor/StackFrameDataType.java@@ -1098,6 +1098,12 @@ class StackFrameDataType implements Structure {return dtc != null ? new StackComponentWrapper(dtc) : null;}+ @Override+ public DataTypeComponent getDefinedComponent(int index) throws IndexOutOfBoundsException {+ DataTypeComponent dtc = wrappedStruct.getDefinedComponent(index);+ return new StackComponentWrapper(dtc);+ }+@Overridepublic StackComponentWrapper getComponent(int ordinal) throws IndexOutOfBoundsException {DataTypeComponent dtc = wrappedStruct.getComponent(ordinal);diff --git a/Ghidra/Features/Base/src/test.slow/java/ghidra/app/merge/datatypes/DataTypeMerge4Test.java b/Ghidra/Features/Base/src/test.slow/java/ghidra/app/merge/datatypes/DataTypeMerge4Test.javaindex d030a52822..0e7a169719 100644--- a/Ghidra/Features/Base/src/test.slow/java/ghidra/app/merge/datatypes/DataTypeMerge4Test.java+++ b/Ghidra/Features/Base/src/test.slow/java/ghidra/app/merge/datatypes/DataTypeMerge4Test.java@@ -1169,6 +1169,72 @@ public class DataTypeMerge4Test extends AbstractDataTypeMergeTest {checkConflictCount(0);}+ @Test+ public void testMultiEdits14() throws Exception {++ mtf.initialize("notepad2", new ProgramModifierListener() {+ @Override+ public void modifyLatest(ProgramDB program) {+ DataTypeManager dtm = program.getDataTypeManager();+ Structure bar = (Structure) dtm.getDataType(new CategoryPath("/MISC"), "Bar");++ // Create a conflict while retaining Bar's original six-byte length.+ assertEquals(6, bar.getLength());+ bar.getComponent(0).setComment("Latest Bar component");++ int junk = 0;+ }++ @Override+ public void modifyPrivate(ProgramDB program) {+ DataTypeManager dtm = program.getDataTypeManager();+ CategoryPath path = new CategoryPath("/MISC");+ Structure bar = (Structure) dtm.getDataType(path, "Bar");+ bar.delete(1); // Remove the pointer, shrinking Bar from six bytes to two.+ assertEquals(2, bar.getLength());++ // Allocate the container before its target so that the merge records a fixup+ // for the as-yet-unresolved target when processing the added container.+ Structure container = (Structure) dtm.addDataType(+ new StructureDataType(path, "FixupContainer", 0),+ DataTypeConflictHandler.DEFAULT_HANDLER);+ Structure target = new StructureDataType(path, "FixupTarget", 0);+ target.add(ByteDataType.dataType);+ target = (Structure) dtm.addDataType(target, DataTypeConflictHandler.DEFAULT_HANDLER);++ container.add(bar, "bar", null);+ container.growStructure(4);+ container.add(target, "target", null);+ assertFalse(container.isPackingEnabled());+ assertEquals(6, container.getComponent(5).getOffset());++ int junk = 0;+ }+ });++ executeMerge();+ DataTypeManager dtm = resultProgram.getDataTypeManager();++ // The added container initially uses Latest's six-byte Bar, so the placeholder+ // at offset 6 has ordinal 1. Choosing MY Bar shrinks that component to two bytes,+ // introducing four undefined components before the placeholder. Its ordinal is+ // now 5, but FixUpInfo still records 1. The merge must not use that stale ordinal.+ chooseOption(DataTypeMergeManager.OPTION_MY);+ waitForCompletion();++ Structure bar = (Structure) dtm.getDataType(new CategoryPath("/MISC"), "Bar");+ Structure container =+ (Structure) dtm.getDataType(new CategoryPath("/MISC"), "FixupContainer");+ DataType target = dtm.getDataType(new CategoryPath("/MISC"), "FixupTarget");+ assertEquals(2, bar.getLength());+ assertEquals(7, container.getLength());+ assertEquals(2, container.getNumDefinedComponents());+ assertEquals(bar, container.getComponent(0).getDataType());+ assertEquals(6, container.getComponent(5).getOffset());+ assertEquals(target, container.getComponent(5).getDataType());+ checkConflictCount(0);+ }+@Testpublic void testDeletedBaseTypeDef() throws Exception {diff --git a/Ghidra/Features/Base/src/test.slow/java/ghidra/app/merge/datatypes/DataTypeMergeFixupTest.java b/Ghidra/Features/Base/src/test.slow/java/ghidra/app/merge/datatypes/DataTypeMergeFixupTest.javaindex 99049264df..bb23ee93e4 100644--- a/Ghidra/Features/Base/src/test.slow/java/ghidra/app/merge/datatypes/DataTypeMergeFixupTest.java+++ b/Ghidra/Features/Base/src/test.slow/java/ghidra/app/merge/datatypes/DataTypeMergeFixupTest.java@@ -28,6 +28,107 @@ import ghidra.program.model.data.*;*/public class DataTypeMergeFixupTest extends AbstractDataTypeMergeTest {+ @Test+ public void testDefinedComponentFixupAfterResize() throws Exception {+ checkDefinedComponentFixupAfterLayoutChange(false, false);+ }++ @Test+ public void testDefinedComponentFixupAfterEnablingPacking() throws Exception {+ checkDefinedComponentFixupAfterLayoutChange(false, true);+ }++ @Test+ public void testDefinedComponentFixupAfterDisablingPacking() throws Exception {+ checkDefinedComponentFixupAfterLayoutChange(true, false);+ }++ private void checkDefinedComponentFixupAfterLayoutChange(boolean initiallyPacked,+ boolean finallyPacked) throws Exception {+ CategoryPath path = new CategoryPath("/MISC");+ mtf.initialize("notepad2", new OriginalProgramModifierListener() {+ @Override+ public void modifyOriginal(ProgramDB program) throws Exception {+ // Ensure the zero-length type is already resolved when the container is added.+ program.getDataTypeManager().addDataType(new ArrayDataType(ByteDataType.dataType, 0),+ DataTypeConflictHandler.DEFAULT_HANDLER);+ }++ @Override+ public void modifyLatest(ProgramDB program) throws Exception {+ Structure bar = (Structure) program.getDataTypeManager().getDataType(path, "Bar");+ bar.getComponent(0).setComment("Latest Bar component");+ }++ @Override+ public void modifyPrivate(ProgramDB program) throws Exception {+ DataTypeManager dtm = program.getDataTypeManager();+ Structure bar = (Structure) dtm.getDataType(path, "Bar");+ bar.delete(1);+ assertEquals(2, bar.getLength());++ // Allocate the container first so its target components require deferred fixups.+ Structure container = (Structure) dtm.addDataType(+ new StructureDataType(path, "LayoutContainer", 0),+ DataTypeConflictHandler.DEFAULT_HANDLER);+ Structure target = new StructureDataType(path, "LayoutTarget", 0);+ target.add(ByteDataType.dataType);+ target = (Structure) dtm.addDataType(target, DataTypeConflictHandler.DEFAULT_HANDLER);++ container.add(bar, "bar", null);+ container.growStructure(4);+ container.insertBitFieldAt(6, 1, 0, ByteDataType.dataType, 3, "bits1", null);+ container.insertBitFieldAt(6, 1, 3, ByteDataType.dataType, 2, "bits2", null);+ container.add(new ArrayDataType(ByteDataType.dataType, 0), "zero1", null);+ container.add(new ArrayDataType(ByteDataType.dataType, 0), "zero2", null);+ container.add(target, "target1", null);+ container.add(target, "target2", null);+ container.setPackingEnabled(initiallyPacked);+ }+ });++ executeMerge();+ waitForPrompting(); // Wait until additions are complete and the Bar conflict is displayed.+ DataTypeManager dtm = resultProgram.getDataTypeManager();+ Structure container = (Structure) dtm.getDataType(path, "LayoutContainer");+ assertNotNull(container);+ DataTypeComponent[] components = container.getDefinedComponents();+ assertEquals(7, components.length);+ assertEquals(BadDataType.dataType, components[5].getDataType());+ assertEquals(BadDataType.dataType, components[6].getDataType());++ // The merge is paused at the Bar conflict, after the container fixups were recorded.+ // Exercise a packing transition without replacing its defined-component sequence.+ int tx = resultProgram.startTransaction("Change packing with pending fixups");+ try {+ container.setPackingEnabled(finallyPacked);+ }+ finally {+ resultProgram.endTransaction(tx, true);+ }+ chooseOption(DataTypeMergeManager.OPTION_MY);+ waitForCompletion();++ container = (Structure) dtm.getDataType(path, "LayoutContainer");+ components = container.getDefinedComponents();+ assertEquals(finallyPacked, container.isPackingEnabled());+ assertEquals(7, components.length);+ assertEquals(2, components[0].getLength());+ assertTrue(components[1].isBitFieldComponent());+ assertTrue(components[2].isBitFieldComponent());+ assertEquals(components[1].getOffset(), components[2].getOffset());+ assertEquals(0, components[3].getLength());+ assertEquals(0, components[4].getLength());+ assertEquals(components[3].getOffset(), components[4].getOffset());+ DataType target = dtm.getDataType(path, "LayoutTarget");+ assertNotNull(target);+ assertEquals("target1", components[5].getFieldName());+ assertEquals(target, components[5].getDataType());+ assertEquals("target2", components[6].getFieldName());+ assertEquals(target, components[6].getDataType());+ checkConflictCount(0);+ }+private void setupRemoveInnerVsAddOuterContainingChangedInner() throws Exception {final CategoryPath rootPath = new CategoryPath("/");diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/StructureDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/StructureDB.javaindex 73c8456871..dec67f9f1a 100644--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/StructureDB.java+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/StructureDB.java@@ -746,10 +746,22 @@ class StructureDB extends CompositeDB implements StructureInternal {@Overridepublic int getNumDefinedComponents() {try (Closeable c = lock.read()) {+ refreshIfNeeded();return components.size();}}+ @Override+ public DataTypeComponentDB getDefinedComponent(int index) throws IndexOutOfBoundsException {+ try (Closeable c = lock.read()) {+ refreshIfNeeded();+ if (index < 0 || index >= components.size()) {+ throw new IndexOutOfBoundsException(index);+ }+ return components.get(index);+ }+ }+@Overridepublic DataTypeComponentDB getComponent(int ordinal) {try (Closeable c = lock.read()) {diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/UnionDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/UnionDB.javaindex 815b46c695..c20f79aa60 100644--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/UnionDB.java+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/data/UnionDB.java@@ -389,16 +389,21 @@ class UnionDB extends CompositeDB implements UnionInternal {}@Override- public DataTypeComponentDB getComponent(int ordinal) {+ public DataTypeComponentDB getDefinedComponent(int index) throws IndexOutOfBoundsException {try (Closeable c = lock.read()) {refreshIfNeeded();- if (ordinal < 0 || ordinal >= components.size()) {- return null;+ if (index < 0 || index >= components.size()) {+ throw new IndexOutOfBoundsException(index);}- return components.get(ordinal);+ return components.get(index);}}+ @Override+ public DataTypeComponentDB getComponent(int ordinal) {+ return getDefinedComponent(ordinal);+ }+@Overridepublic DataTypeComponentDB[] getComponents() {try (Closeable c = lock.read()) {diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/Composite.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/Composite.javaindex ec104df709..ea449abac1 100644--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/Composite.java+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/Composite.java@@ -47,6 +47,17 @@ public interface Composite extends DataType {*/public abstract int getNumDefinedComponents();+ /**+ * Returns the defined component of this data type at the specified index+ * within the ordered sequence of {@link #getDefinedComponents() defined components}.+ * See {@link #getNumDefinedComponents()}.+ * @param index the index of the defined component (numbering starts at 0).+ * @return the data type component.+ * @throws IndexOutOfBoundsException if the index is out of bounds+ */+ public abstract DataTypeComponent getDefinedComponent(int index)+ throws IndexOutOfBoundsException;+/*** Returns the component of this data type with the indicated ordinal.* @param ordinal the component's ordinal (numbering starts at 0).diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StructureDataType.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StructureDataType.javaindex 94193ea48d..3c59391b26 100644--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StructureDataType.java+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/StructureDataType.java@@ -448,6 +448,14 @@ public class StructureDataType extends CompositeDataTypeImpl implements Structurdtc.setOrdinal(dtc.getOrdinal() + deltaOrdinal);}+ @Override+ public DataTypeComponentImpl getDefinedComponent(int index) throws IndexOutOfBoundsException {+ if (index < 0 || index >= components.size()) {+ throw new IndexOutOfBoundsException(index);+ }+ return components.get(index);+ }+@Overridepublic DataTypeComponentImpl getComponent(int ordinal) {if (ordinal < 0 || ordinal >= numComponents) {diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/UnionDataType.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/UnionDataType.javaindex 7d1192c4c7..5234ec1589 100644--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/UnionDataType.java+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/UnionDataType.java@@ -104,8 +104,16 @@ public class UnionDataType extends CompositeDataTypeImpl implements UnionInterna}@Override- public DataTypeComponent getComponent(int ordinal) {- return components.get(ordinal);+ public DataTypeComponentImpl getDefinedComponent(int index) throws IndexOutOfBoundsException {+ if (index < 0 || index >= components.size()) {+ throw new IndexOutOfBoundsException(index);+ }+ return components.get(index);+ }++ @Override+ public DataTypeComponentImpl getComponent(int ordinal) throws IndexOutOfBoundsException {+ return getDefinedComponent(ordinal);}@Override