diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/CppCompositeType.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/CppCompositeType.java index 4dbb7c6c71..96d14020c7 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/CppCompositeType.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/CppCompositeType.java @@ -391,7 +391,8 @@ public class CppCompositeType { createMembersOnlyClassLayout(monitor); break; case CLASS_HIERARCHY: - createHierarchicalClassLayout(vxtManager, monitor); + case CLASS_HIERARCHY_SPECULATIVE: + createHierarchicalClassLayout(vxtManager, layoutOptions, monitor); // Next line for developer testing cfb432 //System.out.print(summarizedClassVxtPtrInfo); break; @@ -817,7 +818,8 @@ public class CppCompositeType { //============================================================================================== //============================================================================================== - private void createHierarchicalClassLayout(MsftVxtManager vxtManager, TaskMonitor monitor) + private void createHierarchicalClassLayout(MsftVxtManager vxtManager, + ObjectOrientedClassLayout layoutOptions, TaskMonitor monitor) throws PdbException, CancelledException { initLayoutAlgorithmData(); @@ -827,7 +829,7 @@ public class CppCompositeType { findOrAllocateMainVftPtr(vxtManager); findOrAllocateMainVbtPtr(vxtManager); - createClassLayout(vxtManager, monitor); + createClassLayout(vxtManager, layoutOptions, monitor); finalizeAllVxtParentage(); @@ -1045,7 +1047,8 @@ public class CppCompositeType { * @throws CancelledException upon user cancellation * @throws PdbException up issue with finding the vbt or assigning offsets to virtual bases */ - private void createClassLayout(MsftVxtManager vxtManager, TaskMonitor monitor) + private void createClassLayout(MsftVxtManager vxtManager, + ObjectOrientedClassLayout layoutOptions, TaskMonitor monitor) throws CancelledException, PdbException { List selfBaseMembers = getSelfBaseClassMembers(); mainVft = getMainVft(vxtManager); @@ -1082,16 +1085,11 @@ public class CppCompositeType { // updateVbtFromSelf(vbt); // } } - assignVirtualBaseOffsets(); - - String baseComment = (mainVbt instanceof ProgramVirtualBaseTable) ? VIRTUAL_BASE_COMMENT - : VIRTUAL_BASE_SPECULATIVE_COMMENT; - TreeMap virtualBasePdbMembers = - getVirtualBaseClassMembers(baseComment); - findVirtualBaseVxtPtrs(vxtManager); TreeMap allMembers = new TreeMap<>(); allMembers.put(0L, directClassPdbMember); + TreeMap virtualBasePdbMembers = + processVirtualBaseClasses(vxtManager, layoutOptions); allMembers.putAll(virtualBasePdbMembers); List am = new ArrayList<>(allMembers.values()); @@ -1448,6 +1446,58 @@ public class CppCompositeType { return newParentage; } + private TreeMap processVirtualBaseClasses(MsftVxtManager vxtManager, + ObjectOrientedClassLayout layoutOptions) + throws PdbException { + if (mainVbt instanceof PlaceholderVirtualBaseTable pvbt && + layoutOptions == ObjectOrientedClassLayout.CLASS_HIERARCHY && + virtualLayoutBaseClasses.size() > 0) { + TreeMap virtualBasePdbMembers = provideVirtualBaseFillerBytes(); + return virtualBasePdbMembers; + } + // Below processes CLASS_HIERARCHY with ProgramVirtualBaseTable and also processes + // CLASS_HIERARCHY_SPECULATIVE + assignVirtualBaseOffsets(); + String baseComment = (mainVbt instanceof ProgramVirtualBaseTable) ? VIRTUAL_BASE_COMMENT + : VIRTUAL_BASE_SPECULATIVE_COMMENT; + TreeMap virtualBasePdbMembers = + getVirtualBaseClassMembers(baseComment); + findVirtualBaseVxtPtrs(vxtManager); + return virtualBasePdbMembers; + } + + private TreeMap provideVirtualBaseFillerBytes() throws PdbException { + TreeMap fillerForVirtualBasePdbMembers = new TreeMap<>(); + int numVirtualBases = virtualLayoutBaseClasses.size(); + if (numVirtualBases == 0) { + return fillerForVirtualBasePdbMembers; + } + int offset = selfBaseType.getLength(); + int fillerSize = size - offset; + StringBuilder builder = new StringBuilder(); + builder.append("Filler for " + numVirtualBases + " Unplaceable Virtual Base"); + builder.append(numVirtualBases == 1 ? ":" : "s:"); + boolean first = true; + for (VirtualLayoutBaseClass base : virtualLayoutBaseClasses) { + CppCompositeType cppBaseType = base.getBaseClassType(); + if (!first) { + builder.append(";"); + } + first = false; + builder.append(" "); + builder.append(cppBaseType.getName()); + } + String comment = builder.toString(); + ArrayDataType fillerDataType = new ArrayDataType(CharDataType.dataType, fillerSize); + boolean isFlexArray = (fillerSize == 0); + // This does not have attributes + + ClassPdbMember fillerPdbMember = + new ClassPdbMember("", fillerDataType, isFlexArray, offset, comment); + fillerForVirtualBasePdbMembers.put((long) offset, fillerPdbMember); + return fillerForVirtualBasePdbMembers; + } + /** * Uses the main virtual base table to assign offsets for the virtual bases * @throws PdbException if a virtual base offset cannot be identified diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ObjectOrientedClassLayout.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ObjectOrientedClassLayout.java index 702a844ceb..68a2f7b263 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ObjectOrientedClassLayout.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ObjectOrientedClassLayout.java @@ -32,7 +32,13 @@ public enum ObjectOrientedClassLayout { * Include base class hierarchies and other C++-isms into a class layout that is suited for * understanding the hierarchies and components from the Structure Editor perspective */ - CLASS_HIERARCHY("Class Hierarchy (Experimental)"); + CLASS_HIERARCHY("Class Hierarchy (Experimental)"), + /** + * Same as {@link #CLASS_HIERARCHY}, but also performs speculative virtual class placement + * if an in-memory Virtual Base Table is not found. This is risky, and not an advised + * solution + */ + CLASS_HIERARCHY_SPECULATIVE("Class Hierarchy (Missing VBT Speculatation - Risky)"); private final String label; diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Cfb432ProgramCreator.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Cfb432ProgramCreator.java index bc70571e33..2cfafc925a 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Cfb432ProgramCreator.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Cfb432ProgramCreator.java @@ -1084,6 +1084,29 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructA() { + String expected = + //@formatter:off + """ + /ANS::A + pack() + Structure ANS::A { + 0 ANS::A 12 "Self Base" + 12 char[16] 16 "Filler for 2 Unplaceable Virtual Bases: A1NS::A1; A2NS::A2" + } + Length: 28 Alignment: 4 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 a "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructA() { return convertCommentsToSpeculative(getExpectedStructA()); } @@ -1392,6 +1415,29 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructB() { + String expected = + //@formatter:off + """ + /BNS::B + pack() + Structure BNS::B { + 0 BNS::B 12 "Self Base" + 12 char[16] 16 "Filler for 2 Unplaceable Virtual Bases: B1NS::B1; B2NS::B2" + } + Length: 28 Alignment: 4 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 b "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructB() { return convertCommentsToSpeculative(getExpectedStructB()); } @@ -1604,6 +1650,29 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructC() { + String expected = + //@formatter:off + """ + /CNS::C + pack() + Structure CNS::C { + 0 CNS::C 12 "Self Base" + 12 char[32] 32 "Filler for 4 Unplaceable Virtual Bases: A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 44 Alignment: 4 + /CNS::C/!internal/CNS::C + pack() + Structure CNS::C { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 c "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructC() { return convertCommentsToSpeculative(getExpectedStructC()); } @@ -1907,6 +1976,54 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructD() { + String expected = + //@formatter:off + """ + /DNS::D + pack() + Structure DNS::D { + 0 DNS::D 40 "Self Base" + 40 char[32] 32 "Filler for 4 Unplaceable Virtual Bases: A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 72 Alignment: 4 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 a "" + } + Length: 12 Alignment: 4 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 b "" + } + Length: 12 Alignment: 4 + /CNS::C/!internal/CNS::C + pack() + Structure CNS::C { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 c "" + } + Length: 12 Alignment: 4 + /DNS::D/!internal/DNS::D + pack() + Structure DNS::D { + 0 CNS::C 12 "Base" + 12 ANS::A 12 "Base" + 24 BNS::B 12 "Base" + 36 int 4 d "" + } + Length: 40 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructD() { return convertCommentsToSpeculative(getExpectedStructD()); } @@ -2254,6 +2371,36 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructE() { + String expected = + //@formatter:off + """ + /ENS::E + pack() + Structure ENS::E { + 0 ENS::E 16 "Self Base" + 16 char[44] 44 "Filler for 5 Unplaceable Virtual Bases: BNS::B; A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 60 Alignment: 4 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 a "" + } + Length: 12 Alignment: 4 + /ENS::E/!internal/ENS::E + pack() + Structure ENS::E { + 0 ANS::A 12 "Base" + 12 int 4 e "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructE() { return convertCommentsToSpeculative(getExpectedStructE()); } @@ -2467,6 +2614,28 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructF() { + String expected = + //@formatter:off + """ + /FNS::F + pack() + Structure FNS::F { + 0 FNS::F 8 "Self Base" + 8 char[8] 8 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 16 Alignment: 4 + /FNS::F/!internal/FNS::F + pack() + Structure FNS::F { + 0 pointer 4 {vbptr} "" + 4 int 4 f "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructF() { return convertCommentsToSpeculative(getExpectedStructF()); } @@ -2583,6 +2752,35 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructG() { + String expected = + //@formatter:off + """ + /GNS::G + pack() + Structure GNS::G { + 0 GNS::G 12 "Self Base" + 12 char[8] 8 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 20 Alignment: 4 + /FNS::F/!internal/FNS::F + pack() + Structure FNS::F { + 0 pointer 4 {vbptr} "" + 4 int 4 f "" + } + Length: 8 Alignment: 4 + /GNS::G/!internal/GNS::G + pack() + Structure GNS::G { + 0 FNS::F 8 "Base" + 8 int 4 g "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructG() { return convertCommentsToSpeculative(getExpectedStructG()); } @@ -2699,6 +2897,35 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructH() { + String expected = + //@formatter:off + """ + /HNS::H + pack() + Structure HNS::H { + 0 HNS::H 12 "Self Base" + 12 char[8] 8 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 20 Alignment: 4 + /FNS::F/!internal/FNS::F + pack() + Structure FNS::F { + 0 pointer 4 {vbptr} "" + 4 int 4 f "" + } + Length: 8 Alignment: 4 + /HNS::H/!internal/HNS::H + pack() + Structure HNS::H { + 0 FNS::F 8 "Base" + 8 int 4 h "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructH() { return convertCommentsToSpeculative(getExpectedStructH()); } @@ -2844,6 +3071,50 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI() { + String expected = + //@formatter:off + """ + /INS::I + pack() + Structure INS::I { + 0 INS::I 28 "Self Base" + 28 char[8] 8 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 36 Alignment: 4 + /FNS::F/!internal/FNS::F + pack() + Structure FNS::F { + 0 pointer 4 {vbptr} "" + 4 int 4 f "" + } + Length: 8 Alignment: 4 + /GNS::G/!internal/GNS::G + pack() + Structure GNS::G { + 0 FNS::F 8 "Base" + 8 int 4 g "" + } + Length: 12 Alignment: 4 + /HNS::H/!internal/HNS::H + pack() + Structure HNS::H { + 0 FNS::F 8 "Base" + 8 int 4 h "" + } + Length: 12 Alignment: 4 + /INS::I/!internal/INS::I + pack() + Structure INS::I { + 0 GNS::G 12 "Base" + 12 HNS::H 12 "Base" + 24 int 4 i "" + } + Length: 28 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI() { return convertCommentsToSpeculative(getExpectedStructI()); } @@ -2966,6 +3237,28 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ() { + String expected = + //@formatter:off + """ + /JNS::J + pack() + Structure JNS::J { + 0 JNS::J 8 "Self Base" + 8 char[8] 8 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 16 Alignment: 4 + /JNS::J/!internal/JNS::J + pack() + Structure JNS::J { + 0 pointer 4 {vbptr} "" + 4 int 4 j "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructJ() { return convertCommentsToSpeculative(getExpectedStructJ()); } @@ -3082,6 +3375,35 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructK() { + String expected = + //@formatter:off + """ + /KNS::K + pack() + Structure KNS::K { + 0 KNS::K 12 "Self Base" + 12 char[8] 8 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 20 Alignment: 4 + /JNS::J/!internal/JNS::J + pack() + Structure JNS::J { + 0 pointer 4 {vbptr} "" + 4 int 4 j "" + } + Length: 8 Alignment: 4 + /KNS::K/!internal/KNS::K + pack() + Structure KNS::K { + 0 JNS::J 8 "Base" + 8 int 4 k "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructK() { return convertCommentsToSpeculative(getExpectedStructK()); } @@ -3208,6 +3530,42 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructL() { + String expected = + //@formatter:off + """ + /LNS::L + pack() + Structure LNS::L { + 0 LNS::L 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 24 Alignment: 4 + /JNS::J/!internal/JNS::J + pack() + Structure JNS::J { + 0 pointer 4 {vbptr} "" + 4 int 4 j "" + } + Length: 8 Alignment: 4 + /KNS::K/!internal/KNS::K + pack() + Structure KNS::K { + 0 JNS::J 8 "Base" + 8 int 4 k "" + } + Length: 12 Alignment: 4 + /LNS::L/!internal/LNS::L + pack() + Structure LNS::L { + 0 KNS::K 12 "Base" + 12 int 4 l "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructL() { return convertCommentsToSpeculative(getExpectedStructL()); } @@ -3756,6 +4114,121 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructM() { + String expected = + //@formatter:off + """ + /MNS::M + pack() + Structure MNS::M { + 0 MNS::M 104 "Self Base" + 104 char[60] 60 "Filler for 7 Unplaceable Virtual Bases: N1NS::N1; N2NS::N2; A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2; BNS::B" + } + Length: 164 Alignment: 4 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 a "" + } + Length: 12 Alignment: 4 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 b "" + } + Length: 12 Alignment: 4 + /CNS::C/!internal/CNS::C + pack() + Structure CNS::C { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 c "" + } + Length: 12 Alignment: 4 + /DNS::D/!internal/DNS::D + pack() + Structure DNS::D { + 0 CNS::C 12 "Base" + 12 ANS::A 12 "Base" + 24 BNS::B 12 "Base" + 36 int 4 d "" + } + Length: 40 Alignment: 4 + /ENS::E/!internal/ENS::E + pack() + Structure ENS::E { + 0 ANS::A 12 "Base" + 12 int 4 e "" + } + Length: 16 Alignment: 4 + /FNS::F/!internal/FNS::F + pack() + Structure FNS::F { + 0 pointer 4 {vbptr} "" + 4 int 4 f "" + } + Length: 8 Alignment: 4 + /GNS::G/!internal/GNS::G + pack() + Structure GNS::G { + 0 FNS::F 8 "Base" + 8 int 4 g "" + } + Length: 12 Alignment: 4 + /HNS::H/!internal/HNS::H + pack() + Structure HNS::H { + 0 FNS::F 8 "Base" + 8 int 4 h "" + } + Length: 12 Alignment: 4 + /INS::I/!internal/INS::I + pack() + Structure INS::I { + 0 GNS::G 12 "Base" + 12 HNS::H 12 "Base" + 24 int 4 i "" + } + Length: 28 Alignment: 4 + /JNS::J/!internal/JNS::J + pack() + Structure JNS::J { + 0 pointer 4 {vbptr} "" + 4 int 4 j "" + } + Length: 8 Alignment: 4 + /KNS::K/!internal/KNS::K + pack() + Structure KNS::K { + 0 JNS::J 8 "Base" + 8 int 4 k "" + } + Length: 12 Alignment: 4 + /LNS::L/!internal/LNS::L + pack() + Structure LNS::L { + 0 KNS::K 12 "Base" + 12 int 4 l "" + } + Length: 16 Alignment: 4 + /MNS::M/!internal/MNS::M + pack() + Structure MNS::M { + 0 ENS::E 16 "Base" + 16 DNS::D 40 "Base" + 56 INS::I 28 "Base" + 84 LNS::L 16 "Base" + 100 int 4 m "" + } + Length: 104 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructM() { String expected = //@formatter:off @@ -4595,6 +5068,45 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructO1() { + String expected = + //@formatter:off + """ + /O1NS::O1 + pack() + Structure O1NS::O1 { + 0 O1NS::O1 28 "Self Base" + 28 char[32] 32 "Filler for 4 Unplaceable Virtual Bases: A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 60 Alignment: 4 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 a "" + } + Length: 12 Alignment: 4 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 b "" + } + Length: 12 Alignment: 4 + /O1NS::O1/!internal/O1NS::O1 + pack() + Structure O1NS::O1 { + 0 ANS::A 12 "Base" + 12 BNS::B 12 "Base" + 24 int 4 o1 "" + } + Length: 28 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructO1() { return convertCommentsToSpeculative(getExpectedStructO1()); } @@ -4912,6 +5424,36 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructO2() { + String expected = + //@formatter:off + """ + /O2NS::O2 + pack() + Structure O2NS::O2 { + 0 O2NS::O2 16 "Self Base" + 16 char[44] 44 "Filler for 5 Unplaceable Virtual Bases: BNS::B; A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 60 Alignment: 4 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 a "" + } + Length: 12 Alignment: 4 + /O2NS::O2/!internal/O2NS::O2 + pack() + Structure O2NS::O2 { + 0 ANS::A 12 "Base" + 12 int 4 o2 "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructO2() { return convertCommentsToSpeculative(getExpectedStructO2()); } @@ -5228,6 +5770,45 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructO3() { + String expected = + //@formatter:off + """ + /O3NS::O3 + pack() + Structure O3NS::O3 { + 0 O3NS::O3 28 "Self Base" + 28 char[32] 32 "Filler for 4 Unplaceable Virtual Bases: A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 60 Alignment: 4 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 a "" + } + Length: 12 Alignment: 4 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 b "" + } + Length: 12 Alignment: 4 + /O3NS::O3/!internal/O3NS::O3 + pack() + Structure O3NS::O3 { + 0 ANS::A 12 "Base" + 12 BNS::B 12 "Base" + 24 int 4 o3 "" + } + Length: 28 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructO3() { return convertCommentsToSpeculative(getExpectedStructO3()); } @@ -5545,6 +6126,36 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructO4() { + String expected = + //@formatter:off + """ + /O4NS::O4 + pack() + Structure O4NS::O4 { + 0 O4NS::O4 16 "Self Base" + 16 char[44] 44 "Filler for 5 Unplaceable Virtual Bases: BNS::B; A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 60 Alignment: 4 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 a "" + } + Length: 12 Alignment: 4 + /O4NS::O4/!internal/O4NS::O4 + pack() + Structure O4NS::O4 { + 0 ANS::A 12 "Base" + 12 int 4 o4 "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructO4() { return convertCommentsToSpeculative(getExpectedStructO4()); } @@ -6001,6 +6612,60 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructO() { + String expected = + //@formatter:off + """ + /ONS::O + pack() + Structure ONS::O { + 0 ONS::O 48 "Self Base" + 48 char[88] 88 "Filler for 7 Unplaceable Virtual Bases: O3NS::O3; O4NS::O4; A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2; BNS::B" + } + Length: 136 Alignment: 4 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 a "" + } + Length: 12 Alignment: 4 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 b "" + } + Length: 12 Alignment: 4 + /O1NS::O1/!internal/O1NS::O1 + pack() + Structure O1NS::O1 { + 0 ANS::A 12 "Base" + 12 BNS::B 12 "Base" + 24 int 4 o1 "" + } + Length: 28 Alignment: 4 + /O2NS::O2/!internal/O2NS::O2 + pack() + Structure O2NS::O2 { + 0 ANS::A 12 "Base" + 12 int 4 o2 "" + } + Length: 16 Alignment: 4 + /ONS::O/!internal/ONS::O + pack() + Structure ONS::O { + 0 O1NS::O1 28 "Base" + 28 O2NS::O2 16 "Base" + 44 int 4 o "" + } + Length: 48 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructO() { return convertCommentsToSpeculative(getExpectedStructO()); } @@ -6394,6 +7059,29 @@ public class Cfb432ProgramCreator extends ProgramCreator { expectedStructs.put(O, getExpectedStructO()); } + private static final Map fillerStructs = new LinkedHashMap<>(); + static { + fillerStructs.putAll(expectedStructs); + fillerStructs.put(A, getFillerStructA()); + fillerStructs.put(B, getFillerStructB()); + fillerStructs.put(C, getFillerStructC()); + fillerStructs.put(D, getFillerStructD()); + fillerStructs.put(E, getFillerStructE()); + fillerStructs.put(F, getFillerStructF()); + fillerStructs.put(G, getFillerStructG()); + fillerStructs.put(H, getFillerStructH()); + fillerStructs.put(I, getFillerStructI()); + fillerStructs.put(J, getFillerStructJ()); + fillerStructs.put(K, getFillerStructK()); + fillerStructs.put(L, getFillerStructL()); + fillerStructs.put(M, getFillerStructM()); + fillerStructs.put(O1, getFillerStructO1()); + fillerStructs.put(O2, getFillerStructO2()); + fillerStructs.put(O3, getFillerStructO3()); + fillerStructs.put(O4, getFillerStructO4()); + fillerStructs.put(O, getFillerStructO()); + } + private static final Map speculatedStructs = new LinkedHashMap<>(); static { speculatedStructs.put(A1, getSpeculatedStructA1()); @@ -6513,6 +7201,10 @@ public class Cfb432ProgramCreator extends ProgramCreator { return expectedStructs; } + public Map getFillerStructs() { + return fillerStructs; + } + public Map getSpeculatedStructs() { return speculatedStructs; } diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Cfb464ProgramCreator.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Cfb464ProgramCreator.java index f42565f3b3..7e67bbfddf 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Cfb464ProgramCreator.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Cfb464ProgramCreator.java @@ -1123,6 +1123,29 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructA() { + String expected = + //@formatter:off + """ + /ANS::A + pack() + Structure ANS::A { + 0 ANS::A 24 "Self Base" + 24 char[32] 32 "Filler for 2 Unplaceable Virtual Bases: A1NS::A1; A2NS::A2" + } + Length: 56 Alignment: 8 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 a "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructA() { return convertCommentsToSpeculative(getExpectedStructA()); } @@ -1436,6 +1459,29 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructB() { + String expected = + //@formatter:off + """ + /BNS::B + pack() + Structure BNS::B { + 0 BNS::B 24 "Self Base" + 24 char[32] 32 "Filler for 2 Unplaceable Virtual Bases: B1NS::B1; B2NS::B2" + } + Length: 56 Alignment: 8 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 b "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructB() { return convertCommentsToSpeculative(getExpectedStructB()); } @@ -1653,6 +1699,29 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructC() { + String expected = + //@formatter:off + """ + /CNS::C + pack() + Structure CNS::C { + 0 CNS::C 24 "Self Base" + 24 char[64] 64 "Filler for 4 Unplaceable Virtual Bases: A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 88 Alignment: 8 + /CNS::C/!internal/CNS::C + pack() + Structure CNS::C { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 c "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructC() { return convertCommentsToSpeculative(getExpectedStructC()); } @@ -1964,6 +2033,54 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructD() { + String expected = + //@formatter:off + """ + /DNS::D + pack() + Structure DNS::D { + 0 DNS::D 80 "Self Base" + 80 char[64] 64 "Filler for 4 Unplaceable Virtual Bases: A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 144 Alignment: 8 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 a "" + } + Length: 24 Alignment: 8 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 b "" + } + Length: 24 Alignment: 8 + /CNS::C/!internal/CNS::C + pack() + Structure CNS::C { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 c "" + } + Length: 24 Alignment: 8 + /DNS::D/!internal/DNS::D + pack() + Structure DNS::D { + 0 CNS::C 24 "Base" + 24 ANS::A 24 "Base" + 48 BNS::B 24 "Base" + 72 int 4 d "" + } + Length: 80 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructD() { return convertCommentsToSpeculative(getExpectedStructD()); } @@ -2318,6 +2435,36 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructE() { + String expected = + //@formatter:off + """ + /ENS::E + pack() + Structure ENS::E { + 0 ENS::E 32 "Self Base" + 32 char[88] 88 "Filler for 5 Unplaceable Virtual Bases: BNS::B; A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 120 Alignment: 8 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 a "" + } + Length: 24 Alignment: 8 + /ENS::E/!internal/ENS::E + pack() + Structure ENS::E { + 0 ANS::A 24 "Base" + 24 int 4 e "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructE() { return convertCommentsToSpeculative(getExpectedStructE()); } @@ -2533,6 +2680,28 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructF() { + String expected = + //@formatter:off + """ + /FNS::F + pack() + Structure FNS::F { + 0 FNS::F 16 "Self Base" + 16 char[16] 16 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 32 Alignment: 8 + /FNS::F/!internal/FNS::F + pack() + Structure FNS::F { + 0 pointer 8 {vbptr} "" + 8 int 4 f "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructF() { return convertCommentsToSpeculative(getExpectedStructF()); } @@ -2652,6 +2821,35 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructG() { + String expected = + //@formatter:off + """ + /GNS::G + pack() + Structure GNS::G { + 0 GNS::G 24 "Self Base" + 24 char[16] 16 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 40 Alignment: 8 + /FNS::F/!internal/FNS::F + pack() + Structure FNS::F { + 0 pointer 8 {vbptr} "" + 8 int 4 f "" + } + Length: 16 Alignment: 8 + /GNS::G/!internal/GNS::G + pack() + Structure GNS::G { + 0 FNS::F 16 "Base" + 16 int 4 g "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructG() { return convertCommentsToSpeculative(getExpectedStructG()); } @@ -2771,6 +2969,35 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructH() { + String expected = + //@formatter:off + """ + /HNS::H + pack() + Structure HNS::H { + 0 HNS::H 24 "Self Base" + 24 char[16] 16 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 40 Alignment: 8 + /FNS::F/!internal/FNS::F + pack() + Structure FNS::F { + 0 pointer 8 {vbptr} "" + 8 int 4 f "" + } + Length: 16 Alignment: 8 + /HNS::H/!internal/HNS::H + pack() + Structure HNS::H { + 0 FNS::F 16 "Base" + 16 int 4 h "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructH() { return convertCommentsToSpeculative(getExpectedStructH()); } @@ -2922,6 +3149,50 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI() { + String expected = + //@formatter:off + """ + /INS::I + pack() + Structure INS::I { + 0 INS::I 56 "Self Base" + 56 char[16] 16 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 72 Alignment: 8 + /FNS::F/!internal/FNS::F + pack() + Structure FNS::F { + 0 pointer 8 {vbptr} "" + 8 int 4 f "" + } + Length: 16 Alignment: 8 + /GNS::G/!internal/GNS::G + pack() + Structure GNS::G { + 0 FNS::F 16 "Base" + 16 int 4 g "" + } + Length: 24 Alignment: 8 + /HNS::H/!internal/HNS::H + pack() + Structure HNS::H { + 0 FNS::F 16 "Base" + 16 int 4 h "" + } + Length: 24 Alignment: 8 + /INS::I/!internal/INS::I + pack() + Structure INS::I { + 0 GNS::G 24 "Base" + 24 HNS::H 24 "Base" + 48 int 4 i "" + } + Length: 56 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI() { return convertCommentsToSpeculative(getExpectedStructI()); } @@ -3046,6 +3317,28 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ() { + String expected = + //@formatter:off + """ + /JNS::J + pack() + Structure JNS::J { + 0 JNS::J 16 "Self Base" + 16 char[16] 16 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 32 Alignment: 8 + /JNS::J/!internal/JNS::J + pack() + Structure JNS::J { + 0 pointer 8 {vbptr} "" + 8 int 4 j "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructJ() { return convertCommentsToSpeculative(getExpectedStructJ()); } @@ -3165,6 +3458,35 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructK() { + String expected = + //@formatter:off + """ + /KNS::K + pack() + Structure KNS::K { + 0 KNS::K 24 "Self Base" + 24 char[16] 16 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 40 Alignment: 8 + /JNS::J/!internal/JNS::J + pack() + Structure JNS::J { + 0 pointer 8 {vbptr} "" + 8 int 4 j "" + } + Length: 16 Alignment: 8 + /KNS::K/!internal/KNS::K + pack() + Structure KNS::K { + 0 JNS::J 16 "Base" + 16 int 4 k "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructK() { return convertCommentsToSpeculative(getExpectedStructK()); } @@ -3295,6 +3617,42 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructL() { + String expected = + //@formatter:off + """ + /LNS::L + pack() + Structure LNS::L { + 0 LNS::L 32 "Self Base" + 32 char[16] 16 "Filler for 1 Unplaceable Virtual Base: A1NS::A1" + } + Length: 48 Alignment: 8 + /JNS::J/!internal/JNS::J + pack() + Structure JNS::J { + 0 pointer 8 {vbptr} "" + 8 int 4 j "" + } + Length: 16 Alignment: 8 + /KNS::K/!internal/KNS::K + pack() + Structure KNS::K { + 0 JNS::J 16 "Base" + 16 int 4 k "" + } + Length: 24 Alignment: 8 + /LNS::L/!internal/LNS::L + pack() + Structure LNS::L { + 0 KNS::K 24 "Base" + 24 int 4 l "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructL() { return convertCommentsToSpeculative(getExpectedStructL()); } @@ -3867,6 +4225,121 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructM() { + String expected = + //@formatter:off + """ + /MNS::M + pack() + Structure MNS::M { + 0 MNS::M 208 "Self Base" + 208 char[120] 120 "Filler for 7 Unplaceable Virtual Bases: N1NS::N1; N2NS::N2; A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2; BNS::B" + } + Length: 328 Alignment: 8 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 a "" + } + Length: 24 Alignment: 8 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 b "" + } + Length: 24 Alignment: 8 + /CNS::C/!internal/CNS::C + pack() + Structure CNS::C { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 c "" + } + Length: 24 Alignment: 8 + /DNS::D/!internal/DNS::D + pack() + Structure DNS::D { + 0 CNS::C 24 "Base" + 24 ANS::A 24 "Base" + 48 BNS::B 24 "Base" + 72 int 4 d "" + } + Length: 80 Alignment: 8 + /ENS::E/!internal/ENS::E + pack() + Structure ENS::E { + 0 ANS::A 24 "Base" + 24 int 4 e "" + } + Length: 32 Alignment: 8 + /FNS::F/!internal/FNS::F + pack() + Structure FNS::F { + 0 pointer 8 {vbptr} "" + 8 int 4 f "" + } + Length: 16 Alignment: 8 + /GNS::G/!internal/GNS::G + pack() + Structure GNS::G { + 0 FNS::F 16 "Base" + 16 int 4 g "" + } + Length: 24 Alignment: 8 + /HNS::H/!internal/HNS::H + pack() + Structure HNS::H { + 0 FNS::F 16 "Base" + 16 int 4 h "" + } + Length: 24 Alignment: 8 + /INS::I/!internal/INS::I + pack() + Structure INS::I { + 0 GNS::G 24 "Base" + 24 HNS::H 24 "Base" + 48 int 4 i "" + } + Length: 56 Alignment: 8 + /JNS::J/!internal/JNS::J + pack() + Structure JNS::J { + 0 pointer 8 {vbptr} "" + 8 int 4 j "" + } + Length: 16 Alignment: 8 + /KNS::K/!internal/KNS::K + pack() + Structure KNS::K { + 0 JNS::J 16 "Base" + 16 int 4 k "" + } + Length: 24 Alignment: 8 + /LNS::L/!internal/LNS::L + pack() + Structure LNS::L { + 0 KNS::K 24 "Base" + 24 int 4 l "" + } + Length: 32 Alignment: 8 + /MNS::M/!internal/MNS::M + pack() + Structure MNS::M { + 0 ENS::E 32 "Base" + 32 DNS::D 80 "Base" + 112 INS::I 56 "Base" + 168 LNS::L 32 "Base" + 200 int 4 m "" + } + Length: 208 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructM() { String expected = //@formatter:off @@ -4713,6 +5186,45 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructO1() { + String expected = + //@formatter:off + """ + /O1NS::O1 + pack() + Structure O1NS::O1 { + 0 O1NS::O1 56 "Self Base" + 56 char[64] 64 "Filler for 4 Unplaceable Virtual Bases: A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 120 Alignment: 8 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 a "" + } + Length: 24 Alignment: 8 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 b "" + } + Length: 24 Alignment: 8 + /O1NS::O1/!internal/O1NS::O1 + pack() + Structure O1NS::O1 { + 0 ANS::A 24 "Base" + 24 BNS::B 24 "Base" + 48 int 4 o1 "" + } + Length: 56 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructO1() { return convertCommentsToSpeculative(getExpectedStructO1()); } @@ -5037,6 +5549,36 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructO2() { + String expected = + //@formatter:off + """ + /O2NS::O2 + pack() + Structure O2NS::O2 { + 0 O2NS::O2 32 "Self Base" + 32 char[88] 88 "Filler for 5 Unplaceable Virtual Bases: BNS::B; A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 120 Alignment: 8 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 a "" + } + Length: 24 Alignment: 8 + /O2NS::O2/!internal/O2NS::O2 + pack() + Structure O2NS::O2 { + 0 ANS::A 24 "Base" + 24 int 4 o2 "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructO2() { return convertCommentsToSpeculative(getExpectedStructO2()); } @@ -5360,6 +5902,45 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructO3() { + String expected = + //@formatter:off + """ + /O3NS::O3 + pack() + Structure O3NS::O3 { + 0 O3NS::O3 56 "Self Base" + 56 char[64] 64 "Filler for 4 Unplaceable Virtual Bases: A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 120 Alignment: 8 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 a "" + } + Length: 24 Alignment: 8 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 b "" + } + Length: 24 Alignment: 8 + /O3NS::O3/!internal/O3NS::O3 + pack() + Structure O3NS::O3 { + 0 ANS::A 24 "Base" + 24 BNS::B 24 "Base" + 48 int 4 o3 "" + } + Length: 56 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructO3() { return convertCommentsToSpeculative(getExpectedStructO3()); } @@ -5684,6 +6265,36 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructO4() { + String expected = + //@formatter:off + """ + /O4NS::O4 + pack() + Structure O4NS::O4 { + 0 O4NS::O4 32 "Self Base" + 32 char[88] 88 "Filler for 5 Unplaceable Virtual Bases: BNS::B; A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2" + } + Length: 120 Alignment: 8 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 a "" + } + Length: 24 Alignment: 8 + /O4NS::O4/!internal/O4NS::O4 + pack() + Structure O4NS::O4 { + 0 ANS::A 24 "Base" + 24 int 4 o4 "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructO4() { return convertCommentsToSpeculative(getExpectedStructO4()); } @@ -6140,6 +6751,60 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructO() { + String expected = + //@formatter:off + """ + /ONS::O + pack() + Structure ONS::O { + 0 ONS::O 96 "Self Base" + 96 char[176] 176 "Filler for 7 Unplaceable Virtual Bases: O3NS::O3; O4NS::O4; A1NS::A1; A2NS::A2; B1NS::B1; B2NS::B2; BNS::B" + } + Length: 272 Alignment: 8 + /ANS::A/!internal/ANS::A + pack() + Structure ANS::A { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 a "" + } + Length: 24 Alignment: 8 + /BNS::B/!internal/BNS::B + pack() + Structure BNS::B { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 b "" + } + Length: 24 Alignment: 8 + /O1NS::O1/!internal/O1NS::O1 + pack() + Structure O1NS::O1 { + 0 ANS::A 24 "Base" + 24 BNS::B 24 "Base" + 48 int 4 o1 "" + } + Length: 56 Alignment: 8 + /O2NS::O2/!internal/O2NS::O2 + pack() + Structure O2NS::O2 { + 0 ANS::A 24 "Base" + 24 int 4 o2 "" + } + Length: 32 Alignment: 8 + /ONS::O/!internal/ONS::O + pack() + Structure ONS::O { + 0 O1NS::O1 56 "Base" + 56 O2NS::O2 32 "Base" + 88 int 4 o "" + } + Length: 96 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructO() { return convertCommentsToSpeculative(getExpectedStructO()); } @@ -6533,6 +7198,29 @@ public class Cfb464ProgramCreator extends ProgramCreator { expectedStructs.put(O, getExpectedStructO()); } + private static final Map fillerStructs = new LinkedHashMap<>(); + static { + fillerStructs.putAll(expectedStructs); + fillerStructs.put(A, getFillerStructA()); + fillerStructs.put(B, getFillerStructB()); + fillerStructs.put(C, getFillerStructC()); + fillerStructs.put(D, getFillerStructD()); + fillerStructs.put(E, getFillerStructE()); + fillerStructs.put(F, getFillerStructF()); + fillerStructs.put(G, getFillerStructG()); + fillerStructs.put(H, getFillerStructH()); + fillerStructs.put(I, getFillerStructI()); + fillerStructs.put(J, getFillerStructJ()); + fillerStructs.put(K, getFillerStructK()); + fillerStructs.put(L, getFillerStructL()); + fillerStructs.put(M, getFillerStructM()); + fillerStructs.put(O1, getFillerStructO1()); + fillerStructs.put(O2, getFillerStructO2()); + fillerStructs.put(O3, getFillerStructO3()); + fillerStructs.put(O4, getFillerStructO4()); + fillerStructs.put(O, getFillerStructO()); + } + private static final Map speculatedStructs = new LinkedHashMap<>(); static { speculatedStructs.put(A1, getSpeculatedStructA1()); @@ -6652,6 +7340,10 @@ public class Cfb464ProgramCreator extends ProgramCreator { return expectedStructs; } + public Map getFillerStructs() { + return fillerStructs; + } + public Map getSpeculatedStructs() { return speculatedStructs; } diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Egray832ProgramCreator.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Egray832ProgramCreator.java index 67c70384a6..e8ed7d3085 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Egray832ProgramCreator.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Egray832ProgramCreator.java @@ -2457,6 +2457,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructG() { + String expected = + //@formatter:off + """ + /G + pack() + Structure G { + 0 G 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 12 Alignment: 4 + /G/!internal/G + pack() + Structure G { + 0 pointer 4 {vbptr} "" + 4 int 4 g1 "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructG() { return convertCommentsToSpeculative(getExpectedStructG()); } @@ -2540,6 +2562,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructH() { + String expected = + //@formatter:off + """ + /H + pack() + Structure H { + 0 H 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 12 Alignment: 4 + /H/!internal/H + pack() + Structure H { + 0 pointer 4 {vbptr} "" + 4 int 4 h1 "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructH() { return convertCommentsToSpeculative(getExpectedStructH()); } @@ -2623,6 +2667,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructGG1() { + String expected = + //@formatter:off + """ + /GG1 + pack() + Structure GG1 { + 0 GG1 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: CC1" + } + Length: 12 Alignment: 4 + /GG1/!internal/GG1 + pack() + Structure GG1 { + 0 pointer 4 {vbptr} "" + 4 int 4 gg11 "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructGG1() { return convertCommentsToSpeculative(getExpectedStructGG1()); } @@ -2706,6 +2772,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructGG2() { + String expected = + //@formatter:off + """ + /GG2 + pack() + Structure GG2 { + 0 GG2 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: CC2" + } + Length: 12 Alignment: 4 + /GG2/!internal/GG2 + pack() + Structure GG2 { + 0 pointer 4 {vbptr} "" + 4 int 4 gg21 "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructGG2() { return convertCommentsToSpeculative(getExpectedStructGG2()); } @@ -2789,6 +2877,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructGG3() { + String expected = + //@formatter:off + """ + /GG3 + pack() + Structure GG3 { + 0 GG3 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: CC2" + } + Length: 12 Alignment: 4 + /GG3/!internal/GG3 + pack() + Structure GG3 { + 0 pointer 4 {vbptr} "" + 4 int 4 gg31 "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructGG3() { return convertCommentsToSpeculative(getExpectedStructGG3()); } @@ -2868,6 +2978,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructGG4() { + String expected = + //@formatter:off + """ + /GG4 + pack() + Structure GG4 { + 0 GG4 8 "Self Base" + 8 char[0] 0 "Filler for 1 Unplaceable Virtual Base: CC3" + } + Length: 8 Alignment: 4 + /GG4/!internal/GG4 + pack() + Structure GG4 { + 0 pointer 4 {vbptr} "" + 4 int 4 gg41 "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructGG4() { return convertCommentsToSpeculative(getExpectedStructGG4()); } @@ -2977,6 +3109,43 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI() { + String expected = + //@formatter:off + """ + /I + pack() + Structure I { + 0 I 20 "Self Base" + 20 char[4] 4 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 24 Alignment: 4 + /G/!internal/G + pack() + Structure G { + 0 pointer 4 {vbptr} "" + 4 int 4 g1 "" + } + Length: 8 Alignment: 4 + /H/!internal/H + pack() + Structure H { + 0 pointer 4 {vbptr} "" + 4 int 4 h1 "" + } + Length: 8 Alignment: 4 + /I/!internal/I + pack() + Structure I { + 0 G 8 "Base" + 8 H 8 "Base" + 16 int 4 i1 "" + } + Length: 20 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI() { return convertCommentsToSpeculative(getExpectedStructI()); } @@ -3069,6 +3238,27 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructGX1() { + String expected = + //@formatter:off + """ + /GX1 + pack() + Structure GX1 { + 0 GX1 4 "Self Base" + 4 char[4] 4 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 8 Alignment: 4 + /GX1/!internal/GX1 + pack() + Structure GX1 { + 0 pointer 4 {vbptr} "" + } + Length: 4 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructGX1() { return convertCommentsToSpeculative(getExpectedStructGX1()); } @@ -3146,6 +3336,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructHX1() { + String expected = + //@formatter:off + """ + /HX1 + pack() + Structure HX1 { + 0 HX1 4 "Self Base" + 4 char[4] 4 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 8 Alignment: 4 + /HX1/!internal/HX1 + pack() + Structure HX1 { + 0 pointer 4 {vbptr} "" + } + Length: 4 Alignment: 4 + """; + //@formatter:on + return expected; + } + private static String getSpeculatedStructHX1() { return convertCommentsToSpeculative(getExpectedStructHX1()); } @@ -3246,6 +3458,41 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructIX1() { + String expected = + //@formatter:off + """ + /IX1 + pack() + Structure IX1 { + 0 IX1 12 "Self Base" + 12 char[4] 4 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 16 Alignment: 4 + /GX1/!internal/GX1 + pack() + Structure GX1 { + 0 pointer 4 {vbptr} "" + } + Length: 4 Alignment: 4 + /HX1/!internal/HX1 + pack() + Structure HX1 { + 0 pointer 4 {vbptr} "" + } + Length: 4 Alignment: 4 + /IX1/!internal/IX1 + pack() + Structure IX1 { + 0 GX1 4 "Base" + 4 HX1 4 "Base" + 8 int 4 ix11 "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructIX1() { return convertCommentsToSpeculative(getExpectedStructIX1()); } @@ -3357,6 +3604,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructG1() { + String expected = + //@formatter:off + """ + /G1 + pack() + Structure G1 { + 0 G1 8 "Self Base" + 8 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 16 Alignment: 4 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 4 {vbptr} "" + 4 int 4 g11 "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructG1() { return convertCommentsToSpeculative(getExpectedStructG1()); } @@ -3453,6 +3722,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructH1() { + String expected = + //@formatter:off + """ + /H1 + pack() + Structure H1 { + 0 H1 8 "Self Base" + 8 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: E; C" + } + Length: 16 Alignment: 4 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 4 {vbptr} "" + 4 int 4 h11 "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructH1() { return convertCommentsToSpeculative(getExpectedStructH1()); } @@ -3575,6 +3866,43 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI1() { + String expected = + //@formatter:off + """ + /I1 + pack() + Structure I1 { + 0 I1 20 "Self Base" + 20 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 28 Alignment: 4 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 4 {vbptr} "" + 4 int 4 g11 "" + } + Length: 8 Alignment: 4 + /H/!internal/H + pack() + Structure H { + 0 pointer 4 {vbptr} "" + 4 int 4 h1 "" + } + Length: 8 Alignment: 4 + /I1/!internal/I1 + pack() + Structure I1 { + 0 G1 8 "Base" + 8 H 8 "Base" + 16 int 4 i11 "" + } + Length: 20 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI1() { return convertCommentsToSpeculative(getExpectedStructI1()); } @@ -3714,6 +4042,43 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI2() { + String expected = + //@formatter:off + """ + /I2 + pack() + Structure I2 { + 0 I2 20 "Self Base" + 20 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 28 Alignment: 4 + /G/!internal/G + pack() + Structure G { + 0 pointer 4 {vbptr} "" + 4 int 4 g1 "" + } + Length: 8 Alignment: 4 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 4 {vbptr} "" + 4 int 4 h11 "" + } + Length: 8 Alignment: 4 + /I2/!internal/I2 + pack() + Structure I2 { + 0 G 8 "Base" + 8 H1 8 "Base" + 16 int 4 i21 "" + } + Length: 20 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI2() { return convertCommentsToSpeculative(getExpectedStructI2()); } @@ -3854,6 +4219,43 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI3() { + String expected = + //@formatter:off + """ + /I3 + pack() + Structure I3 { + 0 I3 20 "Self Base" + 20 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 28 Alignment: 4 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 4 {vbptr} "" + 4 int 4 g11 "" + } + Length: 8 Alignment: 4 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 4 {vbptr} "" + 4 int 4 h11 "" + } + Length: 8 Alignment: 4 + /I3/!internal/I3 + pack() + Structure I3 { + 0 G1 8 "Base" + 8 H1 8 "Base" + 16 int 4 i31 "" + } + Length: 20 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI3() { return convertCommentsToSpeculative(getExpectedStructI3()); } @@ -3977,6 +4379,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI4() { + String expected = + //@formatter:off + """ + /I4 + pack() + Structure I4 { + 0 I4 12 "Self Base" + 12 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: E; C" + } + Length: 20 Alignment: 4 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 4 {vbptr} "" + 4 int 4 g11 "" + } + Length: 8 Alignment: 4 + /I4/!internal/I4 + pack() + Structure I4 { + 0 G1 8 "Base" + 8 int 4 i41 "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI4() { return convertCommentsToSpeculative(getExpectedStructI4()); } @@ -4083,6 +4514,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI5() { + String expected = + //@formatter:off + """ + /I5 + pack() + Structure I5 { + 0 I5 12 "Self Base" + 12 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: E; C" + } + Length: 20 Alignment: 4 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 4 {vbptr} "" + 4 int 4 g11 "" + } + Length: 8 Alignment: 4 + /I5/!internal/I5 + pack() + Structure I5 { + 0 G1 8 "Base" + 8 int 4 i51 "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + /** * Test struct I5 - 32 - speculative placement *

THIS TEST STILL HAS PROBLEMS... @@ -4309,6 +4769,73 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ1() { + String expected = + //@formatter:off + """ + /J1 + pack() + Structure J1 { + 0 J1 44 "Self Base" + 44 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 52 Alignment: 4 + /G/!internal/G + pack() + Structure G { + 0 pointer 4 {vbptr} "" + 4 int 4 g1 "" + } + Length: 8 Alignment: 4 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 4 {vbptr} "" + 4 int 4 g11 "" + } + Length: 8 Alignment: 4 + /H/!internal/H + pack() + Structure H { + 0 pointer 4 {vbptr} "" + 4 int 4 h1 "" + } + Length: 8 Alignment: 4 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 4 {vbptr} "" + 4 int 4 h11 "" + } + Length: 8 Alignment: 4 + /I1/!internal/I1 + pack() + Structure I1 { + 0 G1 8 "Base" + 8 H 8 "Base" + 16 int 4 i11 "" + } + Length: 20 Alignment: 4 + /I2/!internal/I2 + pack() + Structure I2 { + 0 G 8 "Base" + 8 H1 8 "Base" + 16 int 4 i21 "" + } + Length: 20 Alignment: 4 + /J1/!internal/J1 + pack() + Structure J1 { + 0 I1 20 "Base" + 20 I2 20 "Base" + 40 int 4 j11 "" + } + Length: 44 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructJ1() { return convertCommentsToSpeculative(getExpectedStructJ1()); } @@ -4535,6 +5062,73 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ2() { + String expected = + //@formatter:off + """ + /J2 + pack() + Structure J2 { + 0 J2 44 "Self Base" + 44 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 52 Alignment: 4 + /G/!internal/G + pack() + Structure G { + 0 pointer 4 {vbptr} "" + 4 int 4 g1 "" + } + Length: 8 Alignment: 4 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 4 {vbptr} "" + 4 int 4 g11 "" + } + Length: 8 Alignment: 4 + /H/!internal/H + pack() + Structure H { + 0 pointer 4 {vbptr} "" + 4 int 4 h1 "" + } + Length: 8 Alignment: 4 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 4 {vbptr} "" + 4 int 4 h11 "" + } + Length: 8 Alignment: 4 + /I1/!internal/I1 + pack() + Structure I1 { + 0 G1 8 "Base" + 8 H 8 "Base" + 16 int 4 i11 "" + } + Length: 20 Alignment: 4 + /I2/!internal/I2 + pack() + Structure I2 { + 0 G 8 "Base" + 8 H1 8 "Base" + 16 int 4 i21 "" + } + Length: 20 Alignment: 4 + /J2/!internal/J2 + pack() + Structure J2 { + 0 I2 20 "Base" + 20 I1 20 "Base" + 40 int 4 j21 "" + } + Length: 44 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructJ2() { return convertCommentsToSpeculative(getExpectedStructJ2()); } @@ -4774,6 +5368,81 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ3() { + String expected = + //@formatter:off + """ + /J3 + pack() + Structure J3 { + 0 J3 52 "Self Base" + 52 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 60 Alignment: 4 + /A + pack() + Structure A { + 0 char 1 c "" + 4 int 4 i "" + } + Length: 8 Alignment: 4 + /G/!internal/G + pack() + Structure G { + 0 pointer 4 {vbptr} "" + 4 int 4 g1 "" + } + Length: 8 Alignment: 4 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 4 {vbptr} "" + 4 int 4 g11 "" + } + Length: 8 Alignment: 4 + /H/!internal/H + pack() + Structure H { + 0 pointer 4 {vbptr} "" + 4 int 4 h1 "" + } + Length: 8 Alignment: 4 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 4 {vbptr} "" + 4 int 4 h11 "" + } + Length: 8 Alignment: 4 + /I1/!internal/I1 + pack() + Structure I1 { + 0 G1 8 "Base" + 8 H 8 "Base" + 16 int 4 i11 "" + } + Length: 20 Alignment: 4 + /I2/!internal/I2 + pack() + Structure I2 { + 0 G 8 "Base" + 8 H1 8 "Base" + 16 int 4 i21 "" + } + Length: 20 Alignment: 4 + /J3/!internal/J3 + pack() + Structure J3 { + 0 I2 20 "Base" + 20 I1 20 "Base" + 40 A 8 "Base" + 48 int 4 j31 "" + } + Length: 52 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructJ3() { return convertCommentsToSpeculative(getExpectedStructJ3()); } @@ -5088,6 +5757,89 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ4() { + String expected = + //@formatter:off + """ + /J4 + pack() + Structure J4 { + 0 J4 60 "Self Base" + 60 char[32] 32 "Filler for 6 Unplaceable Virtual Bases: GG2; GG3; C; E; CC1; CC2" + } + Length: 92 Alignment: 4 + /A + pack() + Structure A { + 0 char 1 c "" + 4 int 4 i "" + } + Length: 8 Alignment: 4 + /G/!internal/G + pack() + Structure G { + 0 pointer 4 {vbptr} "" + 4 int 4 g1 "" + } + Length: 8 Alignment: 4 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 4 {vbptr} "" + 4 int 4 g11 "" + } + Length: 8 Alignment: 4 + /GG1/!internal/GG1 + pack() + Structure GG1 { + 0 pointer 4 {vbptr} "" + 4 int 4 gg11 "" + } + Length: 8 Alignment: 4 + /H/!internal/H + pack() + Structure H { + 0 pointer 4 {vbptr} "" + 4 int 4 h1 "" + } + Length: 8 Alignment: 4 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 4 {vbptr} "" + 4 int 4 h11 "" + } + Length: 8 Alignment: 4 + /I/!internal/I + pack() + Structure I { + 0 G 8 "Base" + 8 H 8 "Base" + 16 int 4 i1 "" + } + Length: 20 Alignment: 4 + /I3/!internal/I3 + pack() + Structure I3 { + 0 G1 8 "Base" + 8 H1 8 "Base" + 16 int 4 i31 "" + } + Length: 20 Alignment: 4 + /J4/!internal/J4 + pack() + Structure J4 { + 0 I3 20 "Base" + 20 GG1 8 "Base" + 28 I 20 "Base" + 48 A 8 "Base" + 56 int 4 j41 "" + } + Length: 60 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructJ4() { return convertCommentsToSpeculative(getExpectedStructJ4()); } @@ -5868,6 +6620,37 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ6() { + String expected = + //@formatter:off + """ + /J6 + pack() + Structure J6 { + 0 J6 16 "Self Base" + 16 char[20] 20 "Filler for 4 Unplaceable Virtual Bases: GG4; GG3; CC3; CC2" + } + Length: 36 Alignment: 4 + /A + pack() + Structure A { + 0 char 1 c "" + 4 int 4 i "" + } + Length: 8 Alignment: 4 + /J6/!internal/J6 + pack() + Structure J6 { + 0 A 8 "Base" + 8 pointer 4 {vbptr} "" + 12 int 4 j61 "" + } + Length: 16 Alignment: 4"""; + + //@formatter:on + return expected; + } + // TODO: Need to work on layout algorithm... believe we can do better, but don't have // a decision on the best speculative results yet. private static String getSpeculatedStructJ6() { @@ -6394,6 +7177,29 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructT() { + String expected = + //@formatter:off + """ + /T + pack() + Structure T { + 0 T 12 "Self Base" + 12 char[12] 12 "Filler for 1 Unplaceable Virtual Base: P" + } + Length: 24 Alignment: 4 + /T/!internal/T + pack() + Structure T { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 t1 "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructT() { String expected = //@formatter:off @@ -6581,6 +7387,36 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructU() { + String expected = + //@formatter:off + """ + /U + pack() + Structure U { + 0 U 16 "Self Base" + 16 char[12] 12 "Filler for 1 Unplaceable Virtual Base: P" + } + Length: 28 Alignment: 4 + /T/!internal/T + pack() + Structure T { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 t1 "" + } + Length: 12 Alignment: 4 + /U/!internal/U + pack() + Structure U { + 0 T 12 "Base" + 12 int 4 u1 "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructU() { String expected = //@formatter:off @@ -7325,6 +8161,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA3a() { + String expected = + //@formatter:off + """ + /AA3a + pack() + Structure AA3a { + 0 AA3a 8 "Self Base" + 8 char[12] 12 "Filler for 1 Unplaceable Virtual Base: AA2" + } + Length: 20 Alignment: 4 + /AA3a/!internal/AA3a + pack() + Structure AA3a { + 0 pointer 4 {vbptr} "" + 4 int 4 aa3ai "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA3a() { return convertCommentsToSpeculative(getExpectedStructAA3a()); } @@ -7423,6 +8281,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA3b() { + String expected = + //@formatter:off + """ + /AA3b + pack() + Structure AA3b { + 0 AA3b 8 "Self Base" + 8 char[12] 12 "Filler for 1 Unplaceable Virtual Base: AA2" + } + Length: 20 Alignment: 4 + /AA3b/!internal/AA3b + pack() + Structure AA3b { + 0 pointer 4 {vbptr} "" + 4 int 4 aa3bi "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA3b() { return convertCommentsToSpeculative(getExpectedStructAA3b()); } @@ -7579,6 +8459,43 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA3c() { + String expected = + //@formatter:off + """ + /AA3c + pack() + Structure AA3c { + 0 AA3c 20 "Self Base" + 20 char[24] 24 "Filler for 2 Unplaceable Virtual Bases: AA1; AA2" + } + Length: 44 Alignment: 4 + /AA3a/!internal/AA3a + pack() + Structure AA3a { + 0 pointer 4 {vbptr} "" + 4 int 4 aa3ai "" + } + Length: 8 Alignment: 4 + /AA3b/!internal/AA3b + pack() + Structure AA3b { + 0 pointer 4 {vbptr} "" + 4 int 4 aa3bi "" + } + Length: 8 Alignment: 4 + /AA3c/!internal/AA3c + pack() + Structure AA3c { + 0 AA3a 8 "Base" + 8 AA3b 8 "Base" + 16 int 4 aa3ci "" + } + Length: 20 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA3c() { String expected = //@formatter:off @@ -7836,6 +8753,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA3d() { + String expected = + //@formatter:off + """ + /AA3d + pack() + Structure AA3d { + 0 AA3d 8 "Self Base" + 8 char[40] 40 "Filler for 4 Unplaceable Virtual Bases: AA1; AA3a; AA3b; AA2" + } + Length: 48 Alignment: 4 + /AA3d/!internal/AA3d + pack() + Structure AA3d { + 0 pointer 4 {vbptr} "" + 4 int 4 aa3di "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA3d() { String expected = //@formatter:off @@ -8212,6 +9151,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA3g() { + String expected = + //@formatter:off + """ + /AA3g + pack() + Structure AA3g { + 0 AA3g 8 "Self Base" + 8 char[32] 32 "Filler for 2 Unplaceable Virtual Bases: AA3e; AA3f" + } + Length: 40 Alignment: 4 + /AA3g/!internal/AA3g + pack() + Structure AA3g { + 0 pointer 4 {vbptr} "" + 4 int 4 aa3gi "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA3g() { return convertCommentsToSpeculative(getExpectedStructAA3g()); } @@ -8311,6 +9272,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4a() { + String expected = + //@formatter:off + """ + /AA4a + pack() + Structure AA4a { + 0 AA4a 8 "Self Base" + 8 char[12] 12 "Filler for 1 Unplaceable Virtual Base: AA1" + } + Length: 20 Alignment: 4 + /AA4a/!internal/AA4a + pack() + Structure AA4a { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4ai "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4a() { return convertCommentsToSpeculative(getExpectedStructAA4a()); } @@ -8409,6 +9392,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4b() { + String expected = + //@formatter:off + """ + /AA4b + pack() + Structure AA4b { + 0 AA4b 8 "Self Base" + 8 char[12] 12 "Filler for 1 Unplaceable Virtual Base: AA1" + } + Length: 20 Alignment: 4 + /AA4b/!internal/AA4b + pack() + Structure AA4b { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4bi "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4b() { return convertCommentsToSpeculative(getExpectedStructAA4b()); } @@ -8533,6 +9538,43 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4c() { + String expected = + //@formatter:off + """ + /AA4c + pack() + Structure AA4c { + 0 AA4c 20 "Self Base" + 20 char[12] 12 "Filler for 1 Unplaceable Virtual Base: AA1" + } + Length: 32 Alignment: 4 + /AA4a/!internal/AA4a + pack() + Structure AA4a { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4ai "" + } + Length: 8 Alignment: 4 + /AA4b/!internal/AA4b + pack() + Structure AA4b { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4bi "" + } + Length: 8 Alignment: 4 + /AA4c/!internal/AA4c + pack() + Structure AA4c { + 0 AA4a 8 "Base" + 8 AA4b 8 "Base" + 16 int 4 aa4ci "" + } + Length: 20 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4c() { return convertCommentsToSpeculative(getExpectedStructAA4c()); } @@ -8675,6 +9717,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4d() { + String expected = + //@formatter:off + """ + /AA4d + pack() + Structure AA4d { + 0 AA4d 12 "Self Base" + 12 char[20] 20 "Filler for 2 Unplaceable Virtual Bases: AA4a; AA1" + } + Length: 32 Alignment: 4 + /AA4b/!internal/AA4b + pack() + Structure AA4b { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4bi "" + } + Length: 8 Alignment: 4 + /AA4d/!internal/AA4d + pack() + Structure AA4d { + 0 AA4b 8 "Base" + 8 int 4 aa4di "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4d() { return convertCommentsToSpeculative(getExpectedStructAA4d()); } @@ -8818,6 +9889,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4e() { + String expected = + //@formatter:off + """ + /AA4e + pack() + Structure AA4e { + 0 AA4e 12 "Self Base" + 12 char[20] 20 "Filler for 2 Unplaceable Virtual Bases: AA4b; AA1" + } + Length: 32 Alignment: 4 + /AA4a/!internal/AA4a + pack() + Structure AA4a { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4ai "" + } + Length: 8 Alignment: 4 + /AA4e/!internal/AA4e + pack() + Structure AA4e { + 0 AA4a 8 "Base" + 8 int 4 aa4ei "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4e() { return convertCommentsToSpeculative(getExpectedStructAA4e()); } @@ -8969,6 +10069,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4f() { + String expected = + //@formatter:off + """ + /AA4f + pack() + Structure AA4f { + 0 AA4f 8 "Self Base" + 8 char[28] 28 "Filler for 3 Unplaceable Virtual Bases: AA4a; AA4b; AA1" + } + Length: 36 Alignment: 4 + /AA4f/!internal/AA4f + pack() + Structure AA4f { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4fi "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4f() { return convertCommentsToSpeculative(getExpectedStructAA4f()); } @@ -9111,6 +10233,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4g() { + String expected = + //@formatter:off + """ + /AA4g + pack() + Structure AA4g { + 0 AA4g 12 "Self Base" + 12 char[12] 12 "Filler for 1 Unplaceable Virtual Base: AA1" + } + Length: 24 Alignment: 4 + /AA4b/!internal/AA4b + pack() + Structure AA4b { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4bi "" + } + Length: 8 Alignment: 4 + /AA4g/!internal/AA4g + pack() + Structure AA4g { + 0 AA4b 8 "Base" + 8 int 4 aa4gi "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4g() { return convertCommentsToSpeculative(getExpectedStructAA4g()); } @@ -9227,6 +10378,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4j() { + String expected = + //@formatter:off + """ + /AA4j + pack() + Structure AA4j { + 0 AA4j 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 12 Alignment: 4 + /AA4j/!internal/AA4j + pack() + Structure AA4j { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4ji "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4j() { return convertCommentsToSpeculative(getExpectedStructAA4j()); } @@ -9305,6 +10478,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4k() { + String expected = + //@formatter:off + """ + /AA4k + pack() + Structure AA4k { + 0 AA4k 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 12 Alignment: 4 + /AA4k/!internal/AA4k + pack() + Structure AA4k { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4ki "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4k() { return convertCommentsToSpeculative(getExpectedStructAA4k()); } @@ -9393,6 +10588,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4m() { + String expected = + //@formatter:off + """ + /AA4m + pack() + Structure AA4m { + 0 AA4m 12 "Self Base" + 12 char[4] 4 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 16 Alignment: 4 + /AA4j/!internal/AA4j + pack() + Structure AA4j { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4ji "" + } + Length: 8 Alignment: 4 + /AA4m/!internal/AA4m + pack() + Structure AA4m { + 0 AA4j 8 "Base" + 8 int 4 aa4mi "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4m() { return convertCommentsToSpeculative(getExpectedStructAA4m()); } @@ -9481,6 +10705,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4n() { + String expected = + //@formatter:off + """ + /AA4n + pack() + Structure AA4n { + 0 AA4n 12 "Self Base" + 12 char[4] 4 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 16 Alignment: 4 + /AA4k/!internal/AA4k + pack() + Structure AA4k { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4ki "" + } + Length: 8 Alignment: 4 + /AA4n/!internal/AA4n + pack() + Structure AA4n { + 0 AA4k 8 "Base" + 8 int 4 aa4ni "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4n() { return convertCommentsToSpeculative(getExpectedStructAA4n()); } @@ -9579,6 +10832,42 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4p() { + String expected = + //@formatter:off + """ + /AA4p + pack() + Structure AA4p { + 0 AA4p 16 "Self Base" + 16 char[4] 4 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 20 Alignment: 4 + /AA4j/!internal/AA4j + pack() + Structure AA4j { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4ji "" + } + Length: 8 Alignment: 4 + /AA4m/!internal/AA4m + pack() + Structure AA4m { + 0 AA4j 8 "Base" + 8 int 4 aa4mi "" + } + Length: 12 Alignment: 4 + /AA4p/!internal/AA4p + pack() + Structure AA4p { + 0 AA4m 12 "Base" + 12 int 4 aa4pi "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4p() { return convertCommentsToSpeculative(getExpectedStructAA4p()); } @@ -9703,6 +10992,57 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4q() { + String expected = + //@formatter:off + """ + /AA4q + pack() + Structure AA4q { + 0 AA4q 28 "Self Base" + 28 char[4] 4 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 32 Alignment: 4 + /AA4j/!internal/AA4j + pack() + Structure AA4j { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4ji "" + } + Length: 8 Alignment: 4 + /AA4k/!internal/AA4k + pack() + Structure AA4k { + 0 pointer 4 {vbptr} "" + 4 int 4 aa4ki "" + } + Length: 8 Alignment: 4 + /AA4m/!internal/AA4m + pack() + Structure AA4m { + 0 AA4j 8 "Base" + 8 int 4 aa4mi "" + } + Length: 12 Alignment: 4 + /AA4n/!internal/AA4n + pack() + Structure AA4n { + 0 AA4k 8 "Base" + 8 int 4 aa4ni "" + } + Length: 12 Alignment: 4 + /AA4q/!internal/AA4q + pack() + Structure AA4q { + 0 AA4n 12 "Base" + 12 AA4m 12 "Base" + 24 int 4 aa4qi "" + } + Length: 28 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4q() { return convertCommentsToSpeculative(getExpectedStructAA4q()); } @@ -9967,6 +11307,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA5e() { + String expected = + //@formatter:off + """ + /AA5e + pack() + Structure AA5e { + 0 AA5e 12 "Self Base" + 12 char[4] 4 "Filler for 1 Unplaceable Virtual Base: AA5b" + } + Length: 16 Alignment: 4 + /AA5a + pack() + Structure AA5a { + 0 int 4 aa5ai "" + } + Length: 4 Alignment: 4 + /AA5e/!internal/AA5e + pack() + Structure AA5e { + 0 AA5a 4 "Base" + 4 pointer 4 {vbptr} "" + 8 int 4 aa5ei "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA5e() { return convertCommentsToSpeculative(getExpectedStructAA5e()); } @@ -10055,6 +11424,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA5f() { + String expected = + //@formatter:off + """ + /AA5f + pack() + Structure AA5f { + 0 AA5f 12 "Self Base" + 12 char[4] 4 "Filler for 1 Unplaceable Virtual Base: AA5d" + } + Length: 16 Alignment: 4 + /AA5c + pack() + Structure AA5c { + 0 int 4 aa5ci "" + } + Length: 4 Alignment: 4 + /AA5f/!internal/AA5f + pack() + Structure AA5f { + 0 AA5c 4 "Base" + 4 pointer 4 {vbptr} "" + 8 int 4 aa5fi "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA5f() { return convertCommentsToSpeculative(getExpectedStructAA5f()); } @@ -10171,6 +11569,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA5g() { + String expected = + //@formatter:off + """ + /AA5g + pack() + Structure AA5g { + 0 AA5g 12 "Self Base" + 12 char[16] 16 "Filler for 2 Unplaceable Virtual Bases: AA5e; AA5b" + } + Length: 28 Alignment: 4 + /AA5c + pack() + Structure AA5c { + 0 int 4 aa5ci "" + } + Length: 4 Alignment: 4 + /AA5g/!internal/AA5g + pack() + Structure AA5g { + 0 AA5c 4 "Base" + 4 pointer 4 {vbptr} "" + 8 int 4 aa5gi "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA5g() { return convertCommentsToSpeculative(getExpectedStructAA5g()); } @@ -10308,6 +11735,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA5h() { + String expected = + //@formatter:off + """ + /AA5h + pack() + Structure AA5h { + 0 AA5h 12 "Self Base" + 12 char[16] 16 "Filler for 2 Unplaceable Virtual Bases: AA5f; AA5d" + } + Length: 28 Alignment: 4 + /AA5a + pack() + Structure AA5a { + 0 int 4 aa5ai "" + } + Length: 4 Alignment: 4 + /AA5h/!internal/AA5h + pack() + Structure AA5h { + 0 AA5a 4 "Base" + 4 pointer 4 {vbptr} "" + 8 int 4 aa5hi "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA5h() { return convertCommentsToSpeculative(getExpectedStructAA5h()); } @@ -10510,6 +11966,57 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA5j() { + String expected = + //@formatter:off + """ + /AA5j + pack() + Structure AA5j { + 0 AA5j 28 "Self Base" + 28 char[32] 32 "Filler for 4 Unplaceable Virtual Bases: AA5b; AA5e; AA5d; AA5f" + } + Length: 60 Alignment: 4 + /AA5a + pack() + Structure AA5a { + 0 int 4 aa5ai "" + } + Length: 4 Alignment: 4 + /AA5c + pack() + Structure AA5c { + 0 int 4 aa5ci "" + } + Length: 4 Alignment: 4 + /AA5g/!internal/AA5g + pack() + Structure AA5g { + 0 AA5c 4 "Base" + 4 pointer 4 {vbptr} "" + 8 int 4 aa5gi "" + } + Length: 12 Alignment: 4 + /AA5h/!internal/AA5h + pack() + Structure AA5h { + 0 AA5a 4 "Base" + 4 pointer 4 {vbptr} "" + 8 int 4 aa5hi "" + } + Length: 12 Alignment: 4 + /AA5j/!internal/AA5j + pack() + Structure AA5j { + 0 AA5g 12 "Base" + 12 AA5h 12 "Base" + 24 int 4 aa5ji "" + } + Length: 28 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA5j() { return convertCommentsToSpeculative(getExpectedStructAA5j()); } @@ -10734,6 +12241,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA6c() { + String expected = + //@formatter:off + """ + /AA6c + pack() + Structure AA6c { + 0 AA6c 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: AA6a" + } + Length: 12 Alignment: 4 + /AA6c/!internal/AA6c + pack() + Structure AA6c { + 0 pointer 4 {vbptr} "" + 4 int 4 aa6ci "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA6c() { return convertCommentsToSpeculative(getExpectedStructAA6c()); } @@ -10980,6 +12509,42 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA6g() { + String expected = + //@formatter:off + """ + /AA6g + pack() + Structure AA6g { + 0 AA6g 16 "Self Base" + 16 char[4] 4 "Filler for 1 Unplaceable Virtual Base: AA6a" + } + Length: 20 Alignment: 4 + /AA6a + pack() + Structure AA6a { + 0 int 4 aa6ai "" + } + Length: 4 Alignment: 4 + /AA6c/!internal/AA6c + pack() + Structure AA6c { + 0 pointer 4 {vbptr} "" + 4 int 4 aa6ci "" + } + Length: 8 Alignment: 4 + /AA6g/!internal/AA6g + pack() + Structure AA6g { + 0 AA6c 8 "Base" + 8 int 4 aa6gi "" + 12 AA6a 4 aa6a "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA6g() { return convertCommentsToSpeculative(getExpectedStructAA6g()); } @@ -11078,6 +12643,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA6h() { + String expected = + //@formatter:off + """ + /AA6h + pack() + Structure AA6h { + 0 AA6h 12 "Self Base" + 12 char[12] 12 "Filler for 2 Unplaceable Virtual Bases: AA6c; AA6a" + } + Length: 24 Alignment: 4 + /AA6a + pack() + Structure AA6a { + 0 int 4 aa6ai "" + } + Length: 4 Alignment: 4 + /AA6h/!internal/AA6h + pack() + Structure AA6h { + 0 pointer 4 {vbptr} "" + 4 int 4 aa6hi "" + 8 AA6a 4 aa6a "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA6h() { return convertCommentsToSpeculative(getExpectedStructAA6h()); } @@ -11199,6 +12793,36 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA6j() { + String expected = + //@formatter:off + """ + /AA6j + pack() + Structure AA6j { + 0 AA6j 16 "Self Base" + 16 char[12] 12 "Filler for 2 Unplaceable Virtual Bases: AA6c; AA6a" + } + Length: 28 Alignment: 4 + /AA6a + pack() + Structure AA6a { + 0 int 4 aa6ai "" + } + Length: 4 Alignment: 4 + /AA6j/!internal/AA6j + pack() + Structure AA6j { + 0 pointer 4 {vbptr} "" + 4 int 4 aa6hj "" + 8 AA6a 4 aa6a "" + 12 AA6j * 4 paa6j "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA6j() { return convertCommentsToSpeculative(getExpectedStructAA6j()); } @@ -11576,6 +13200,29 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA7d() { + String expected = + //@formatter:off + """ + /AA7d + pack() + Structure AA7d { + 0 AA7d 12 "Self Base" + 12 char[16] 16 "Filler for 2 Unplaceable Virtual Bases: AA7a; AA7b" + } + Length: 28 Alignment: 4 + /AA7d/!internal/AA7d + pack() + Structure AA7d { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 aa7di "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA7d() { return convertCommentsToSpeculative(getExpectedStructAA7d()); } @@ -11791,6 +13438,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB1c() { + String expected = + //@formatter:off + """ + /BB1c + pack() + Structure BB1c { + 0 BB1c 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: BB1a" + } + Length: 12 Alignment: 4 + /BB1c/!internal/BB1c + pack() + Structure BB1c { + 0 pointer 4 {vbptr} "" + 4 int 4 bb1ci "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB1c() { return convertCommentsToSpeculative(getExpectedStructBB1c()); } @@ -11893,6 +13562,49 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB1d() { + String expected = + //@formatter:off + """ + /BB1d + pack() + Structure BB1d { + 0 BB1d 20 "Self Base" + 20 char[4] 4 "Filler for 1 Unplaceable Virtual Base: BB1a" + } + Length: 24 Alignment: 4 + /BB1a + pack() + Structure BB1a { + 0 int 4 bb1ai "" + } + Length: 4 Alignment: 4 + /BB1b + pack() + Structure BB1b { + 0 BB1a 4 "Base" + 4 int 4 bb1bi "" + } + Length: 8 Alignment: 4 + /BB1c/!internal/BB1c + pack() + Structure BB1c { + 0 pointer 4 {vbptr} "" + 4 int 4 bb1ci "" + } + Length: 8 Alignment: 4 + /BB1d/!internal/BB1d + pack() + Structure BB1d { + 0 BB1b 8 "Base" + 8 BB1c 8 "Base" + 16 int 4 bb1di "" + } + Length: 20 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB1d() { return convertCommentsToSpeculative(getExpectedStructBB1d()); } @@ -12009,6 +13721,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB2a() { + String expected = + //@formatter:off + """ + /BB2a + pack() + Structure BB2a { + 0 BB2a 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: BB2z" + } + Length: 12 Alignment: 4 + /BB2a/!internal/BB2a + pack() + Structure BB2a { + 0 pointer 4 {vbptr} "" + 4 int 4 bb2ai "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB2a() { return convertCommentsToSpeculative(getExpectedStructBB2a()); } @@ -12097,6 +13831,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB2b() { + String expected = + //@formatter:off + """ + /BB2b + pack() + Structure BB2b { + 0 BB2b 12 "Self Base" + 12 char[4] 4 "Filler for 1 Unplaceable Virtual Base: BB2z" + } + Length: 16 Alignment: 4 + /BB2a/!internal/BB2a + pack() + Structure BB2a { + 0 pointer 4 {vbptr} "" + 4 int 4 bb2ai "" + } + Length: 8 Alignment: 4 + /BB2b/!internal/BB2b + pack() + Structure BB2b { + 0 BB2a 8 "Base" + 8 int 4 bb2bi "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB2b() { return convertCommentsToSpeculative(getExpectedStructBB2b()); } @@ -12193,6 +13956,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB2c() { + String expected = + //@formatter:off + """ + /BB2c + pack() + Structure BB2c { + 0 BB2c 8 "Self Base" + 8 char[12] 12 "Filler for 2 Unplaceable Virtual Bases: BB2a; BB2z" + } + Length: 20 Alignment: 4 + /BB2c/!internal/BB2c + pack() + Structure BB2c { + 0 pointer 4 {vbptr} "" + 4 int 4 bb2ci "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB2c() { return convertCommentsToSpeculative(getExpectedStructBB2c()); } @@ -12340,6 +14125,50 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB2d() { + String expected = + //@formatter:off + """ + /BB2d + pack() + Structure BB2d { + 0 BB2d 24 "Self Base" + 24 char[12] 12 "Filler for 2 Unplaceable Virtual Bases: BB2z; BB2a" + } + Length: 36 Alignment: 4 + /BB2a/!internal/BB2a + pack() + Structure BB2a { + 0 pointer 4 {vbptr} "" + 4 int 4 bb2ai "" + } + Length: 8 Alignment: 4 + /BB2b/!internal/BB2b + pack() + Structure BB2b { + 0 BB2a 8 "Base" + 8 int 4 bb2bi "" + } + Length: 12 Alignment: 4 + /BB2c/!internal/BB2c + pack() + Structure BB2c { + 0 pointer 4 {vbptr} "" + 4 int 4 bb2ci "" + } + Length: 8 Alignment: 4 + /BB2d/!internal/BB2d + pack() + Structure BB2d { + 0 BB2b 12 "Base" + 12 BB2c 8 "Base" + 20 int 4 bb2di "" + } + Length: 24 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB2d() { return convertCommentsToSpeculative(getExpectedStructBB2d()); } @@ -12480,6 +14309,42 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB2e() { + String expected = + //@formatter:off + """ + /BB2e + pack() + Structure BB2e { + 0 BB2e 16 "Self Base" + 16 char[4] 4 "Filler for 1 Unplaceable Virtual Base: BB2z" + } + Length: 20 Alignment: 4 + /BB2a/!internal/BB2a + pack() + Structure BB2a { + 0 pointer 4 {vbptr} "" + 4 int 4 bb2ai "" + } + Length: 8 Alignment: 4 + /BB2b/!internal/BB2b + pack() + Structure BB2b { + 0 BB2a 8 "Base" + 8 int 4 bb2bi "" + } + Length: 12 Alignment: 4 + /BB2e/!internal/BB2e + pack() + Structure BB2e { + 0 BB2b 12 "Base" + 12 int 4 bb2ei "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB2e() { return convertCommentsToSpeculative(getExpectedStructBB2e()); } @@ -12692,6 +14557,42 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB3d() { + String expected = + //@formatter:off + """ + /BB3d + pack() + Structure BB3d { + 0 BB3d 16 "Self Base" + 16 char[4] 4 "Filler for 1 Unplaceable Virtual Base: BB3b" + } + Length: 20 Alignment: 4 + /BB3a + pack() + Structure BB3a { + 0 int 4 bb3ai "" + } + Length: 4 Alignment: 4 + /BB3c + pack() + Structure BB3c { + 0 int 4 bb3ci "" + } + Length: 4 Alignment: 4 + /BB3d/!internal/BB3d + pack() + Structure BB3d { + 0 BB3a 4 "Base" + 4 BB3c 4 "Base" + 8 pointer 4 {vbptr} "" + 12 int 4 bb3di "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB3d() { return convertCommentsToSpeculative(getExpectedStructBB3d()); } @@ -12792,6 +14693,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB3e() { + String expected = + //@formatter:off + """ + /BB3e + pack() + Structure BB3e { + 0 BB3e 12 "Self Base" + 12 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: BB3a; BB3c" + } + Length: 20 Alignment: 4 + /BB3b + pack() + Structure BB3b { + 0 int 4 bb3bi "" + } + Length: 4 Alignment: 4 + /BB3e/!internal/BB3e + pack() + Structure BB3e { + 0 BB3b 4 "Base" + 4 pointer 4 {vbptr} "" + 8 int 4 bb3ei "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB3e() { return convertCommentsToSpeculative(getExpectedStructBB3e()); } @@ -12934,6 +14864,64 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB3f() { + String expected = + //@formatter:off + """ + /BB3f + pack() + Structure BB3f { + 0 BB3f 32 "Self Base" + 32 char[12] 12 "Filler for 3 Unplaceable Virtual Bases: BB3b; BB3a; BB3c" + } + Length: 44 Alignment: 4 + /BB3a + pack() + Structure BB3a { + 0 int 4 bb3ai "" + } + Length: 4 Alignment: 4 + /BB3b + pack() + Structure BB3b { + 0 int 4 bb3bi "" + } + Length: 4 Alignment: 4 + /BB3c + pack() + Structure BB3c { + 0 int 4 bb3ci "" + } + Length: 4 Alignment: 4 + /BB3d/!internal/BB3d + pack() + Structure BB3d { + 0 BB3a 4 "Base" + 4 BB3c 4 "Base" + 8 pointer 4 {vbptr} "" + 12 int 4 bb3di "" + } + Length: 16 Alignment: 4 + /BB3e/!internal/BB3e + pack() + Structure BB3e { + 0 BB3b 4 "Base" + 4 pointer 4 {vbptr} "" + 8 int 4 bb3ei "" + } + Length: 12 Alignment: 4 + /BB3f/!internal/BB3f + pack() + Structure BB3f { + 0 BB3d 16 "Base" + 16 BB3e 12 "Base" + 28 int 4 bb3fi "" + } + Length: 32 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB3f() { return convertCommentsToSpeculative(getExpectedStructBB3f()); } @@ -13093,6 +15081,64 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB3g() { + String expected = + //@formatter:off + """ + /BB3g + pack() + Structure BB3g { + 0 BB3g 32 "Self Base" + 32 char[12] 12 "Filler for 3 Unplaceable Virtual Bases: BB3a; BB3c; BB3b" + } + Length: 44 Alignment: 4 + /BB3a + pack() + Structure BB3a { + 0 int 4 bb3ai "" + } + Length: 4 Alignment: 4 + /BB3b + pack() + Structure BB3b { + 0 int 4 bb3bi "" + } + Length: 4 Alignment: 4 + /BB3c + pack() + Structure BB3c { + 0 int 4 bb3ci "" + } + Length: 4 Alignment: 4 + /BB3d/!internal/BB3d + pack() + Structure BB3d { + 0 BB3a 4 "Base" + 4 BB3c 4 "Base" + 8 pointer 4 {vbptr} "" + 12 int 4 bb3di "" + } + Length: 16 Alignment: 4 + /BB3e/!internal/BB3e + pack() + Structure BB3e { + 0 BB3b 4 "Base" + 4 pointer 4 {vbptr} "" + 8 int 4 bb3ei "" + } + Length: 12 Alignment: 4 + /BB3g/!internal/BB3g + pack() + Structure BB3g { + 0 BB3e 12 "Base" + 12 BB3d 16 "Base" + 28 int 4 bb3gi "" + } + Length: 32 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB3g() { return convertCommentsToSpeculative(getExpectedStructBB3g()); } @@ -13579,6 +15625,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructCC1h() { + String expected = + //@formatter:off + """ + /CC1h + pack() + Structure CC1h { + 0 CC1h 8 "Self Base" + 8 char[32] 32 "Filler for 6 Unplaceable Virtual Bases: CC1a; CC1b; CC1c; CC1d; CC1e; CC1f" + } + Length: 40 Alignment: 4 + /CC1h/!internal/CC1h + pack() + Structure CC1h { + 0 pointer 4 {vbptr} "" + 4 char 1 cc1hc "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructCC1h() { String expected = //@formatter:off @@ -14339,6 +16407,28 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructDD1b() { + String expected = + //@formatter:off + """ + /DD1b + pack() + Structure DD1b { + 0 DD1b 8 "Self Base" + 8 char[4] 4 "Filler for 1 Unplaceable Virtual Base: DD1a" + } + Length: 12 Alignment: 4 + /DD1b/!internal/DD1b + pack() + Structure DD1b { + 0 pointer 4 {vbptr} "" + 4 int 4 dd1bi "" + } + Length: 8 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructDD1b() { return convertCommentsToSpeculative(getExpectedStructDD1b()); } @@ -14427,6 +16517,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructDD1c() { + String expected = + //@formatter:off + """ + /DD1c + pack() + Structure DD1c { + 0 DD1c 12 "Self Base" + 12 char[4] 4 "Filler for 1 Unplaceable Virtual Base: DD1a" + } + Length: 16 Alignment: 4 + /DD1b/!internal/DD1b + pack() + Structure DD1b { + 0 pointer 4 {vbptr} "" + 4 int 4 dd1bi "" + } + Length: 8 Alignment: 4 + /DD1c/!internal/DD1c + pack() + Structure DD1c { + 0 DD1b 8 "Base" + 8 int 4 dd1ci "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructDD1c() { return convertCommentsToSpeculative(getExpectedStructDD1c()); } @@ -14515,6 +16634,35 @@ public class Egray832ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructDD1d() { + String expected = + //@formatter:off + """ + /DD1d + pack() + Structure DD1d { + 0 DD1d 12 "Self Base" + 12 char[4] 4 "Filler for 1 Unplaceable Virtual Base: DD1a" + } + Length: 16 Alignment: 4 + /DD1b/!internal/DD1b + pack() + Structure DD1b { + 0 pointer 4 {vbptr} "" + 4 int 4 dd1bi "" + } + Length: 8 Alignment: 4 + /DD1d/!internal/DD1d + pack() + Structure DD1d { + 0 DD1b 8 "Base" + 8 int 4 dd1di "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructDD1d() { return convertCommentsToSpeculative(getExpectedStructDD1d()); } @@ -14966,6 +17114,78 @@ public class Egray832ProgramCreator extends ProgramCreator { expectedStructs.put(DD2e, getExpectedStructDD2e()); } + private static final Map fillerStructs = new LinkedHashMap<>(); + static { + fillerStructs.putAll(expectedStructs); + fillerStructs.put(G, getFillerStructG()); + fillerStructs.put(H, getFillerStructH()); + fillerStructs.put(GG1, getFillerStructGG1()); + fillerStructs.put(GG2, getFillerStructGG2()); + fillerStructs.put(GG3, getFillerStructGG3()); + fillerStructs.put(GG4, getFillerStructGG4()); + fillerStructs.put(I, getFillerStructI()); + fillerStructs.put(GX1, getFillerStructGX1()); + fillerStructs.put(HX1, getFillerStructHX1()); + fillerStructs.put(IX1, getFillerStructIX1()); + fillerStructs.put(G1, getFillerStructG1()); + fillerStructs.put(H1, getFillerStructH1()); + fillerStructs.put(I1, getFillerStructI1()); + fillerStructs.put(I2, getFillerStructI2()); + fillerStructs.put(I3, getFillerStructI3()); + fillerStructs.put(I4, getFillerStructI4()); + fillerStructs.put(I5, getFillerStructI5()); + fillerStructs.put(J1, getFillerStructJ1()); + fillerStructs.put(J2, getFillerStructJ2()); + fillerStructs.put(J3, getFillerStructJ3()); + fillerStructs.put(J4, getFillerStructJ4()); + fillerStructs.put(J6, getFillerStructJ6()); + fillerStructs.put(T, getFillerStructT()); + fillerStructs.put(U, getFillerStructU()); + fillerStructs.put(AA3a, getFillerStructAA3a()); + fillerStructs.put(AA3b, getFillerStructAA3b()); + fillerStructs.put(AA3c, getFillerStructAA3c()); + fillerStructs.put(AA3d, getFillerStructAA3d()); + fillerStructs.put(AA3g, getFillerStructAA3g()); + fillerStructs.put(AA4a, getFillerStructAA4a()); + fillerStructs.put(AA4b, getFillerStructAA4b()); + fillerStructs.put(AA4c, getFillerStructAA4c()); + fillerStructs.put(AA4d, getFillerStructAA4d()); + fillerStructs.put(AA4e, getFillerStructAA4e()); + fillerStructs.put(AA4f, getFillerStructAA4f()); + fillerStructs.put(AA4g, getFillerStructAA4g()); + fillerStructs.put(AA4j, getFillerStructAA4j()); + fillerStructs.put(AA4k, getFillerStructAA4k()); + fillerStructs.put(AA4m, getFillerStructAA4m()); + fillerStructs.put(AA4n, getFillerStructAA4n()); + fillerStructs.put(AA4p, getFillerStructAA4p()); + fillerStructs.put(AA4q, getFillerStructAA4q()); + fillerStructs.put(AA5e, getFillerStructAA5e()); + fillerStructs.put(AA5f, getFillerStructAA5f()); + fillerStructs.put(AA5g, getFillerStructAA5g()); + fillerStructs.put(AA5h, getFillerStructAA5h()); + fillerStructs.put(AA5j, getFillerStructAA5j()); + fillerStructs.put(AA6c, getFillerStructAA6c()); + fillerStructs.put(AA6g, getFillerStructAA6g()); + fillerStructs.put(AA6h, getFillerStructAA6h()); + fillerStructs.put(AA6j, getFillerStructAA6j()); + fillerStructs.put(AA7d, getFillerStructAA7d()); + fillerStructs.put(BB1c, getFillerStructBB1c()); + fillerStructs.put(BB1d, getFillerStructBB1d()); + fillerStructs.put(BB2a, getFillerStructBB2a()); + fillerStructs.put(BB2b, getFillerStructBB2b()); + fillerStructs.put(BB2c, getFillerStructBB2c()); + fillerStructs.put(BB2d, getFillerStructBB2d()); + fillerStructs.put(BB2e, getFillerStructBB2e()); + fillerStructs.put(BB3d, getFillerStructBB3d()); + fillerStructs.put(BB3e, getFillerStructBB3e()); + fillerStructs.put(BB3f, getFillerStructBB3f()); + fillerStructs.put(BB3g, getFillerStructBB3g()); + fillerStructs.put(CC1h, getFillerStructCC1h()); + fillerStructs.put(DD1b, getFillerStructDD1b()); + fillerStructs.put(DD1c, getFillerStructDD1c()); + fillerStructs.put(DD1d, getFillerStructDD1d()); + } + private static final Map speculatedStructs = new LinkedHashMap<>(); static { speculatedStructs.put(A, getSpeculatedStructA()); @@ -15440,6 +17660,10 @@ public class Egray832ProgramCreator extends ProgramCreator { return expectedStructs; } + public Map getFillerStructs() { + return fillerStructs; + } + public Map getSpeculatedStructs() { return speculatedStructs; } diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Egray864ProgramCreator.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Egray864ProgramCreator.java index 42b3cadb21..3ac1f58938 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Egray864ProgramCreator.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Egray864ProgramCreator.java @@ -2494,6 +2494,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructG() { + String expected = + //@formatter:off + """ + /G + pack() + Structure G { + 0 G 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 24 Alignment: 8 + /G/!internal/G + pack() + Structure G { + 0 pointer 8 {vbptr} "" + 8 int 4 g1 "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructG() { return convertCommentsToSpeculative(getExpectedStructG()); } @@ -2578,6 +2600,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructH() { + String expected = + //@formatter:off + """ + /H + pack() + Structure H { + 0 H 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 24 Alignment: 8 + /H/!internal/H + pack() + Structure H { + 0 pointer 8 {vbptr} "" + 8 int 4 h1 "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructH() { return convertCommentsToSpeculative(getExpectedStructH()); } @@ -2662,6 +2706,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructGG1() { + String expected = + //@formatter:off + """ + /GG1 + pack() + Structure GG1 { + 0 GG1 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: CC1" + } + Length: 24 Alignment: 8 + /GG1/!internal/GG1 + pack() + Structure GG1 { + 0 pointer 8 {vbptr} "" + 8 int 4 gg11 "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructGG1() { return convertCommentsToSpeculative(getExpectedStructGG1()); } @@ -2746,6 +2812,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructGG2() { + String expected = + //@formatter:off + """ + /GG2 + pack() + Structure GG2 { + 0 GG2 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: CC2" + } + Length: 24 Alignment: 8 + /GG2/!internal/GG2 + pack() + Structure GG2 { + 0 pointer 8 {vbptr} "" + 8 int 4 gg21 "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructGG2() { return convertCommentsToSpeculative(getExpectedStructGG2()); } @@ -2830,6 +2918,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructGG3() { + String expected = + //@formatter:off + """ + /GG3 + pack() + Structure GG3 { + 0 GG3 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: CC2" + } + Length: 24 Alignment: 8 + /GG3/!internal/GG3 + pack() + Structure GG3 { + 0 pointer 8 {vbptr} "" + 8 int 4 gg31 "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructGG3() { return convertCommentsToSpeculative(getExpectedStructGG3()); } @@ -2910,6 +3020,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructGG4() { + String expected = + //@formatter:off + """ + /GG4 + pack() + Structure GG4 { + 0 GG4 16 "Self Base" + 16 char[0] 0 "Filler for 1 Unplaceable Virtual Base: CC3" + } + Length: 16 Alignment: 8 + /GG4/!internal/GG4 + pack() + Structure GG4 { + 0 pointer 8 {vbptr} "" + 8 int 4 gg41 "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructGG4() { return convertCommentsToSpeculative(getExpectedStructGG4()); } @@ -3024,6 +3156,43 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI() { + String expected = + //@formatter:off + """ + /I + pack() + Structure I { + 0 I 40 "Self Base" + 40 char[8] 8 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 48 Alignment: 8 + /G/!internal/G + pack() + Structure G { + 0 pointer 8 {vbptr} "" + 8 int 4 g1 "" + } + Length: 16 Alignment: 8 + /H/!internal/H + pack() + Structure H { + 0 pointer 8 {vbptr} "" + 8 int 4 h1 "" + } + Length: 16 Alignment: 8 + /I/!internal/I + pack() + Structure I { + 0 G 16 "Base" + 16 H 16 "Base" + 32 int 4 i1 "" + } + Length: 40 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI() { return convertCommentsToSpeculative(getExpectedStructI()); } @@ -3121,6 +3290,27 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructGX1() { + String expected = + //@formatter:off + """ + /GX1 + pack() + Structure GX1 { + 0 GX1 8 "Self Base" + 8 char[8] 8 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 16 Alignment: 8 + /GX1/!internal/GX1 + pack() + Structure GX1 { + 0 pointer 8 {vbptr} "" + } + Length: 8 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructGX1() { return convertCommentsToSpeculative(getExpectedStructGX1()); } @@ -3203,6 +3393,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructHX1() { + String expected = + //@formatter:off + """ + /HX1 + pack() + Structure HX1 { + 0 HX1 8 "Self Base" + 8 char[8] 8 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 16 Alignment: 8 + /HX1/!internal/HX1 + pack() + Structure HX1 { + 0 pointer 8 {vbptr} "" + } + Length: 8 Alignment: 8 + """; + //@formatter:on + return expected; + } + private static String getSpeculatedStructHX1() { return convertCommentsToSpeculative(getExpectedStructHX1()); } @@ -3312,6 +3524,41 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructIX1() { + String expected = + //@formatter:off + """ + /IX1 + pack() + Structure IX1 { + 0 IX1 24 "Self Base" + 24 char[8] 8 "Filler for 1 Unplaceable Virtual Base: C" + } + Length: 32 Alignment: 8 + /GX1/!internal/GX1 + pack() + Structure GX1 { + 0 pointer 8 {vbptr} "" + } + Length: 8 Alignment: 8 + /HX1/!internal/HX1 + pack() + Structure HX1 { + 0 pointer 8 {vbptr} "" + } + Length: 8 Alignment: 8 + /IX1/!internal/IX1 + pack() + Structure IX1 { + 0 GX1 8 "Base" + 8 HX1 8 "Base" + 16 int 4 ix11 "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructIX1() { return convertCommentsToSpeculative(getExpectedStructIX1()); } @@ -3424,6 +3671,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructG1() { + String expected = + //@formatter:off + """ + /G1 + pack() + Structure G1 { + 0 G1 16 "Self Base" + 16 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 24 Alignment: 8 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 8 {vbptr} "" + 8 int 4 g11 "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructG1() { return convertCommentsToSpeculative(getExpectedStructG1()); } @@ -3521,6 +3790,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructH1() { + String expected = + //@formatter:off + """ + /H1 + pack() + Structure H1 { + 0 H1 16 "Self Base" + 16 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: E; C" + } + Length: 24 Alignment: 8 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 8 {vbptr} "" + 8 int 4 h11 "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructH1() { return convertCommentsToSpeculative(getExpectedStructH1()); } @@ -3647,6 +3938,43 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI1() { + String expected = + //@formatter:off + """ + /I1 + pack() + Structure I1 { + 0 I1 40 "Self Base" + 40 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 48 Alignment: 8 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 8 {vbptr} "" + 8 int 4 g11 "" + } + Length: 16 Alignment: 8 + /H/!internal/H + pack() + Structure H { + 0 pointer 8 {vbptr} "" + 8 int 4 h1 "" + } + Length: 16 Alignment: 8 + /I1/!internal/I1 + pack() + Structure I1 { + 0 G1 16 "Base" + 16 H 16 "Base" + 32 int 4 i11 "" + } + Length: 40 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI1() { return convertCommentsToSpeculative(getExpectedStructI1()); } @@ -3790,6 +4118,43 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI2() { + String expected = + //@formatter:off + """ + /I2 + pack() + Structure I2 { + 0 I2 40 "Self Base" + 40 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 48 Alignment: 8 + /G/!internal/G + pack() + Structure G { + 0 pointer 8 {vbptr} "" + 8 int 4 g1 "" + } + Length: 16 Alignment: 8 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 8 {vbptr} "" + 8 int 4 h11 "" + } + Length: 16 Alignment: 8 + /I2/!internal/I2 + pack() + Structure I2 { + 0 G 16 "Base" + 16 H1 16 "Base" + 32 int 4 i21 "" + } + Length: 40 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI2() { return convertCommentsToSpeculative(getExpectedStructI2()); } @@ -3933,6 +4298,43 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI3() { + String expected = + //@formatter:off + """ + /I3 + pack() + Structure I3 { + 0 I3 40 "Self Base" + 40 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 48 Alignment: 8 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 8 {vbptr} "" + 8 int 4 g11 "" + } + Length: 16 Alignment: 8 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 8 {vbptr} "" + 8 int 4 h11 "" + } + Length: 16 Alignment: 8 + /I3/!internal/I3 + pack() + Structure I3 { + 0 G1 16 "Base" + 16 H1 16 "Base" + 32 int 4 i31 "" + } + Length: 40 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI3() { return convertCommentsToSpeculative(getExpectedStructI3()); } @@ -4057,6 +4459,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI4() { + String expected = + //@formatter:off + """ + /I4 + pack() + Structure I4 { + 0 I4 24 "Self Base" + 24 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: E; C" + } + Length: 32 Alignment: 8 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 8 {vbptr} "" + 8 int 4 g11 "" + } + Length: 16 Alignment: 8 + /I4/!internal/I4 + pack() + Structure I4 { + 0 G1 16 "Base" + 16 int 4 i41 "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructI4() { return convertCommentsToSpeculative(getExpectedStructI4()); } @@ -4165,6 +4596,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructI5() { + String expected = + //@formatter:off + """ + /I5 + pack() + Structure I5 { + 0 I5 24 "Self Base" + 24 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: E; C" + } + Length: 32 Alignment: 8 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 8 {vbptr} "" + 8 int 4 g11 "" + } + Length: 16 Alignment: 8 + /I5/!internal/I5 + pack() + Structure I5 { + 0 G1 16 "Base" + 16 int 4 i51 "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + /** * Test struct I5 - 64 - speculative placement. *

THIS TEST STILL HAS PROBLEMS... @@ -4400,6 +4860,73 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ1() { + String expected = + //@formatter:off + """ + /J1 + pack() + Structure J1 { + 0 J1 88 "Self Base" + 88 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 96 Alignment: 8 + /G/!internal/G + pack() + Structure G { + 0 pointer 8 {vbptr} "" + 8 int 4 g1 "" + } + Length: 16 Alignment: 8 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 8 {vbptr} "" + 8 int 4 g11 "" + } + Length: 16 Alignment: 8 + /H/!internal/H + pack() + Structure H { + 0 pointer 8 {vbptr} "" + 8 int 4 h1 "" + } + Length: 16 Alignment: 8 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 8 {vbptr} "" + 8 int 4 h11 "" + } + Length: 16 Alignment: 8 + /I1/!internal/I1 + pack() + Structure I1 { + 0 G1 16 "Base" + 16 H 16 "Base" + 32 int 4 i11 "" + } + Length: 40 Alignment: 8 + /I2/!internal/I2 + pack() + Structure I2 { + 0 G 16 "Base" + 16 H1 16 "Base" + 32 int 4 i21 "" + } + Length: 40 Alignment: 8 + /J1/!internal/J1 + pack() + Structure J1 { + 0 I1 40 "Base" + 40 I2 40 "Base" + 80 int 4 j11 "" + } + Length: 88 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructJ1() { return convertCommentsToSpeculative(getExpectedStructJ1()); } @@ -4635,6 +5162,73 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ2() { + String expected = + //@formatter:off + """ + /J2 + pack() + Structure J2 { + 0 J2 88 "Self Base" + 88 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 96 Alignment: 8 + /G/!internal/G + pack() + Structure G { + 0 pointer 8 {vbptr} "" + 8 int 4 g1 "" + } + Length: 16 Alignment: 8 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 8 {vbptr} "" + 8 int 4 g11 "" + } + Length: 16 Alignment: 8 + /H/!internal/H + pack() + Structure H { + 0 pointer 8 {vbptr} "" + 8 int 4 h1 "" + } + Length: 16 Alignment: 8 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 8 {vbptr} "" + 8 int 4 h11 "" + } + Length: 16 Alignment: 8 + /I1/!internal/I1 + pack() + Structure I1 { + 0 G1 16 "Base" + 16 H 16 "Base" + 32 int 4 i11 "" + } + Length: 40 Alignment: 8 + /I2/!internal/I2 + pack() + Structure I2 { + 0 G 16 "Base" + 16 H1 16 "Base" + 32 int 4 i21 "" + } + Length: 40 Alignment: 8 + /J2/!internal/J2 + pack() + Structure J2 { + 0 I2 40 "Base" + 40 I1 40 "Base" + 80 int 4 j21 "" + } + Length: 88 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructJ2() { return convertCommentsToSpeculative(getExpectedStructJ2()); } @@ -4883,6 +5477,81 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ3() { + String expected = + //@formatter:off + """ + /J3 + pack() + Structure J3 { + 0 J3 96 "Self Base" + 96 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: C; E" + } + Length: 104 Alignment: 8 + /A + pack() + Structure A { + 0 char 1 c "" + 4 int 4 i "" + } + Length: 8 Alignment: 4 + /G/!internal/G + pack() + Structure G { + 0 pointer 8 {vbptr} "" + 8 int 4 g1 "" + } + Length: 16 Alignment: 8 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 8 {vbptr} "" + 8 int 4 g11 "" + } + Length: 16 Alignment: 8 + /H/!internal/H + pack() + Structure H { + 0 pointer 8 {vbptr} "" + 8 int 4 h1 "" + } + Length: 16 Alignment: 8 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 8 {vbptr} "" + 8 int 4 h11 "" + } + Length: 16 Alignment: 8 + /I1/!internal/I1 + pack() + Structure I1 { + 0 G1 16 "Base" + 16 H 16 "Base" + 32 int 4 i11 "" + } + Length: 40 Alignment: 8 + /I2/!internal/I2 + pack() + Structure I2 { + 0 G 16 "Base" + 16 H1 16 "Base" + 32 int 4 i21 "" + } + Length: 40 Alignment: 8 + /J3/!internal/J3 + pack() + Structure J3 { + 0 I2 40 "Base" + 40 I1 40 "Base" + 80 A 8 "Base" + 88 int 4 j31 "" + } + Length: 96 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructJ3() { return convertCommentsToSpeculative(getExpectedStructJ3()); } @@ -5213,6 +5882,89 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ4() { + String expected = + //@formatter:off + """ + /J4 + pack() + Structure J4 { + 0 J4 112 "Self Base" + 112 char[48] 48 "Filler for 6 Unplaceable Virtual Bases: GG2; GG3; C; E; CC1; CC2" + } + Length: 160 Alignment: 8 + /A + pack() + Structure A { + 0 char 1 c "" + 4 int 4 i "" + } + Length: 8 Alignment: 4 + /G/!internal/G + pack() + Structure G { + 0 pointer 8 {vbptr} "" + 8 int 4 g1 "" + } + Length: 16 Alignment: 8 + /G1/!internal/G1 + pack() + Structure G1 { + 0 pointer 8 {vbptr} "" + 8 int 4 g11 "" + } + Length: 16 Alignment: 8 + /GG1/!internal/GG1 + pack() + Structure GG1 { + 0 pointer 8 {vbptr} "" + 8 int 4 gg11 "" + } + Length: 16 Alignment: 8 + /H/!internal/H + pack() + Structure H { + 0 pointer 8 {vbptr} "" + 8 int 4 h1 "" + } + Length: 16 Alignment: 8 + /H1/!internal/H1 + pack() + Structure H1 { + 0 pointer 8 {vbptr} "" + 8 int 4 h11 "" + } + Length: 16 Alignment: 8 + /I/!internal/I + pack() + Structure I { + 0 G 16 "Base" + 16 H 16 "Base" + 32 int 4 i1 "" + } + Length: 40 Alignment: 8 + /I3/!internal/I3 + pack() + Structure I3 { + 0 G1 16 "Base" + 16 H1 16 "Base" + 32 int 4 i31 "" + } + Length: 40 Alignment: 8 + /J4/!internal/J4 + pack() + Structure J4 { + 0 I3 40 "Base" + 40 GG1 16 "Base" + 56 I 40 "Base" + 96 A 8 "Base" + 104 int 4 j41 "" + } + Length: 112 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructJ4() { return convertCommentsToSpeculative(getExpectedStructJ4()); } @@ -6015,6 +6767,36 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructJ6() { + String expected = + //@formatter:off + """ + /J6 + pack() + Structure J6 { + 0 J6 24 "Self Base" + 24 char[40] 40 "Filler for 4 Unplaceable Virtual Bases: GG4; GG3; CC3; CC2" + } + Length: 64 Alignment: 8 + /A + pack() + Structure A { + 0 char 1 c "" + 4 int 4 i "" + } + Length: 8 Alignment: 4 + /J6/!internal/J6 + pack() + Structure J6 { + 0 A 8 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 j61 "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + // TODO: Need to work on layout algorithm... believe we can do better, but don't have // a decision on the best speculative results yet. private static String getSpeculatedStructJ6() { @@ -6564,6 +7346,29 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructT() { + String expected = + //@formatter:off + """ + /T + pack() + Structure T { + 0 T 24 "Self Base" + 24 char[24] 24 "Filler for 1 Unplaceable Virtual Base: P" + } + Length: 48 Alignment: 8 + /T/!internal/T + pack() + Structure T { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 t1 "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructT() { String expected = //@formatter:off @@ -6756,6 +7561,36 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructU() { + String expected = + //@formatter:off + """ + /U + pack() + Structure U { + 0 U 32 "Self Base" + 32 char[24] 24 "Filler for 1 Unplaceable Virtual Base: P" + } + Length: 56 Alignment: 8 + /T/!internal/T + pack() + Structure T { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 t1 "" + } + Length: 24 Alignment: 8 + /U/!internal/U + pack() + Structure U { + 0 T 24 "Base" + 24 int 4 u1 "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructU() { String expected = //@formatter:off @@ -7502,6 +8337,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA3a() { + String expected = + //@formatter:off + """ + /AA3a + pack() + Structure AA3a { + 0 AA3a 16 "Self Base" + 16 char[16] 16 "Filler for 1 Unplaceable Virtual Base: AA2" + } + Length: 32 Alignment: 8 + /AA3a/!internal/AA3a + pack() + Structure AA3a { + 0 pointer 8 {vbptr} "" + 8 int 4 aa3ai "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA3a() { return convertCommentsToSpeculative(getExpectedStructAA3a()); } @@ -7601,6 +8458,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA3b() { + String expected = + //@formatter:off + """ + /AA3b + pack() + Structure AA3b { + 0 AA3b 16 "Self Base" + 16 char[16] 16 "Filler for 1 Unplaceable Virtual Base: AA2" + } + Length: 32 Alignment: 8 + /AA3b/!internal/AA3b + pack() + Structure AA3b { + 0 pointer 8 {vbptr} "" + 8 int 4 aa3bi "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA3b() { return convertCommentsToSpeculative(getExpectedStructAA3b()); } @@ -7762,6 +8641,43 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA3c() { + String expected = + //@formatter:off + """ + /AA3c + pack() + Structure AA3c { + 0 AA3c 40 "Self Base" + 40 char[24] 24 "Filler for 2 Unplaceable Virtual Bases: AA1; AA2" + } + Length: 64 Alignment: 8 + /AA3a/!internal/AA3a + pack() + Structure AA3a { + 0 pointer 8 {vbptr} "" + 8 int 4 aa3ai "" + } + Length: 16 Alignment: 8 + /AA3b/!internal/AA3b + pack() + Structure AA3b { + 0 pointer 8 {vbptr} "" + 8 int 4 aa3bi "" + } + Length: 16 Alignment: 8 + /AA3c/!internal/AA3c + pack() + Structure AA3c { + 0 AA3a 16 "Base" + 16 AA3b 16 "Base" + 32 int 4 aa3ci "" + } + Length: 40 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA3c() { String expected = //@formatter:off @@ -8024,6 +8940,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA3d() { + String expected = + //@formatter:off + """ + /AA3d + pack() + Structure AA3d { + 0 AA3d 16 "Self Base" + 16 char[56] 56 "Filler for 4 Unplaceable Virtual Bases: AA1; AA3a; AA3b; AA2" + } + Length: 72 Alignment: 8 + /AA3d/!internal/AA3d + pack() + Structure AA3d { + 0 pointer 8 {vbptr} "" + 8 int 4 aa3di "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA3d() { String expected = //@formatter:off @@ -8401,6 +9339,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA3g() { + String expected = + //@formatter:off + """ + /AA3g + pack() + Structure AA3g { + 0 AA3g 16 "Self Base" + 16 char[32] 32 "Filler for 2 Unplaceable Virtual Bases: AA3e; AA3f" + } + Length: 48 Alignment: 8 + /AA3g/!internal/AA3g + pack() + Structure AA3g { + 0 pointer 8 {vbptr} "" + 8 int 4 aa3gi "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA3g() { return convertCommentsToSpeculative(getExpectedStructAA3g()); } @@ -8501,6 +9461,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4a() { + String expected = + //@formatter:off + """ + /AA4a + pack() + Structure AA4a { + 0 AA4a 16 "Self Base" + 16 char[16] 16 "Filler for 1 Unplaceable Virtual Base: AA1" + } + Length: 32 Alignment: 8 + /AA4a/!internal/AA4a + pack() + Structure AA4a { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4ai "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4a() { return convertCommentsToSpeculative(getExpectedStructAA4a()); } @@ -8600,6 +9582,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4b() { + String expected = + //@formatter:off + """ + /AA4b + pack() + Structure AA4b { + 0 AA4b 16 "Self Base" + 16 char[16] 16 "Filler for 1 Unplaceable Virtual Base: AA1" + } + Length: 32 Alignment: 8 + /AA4b/!internal/AA4b + pack() + Structure AA4b { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4bi "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4b() { return convertCommentsToSpeculative(getExpectedStructAA4b()); } @@ -8729,6 +9733,43 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4c() { + String expected = + //@formatter:off + """ + /AA4c + pack() + Structure AA4c { + 0 AA4c 40 "Self Base" + 40 char[16] 16 "Filler for 1 Unplaceable Virtual Base: AA1" + } + Length: 56 Alignment: 8 + /AA4a/!internal/AA4a + pack() + Structure AA4a { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4ai "" + } + Length: 16 Alignment: 8 + /AA4b/!internal/AA4b + pack() + Structure AA4b { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4bi "" + } + Length: 16 Alignment: 8 + /AA4c/!internal/AA4c + pack() + Structure AA4c { + 0 AA4a 16 "Base" + 16 AA4b 16 "Base" + 32 int 4 aa4ci "" + } + Length: 40 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4c() { return convertCommentsToSpeculative(getExpectedStructAA4c()); } @@ -8877,6 +9918,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4d() { + String expected = + //@formatter:off + """ + /AA4d + pack() + Structure AA4d { + 0 AA4d 24 "Self Base" + 24 char[32] 32 "Filler for 2 Unplaceable Virtual Bases: AA4a; AA1" + } + Length: 56 Alignment: 8 + /AA4b/!internal/AA4b + pack() + Structure AA4b { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4bi "" + } + Length: 16 Alignment: 8 + /AA4d/!internal/AA4d + pack() + Structure AA4d { + 0 AA4b 16 "Base" + 16 int 4 aa4di "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4d() { return convertCommentsToSpeculative(getExpectedStructAA4d()); } @@ -9026,6 +10096,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4e() { + String expected = + //@formatter:off + """ + /AA4e + pack() + Structure AA4e { + 0 AA4e 24 "Self Base" + 24 char[32] 32 "Filler for 2 Unplaceable Virtual Bases: AA4b; AA1" + } + Length: 56 Alignment: 8 + /AA4a/!internal/AA4a + pack() + Structure AA4a { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4ai "" + } + Length: 16 Alignment: 8 + /AA4e/!internal/AA4e + pack() + Structure AA4e { + 0 AA4a 16 "Base" + 16 int 4 aa4ei "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4e() { return convertCommentsToSpeculative(getExpectedStructAA4e()); } @@ -9183,6 +10282,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4f() { + String expected = + //@formatter:off + """ + /AA4f + pack() + Structure AA4f { + 0 AA4f 16 "Self Base" + 16 char[48] 48 "Filler for 3 Unplaceable Virtual Bases: AA4a; AA4b; AA1" + } + Length: 64 Alignment: 8 + /AA4f/!internal/AA4f + pack() + Structure AA4f { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4fi "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4f() { return convertCommentsToSpeculative(getExpectedStructAA4f()); } @@ -9328,6 +10449,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4g() { + String expected = + //@formatter:off + """ + /AA4g + pack() + Structure AA4g { + 0 AA4g 24 "Self Base" + 24 char[16] 16 "Filler for 1 Unplaceable Virtual Base: AA1" + } + Length: 40 Alignment: 8 + /AA4b/!internal/AA4b + pack() + Structure AA4b { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4bi "" + } + Length: 16 Alignment: 8 + /AA4g/!internal/AA4g + pack() + Structure AA4g { + 0 AA4b 16 "Base" + 16 int 4 aa4gi "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4g() { return convertCommentsToSpeculative(getExpectedStructAA4g()); } @@ -9445,6 +10595,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4j() { + String expected = + //@formatter:off + """ + /AA4j + pack() + Structure AA4j { + 0 AA4j 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 24 Alignment: 8 + /AA4j/!internal/AA4j + pack() + Structure AA4j { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4ji "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4j() { return convertCommentsToSpeculative(getExpectedStructAA4j()); } @@ -9524,6 +10696,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4k() { + String expected = + //@formatter:off + """ + /AA4k + pack() + Structure AA4k { + 0 AA4k 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 24 Alignment: 8 + /AA4k/!internal/AA4k + pack() + Structure AA4k { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4ki "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4k() { return convertCommentsToSpeculative(getExpectedStructAA4k()); } @@ -9615,6 +10809,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4m() { + String expected = + //@formatter:off + """ + /AA4m + pack() + Structure AA4m { + 0 AA4m 24 "Self Base" + 24 char[8] 8 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 32 Alignment: 8 + /AA4j/!internal/AA4j + pack() + Structure AA4j { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4ji "" + } + Length: 16 Alignment: 8 + /AA4m/!internal/AA4m + pack() + Structure AA4m { + 0 AA4j 16 "Base" + 16 int 4 aa4mi "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4m() { return convertCommentsToSpeculative(getExpectedStructAA4m()); } @@ -9706,6 +10929,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4n() { + String expected = + //@formatter:off + """ + /AA4n + pack() + Structure AA4n { + 0 AA4n 24 "Self Base" + 24 char[8] 8 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 32 Alignment: 8 + /AA4k/!internal/AA4k + pack() + Structure AA4k { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4ki "" + } + Length: 16 Alignment: 8 + /AA4n/!internal/AA4n + pack() + Structure AA4n { + 0 AA4k 16 "Base" + 16 int 4 aa4ni "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4n() { return convertCommentsToSpeculative(getExpectedStructAA4n()); } @@ -9809,6 +11061,42 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4p() { + String expected = + //@formatter:off + """ + /AA4p + pack() + Structure AA4p { + 0 AA4p 32 "Self Base" + 32 char[8] 8 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 40 Alignment: 8 + /AA4j/!internal/AA4j + pack() + Structure AA4j { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4ji "" + } + Length: 16 Alignment: 8 + /AA4m/!internal/AA4m + pack() + Structure AA4m { + 0 AA4j 16 "Base" + 16 int 4 aa4mi "" + } + Length: 24 Alignment: 8 + /AA4p/!internal/AA4p + pack() + Structure AA4p { + 0 AA4m 24 "Base" + 24 int 4 aa4pi "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4p() { return convertCommentsToSpeculative(getExpectedStructAA4p()); } @@ -9942,6 +11230,57 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA4q() { + String expected = + //@formatter:off + """ + /AA4q + pack() + Structure AA4q { + 0 AA4q 56 "Self Base" + 56 char[8] 8 "Filler for 1 Unplaceable Virtual Base: AA4h" + } + Length: 64 Alignment: 8 + /AA4j/!internal/AA4j + pack() + Structure AA4j { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4ji "" + } + Length: 16 Alignment: 8 + /AA4k/!internal/AA4k + pack() + Structure AA4k { + 0 pointer 8 {vbptr} "" + 8 int 4 aa4ki "" + } + Length: 16 Alignment: 8 + /AA4m/!internal/AA4m + pack() + Structure AA4m { + 0 AA4j 16 "Base" + 16 int 4 aa4mi "" + } + Length: 24 Alignment: 8 + /AA4n/!internal/AA4n + pack() + Structure AA4n { + 0 AA4k 16 "Base" + 16 int 4 aa4ni "" + } + Length: 24 Alignment: 8 + /AA4q/!internal/AA4q + pack() + Structure AA4q { + 0 AA4n 24 "Base" + 24 AA4m 24 "Base" + 48 int 4 aa4qi "" + } + Length: 56 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA4q() { return convertCommentsToSpeculative(getExpectedStructAA4q()); } @@ -10207,6 +11546,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA5e() { + String expected = + //@formatter:off + """ + /AA5e + pack() + Structure AA5e { + 0 AA5e 24 "Self Base" + 24 char[8] 8 "Filler for 1 Unplaceable Virtual Base: AA5b" + } + Length: 32 Alignment: 8 + /AA5a + pack() + Structure AA5a { + 0 int 4 aa5ai "" + } + Length: 4 Alignment: 4 + /AA5e/!internal/AA5e + pack() + Structure AA5e { + 0 AA5a 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 aa5ei "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA5e() { return convertCommentsToSpeculative(getExpectedStructAA5e()); } @@ -10296,6 +11664,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA5f() { + String expected = + //@formatter:off + """ + /AA5f + pack() + Structure AA5f { + 0 AA5f 24 "Self Base" + 24 char[8] 8 "Filler for 1 Unplaceable Virtual Base: AA5d" + } + Length: 32 Alignment: 8 + /AA5c + pack() + Structure AA5c { + 0 int 4 aa5ci "" + } + Length: 4 Alignment: 4 + /AA5f/!internal/AA5f + pack() + Structure AA5f { + 0 AA5c 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 aa5fi "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA5f() { return convertCommentsToSpeculative(getExpectedStructAA5f()); } @@ -10416,6 +11813,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA5g() { + String expected = + //@formatter:off + """ + /AA5g + pack() + Structure AA5g { + 0 AA5g 24 "Self Base" + 24 char[32] 32 "Filler for 2 Unplaceable Virtual Bases: AA5e; AA5b" + } + Length: 56 Alignment: 8 + /AA5c + pack() + Structure AA5c { + 0 int 4 aa5ci "" + } + Length: 4 Alignment: 4 + /AA5g/!internal/AA5g + pack() + Structure AA5g { + 0 AA5c 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 aa5gi "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA5g() { return convertCommentsToSpeculative(getExpectedStructAA5g()); } @@ -10557,6 +11983,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA5h() { + String expected = + //@formatter:off + """ + /AA5h + pack() + Structure AA5h { + 0 AA5h 24 "Self Base" + 24 char[32] 32 "Filler for 2 Unplaceable Virtual Bases: AA5f; AA5d" + } + Length: 56 Alignment: 8 + /AA5a + pack() + Structure AA5a { + 0 int 4 aa5ai "" + } + Length: 4 Alignment: 4 + /AA5h/!internal/AA5h + pack() + Structure AA5h { + 0 AA5a 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 aa5hi "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA5h() { return convertCommentsToSpeculative(getExpectedStructAA5h()); } @@ -10770,6 +12225,57 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA5j() { + String expected = + //@formatter:off + """ + /AA5j + pack() + Structure AA5j { + 0 AA5j 56 "Self Base" + 56 char[64] 64 "Filler for 4 Unplaceable Virtual Bases: AA5b; AA5e; AA5d; AA5f" + } + Length: 120 Alignment: 8 + /AA5a + pack() + Structure AA5a { + 0 int 4 aa5ai "" + } + Length: 4 Alignment: 4 + /AA5c + pack() + Structure AA5c { + 0 int 4 aa5ci "" + } + Length: 4 Alignment: 4 + /AA5g/!internal/AA5g + pack() + Structure AA5g { + 0 AA5c 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 aa5gi "" + } + Length: 24 Alignment: 8 + /AA5h/!internal/AA5h + pack() + Structure AA5h { + 0 AA5a 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 aa5hi "" + } + Length: 24 Alignment: 8 + /AA5j/!internal/AA5j + pack() + Structure AA5j { + 0 AA5g 24 "Base" + 24 AA5h 24 "Base" + 48 int 4 aa5ji "" + } + Length: 56 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA5j() { return convertCommentsToSpeculative(getExpectedStructAA5j()); } @@ -10995,6 +12501,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA6c() { + String expected = + //@formatter:off + """ + /AA6c + pack() + Structure AA6c { + 0 AA6c 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: AA6a" + } + Length: 24 Alignment: 8 + /AA6c/!internal/AA6c + pack() + Structure AA6c { + 0 pointer 8 {vbptr} "" + 8 int 4 aa6ci "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA6c() { return convertCommentsToSpeculative(getExpectedStructAA6c()); } @@ -11243,6 +12771,42 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA6g() { + String expected = + //@formatter:off + """ + /AA6g + pack() + Structure AA6g { + 0 AA6g 24 "Self Base" + 24 char[8] 8 "Filler for 1 Unplaceable Virtual Base: AA6a" + } + Length: 32 Alignment: 8 + /AA6a + pack() + Structure AA6a { + 0 int 4 aa6ai "" + } + Length: 4 Alignment: 4 + /AA6c/!internal/AA6c + pack() + Structure AA6c { + 0 pointer 8 {vbptr} "" + 8 int 4 aa6ci "" + } + Length: 16 Alignment: 8 + /AA6g/!internal/AA6g + pack() + Structure AA6g { + 0 AA6c 16 "Base" + 16 int 4 aa6gi "" + 20 AA6a 4 aa6a "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA6g() { return convertCommentsToSpeculative(getExpectedStructAA6g()); } @@ -11344,6 +12908,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA6h() { + String expected = + //@formatter:off + """ + /AA6h + pack() + Structure AA6h { + 0 AA6h 16 "Self Base" + 16 char[24] 24 "Filler for 2 Unplaceable Virtual Bases: AA6c; AA6a" + } + Length: 40 Alignment: 8 + /AA6a + pack() + Structure AA6a { + 0 int 4 aa6ai "" + } + Length: 4 Alignment: 4 + /AA6h/!internal/AA6h + pack() + Structure AA6h { + 0 pointer 8 {vbptr} "" + 8 int 4 aa6hi "" + 12 AA6a 4 aa6a "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA6h() { return convertCommentsToSpeculative(getExpectedStructAA6h()); } @@ -11468,6 +13061,36 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA6j() { + String expected = + //@formatter:off + """ + /AA6j + pack() + Structure AA6j { + 0 AA6j 24 "Self Base" + 24 char[24] 24 "Filler for 2 Unplaceable Virtual Bases: AA6c; AA6a" + } + Length: 48 Alignment: 8 + /AA6a + pack() + Structure AA6a { + 0 int 4 aa6ai "" + } + Length: 4 Alignment: 4 + /AA6j/!internal/AA6j + pack() + Structure AA6j { + 0 pointer 8 {vbptr} "" + 8 int 4 aa6hj "" + 12 AA6a 4 aa6a "" + 16 AA6j * 8 paa6j "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA6j() { return convertCommentsToSpeculative(getExpectedStructAA6j()); } @@ -11853,6 +13476,29 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructAA7d() { + String expected = + //@formatter:off + """ + /AA7d + pack() + Structure AA7d { + 0 AA7d 24 "Self Base" + 24 char[32] 32 "Filler for 2 Unplaceable Virtual Bases: AA7a; AA7b" + } + Length: 56 Alignment: 8 + /AA7d/!internal/AA7d + pack() + Structure AA7d { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 aa7di "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructAA7d() { return convertCommentsToSpeculative(getExpectedStructAA7d()); } @@ -12069,6 +13715,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB1c() { + String expected = + //@formatter:off + """ + /BB1c + pack() + Structure BB1c { + 0 BB1c 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: BB1a" + } + Length: 24 Alignment: 8 + /BB1c/!internal/BB1c + pack() + Structure BB1c { + 0 pointer 8 {vbptr} "" + 8 int 4 bb1ci "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB1c() { return convertCommentsToSpeculative(getExpectedStructBB1c()); } @@ -12174,6 +13842,49 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB1d() { + String expected = + //@formatter:off + """ + /BB1d + pack() + Structure BB1d { + 0 BB1d 32 "Self Base" + 32 char[8] 8 "Filler for 1 Unplaceable Virtual Base: BB1a" + } + Length: 40 Alignment: 8 + /BB1a + pack() + Structure BB1a { + 0 int 4 bb1ai "" + } + Length: 4 Alignment: 4 + /BB1b + pack() + Structure BB1b { + 0 BB1a 4 "Base" + 4 int 4 bb1bi "" + } + Length: 8 Alignment: 4 + /BB1c/!internal/BB1c + pack() + Structure BB1c { + 0 pointer 8 {vbptr} "" + 8 int 4 bb1ci "" + } + Length: 16 Alignment: 8 + /BB1d/!internal/BB1d + pack() + Structure BB1d { + 0 BB1b 8 "Base" + 8 BB1c 16 "Base" + 24 int 4 bb1di "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB1d() { return convertCommentsToSpeculative(getExpectedStructBB1d()); } @@ -12291,6 +14002,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB2a() { + String expected = + //@formatter:off + """ + /BB2a + pack() + Structure BB2a { + 0 BB2a 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: BB2z" + } + Length: 24 Alignment: 8 + /BB2a/!internal/BB2a + pack() + Structure BB2a { + 0 pointer 8 {vbptr} "" + 8 int 4 bb2ai "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB2a() { return convertCommentsToSpeculative(getExpectedStructBB2a()); } @@ -12382,6 +14115,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB2b() { + String expected = + //@formatter:off + """ + /BB2b + pack() + Structure BB2b { + 0 BB2b 24 "Self Base" + 24 char[8] 8 "Filler for 1 Unplaceable Virtual Base: BB2z" + } + Length: 32 Alignment: 8 + /BB2a/!internal/BB2a + pack() + Structure BB2a { + 0 pointer 8 {vbptr} "" + 8 int 4 bb2ai "" + } + Length: 16 Alignment: 8 + /BB2b/!internal/BB2b + pack() + Structure BB2b { + 0 BB2a 16 "Base" + 16 int 4 bb2bi "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB2b() { return convertCommentsToSpeculative(getExpectedStructBB2b()); } @@ -12482,6 +14244,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB2c() { + String expected = + //@formatter:off + """ + /BB2c + pack() + Structure BB2c { + 0 BB2c 16 "Self Base" + 16 char[24] 24 "Filler for 2 Unplaceable Virtual Bases: BB2a; BB2z" + } + Length: 40 Alignment: 8 + /BB2c/!internal/BB2c + pack() + Structure BB2c { + 0 pointer 8 {vbptr} "" + 8 int 4 bb2ci "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB2c() { return convertCommentsToSpeculative(getExpectedStructBB2c()); } @@ -12639,6 +14423,50 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB2d() { + String expected = + //@formatter:off + """ + /BB2d + pack() + Structure BB2d { + 0 BB2d 48 "Self Base" + 48 char[24] 24 "Filler for 2 Unplaceable Virtual Bases: BB2z; BB2a" + } + Length: 72 Alignment: 8 + /BB2a/!internal/BB2a + pack() + Structure BB2a { + 0 pointer 8 {vbptr} "" + 8 int 4 bb2ai "" + } + Length: 16 Alignment: 8 + /BB2b/!internal/BB2b + pack() + Structure BB2b { + 0 BB2a 16 "Base" + 16 int 4 bb2bi "" + } + Length: 24 Alignment: 8 + /BB2c/!internal/BB2c + pack() + Structure BB2c { + 0 pointer 8 {vbptr} "" + 8 int 4 bb2ci "" + } + Length: 16 Alignment: 8 + /BB2d/!internal/BB2d + pack() + Structure BB2d { + 0 BB2b 24 "Base" + 24 BB2c 16 "Base" + 40 int 4 bb2di "" + } + Length: 48 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB2d() { return convertCommentsToSpeculative(getExpectedStructBB2d()); } @@ -12784,6 +14612,42 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB2e() { + String expected = + //@formatter:off + """ + /BB2e + pack() + Structure BB2e { + 0 BB2e 32 "Self Base" + 32 char[8] 8 "Filler for 1 Unplaceable Virtual Base: BB2z" + } + Length: 40 Alignment: 8 + /BB2a/!internal/BB2a + pack() + Structure BB2a { + 0 pointer 8 {vbptr} "" + 8 int 4 bb2ai "" + } + Length: 16 Alignment: 8 + /BB2b/!internal/BB2b + pack() + Structure BB2b { + 0 BB2a 16 "Base" + 16 int 4 bb2bi "" + } + Length: 24 Alignment: 8 + /BB2e/!internal/BB2e + pack() + Structure BB2e { + 0 BB2b 24 "Base" + 24 int 4 bb2ei "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB2e() { return convertCommentsToSpeculative(getExpectedStructBB2e()); } @@ -12997,6 +14861,42 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB3d() { + String expected = + //@formatter:off + """ + /BB3d + pack() + Structure BB3d { + 0 BB3d 24 "Self Base" + 24 char[8] 8 "Filler for 1 Unplaceable Virtual Base: BB3b" + } + Length: 32 Alignment: 8 + /BB3a + pack() + Structure BB3a { + 0 int 4 bb3ai "" + } + Length: 4 Alignment: 4 + /BB3c + pack() + Structure BB3c { + 0 int 4 bb3ci "" + } + Length: 4 Alignment: 4 + /BB3d/!internal/BB3d + pack() + Structure BB3d { + 0 BB3a 4 "Base" + 4 BB3c 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 bb3di "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB3d() { return convertCommentsToSpeculative(getExpectedStructBB3d()); } @@ -13098,6 +14998,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB3e() { + String expected = + //@formatter:off + """ + /BB3e + pack() + Structure BB3e { + 0 BB3e 24 "Self Base" + 24 char[8] 8 "Filler for 2 Unplaceable Virtual Bases: BB3a; BB3c" + } + Length: 32 Alignment: 8 + /BB3b + pack() + Structure BB3b { + 0 int 4 bb3bi "" + } + Length: 4 Alignment: 4 + /BB3e/!internal/BB3e + pack() + Structure BB3e { + 0 BB3b 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 bb3ei "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB3e() { return convertCommentsToSpeculative(getExpectedStructBB3e()); } @@ -13244,6 +15173,64 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB3f() { + String expected = + //@formatter:off + """ + /BB3f + pack() + Structure BB3f { + 0 BB3f 56 "Self Base" + 56 char[16] 16 "Filler for 3 Unplaceable Virtual Bases: BB3b; BB3a; BB3c" + } + Length: 72 Alignment: 8 + /BB3a + pack() + Structure BB3a { + 0 int 4 bb3ai "" + } + Length: 4 Alignment: 4 + /BB3b + pack() + Structure BB3b { + 0 int 4 bb3bi "" + } + Length: 4 Alignment: 4 + /BB3c + pack() + Structure BB3c { + 0 int 4 bb3ci "" + } + Length: 4 Alignment: 4 + /BB3d/!internal/BB3d + pack() + Structure BB3d { + 0 BB3a 4 "Base" + 4 BB3c 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 bb3di "" + } + Length: 24 Alignment: 8 + /BB3e/!internal/BB3e + pack() + Structure BB3e { + 0 BB3b 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 bb3ei "" + } + Length: 24 Alignment: 8 + /BB3f/!internal/BB3f + pack() + Structure BB3f { + 0 BB3d 24 "Base" + 24 BB3e 24 "Base" + 48 int 4 bb3fi "" + } + Length: 56 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB3f() { return convertCommentsToSpeculative(getExpectedStructBB3f()); } @@ -13407,6 +15394,64 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructBB3g() { + String expected = + //@formatter:off + """ + /BB3g + pack() + Structure BB3g { + 0 BB3g 56 "Self Base" + 56 char[16] 16 "Filler for 3 Unplaceable Virtual Bases: BB3a; BB3c; BB3b" + } + Length: 72 Alignment: 8 + /BB3a + pack() + Structure BB3a { + 0 int 4 bb3ai "" + } + Length: 4 Alignment: 4 + /BB3b + pack() + Structure BB3b { + 0 int 4 bb3bi "" + } + Length: 4 Alignment: 4 + /BB3c + pack() + Structure BB3c { + 0 int 4 bb3ci "" + } + Length: 4 Alignment: 4 + /BB3d/!internal/BB3d + pack() + Structure BB3d { + 0 BB3a 4 "Base" + 4 BB3c 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 bb3di "" + } + Length: 24 Alignment: 8 + /BB3e/!internal/BB3e + pack() + Structure BB3e { + 0 BB3b 4 "Base" + 8 pointer 8 {vbptr} "" + 16 int 4 bb3ei "" + } + Length: 24 Alignment: 8 + /BB3g/!internal/BB3g + pack() + Structure BB3g { + 0 BB3e 24 "Base" + 24 BB3d 24 "Base" + 48 int 4 bb3gi "" + } + Length: 56 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructBB3g() { return convertCommentsToSpeculative(getExpectedStructBB3g()); } @@ -13892,6 +15937,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructCC1h() { + String expected = + //@formatter:off + """ + /CC1h + pack() + Structure CC1h { + 0 CC1h 16 "Self Base" + 16 char[32] 32 "Filler for 6 Unplaceable Virtual Bases: CC1a; CC1b; CC1c; CC1d; CC1e; CC1f" + } + Length: 48 Alignment: 8 + /CC1h/!internal/CC1h + pack() + Structure CC1h { + 0 pointer 8 {vbptr} "" + 8 char 1 cc1hc "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructCC1h() { String expected = //@formatter:off @@ -14651,6 +16718,28 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructDD1b() { + String expected = + //@formatter:off + """ + /DD1b + pack() + Structure DD1b { + 0 DD1b 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: DD1a" + } + Length: 24 Alignment: 8 + /DD1b/!internal/DD1b + pack() + Structure DD1b { + 0 pointer 8 {vbptr} "" + 8 int 4 dd1bi "" + } + Length: 16 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructDD1b() { return convertCommentsToSpeculative(getExpectedStructDD1b()); } @@ -14742,6 +16831,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructDD1c() { + String expected = + //@formatter:off + """ + /DD1c + pack() + Structure DD1c { + 0 DD1c 24 "Self Base" + 24 char[8] 8 "Filler for 1 Unplaceable Virtual Base: DD1a" + } + Length: 32 Alignment: 8 + /DD1b/!internal/DD1b + pack() + Structure DD1b { + 0 pointer 8 {vbptr} "" + 8 int 4 dd1bi "" + } + Length: 16 Alignment: 8 + /DD1c/!internal/DD1c + pack() + Structure DD1c { + 0 DD1b 16 "Base" + 16 int 4 dd1ci "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructDD1c() { return convertCommentsToSpeculative(getExpectedStructDD1c()); } @@ -14833,6 +16951,35 @@ public class Egray864ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructDD1d() { + String expected = + //@formatter:off + """ + /DD1d + pack() + Structure DD1d { + 0 DD1d 24 "Self Base" + 24 char[8] 8 "Filler for 1 Unplaceable Virtual Base: DD1a" + } + Length: 32 Alignment: 8 + /DD1b/!internal/DD1b + pack() + Structure DD1b { + 0 pointer 8 {vbptr} "" + 8 int 4 dd1bi "" + } + Length: 16 Alignment: 8 + /DD1d/!internal/DD1d + pack() + Structure DD1d { + 0 DD1b 16 "Base" + 16 int 4 dd1di "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructDD1d() { return convertCommentsToSpeculative(getExpectedStructDD1d()); } @@ -15284,6 +17431,78 @@ public class Egray864ProgramCreator extends ProgramCreator { expectedStructs.put(DD2e, getExpectedStructDD2e()); } + private static final Map fillerStructs = new LinkedHashMap<>(); + static { + fillerStructs.putAll(expectedStructs); + fillerStructs.put(G, getFillerStructG()); + fillerStructs.put(H, getFillerStructH()); + fillerStructs.put(GG1, getFillerStructGG1()); + fillerStructs.put(GG2, getFillerStructGG2()); + fillerStructs.put(GG3, getFillerStructGG3()); + fillerStructs.put(GG4, getFillerStructGG4()); + fillerStructs.put(I, getFillerStructI()); + fillerStructs.put(GX1, getFillerStructGX1()); + fillerStructs.put(HX1, getFillerStructHX1()); + fillerStructs.put(IX1, getFillerStructIX1()); + fillerStructs.put(G1, getFillerStructG1()); + fillerStructs.put(H1, getFillerStructH1()); + fillerStructs.put(I1, getFillerStructI1()); + fillerStructs.put(I2, getFillerStructI2()); + fillerStructs.put(I3, getFillerStructI3()); + fillerStructs.put(I4, getFillerStructI4()); + fillerStructs.put(I5, getFillerStructI5()); + fillerStructs.put(J1, getFillerStructJ1()); + fillerStructs.put(J2, getFillerStructJ2()); + fillerStructs.put(J3, getFillerStructJ3()); + fillerStructs.put(J4, getFillerStructJ4()); + fillerStructs.put(J6, getFillerStructJ6()); + fillerStructs.put(T, getFillerStructT()); + fillerStructs.put(U, getFillerStructU()); + fillerStructs.put(AA3a, getFillerStructAA3a()); + fillerStructs.put(AA3b, getFillerStructAA3b()); + fillerStructs.put(AA3c, getFillerStructAA3c()); + fillerStructs.put(AA3d, getFillerStructAA3d()); + fillerStructs.put(AA3g, getFillerStructAA3g()); + fillerStructs.put(AA4a, getFillerStructAA4a()); + fillerStructs.put(AA4b, getFillerStructAA4b()); + fillerStructs.put(AA4c, getFillerStructAA4c()); + fillerStructs.put(AA4d, getFillerStructAA4d()); + fillerStructs.put(AA4e, getFillerStructAA4e()); + fillerStructs.put(AA4f, getFillerStructAA4f()); + fillerStructs.put(AA4g, getFillerStructAA4g()); + fillerStructs.put(AA4j, getFillerStructAA4j()); + fillerStructs.put(AA4k, getFillerStructAA4k()); + fillerStructs.put(AA4m, getFillerStructAA4m()); + fillerStructs.put(AA4n, getFillerStructAA4n()); + fillerStructs.put(AA4p, getFillerStructAA4p()); + fillerStructs.put(AA4q, getFillerStructAA4q()); + fillerStructs.put(AA5e, getFillerStructAA5e()); + fillerStructs.put(AA5f, getFillerStructAA5f()); + fillerStructs.put(AA5g, getFillerStructAA5g()); + fillerStructs.put(AA5h, getFillerStructAA5h()); + fillerStructs.put(AA5j, getFillerStructAA5j()); + fillerStructs.put(AA6c, getFillerStructAA6c()); + fillerStructs.put(AA6g, getFillerStructAA6g()); + fillerStructs.put(AA6h, getFillerStructAA6h()); + fillerStructs.put(AA6j, getFillerStructAA6j()); + fillerStructs.put(AA7d, getFillerStructAA7d()); + fillerStructs.put(BB1c, getFillerStructBB1c()); + fillerStructs.put(BB1d, getFillerStructBB1d()); + fillerStructs.put(BB2a, getFillerStructBB2a()); + fillerStructs.put(BB2b, getFillerStructBB2b()); + fillerStructs.put(BB2c, getFillerStructBB2c()); + fillerStructs.put(BB2d, getFillerStructBB2d()); + fillerStructs.put(BB2e, getFillerStructBB2e()); + fillerStructs.put(BB3d, getFillerStructBB3d()); + fillerStructs.put(BB3e, getFillerStructBB3e()); + fillerStructs.put(BB3f, getFillerStructBB3f()); + fillerStructs.put(BB3g, getFillerStructBB3g()); + fillerStructs.put(CC1h, getFillerStructCC1h()); + fillerStructs.put(DD1b, getFillerStructDD1b()); + fillerStructs.put(DD1c, getFillerStructDD1c()); + fillerStructs.put(DD1d, getFillerStructDD1d()); + } + private static final Map speculatedStructs = new LinkedHashMap<>(); static { speculatedStructs.put(A, getSpeculatedStructA()); @@ -15769,6 +17988,10 @@ public class Egray864ProgramCreator extends ProgramCreator { return expectedStructs; } + public Map getFillerStructs() { + return fillerStructs; + } + public Map getSpeculatedStructs() { return speculatedStructs; } diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/ProgramCreator.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/ProgramCreator.java index fef2722d67..1948c9f7de 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/ProgramCreator.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/ProgramCreator.java @@ -135,10 +135,31 @@ abstract public class ProgramCreator { return builder.toString(); } + /** + * Modifies an original expected result to look like a result that used speculative + * placement of virtual base classes + * @param original the original result + * @return the result with the modifications + */ protected static String convertCommentsToSpeculative(String original) { return original.replace("Virtual Base", "Virtual Base - Speculative Placement"); } + /** + * Takes an original expected result, and at the specified starting line ('\n' delimited) + * index, replace the remaing expected result with the replacement String (can be multiple + * lines) + * @param orig the original expected result + * @param startLine the line to start the replacement + * @param replacement the String used to replace the remainder of the original String + * @return the result + */ + protected static String doReplacement(String orig, int startLine, String replacement) { + List lines = List.of(orig.split("\\n")); + List newLines = lines.subList(0, startLine); + return String.join("\n", newLines) + "\n" + replacement; + } + private String programName; private String languageId; private String compilerSpec; diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Vftm32ProgramCreator.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Vftm32ProgramCreator.java index 3efbc8cdc4..755df19929 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Vftm32ProgramCreator.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Vftm32ProgramCreator.java @@ -1592,6 +1592,36 @@ public class Vftm32ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructQ4() { + String expected = + //@formatter:off + """ + /Q4NS::Q4 + pack() + Structure Q4NS::Q4 { + 0 Q4NS::Q4 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: P1NS::P1" + } + Length: 24 Alignment: 4 + /P2NS::P2 + pack() + Structure P2NS::P2 { + 0 pointer 4 {vfptr} "" + 4 int 4 p2 "" + } + Length: 8 Alignment: 4 + /Q4NS::Q4/!internal/Q4NS::Q4 + pack() + Structure Q4NS::Q4 { + 0 P2NS::P2 8 "Base" + 8 pointer 4 {vbptr} "" + 12 int 4 q4 "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructQ4() { return convertCommentsToSpeculative(getExpectedStructQ4()); } @@ -1788,6 +1818,36 @@ public class Vftm32ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructQ5() { + String expected = + //@formatter:off + """ + /Q5NS::Q5 + pack() + Structure Q5NS::Q5 { + 0 Q5NS::Q5 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: P2NS::P2" + } + Length: 24 Alignment: 4 + /P1NS::P1 + pack() + Structure P1NS::P1 { + 0 pointer 4 {vfptr} "" + 4 int 4 p1 "" + } + Length: 8 Alignment: 4 + /Q5NS::Q5/!internal/Q5NS::Q5 + pack() + Structure Q5NS::Q5 { + 0 P1NS::P1 8 "Base" + 8 pointer 4 {vbptr} "" + 12 int 4 q5 "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructQ5() { return convertCommentsToSpeculative(getExpectedStructQ5()); } @@ -1984,6 +2044,36 @@ public class Vftm32ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructQ6() { + String expected = + //@formatter:off + """ + /Q6NS::Q6 + pack() + Structure Q6NS::Q6 { + 0 Q6NS::Q6 16 "Self Base" + 16 char[8] 8 "Filler for 1 Unplaceable Virtual Base: P2NS::P2" + } + Length: 24 Alignment: 4 + /P1NS::P1 + pack() + Structure P1NS::P1 { + 0 pointer 4 {vfptr} "" + 4 int 4 p1 "" + } + Length: 8 Alignment: 4 + /Q6NS::Q6/!internal/Q6NS::Q6 + pack() + Structure Q6NS::Q6 { + 0 P1NS::P1 8 "Base" + 8 pointer 4 {vbptr} "" + 12 int 4 q6 "" + } + Length: 16 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructQ6() { return convertCommentsToSpeculative(getExpectedStructQ6()); } @@ -2187,6 +2277,29 @@ public class Vftm32ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructQ7() { + String expected = + //@formatter:off + """ + /Q7NS::Q7 + pack() + Structure Q7NS::Q7 { + 0 Q7NS::Q7 12 "Self Base" + 12 char[16] 16 "Filler for 2 Unplaceable Virtual Bases: P1NS::P1; P2NS::P2" + } + Length: 28 Alignment: 4 + /Q7NS::Q7/!internal/Q7NS::Q7 + pack() + Structure Q7NS::Q7 { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 q7 "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructQ7() { return convertCommentsToSpeculative(getExpectedStructQ7()); } @@ -2481,6 +2594,29 @@ public class Vftm32ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructR1() { + String expected = + //@formatter:off + """ + /R1NS::R1 + pack() + Structure R1NS::R1 { + 0 R1NS::R1 12 "Self Base" + 12 char[40] 40 "Filler for 2 Unplaceable Virtual Bases: Q1NS::Q1; Q2NS::Q2" + } + Length: 52 Alignment: 4 + /R1NS::R1/!internal/R1NS::R1 + pack() + Structure R1NS::R1 { + 0 pointer 4 {vfptr} "" + 4 pointer 4 {vbptr} "" + 8 int 4 r1 "" + } + Length: 12 Alignment: 4"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructR1() { return convertCommentsToSpeculative(getExpectedStructR1()); } @@ -2667,6 +2803,16 @@ public class Vftm32ProgramCreator extends ProgramCreator { expectedStructs.put(R1, getExpectedStructR1()); } + private static final Map fillerStructs = new LinkedHashMap<>(); + static { + fillerStructs.putAll(expectedStructs); + fillerStructs.put(Q4, getFillerStructQ4()); + fillerStructs.put(Q5, getFillerStructQ5()); + fillerStructs.put(Q6, getFillerStructQ6()); + fillerStructs.put(Q7, getFillerStructQ7()); + fillerStructs.put(R1, getFillerStructR1()); + } + private static final Map speculatedStructs = new LinkedHashMap<>(); static { speculatedStructs.put(P1, getSpeculatedStructP1()); @@ -2739,6 +2885,10 @@ public class Vftm32ProgramCreator extends ProgramCreator { return expectedStructs; } + public Map getFillerStructs() { + return fillerStructs; + } + public Map getSpeculatedStructs() { return speculatedStructs; } diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Vftm64ProgramCreator.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Vftm64ProgramCreator.java index 8e833693c3..8580f89f16 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Vftm64ProgramCreator.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/Vftm64ProgramCreator.java @@ -1612,6 +1612,36 @@ public class Vftm64ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructQ4() { + String expected = + //@formatter:off + """ + /Q4NS::Q4 + pack() + Structure Q4NS::Q4 { + 0 Q4NS::Q4 32 "Self Base" + 32 char[16] 16 "Filler for 1 Unplaceable Virtual Base: P1NS::P1" + } + Length: 48 Alignment: 8 + /P2NS::P2 + pack() + Structure P2NS::P2 { + 0 pointer 8 {vfptr} "" + 8 int 4 p2 "" + } + Length: 16 Alignment: 8 + /Q4NS::Q4/!internal/Q4NS::Q4 + pack() + Structure Q4NS::Q4 { + 0 P2NS::P2 16 "Base" + 16 pointer 8 {vbptr} "" + 24 int 4 q4 "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructQ4() { return convertCommentsToSpeculative(getExpectedStructQ4()); } @@ -1811,6 +1841,36 @@ public class Vftm64ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructQ5() { + String expected = + //@formatter:off + """ + /Q5NS::Q5 + pack() + Structure Q5NS::Q5 { + 0 Q5NS::Q5 32 "Self Base" + 32 char[16] 16 "Filler for 1 Unplaceable Virtual Base: P2NS::P2" + } + Length: 48 Alignment: 8 + /P1NS::P1 + pack() + Structure P1NS::P1 { + 0 pointer 8 {vfptr} "" + 8 int 4 p1 "" + } + Length: 16 Alignment: 8 + /Q5NS::Q5/!internal/Q5NS::Q5 + pack() + Structure Q5NS::Q5 { + 0 P1NS::P1 16 "Base" + 16 pointer 8 {vbptr} "" + 24 int 4 q5 "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructQ5() { return convertCommentsToSpeculative(getExpectedStructQ5()); } @@ -2010,6 +2070,36 @@ public class Vftm64ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructQ6() { + String expected = + //@formatter:off + """ + /Q6NS::Q6 + pack() + Structure Q6NS::Q6 { + 0 Q6NS::Q6 32 "Self Base" + 32 char[16] 16 "Filler for 1 Unplaceable Virtual Base: P2NS::P2" + } + Length: 48 Alignment: 8 + /P1NS::P1 + pack() + Structure P1NS::P1 { + 0 pointer 8 {vfptr} "" + 8 int 4 p1 "" + } + Length: 16 Alignment: 8 + /Q6NS::Q6/!internal/Q6NS::Q6 + pack() + Structure Q6NS::Q6 { + 0 P1NS::P1 16 "Base" + 16 pointer 8 {vbptr} "" + 24 int 4 q6 "" + } + Length: 32 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructQ6() { return convertCommentsToSpeculative(getExpectedStructQ6()); } @@ -2216,6 +2306,29 @@ public class Vftm64ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructQ7() { + String expected = + //@formatter:off + """ + /Q7NS::Q7 + pack() + Structure Q7NS::Q7 { + 0 Q7NS::Q7 24 "Self Base" + 24 char[32] 32 "Filler for 2 Unplaceable Virtual Bases: P1NS::P1; P2NS::P2" + } + Length: 56 Alignment: 8 + /Q7NS::Q7/!internal/Q7NS::Q7 + pack() + Structure Q7NS::Q7 { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 q7 "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructQ7() { return convertCommentsToSpeculative(getExpectedStructQ7()); } @@ -2517,6 +2630,29 @@ public class Vftm64ProgramCreator extends ProgramCreator { return expected; } + private static String getFillerStructR1() { + String expected = + //@formatter:off + """ + /R1NS::R1 + pack() + Structure R1NS::R1 { + 0 R1NS::R1 24 "Self Base" + 24 char[80] 80 "Filler for 2 Unplaceable Virtual Bases: Q1NS::Q1; Q2NS::Q2" + } + Length: 104 Alignment: 8 + /R1NS::R1/!internal/R1NS::R1 + pack() + Structure R1NS::R1 { + 0 pointer 8 {vfptr} "" + 8 pointer 8 {vbptr} "" + 16 int 4 r1 "" + } + Length: 24 Alignment: 8"""; + //@formatter:on + return expected; + } + private static String getSpeculatedStructR1() { return convertCommentsToSpeculative(getExpectedStructR1()); } @@ -2703,6 +2839,16 @@ public class Vftm64ProgramCreator extends ProgramCreator { expectedStructs.put(R1, getExpectedStructR1()); } + private static final Map fillerStructs = new LinkedHashMap<>(); + static { + fillerStructs.putAll(expectedStructs); + fillerStructs.put(Q4, getFillerStructQ4()); + fillerStructs.put(Q5, getFillerStructQ5()); + fillerStructs.put(Q6, getFillerStructQ6()); + fillerStructs.put(Q7, getFillerStructQ7()); + fillerStructs.put(R1, getFillerStructR1()); + } + private static final Map speculatedStructs = new LinkedHashMap<>(); static { speculatedStructs.put(P1, getSpeculatedStructP1()); @@ -2775,6 +2921,10 @@ public class Vftm64ProgramCreator extends ProgramCreator { return expectedStructs; } + public Map getFillerStructs() { + return fillerStructs; + } + public Map getSpeculatedStructs() { return speculatedStructs; } diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/pdbapplicator/CppCompositeTypeTest.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/pdbapplicator/CppCompositeTypeTest.java index 0c5265fcc1..fef60a84e6 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/pdbapplicator/CppCompositeTypeTest.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/pdbapplicator/CppCompositeTypeTest.java @@ -68,6 +68,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { private static ObjectOrientedClassLayout classLayoutChoice = ObjectOrientedClassLayout.CLASS_HIERARCHY; + private static ObjectOrientedClassLayout speculativeLayoutChoice = + ObjectOrientedClassLayout.CLASS_HIERARCHY_SPECULATIVE; private DataTypeManager dtm32 = new StandAloneDataTypeManager("32-bit win", dataOrg32); private DataTypeManager dtm64 = new StandAloneDataTypeManager("64-bit win", dataOrg64); @@ -2073,17 +2075,11 @@ public class CppCompositeTypeTest extends AbstractGenericTest { egray832Creator.getExpectedVxtPtrSummaries(); Map> expectedVxtStructs = egray832Creator.getExpectedVxtStructs(); - int txID = program.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - program.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } @@ -2092,9 +2088,28 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * @throws Exception upon error */ @Test - public void testEgray8_32_speculative() throws Exception { + public void testEgray8_32_noProgram() throws Exception { boolean is64Bit = false; + Program program = null; + MockPdb pdb = egray832Pdb; + DataTypeManager dtm = dtm32; + MsftVxtManager vxtManager = egray832VxtManagerNoProgram; + Map expectedResults = egray832Creator.getFillerStructs(); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, null); + vxtManager.doTableLayouts(dtm); + }); + // Not checking vxt structures here. + } + /** + * Tests the classes and artifacts of egray8 32-bit program PDB (speculative) + * @throws Exception upon error + */ + @Test + public void testEgray8_32_noProgram_speculative() throws Exception { + boolean is64Bit = false; Program program = null; MockPdb pdb = egray832Pdb; DataTypeManager dtm = dtm32; @@ -2104,17 +2119,11 @@ public class CppCompositeTypeTest extends AbstractGenericTest { egray832Creator.getSpeculatedVxtPtrSummaries(); Map> expectedVxtStructs = egray832Creator.getSpeculatedVxtStructs(); - int txID = dtm.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, speculativeLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - dtm.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } @@ -2135,17 +2144,11 @@ public class CppCompositeTypeTest extends AbstractGenericTest { egray864Creator.getExpectedVxtPtrSummaries(); Map> expectedVxtStructs = egray864Creator.getExpectedVxtStructs(); - int txID = program.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - program.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } @@ -2154,9 +2157,28 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * @throws Exception upon error */ @Test - public void testEgray8_64_speculative() throws Exception { + public void testEgray8_64_noProgram() throws Exception { boolean is64Bit = false; + Program program = null; + MockPdb pdb = egray864Pdb; + DataTypeManager dtm = dtm64; + MsftVxtManager vxtManager = egray864VxtManagerNoProgram; + Map expectedResults = egray864Creator.getFillerStructs(); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, null); + vxtManager.doTableLayouts(dtm); + }); + // Not checking vxt structures here. + } + /** + * Tests the classes and artifacts of egray8 64-bit program PDB (speculative) + * @throws Exception upon error + */ + @Test + public void testEgray8_64_noProgram_speculative() throws Exception { + boolean is64Bit = false; Program program = null; MockPdb pdb = egray864Pdb; DataTypeManager dtm = dtm64; @@ -2166,17 +2188,11 @@ public class CppCompositeTypeTest extends AbstractGenericTest { egray864Creator.getSpeculatedVxtPtrSummaries(); Map> expectedVxtStructs = egray864Creator.getSpeculatedVxtStructs(); - int txID = dtm.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, speculativeLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - dtm.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } @@ -2197,17 +2213,11 @@ public class CppCompositeTypeTest extends AbstractGenericTest { vftm32Creator.getExpectedVxtPtrSummaries(); Map> expectedVxtStructs = vftm32Creator.getExpectedVxtStructs(); - int txID = program.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - program.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } @@ -2216,9 +2226,28 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * @throws Exception upon error */ @Test - public void testVftm_32_speculative() throws Exception { + public void testVftm_32_noProgram() throws Exception { boolean is64Bit = false; + Program program = null; + MockPdb pdb = vftm32Pdb; + DataTypeManager dtm = dtm32; + MsftVxtManager vxtManager = vftm32VxtManagerNoProgram; + Map expectedResults = vftm32Creator.getFillerStructs(); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, null); + vxtManager.doTableLayouts(dtm); + }); + // Not checking vxt structures here. + } + /** + * Tests the classes and artifacts of vftm 32-bit program PDB (speculative) + * @throws Exception upon error + */ + @Test + public void testVftm_32_noProgram_speculative() throws Exception { + boolean is64Bit = false; Program program = null; MockPdb pdb = vftm32Pdb; DataTypeManager dtm = dtm32; @@ -2228,17 +2257,11 @@ public class CppCompositeTypeTest extends AbstractGenericTest { vftm32Creator.getSpeculatedVxtPtrSummaries(); Map> expectedVxtStructs = vftm32Creator.getSpeculatedVxtStructs(); - int txID = dtm.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, speculativeLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - dtm.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } @@ -2259,17 +2282,11 @@ public class CppCompositeTypeTest extends AbstractGenericTest { vftm64Creator.getExpectedVxtPtrSummaries(); Map> expectedVxtStructs = vftm64Creator.getExpectedVxtStructs(); - int txID = program.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - program.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } @@ -2278,9 +2295,28 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * @throws Exception upon error */ @Test - public void testVftm_64_speculative() throws Exception { - boolean is64Bit = true; + public void testVftm_64_noProgram() throws Exception { + boolean is64Bit = false; + Program program = null; + MockPdb pdb = vftm64Pdb; + DataTypeManager dtm = dtm64; + MsftVxtManager vxtManager = vftm64VxtManagerNoProgram; + Map expectedResults = vftm64Creator.getFillerStructs(); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, null); + vxtManager.doTableLayouts(dtm); + }); + // Not checking vxt structures here. + } + /** + * Tests the classes and artifacts of vftm 64-bit program PDB (speculative) + * @throws Exception upon error + */ + @Test + public void testVftm_64_noProgram_speculative() throws Exception { + boolean is64Bit = true; Program program = null; MockPdb pdb = vftm64Pdb; DataTypeManager dtm = dtm64; @@ -2290,17 +2326,11 @@ public class CppCompositeTypeTest extends AbstractGenericTest { vftm64Creator.getSpeculatedVxtPtrSummaries(); Map> expectedVxtStructs = vftm64Creator.getSpeculatedVxtStructs(); - int txID = dtm.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, speculativeLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - dtm.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } @@ -2321,20 +2351,34 @@ public class CppCompositeTypeTest extends AbstractGenericTest { cfb432Creator.getExpectedVxtPtrSummaries(); Map> expectedVxtStructs = cfb432Creator.getExpectedVxtStructs(); - int txID = program.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - program.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } + /** + * Tests the classes and artifacts of cfb4 32-bit program PDB (speculative) + * @throws Exception upon error + */ + @Test + public void testCfb4_32_noProgram() throws Exception { + boolean is64Bit = false; + Program program = null; + MockPdb pdb = cfb432Pdb; + DataTypeManager dtm = dtm32; + MsftVxtManager vxtManager = cfb432VxtManagerNoProgram; + Map expectedResults = cfb432Creator.getFillerStructs(); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, null); + vxtManager.doTableLayouts(dtm); + }); + // Not checking vxt structures here. + } + /** * Tests the classes and artifacts of cfb4 32-bit program PDB (speculative) * @throws Exception upon error @@ -2342,7 +2386,6 @@ public class CppCompositeTypeTest extends AbstractGenericTest { @Test public void testCfb4_32_speculative() throws Exception { boolean is64Bit = false; - Program program = null; MockPdb pdb = cfb432Pdb; DataTypeManager dtm = dtm32; @@ -2352,23 +2395,17 @@ public class CppCompositeTypeTest extends AbstractGenericTest { cfb432Creator.getSpeculatedVxtPtrSummaries(); Map> expectedVxtStructs = cfb432Creator.getSpeculatedVxtStructs(); - int txID = dtm.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, speculativeLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - dtm.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } //============================================================================================== /** - * Tests the classes and artifacts of cfb4 32-bit program + * Tests the classes and artifacts of cfb4 64-bit program * @throws Exception upon error */ @Test @@ -2383,17 +2420,11 @@ public class CppCompositeTypeTest extends AbstractGenericTest { cfb464Creator.getExpectedVxtPtrSummaries(); Map> expectedVxtStructs = cfb464Creator.getExpectedVxtStructs(); - int txID = program.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - program.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } @@ -2402,9 +2433,28 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * @throws Exception upon error */ @Test - public void testCfb4_64_speculative() throws Exception { - boolean is64Bit = true; + public void testCfb4_64_noProgram() throws Exception { + boolean is64Bit = false; + Program program = null; + MockPdb pdb = cfb464Pdb; + DataTypeManager dtm = dtm64; + MsftVxtManager vxtManager = cfb464VxtManagerNoProgram; + Map expectedResults = cfb464Creator.getFillerStructs(); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, classLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, null); + vxtManager.doTableLayouts(dtm); + }); + // Not checking vxt structures here. + } + /** + * Tests the classes and artifacts of cfb4 64-bit program PDB (speculative) + * @throws Exception upon error + */ + @Test + public void testCfb4_64_noProgram_speculative() throws Exception { + boolean is64Bit = true; Program program = null; MockPdb pdb = cfb464Pdb; DataTypeManager dtm = dtm64; @@ -2414,35 +2464,33 @@ public class CppCompositeTypeTest extends AbstractGenericTest { cfb464Creator.getSpeculatedVxtPtrSummaries(); Map> expectedVxtStructs = cfb464Creator.getSpeculatedVxtStructs(); - int txID = dtm.startTransaction("Processing data."); - boolean commit = false; - try { - createAndTestStructures(program, dtm, pdb, is64Bit, vxtManager, expectedResults, - expectedVxtPtrSummaries); + dtm.withTransaction("Processing data.", () -> { + createAndTestStructures(program, dtm, speculativeLayoutChoice, pdb, is64Bit, vxtManager, + expectedResults, expectedVxtPtrSummaries); vxtManager.doTableLayouts(dtm); - commit = true; - } - finally { - dtm.endTransaction(txID, commit); - } + }); checkVxtStructures(dtm, expectedVxtStructs); } //============================================================================================== //============================================================================================== - private void createAndTestStructures(Program program, DataTypeManager dtm, MockPdb pdb, - boolean is64Bit, MsftVxtManager vxtManager, Map expectedResults, + private void createAndTestStructures(Program program, DataTypeManager dtm, + ObjectOrientedClassLayout layoutChoice, MockPdb pdb, boolean is64Bit, + MsftVxtManager vxtManager, Map expectedResults, Map> expectedVxtPtrSummaries) throws Exception { for (CppCompositeType cppType : pdb.getCppTypes()) { ClassID id = cppType.getClassId(); - cppType.createLayout(classLayoutChoice, vxtManager, monitor); + cppType.createLayout(layoutChoice, vxtManager, monitor); Composite composite = pdb.resolveType(dtm, cppType); String expected = expectedResults.get(id); if (expected == null || expected.equals("NOT YET DETERMINED")) { continue; } CompositeTestUtils.assertExpectedComposite(this, expected, composite, true); + if (expectedVxtPtrSummaries == null) { + continue; + } Map expectedSummary = expectedVxtPtrSummaries.get(id); Map vxtPtrSummary = cppType.getVxtPtrSummary(); assertEquals(expectedSummary.size(), vxtPtrSummary.size());