From c1dbadade8082a69d88c9b0dba38197cc2df2783 Mon Sep 17 00:00:00 2001 From: ghizard <50744617+ghizard@users.noreply.github.com> Date: Fri, 25 Jul 2025 11:34:52 -0400 Subject: [PATCH] GP-5874 - PDB CPP - Fix month's old regression in assigning vxt types; add tests to prevent further regression --- .../app/util/pdb/classtype/MsVxtManager.java | 14 +- .../util/pdb/classtype/VirtualBaseTable.java | 10 +- .../app/util/pdb/classtype/VxtManager.java | 27 ++- .../pdb/pdbapplicator/CppCompositeType.java | 224 +++++++++++++++--- .../app/util/pdb/Cfb432ProgramCreator.java | 130 ++++++++++ .../app/util/pdb/Cfb464ProgramCreator.java | 130 ++++++++++ .../app/util/pdb/Egray832ProgramCreator.java | 144 +++++++++++ .../app/util/pdb/Egray864ProgramCreator.java | 144 +++++++++++ .../app/util/pdb/Vftm32ProgramCreator.java | 35 +++ .../app/util/pdb/Vftm64ProgramCreator.java | 35 +++ .../util/pdb/classtype/MsVxtManagerTest.java | 27 ++- .../pdbapplicator/CppCompositeTypeTest.java | 68 +++++- 12 files changed, 916 insertions(+), 72 deletions(-) diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/MsVxtManager.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/MsVxtManager.java index b5c5092915..9020d38407 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/MsVxtManager.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/MsVxtManager.java @@ -53,10 +53,11 @@ import mdemangler.typeinfo.*; * {@link #createVirtualTable(CategoryPath, String, Address, TaskMonitor)} methods demangle * the strings and created tables within a owner/parentage tree based on the demangled information. *

- * The {@link #findVbt(ClassID, List, Integer)} and {@link #findVft(ClassID, List, Integer)} methods - * attempt to find the VF/VB tables by finding the appropriate node in the tree based upon owner - * and at-times-mismatched parentage information from the user. This mismatch is not necessarily - * the fault of the user, but more due to what parentage is incorporated into the mangled name. + * The {@link #findCreateVbt(ClassID, List, Integer)} and + * {@link #findCreateVft(ClassID, List, Integer)} methods attempt to find the VF/VB tables by + * finding the appropriate node in the tree based upon owner and at-times-mismatched parentage + * information from the user. This mismatch is not necessarily the fault of the user, but more + * due to what parentage is incorporated into the mangled name. *

* DESIGN of find mechanism *

@@ -338,7 +339,7 @@ public class MsVxtManager extends VxtManager { * @param ordinal ordinal of table for owner as sorted by address * @return the table */ - public VirtualBaseTable findVbt(ClassID owner, List parentage, Integer ordinal) { + public VirtualBaseTable findCreateVbt(ClassID owner, List parentage, Integer ordinal) { OwnerParentage op = new OwnerParentage(owner, parentage); VirtualBaseTable vbt = vbtsByOwnerParentage.get(op); if (vbt != null) { @@ -424,7 +425,8 @@ public class MsVxtManager extends VxtManager { * @param ordinal ordinal of table for owner as sorted by address * @return the table */ - public VirtualFunctionTable findVft(ClassID owner, List parentage, Integer ordinal) { + public VirtualFunctionTable findCreateVft(ClassID owner, List parentage, + Integer ordinal) { OwnerParentage op = new OwnerParentage(owner, parentage); VirtualFunctionTable vft = vftsByOwnerParentage.get(op); if (vft != null) { diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualBaseTable.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualBaseTable.java index ab488d9ba4..29b65b6b31 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualBaseTable.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualBaseTable.java @@ -72,7 +72,7 @@ public abstract class VirtualBaseTable implements VBTable { public void addEntry(int tableIndex, ClassID baseId) { VirtualBaseTableEntry entry = getNewEntry(baseId); entryByTableIndex.put(tableIndex, entry); - maxTableIndexSeen = Integer.max(maxTableIndexSeen, tableIndex); + witnessTableIndex(tableIndex); } int getMaxTableIndex() { @@ -115,7 +115,7 @@ public abstract class VirtualBaseTable implements VBTable { else { entry.setClassId(baseId); } - maxTableIndexSeen = Integer.max(maxTableIndexSeen, tableIndex); + witnessTableIndex(tableIndex); } /** @@ -130,10 +130,14 @@ public abstract class VirtualBaseTable implements VBTable { if (entry == null) { return null; } - maxTableIndexSeen = Integer.max(maxTableIndexSeen, tableIndex); + witnessTableIndex(tableIndex); return entry.getClassId(); } + private void witnessTableIndex(int tableIndex) { + maxTableIndexSeen = Integer.max(maxTableIndexSeen, tableIndex); + } + /** * Returns the owning class * @return the owner diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VxtManager.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VxtManager.java index fc867d7dda..eaefd37086 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VxtManager.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VxtManager.java @@ -15,8 +15,7 @@ */ package ghidra.app.util.pdb.classtype; -import java.util.HashMap; -import java.util.Map; +import java.util.*; import ghidra.program.model.address.Address; import ghidra.program.model.data.PointerDataType; @@ -28,8 +27,8 @@ public class VxtManager { protected ClassTypeManager ctm; - protected Map vbtByAddress; - protected Map vftByAddress; + protected TreeMap vbtByAddress; + protected TreeMap vftByAddress; /** * Virtual Base Table Lookup Manager @@ -37,8 +36,8 @@ public class VxtManager { */ public VxtManager(ClassTypeManager ctm) { this.ctm = ctm; - vbtByAddress = new HashMap<>(); - vftByAddress = new HashMap<>(); + vbtByAddress = new TreeMap<>(); + vftByAddress = new TreeMap<>(); } /** @@ -75,4 +74,20 @@ public class VxtManager { return vftByAddress.get(address); } + /** + * Dumps vbt addresses + * @return the addresses + */ + public List

dumpVbtAddresses() { + return new ArrayList
(vbtByAddress.keySet()); + } + + /** + * Dumps fbt addresses + * @return the addresses + */ + public List
dumpVftAddresses() { + return new ArrayList
(vftByAddress.keySet()); + } + } 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 bf4192a52a..a8e67553c0 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 @@ -149,8 +149,10 @@ public class CppCompositeType { private TreeSet propagatedIndirectVirtualBaseVbts; private TreeMap finalVftPtrInfoByOffset; private TreeMap finalVbtPtrInfoByOffset; - private TreeMap finalVftByOffset; - private TreeMap finalVbtByOffset; + private LinkedHashMap finalVftByOffset; + private LinkedHashMap finalVbtByOffset; + private List orderedVfts; + private List orderedVbts; //============================================================================================== //============================================================================================== @@ -831,6 +833,9 @@ public class CppCompositeType { createClassLayout(vxtManager, layoutOptions, monitor); + // See comment located with this method regardign possible future removal. + updateOrderedVxtsInVirtualBases(vxtManager); + finalizeAllVxtParentage(); } @@ -864,8 +869,11 @@ public class CppCompositeType { propagatedIndirectVirtualBaseVbts = new TreeSet<>(); finalVftPtrInfoByOffset = new TreeMap<>(); finalVbtPtrInfoByOffset = new TreeMap<>(); - finalVftByOffset = new TreeMap<>(); - finalVbtByOffset = new TreeMap<>(); + orderedVfts = new ArrayList<>(); + orderedVbts = new ArrayList<>(); + + finalVftByOffset = new LinkedHashMap<>(); + finalVbtByOffset = new LinkedHashMap<>(); vxtPtrSummary = new TreeMap<>(); } @@ -923,16 +931,15 @@ public class CppCompositeType { for (VxtPtrInfo info : finalVftPtrInfoByOffset.values()) { List altParentage = finalizeVxtPtrParentage(vftChildToParentRoot, vftParentToChildRoot, info); - String name = ClassUtils.getSpecialVxTableName(info.finalOffset); + String name = ClassUtils.getSpecialVxTableName(info.finalOffset()); String result = dumpVxtPtrResult("vft", info, altParentage.reversed()); builder.append(result + "\n"); results.put(name, result); - } for (VxtPtrInfo info : finalVbtPtrInfoByOffset.values()) { List altParentage = finalizeVxtPtrParentage(vbtChildToParentRoot, vbtParentToChildRoot, info); - String name = ClassUtils.getSpecialVxTableName(info.finalOffset); + String name = ClassUtils.getSpecialVxTableName(info.finalOffset()); String result = dumpVxtPtrResult("vbt", info, altParentage.reversed()); builder.append(result + "\n"); results.put(name, result); @@ -1094,10 +1101,13 @@ public class CppCompositeType { } } - for (VXT t : finalVftByOffset.values()) { - VirtualFunctionTable vft = (VirtualFunctionTable) t; - updateVftFromSelf(vft); - } + // Save for possible future reincorporation if we can get back to better updateVft and + // updateVbt models... of coures this is only updating vfts... this code is found + // else where now, but might move back here. +// for (VXT t : finalVftByOffset.values()) { +// VirtualFunctionTable vft = (VirtualFunctionTable) t; +// updateVftFromSelf(vft); +// } } @@ -1288,33 +1298,46 @@ public class CppCompositeType { private void findVirtualBaseVxtPtrs(MsVxtManager vxtManager) throws PdbException { // Walk direct bases to find vxts of virtual bases. TODO: also notate all rolled up // virtuals for each direct base. + + // We have to defer updating the vxts; the orderedVfts and orderredVbts lists are created + // and used for updating the vxts in the same order that they occur here. And they are + // only used for the virtual bases (not used in for the direct bases above.) The reason + // why they cannot be updated here is that we need the full lists before so that the + // updates can try to find the correct vxt in the MsVxtManager by its ordinal position + // (of the vbt or vft type) within the current class. If we can get a fully error-free + // vxtManager by which we can find owner/parentage vxts without error, then we have the + // change to eliminate the ordinal lookup and can then add back the updateVft() and + // updateVbt() methods here. We aim to maintain the older versions of these methods + // for that possible improvement. The older methods are, nicely, still used above for + // the direct bases. + for (DirectLayoutBaseClass base : directLayoutBaseClasses) { CppCompositeType cppBaseType = base.getBaseClassType(); - ClassID baseId = cppBaseType.getClassId(); + //ClassID baseId = cppBaseType.getClassId(); // for the update commented above for (VxtPtrInfo info : cppBaseType.getPropagatedDirectVirtualBaseVfts()) { VxtPtrInfo newInfo = createSelfOwnedVirtualVxtPtrInfo(info); - updateVft(vxtManager, baseId, newInfo, info); storeVxtInfo(propagatedDirectVirtualBaseVfts, finalVftPtrInfoByOffset, vfTableIdByOffset, vftOffsetByTableId, newInfo); + orderedVfts.add(newInfo); } for (VxtPtrInfo info : cppBaseType.getPropagatedDirectVirtualBaseVbts()) { VxtPtrInfo newInfo = createSelfOwnedVirtualVxtPtrInfo(info); - updateVbt(vxtManager, baseId, newInfo, info); storeVxtInfo(propagatedDirectVirtualBaseVbts, finalVbtPtrInfoByOffset, vbTableIdByOffset, vbtOffsetByTableId, newInfo); + orderedVbts.add(newInfo); } for (VxtPtrInfo info : cppBaseType.getPropagatedIndirectVirtualBaseVfts()) { VxtPtrInfo newInfo = createSelfOwnedVirtualVxtPtrInfo(info); - updateVft(vxtManager, baseId, newInfo, info); storeVxtInfo(propagatededIndirectVirtualBaseVfts, finalVftPtrInfoByOffset, vfTableIdByOffset, vftOffsetByTableId, newInfo); + orderedVfts.add(newInfo); } for (VxtPtrInfo info : cppBaseType.getPropagatedIndirectVirtualBaseVbts()) { VxtPtrInfo newInfo = createSelfOwnedVirtualVxtPtrInfo(info); - updateVbt(vxtManager, baseId, newInfo, info); storeVxtInfo(propagatedIndirectVirtualBaseVbts, finalVbtPtrInfoByOffset, vbTableIdByOffset, vbtOffsetByTableId, newInfo); + orderedVbts.add(newInfo); } } @@ -1328,44 +1351,65 @@ public class CppCompositeType { for (VxtPtrInfo info : cppBaseType.getPropagatedSelfBaseVfts()) { VxtPtrInfo newInfo = createVirtualOwnedSelfVxtPtrInfo(info, baseId); - updateVft(vxtManager, baseId, newInfo, info); storeVxtInfo(propagatedDirectVirtualBaseVfts, finalVftPtrInfoByOffset, vfTableIdByOffset, vftOffsetByTableId, newInfo); + orderedVfts.add(newInfo); } for (VxtPtrInfo info : cppBaseType.getPropagatedSelfBaseVbts()) { VxtPtrInfo newInfo = createVirtualOwnedSelfVxtPtrInfo(info, baseId); - updateVbt(vxtManager, baseId, newInfo, info); storeVxtInfo(propagatedDirectVirtualBaseVbts, finalVbtPtrInfoByOffset, vbTableIdByOffset, vbtOffsetByTableId, newInfo); + orderedVbts.add(newInfo); } for (VxtPtrInfo info : cppBaseType.getPropagatedDirectVirtualBaseVfts()) { VxtPtrInfo newInfo = createVirtualOwnedVirtualVxtPtrInfo(info); - updateVft(vxtManager, baseId, newInfo, info); storeVxtInfo(propagatededIndirectVirtualBaseVfts, finalVftPtrInfoByOffset, vfTableIdByOffset, vftOffsetByTableId, newInfo); + orderedVfts.add(newInfo); } for (VxtPtrInfo info : cppBaseType.getPropagatedDirectVirtualBaseVbts()) { VxtPtrInfo newInfo = createVirtualOwnedVirtualVxtPtrInfo(info); - updateVbt(vxtManager, baseId, newInfo, info); storeVxtInfo(propagatedIndirectVirtualBaseVbts, finalVbtPtrInfoByOffset, vbTableIdByOffset, vbtOffsetByTableId, newInfo); + orderedVbts.add(newInfo); } for (VxtPtrInfo info : cppBaseType.getPropagatedIndirectVirtualBaseVfts()) { VxtPtrInfo newInfo = createVirtualOwnedVirtualVxtPtrInfo(info); - updateVft(vxtManager, baseId, newInfo, info); storeVxtInfo(propagatededIndirectVirtualBaseVfts, finalVftPtrInfoByOffset, vfTableIdByOffset, vftOffsetByTableId, newInfo); + orderedVfts.add(newInfo); } for (VxtPtrInfo info : cppBaseType.getPropagatedIndirectVirtualBaseVbts()) { VxtPtrInfo newInfo = createVirtualOwnedVirtualVxtPtrInfo(info); - updateVbt(vxtManager, baseId, newInfo, info); storeVxtInfo(propagatedIndirectVirtualBaseVbts, finalVbtPtrInfoByOffset, vbTableIdByOffset, vbtOffsetByTableId, newInfo); + orderedVbts.add(newInfo); } } } + // See comment in findVirtualBaseVxtPtrs(). The method here is new and called from the main + // createHierarchicalClassLayout() method, but we might eventually be able to eliminate it. + private void updateOrderedVxtsInVirtualBases(MsVxtManager vxtManager) { + List vftOffsets = List.copyOf(finalVftPtrInfoByOffset.keySet()); + List vbtOffsets = List.copyOf(finalVbtPtrInfoByOffset.keySet()); + + for (VxtPtrInfo info : orderedVfts) { + int ordinal = vftOffsets.indexOf(info.finalOffset()); + updateVft(vxtManager, info, ordinal == -1 ? null : ordinal); + } + for (VxtPtrInfo info : orderedVbts) { + int ordinal = vbtOffsets.indexOf(info.finalOffset()); + updateVbt(vxtManager, info, ordinal == -1 ? null : ordinal); + } + + for (VXT t : finalVftByOffset.values()) { + VirtualFunctionTable vft = (VirtualFunctionTable) t; + updateVftFromSelf(vft); + } + } + // Note sure what the final information will look like when we are done. For this stopping // point, this method stores what we currently want to store /** @@ -1529,7 +1573,7 @@ public class CppCompositeType { myVftPtrOffset = vftPtrTypeByOffset.firstKey(); VxtPtrInfo info = new VxtPtrInfo(myVftPtrOffset, myVftPtrOffset, myId, List.of(myId)); - VirtualFunctionTable myVft = vxtManager.findVft(myId, info.parentage(), 0); + VirtualFunctionTable myVft = vxtManager.findCreateVft(myId, info.parentage(), 0); myVft.setPtrOffsetInClass(info.finalOffset()); propagatedSelfBaseVfts.add(info); finalVftByOffset.put(info.finalOffset(), myVft); @@ -1566,7 +1610,7 @@ public class CppCompositeType { Msg.warn(this, "Mismatch vbt location for " + myId); } VxtPtrInfo info = new VxtPtrInfo(vbtPtrOffset, vbtPtrOffset, myId, List.of(myId)); - VirtualBaseTable myVbt = vxtManager.findVbt(myId, info.parentage(), 0); + VirtualBaseTable myVbt = vxtManager.findCreateVbt(myId, info.parentage(), 0); myVbt.setPtrOffsetInClass(info.finalOffset()); propagatedSelfBaseVbts.add(info); finalVbtByOffset.put(info.finalOffset(), myVbt); @@ -1600,6 +1644,77 @@ public class CppCompositeType { } } + // This method might eventually go away if we are able to eliminate the method that calls it. + // See those comments. We would keep the other version of this method that is found below it. + /** + * Updates vftable entries with values from this class that override those of parent classes + */ + private VirtualFunctionTable updateVft(VxtManager vxtManager, VxtPtrInfo info, + Integer ordinal) { + if (!(vxtManager instanceof MsVxtManager mvxtManager)) { + // error + return null; + } + List parentage = info.parentage(); + List parentParentage = parentage.subList(0, parentage.size() - 1); + + Long finalOffset = info.finalOffset(); + VirtualFunctionTable myVft = (VirtualFunctionTable) finalVftByOffset.get(finalOffset); + if (myVft == null) { + myVft = mvxtManager.findCreateVft(myId, info.parentage(), ordinal); + if (myVft == null) { + return null; + } + finalVftByOffset.put(finalOffset, myVft); + } + + myVft.setPtrOffsetInClass(finalOffset); + if (parentParentage.isEmpty()) { + return myVft; + } + + ClassID parentId = parentParentage.getLast(); + VirtualFunctionTable parentVft = mvxtManager.findCreateVft(parentId, parentParentage, null); + if (parentVft == null) { + // this is an error + return null; + } + + for (Map.Entry mapEntry : parentVft + .getEntriesByTableIndex() + .entrySet()) { + int tableOffset = mapEntry.getKey(); + VFTableEntry e = mapEntry.getValue(); + SymbolPath parentOrigPath = e.getOriginalPath(); + SymbolPath parentPath = e.getOverridePath(); + VFTableEntry currentEntry = myVft.getEntry(tableOffset); + if (currentEntry != null) { + SymbolPath currentOrigPath = currentEntry.getOriginalPath(); + SymbolPath currentPath = currentEntry.getOverridePath(); + // Note that this check also checks the method name + if (!parentOrigPath.equals(currentOrigPath)) { + // problem + } + boolean parentOverride = !parentOrigPath.equals(parentPath); + boolean currentOverride = !currentOrigPath.equals(currentPath); + if (!currentOverride && parentOverride) { + myVft.addEntry(tableOffset, parentOrigPath, parentPath, e.getFunctionPointer()); + } + else if (currentOverride && !parentOverride) { + myVft.addEntry(tableOffset, currentOrigPath, currentPath, + e.getFunctionPointer()); + } + else { + // maybe order matters? + } + } + else { + myVft.addEntry(tableOffset, parentOrigPath, parentPath, e.getFunctionPointer()); + } + } + return myVft; + } + /** * Updates vftable entries with values from this class that override those of parent classes */ @@ -1624,8 +1739,8 @@ public class CppCompositeType { Long finalOffset = info.finalOffset(); VirtualFunctionTable myVft = (VirtualFunctionTable) finalVftByOffset.get(finalOffset); if (myVft == null) { - Integer ordinal = getOrdinalOfKey(finalVftByOffset, finalOffset); - myVft = mvxtManager.findVft(myId, info.parentage(), ordinal); + Integer ordinal = getOrdinalOfKey(finalVftPtrInfoByOffset, finalOffset); + myVft = mvxtManager.findCreateVft(myId, info.parentage(), ordinal); if (myVft == null) { return null; } @@ -1633,7 +1748,7 @@ public class CppCompositeType { } myVft.setPtrOffsetInClass(finalOffset); - VirtualFunctionTable parentVft = mvxtManager.findVft(parentId, parentParentage, null); + VirtualFunctionTable parentVft = mvxtManager.findCreateVft(parentId, parentParentage, null); if (parentVft == null) { // this is an error @@ -1727,6 +1842,51 @@ public class CppCompositeType { } } + // This method might eventually go away if we are able to eliminate the method that calls it. + // See those comments. We would keep the other version of this method that is found below it. + + // TODO: Remove? Believe that only the main VBT should ever possibly get updated. The others + // will only get updated in size when they are the main VBT within those respective base + // classes. + private VirtualBaseTable updateVbt(VxtManager vxtManager, VxtPtrInfo info, Integer ordinal) { + if (!(vxtManager instanceof MsVxtManager mvxtManager)) { + // error + return null; + } + List parentage = info.parentage(); + List parentParentage = parentage.subList(0, parentage.size() - 1); + + Long finalOffset = info.finalOffset(); + VirtualBaseTable myVbt = (VirtualBaseTable) finalVbtByOffset.get(finalOffset); + if (myVbt == null) { + myVbt = mvxtManager.findCreateVbt(myId, info.parentage(), ordinal); + if (myVbt == null) { + return null; + } + finalVbtByOffset.put(finalOffset, myVbt); + } + + myVbt.setPtrOffsetInClass(finalOffset); + if (parentParentage.isEmpty()) { + return myVbt; + } + + ClassID parentId = parentParentage.getLast(); + VirtualBaseTable parentVbt = mvxtManager.findCreateVbt(parentId, parentParentage, null); + if (parentVbt == null) { + // this is an error + return null; + } + for (Map.Entry mapEntry : parentVbt.getEntriesByTableIndex() + .entrySet()) { + int tableOffset = mapEntry.getKey(); + VBTableEntry e = mapEntry.getValue(); + myVbt.addEntry(tableOffset, e.getClassId()); + } + + return myVbt; + } + // TODO: Remove? Believe that only the main VBT should ever possibly get updated. The others // will only get updated in size when they are the main VBT within those respective base // classes. @@ -1751,8 +1911,8 @@ public class CppCompositeType { Long finalOffset = info.finalOffset(); VirtualBaseTable myVbt = (VirtualBaseTable) finalVbtByOffset.get(finalOffset); if (myVbt == null) { - Integer ordinal = getOrdinalOfKey(finalVbtByOffset, finalOffset); - myVbt = mvxtManager.findVbt(myId, info.parentage(), ordinal); + Integer ordinal = getOrdinalOfKey(finalVbtPtrInfoByOffset, finalOffset); + myVbt = mvxtManager.findCreateVbt(myId, info.parentage(), ordinal); if (myVbt == null) { return null; } @@ -1760,7 +1920,7 @@ public class CppCompositeType { } myVbt.setPtrOffsetInClass(finalOffset); - VirtualBaseTable parentVbt = mvxtManager.findVbt(parentId, parentParentage, null); + VirtualBaseTable parentVbt = mvxtManager.findCreateVbt(parentId, parentParentage, null); if (parentVbt == null) { // this is an error return null; @@ -1775,9 +1935,9 @@ public class CppCompositeType { return myVbt; } - private Integer getOrdinalOfKey(Map map, Long key) { + private Integer getOrdinalOfKey(TreeMap map, Long key) { int index = 0; - for (Long offset : finalVftByOffset.keySet()) { + for (Long offset : map.keySet()) { if (offset == key) { return index; } 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 cb7a318961..90bd685b04 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 @@ -7184,6 +7184,132 @@ public class Cfb432ProgramCreator extends ProgramCreator { speculatedVxtStructs.put(M, getSpeculatedVxtStructsM()); } + private static final Map expectedVxtAddressTypes = new LinkedHashMap<>(); + static { + expectedVxtAddressTypes.put("00458268", "/ANS/A/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("004582bc", "/BNS/B/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00458310", "/CNS/C/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("0045837c", "/DNS/D/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00458390", "/DNS/D/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("0045839c", "/DNS/D/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("004583f8", "/ENS/E/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00458410", "/ENS/E/!internal/VTABLE_00000034"); + expectedVxtAddressTypes.put("0045842c", "/FNS/F/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00458444", "/GNS/G/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0045845c", "/HNS/H/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00458474", "/INS/I/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0045847c", "/INS/I/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("00458494", "/JNS/J/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004584ac", "/KNS/K/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004584c4", "/LNS/L/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00458564", "/MNS/M/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00458584", "/MNS/M/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00458598", "/MNS/M/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("004585a4", "/MNS/M/!internal/VTABLE_0000002c"); + expectedVxtAddressTypes.put("004585b0", "/MNS/M/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("004585b8", "/MNS/M/!internal/VTABLE_00000044"); + expectedVxtAddressTypes.put("004585c0", "/MNS/M/!internal/VTABLE_00000054"); + expectedVxtAddressTypes.put("004585c8", "/MNS/M/!internal/VTABLE_00000094"); + expectedVxtAddressTypes.put("00458628", "/O1NS/O1/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("0045863c", "/O1NS/O1/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("0045869c", "/O2NS/O2/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("004586b4", "/O2NS/O2/!internal/VTABLE_00000034"); + expectedVxtAddressTypes.put("00458714", "/O3NS/O3/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00458728", "/O3NS/O3/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("00458788", "/O4NS/O4/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("004587a0", "/O4NS/O4/!internal/VTABLE_00000034"); + expectedVxtAddressTypes.put("00458838", "/ONS/O/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00458858", "/ONS/O/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("00458864", "/ONS/O/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("0045887c", "/ONS/O/!internal/VTABLE_00000054"); + expectedVxtAddressTypes.put("00458888", "/ONS/O/!internal/VTABLE_00000060"); + expectedVxtAddressTypes.put("0045889c", "/ONS/O/!internal/VTABLE_0000006c"); + expectedVxtAddressTypes.put("004588a8", "/ONS/O/!internal/VTABLE_0000007c"); + expectedVxtAddressTypes.put("00458224", "/A1NS/A1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00458234", "/A2NS/A2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00458244", "/ANS/A/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0045824c", "/ANS/A/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("0045825c", "/ANS/A/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00458278", "/B1NS/B1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00458288", "/B2NS/B2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00458298", "/BNS/B/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004582a0", "/BNS/B/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("004582b0", "/BNS/B/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("004582cc", "/CNS/C/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004582d4", "/CNS/C/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("004582e4", "/CNS/C/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("004582f4", "/CNS/C/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("00458304", "/CNS/C/!internal/VTABLE_00000024"); + expectedVxtAddressTypes.put("00458328", "/DNS/D/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00458330", "/DNS/D/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("00458338", "/DNS/D/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("00458340", "/DNS/D/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("00458350", "/DNS/D/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("00458360", "/DNS/D/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("00458370", "/DNS/D/!internal/VTABLE_00000040"); + expectedVxtAddressTypes.put("004583ac", "/ENS/E/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004583b4", "/ENS/E/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("004583c4", "/ENS/E/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("004583d4", "/ENS/E/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("004583e4", "/ENS/E/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("004583f4", "/ENS/E/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("00458420", "/FNS/F/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00458438", "/GNS/G/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("00458450", "/HNS/H/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("00458468", "/INS/I/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("00458488", "/JNS/J/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("004584a0", "/KNS/K/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("004584b8", "/LNS/L/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("004584d0", "/N1NS/N1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004584dc", "/N2NS/N2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004584e8", "/MNS/M/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004584f0", "/MNS/M/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("004584f8", "/MNS/M/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("00458500", "/MNS/M/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("00458508", "/MNS/M/!internal/VTABLE_00000068"); + expectedVxtAddressTypes.put("00458514", "/MNS/M/!internal/VTABLE_00000070"); + expectedVxtAddressTypes.put("00458524", "/MNS/M/!internal/VTABLE_00000078"); + expectedVxtAddressTypes.put("00458534", "/MNS/M/!internal/VTABLE_00000080"); + expectedVxtAddressTypes.put("00458544", "/MNS/M/!internal/VTABLE_00000088"); + expectedVxtAddressTypes.put("00458554", "/MNS/M/!internal/VTABLE_00000090"); + expectedVxtAddressTypes.put("0045855c", "/MNS/M/!internal/VTABLE_0000009c"); + expectedVxtAddressTypes.put("004585d8", "/O1NS/O1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004585e4", "/O1NS/O1/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("004585ec", "/O1NS/O1/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("004585fc", "/O1NS/O1/!internal/VTABLE_00000024"); + expectedVxtAddressTypes.put("0045860c", "/O1NS/O1/!internal/VTABLE_0000002c"); + expectedVxtAddressTypes.put("0045861c", "/O1NS/O1/!internal/VTABLE_00000034"); + expectedVxtAddressTypes.put("0045864c", "/O2NS/O2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00458658", "/O2NS/O2/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("00458668", "/O2NS/O2/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("00458678", "/O2NS/O2/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("00458688", "/O2NS/O2/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("00458698", "/O2NS/O2/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("004586c4", "/O3NS/O3/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004586d0", "/O3NS/O3/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("004586d8", "/O3NS/O3/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("004586e8", "/O3NS/O3/!internal/VTABLE_00000024"); + expectedVxtAddressTypes.put("004586f8", "/O3NS/O3/!internal/VTABLE_0000002c"); + expectedVxtAddressTypes.put("00458708", "/O3NS/O3/!internal/VTABLE_00000034"); + expectedVxtAddressTypes.put("00458738", "/O4NS/O4/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00458744", "/O4NS/O4/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("00458754", "/O4NS/O4/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("00458764", "/O4NS/O4/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("00458774", "/O4NS/O4/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("00458784", "/O4NS/O4/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("004587b0", "/ONS/O/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004587c0", "/ONS/O/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("004587c8", "/ONS/O/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("004587d4", "/ONS/O/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("004587e4", "/ONS/O/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("004587f4", "/ONS/O/!internal/VTABLE_00000040"); + expectedVxtAddressTypes.put("00458804", "/ONS/O/!internal/VTABLE_00000048"); + expectedVxtAddressTypes.put("00458814", "/ONS/O/!internal/VTABLE_00000050"); + expectedVxtAddressTypes.put("0045881c", "/ONS/O/!internal/VTABLE_0000005c"); + expectedVxtAddressTypes.put("00458828", "/ONS/O/!internal/VTABLE_00000068"); + expectedVxtAddressTypes.put("00458830", "/ONS/O/!internal/VTABLE_00000078"); + } + //============================================================================================== //============================================================================================== //============================================================================================== @@ -7225,6 +7351,10 @@ public class Cfb432ProgramCreator extends ProgramCreator { return speculatedVxtStructs; } + public Map getExpectedVxtAddressTypes() { + return expectedVxtAddressTypes; + } + @Override protected List getRegularTypes(DataTypeManager dtm) throws PdbException { return List.of(); 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 8c5c8fb02f..3c04825e3d 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 @@ -7323,6 +7323,132 @@ public class Cfb464ProgramCreator extends ProgramCreator { speculatedVxtStructs.put(M, getSpeculatedVxtStructsM()); } + private static final Map expectedVxtAddressTypes = new LinkedHashMap<>(); + static { + expectedVxtAddressTypes.put("14006f518", "/ANS/A/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006f5b8", "/BNS/B/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006f658", "/CNS/C/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006f720", "/DNS/D/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006f734", "/DNS/D/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("14006f740", "/DNS/D/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("14006f7f0", "/ENS/E/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006f808", "/ENS/E/!internal/VTABLE_00000068"); + expectedVxtAddressTypes.put("14006f838", "/FNS/F/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f860", "/GNS/G/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f888", "/HNS/H/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f8b0", "/INS/I/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f8b8", "/INS/I/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006f8e0", "/JNS/J/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f908", "/KNS/K/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f930", "/LNS/L/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006fa68", "/MNS/M/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006fa88", "/MNS/M/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("14006fa9c", "/MNS/M/!internal/VTABLE_00000040"); + expectedVxtAddressTypes.put("14006faa8", "/MNS/M/!internal/VTABLE_00000058"); + expectedVxtAddressTypes.put("14006fab4", "/MNS/M/!internal/VTABLE_00000070"); + expectedVxtAddressTypes.put("14006fabc", "/MNS/M/!internal/VTABLE_00000088"); + expectedVxtAddressTypes.put("14006fac4", "/MNS/M/!internal/VTABLE_000000a8"); + expectedVxtAddressTypes.put("14006facc", "/MNS/M/!internal/VTABLE_00000128"); + expectedVxtAddressTypes.put("14006fb80", "/O1NS/O1/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006fb94", "/O1NS/O1/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("14006fc48", "/O2NS/O2/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006fc60", "/O2NS/O2/!internal/VTABLE_00000068"); + expectedVxtAddressTypes.put("14006fd18", "/O3NS/O3/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006fd2c", "/O3NS/O3/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("14006fde0", "/O4NS/O4/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006fdf8", "/O4NS/O4/!internal/VTABLE_00000068"); + expectedVxtAddressTypes.put("14006ff20", "/ONS/O/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("14006ff40", "/ONS/O/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("14006ff4c", "/ONS/O/!internal/VTABLE_00000040"); + expectedVxtAddressTypes.put("14006ff64", "/ONS/O/!internal/VTABLE_000000a8"); + expectedVxtAddressTypes.put("14006ff70", "/ONS/O/!internal/VTABLE_000000c0"); + expectedVxtAddressTypes.put("14006ff84", "/ONS/O/!internal/VTABLE_000000d8"); + expectedVxtAddressTypes.put("14006ff90", "/ONS/O/!internal/VTABLE_000000f8"); + expectedVxtAddressTypes.put("14006f490", "/A1NS/A1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f4b0", "/A2NS/A2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f4d0", "/ANS/A/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f4e0", "/ANS/A/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006f500", "/ANS/A/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("14006f530", "/B1NS/B1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f550", "/B2NS/B2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f570", "/BNS/B/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f580", "/BNS/B/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006f5a0", "/BNS/B/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("14006f5d0", "/CNS/C/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f5e0", "/CNS/C/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006f600", "/CNS/C/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("14006f620", "/CNS/C/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("14006f640", "/CNS/C/!internal/VTABLE_00000048"); + expectedVxtAddressTypes.put("14006f678", "/DNS/D/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f688", "/DNS/D/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006f698", "/DNS/D/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("14006f6a8", "/DNS/D/!internal/VTABLE_00000050"); + expectedVxtAddressTypes.put("14006f6c8", "/DNS/D/!internal/VTABLE_00000060"); + expectedVxtAddressTypes.put("14006f6e8", "/DNS/D/!internal/VTABLE_00000070"); + expectedVxtAddressTypes.put("14006f708", "/DNS/D/!internal/VTABLE_00000080"); + expectedVxtAddressTypes.put("14006f758", "/ENS/E/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f768", "/ENS/E/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("14006f788", "/ENS/E/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("14006f7a8", "/ENS/E/!internal/VTABLE_00000040"); + expectedVxtAddressTypes.put("14006f7c8", "/ENS/E/!internal/VTABLE_00000050"); + expectedVxtAddressTypes.put("14006f7e8", "/ENS/E/!internal/VTABLE_00000060"); + expectedVxtAddressTypes.put("14006f820", "/FNS/F/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("14006f848", "/GNS/G/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006f870", "/HNS/H/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006f898", "/INS/I/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("14006f8c8", "/JNS/J/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("14006f8f0", "/KNS/K/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006f918", "/LNS/L/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("14006f940", "/N1NS/N1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f958", "/N2NS/N2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f970", "/MNS/M/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006f980", "/MNS/M/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("14006f990", "/MNS/M/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("14006f9a0", "/MNS/M/!internal/VTABLE_00000050"); + expectedVxtAddressTypes.put("14006f9b0", "/MNS/M/!internal/VTABLE_000000d0"); + expectedVxtAddressTypes.put("14006f9c8", "/MNS/M/!internal/VTABLE_000000e0"); + expectedVxtAddressTypes.put("14006f9e8", "/MNS/M/!internal/VTABLE_000000f0"); + expectedVxtAddressTypes.put("14006fa08", "/MNS/M/!internal/VTABLE_00000100"); + expectedVxtAddressTypes.put("14006fa28", "/MNS/M/!internal/VTABLE_00000110"); + expectedVxtAddressTypes.put("14006fa48", "/MNS/M/!internal/VTABLE_00000120"); + expectedVxtAddressTypes.put("14006fa58", "/MNS/M/!internal/VTABLE_00000138"); + expectedVxtAddressTypes.put("14006fae0", "/O1NS/O1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006faf8", "/O1NS/O1/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006fb08", "/O1NS/O1/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("14006fb28", "/O1NS/O1/!internal/VTABLE_00000048"); + expectedVxtAddressTypes.put("14006fb48", "/O1NS/O1/!internal/VTABLE_00000058"); + expectedVxtAddressTypes.put("14006fb68", "/O1NS/O1/!internal/VTABLE_00000068"); + expectedVxtAddressTypes.put("14006fba8", "/O2NS/O2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006fbc0", "/O2NS/O2/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("14006fbe0", "/O2NS/O2/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("14006fc00", "/O2NS/O2/!internal/VTABLE_00000040"); + expectedVxtAddressTypes.put("14006fc20", "/O2NS/O2/!internal/VTABLE_00000050"); + expectedVxtAddressTypes.put("14006fc40", "/O2NS/O2/!internal/VTABLE_00000060"); + expectedVxtAddressTypes.put("14006fc78", "/O3NS/O3/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006fc90", "/O3NS/O3/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006fca0", "/O3NS/O3/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("14006fcc0", "/O3NS/O3/!internal/VTABLE_00000048"); + expectedVxtAddressTypes.put("14006fce0", "/O3NS/O3/!internal/VTABLE_00000058"); + expectedVxtAddressTypes.put("14006fd00", "/O3NS/O3/!internal/VTABLE_00000068"); + expectedVxtAddressTypes.put("14006fd40", "/O4NS/O4/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006fd58", "/O4NS/O4/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("14006fd78", "/O4NS/O4/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("14006fd98", "/O4NS/O4/!internal/VTABLE_00000040"); + expectedVxtAddressTypes.put("14006fdb8", "/O4NS/O4/!internal/VTABLE_00000050"); + expectedVxtAddressTypes.put("14006fdd8", "/O4NS/O4/!internal/VTABLE_00000060"); + expectedVxtAddressTypes.put("14006fe10", "/ONS/O/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("14006fe30", "/ONS/O/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("14006fe40", "/ONS/O/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("14006fe58", "/ONS/O/!internal/VTABLE_00000060"); + expectedVxtAddressTypes.put("14006fe78", "/ONS/O/!internal/VTABLE_00000070"); + expectedVxtAddressTypes.put("14006fe98", "/ONS/O/!internal/VTABLE_00000080"); + expectedVxtAddressTypes.put("14006feb8", "/ONS/O/!internal/VTABLE_00000090"); + expectedVxtAddressTypes.put("14006fed8", "/ONS/O/!internal/VTABLE_000000a0"); + expectedVxtAddressTypes.put("14006fee8", "/ONS/O/!internal/VTABLE_000000b8"); + expectedVxtAddressTypes.put("14006ff00", "/ONS/O/!internal/VTABLE_000000d0"); + expectedVxtAddressTypes.put("14006ff10", "/ONS/O/!internal/VTABLE_000000f0"); + } + //============================================================================================== //============================================================================================== //============================================================================================== @@ -7364,6 +7490,10 @@ public class Cfb464ProgramCreator extends ProgramCreator { return speculatedVxtStructs; } + public Map getExpectedVxtAddressTypes() { + return expectedVxtAddressTypes; + } + @Override protected List getRegularTypes(DataTypeManager dtm) throws PdbException { return List.of(); 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 48c95b7a61..14e783798e 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 @@ -17643,6 +17643,146 @@ public class Egray832ProgramCreator extends ProgramCreator { } + private static final Map expectedVxtAddressTypes = new LinkedHashMap<>(); + static { + expectedVxtAddressTypes.put("0044619c", "/G/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004461a4", "/H/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004461ac", "/GG1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004461b4", "/GG2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004461bc", "/GG3/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004461c4", "/GG4/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004461cc", "/I/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004461d4", "/I/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("004461dc", "/GX1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004461e4", "/HX1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004461ec", "/IX1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004461f4", "/IX1/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("004461fc", "/G1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446208", "/H1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446214", "/I1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446220", "/I1/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00446228", "/I2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446234", "/I2/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00446240", "/I3/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0044624c", "/I3/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00446258", "/I4/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446264", "/I5/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446270", "/J1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0044627c", "/J1/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00446284", "/J1/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00446290", "/J1/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("0044629c", "/J2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004462a8", "/J2/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("004462b4", "/J2/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("004462c0", "/J2/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("004462c8", "/J3/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004462d4", "/J3/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("004462e0", "/J3/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("004462ec", "/J3/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("004462f4", "/J4/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446310", "/J4/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("0044631c", "/J4/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00446324", "/J4/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("0044632c", "/J4/!internal/VTABLE_00000024"); + expectedVxtAddressTypes.put("00446334", "/J4/!internal/VTABLE_0000004c"); + expectedVxtAddressTypes.put("0044633c", "/J4/!internal/VTABLE_00000054"); + expectedVxtAddressTypes.put("00446344", "/J5/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446360", "/J5/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("0044636c", "/J5/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00446374", "/J5/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("0044637c", "/J5/!internal/VTABLE_00000024"); + expectedVxtAddressTypes.put("00446384", "/J5/!internal/VTABLE_00000040"); + expectedVxtAddressTypes.put("0044638c", "/J5/!internal/VTABLE_00000048"); + expectedVxtAddressTypes.put("00446394", "/J6/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("004463a8", "/J6/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("004463b0", "/J6/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("004463fc", "/T/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00446414", "/U/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00446434", "/AA3a/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0044643c", "/AA3b/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446444", "/AA3c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446450", "/AA3c/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00446458", "/AA3d/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0044646c", "/AA3d/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("00446474", "/AA3d/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("0044647c", "/AA3g/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446488", "/AA4a/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446490", "/AA4b/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446498", "/AA4c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004464a0", "/AA4c/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("004464a8", "/AA4d/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004464b4", "/AA4d/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("004464bc", "/AA4e/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004464c8", "/AA4e/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("004464d0", "/AA4f/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004464e0", "/AA4f/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("004464e8", "/AA4f/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("004464f0", "/AA4g/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004464f8", "/AA4j/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446500", "/AA4k/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446508", "/AA4m/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446510", "/AA4n/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446518", "/AA4p/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446520", "/AA4q/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446528", "/AA4q/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("00446530", "/AA5e/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00446538", "/AA5f/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00446540", "/AA5g/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("0044654c", "/AA5g/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00446554", "/AA5h/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00446560", "/AA5h/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00446568", "/AA5j/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("0044657c", "/AA5j/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("00446588", "/AA5j/!internal/VTABLE_00000024"); + expectedVxtAddressTypes.put("00446590", "/AA5j/!internal/VTABLE_00000034"); + expectedVxtAddressTypes.put("00446598", "/AA6c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004465a0", "/AA6g/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004465a8", "/AA6h/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004465b4", "/AA6h/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("004465bc", "/AA6j/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004465c8", "/AA6j/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00446624", "/AA7d/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00446630", "/BB1c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446638", "/BB1d/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00446640", "/BB2a/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446648", "/BB2b/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446650", "/BB2c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0044665c", "/BB2c/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("00446664", "/BB2d/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446670", "/BB2d/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("0044667c", "/BB2d/!internal/VTABLE_0000001c"); + expectedVxtAddressTypes.put("00446684", "/BB2e/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0044668c", "/BB3d/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00446694", "/BB3e/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("004466a0", "/BB3f/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("004466b0", "/BB3f/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("004466bc", "/BB3g/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("004466cc", "/BB3g/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("004466d4", "/CC1h/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004466f0", "/DD1b/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004466f8", "/DD1c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446700", "/DD1d/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004463bc", "/P/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004463c4", "/Q/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004463d0", "/R/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004463dc", "/S/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004463e4", "/S/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("004463f0", "/T/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004463f8", "/T/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("00446408", "/U/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446410", "/U/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00446420", "/V/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446428", "/W/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446430", "/WW/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004465d4", "/AA7a/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004465e0", "/AA7b/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004465ec", "/AA7c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004465fc", "/AA7c/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00446608", "/AA7d/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00446610", "/AA7d/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("0044661c", "/AA7d/!internal/VTABLE_00000014"); + } + //============================================================================================== //============================================================================================== //============================================================================================== @@ -17684,6 +17824,10 @@ public class Egray832ProgramCreator extends ProgramCreator { return speculatedVxtStructs; } + public Map getExpectedVxtAddressTypes() { + return expectedVxtAddressTypes; + } + @Override protected List getRegularTypes(DataTypeManager dtm) throws PdbException { return List.of(); 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 1f12ea40c4..23f43d29ea 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 @@ -17971,6 +17971,146 @@ public class Egray864ProgramCreator extends ProgramCreator { } + private static final Map expectedVxtAddressTypes = new LinkedHashMap<>(); + static { + expectedVxtAddressTypes.put("140056370", "/G/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056378", "/H/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056380", "/GG1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056388", "/GG2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056390", "/GG3/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056398", "/GG4/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400563a0", "/I/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400563a8", "/I/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("1400563b0", "/GX1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400563b8", "/HX1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400563c0", "/IX1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400563c8", "/IX1/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("1400563d0", "/G1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400563e0", "/H1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400563f0", "/I1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056400", "/I1/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140056408", "/I2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056418", "/I2/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140056428", "/I3/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056438", "/I3/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140056448", "/I4/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056458", "/I5/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056468", "/J1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056478", "/J1/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140056480", "/J1/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("140056490", "/J1/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("1400564a0", "/J2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400564b0", "/J2/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("1400564c0", "/J2/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("1400564d0", "/J2/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("1400564d8", "/J3/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400564e8", "/J3/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("1400564f8", "/J3/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("140056508", "/J3/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("140056510", "/J4/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056530", "/J4/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140056540", "/J4/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("140056548", "/J4/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("140056550", "/J4/!internal/VTABLE_00000048"); + expectedVxtAddressTypes.put("140056558", "/J4/!internal/VTABLE_00000080"); + expectedVxtAddressTypes.put("140056560", "/J4/!internal/VTABLE_00000090"); + expectedVxtAddressTypes.put("140056568", "/J5/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056588", "/J5/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140056598", "/J5/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("1400565a0", "/J5/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("1400565a8", "/J5/!internal/VTABLE_00000048"); + expectedVxtAddressTypes.put("1400565b0", "/J5/!internal/VTABLE_00000078"); + expectedVxtAddressTypes.put("1400565b8", "/J5/!internal/VTABLE_00000088"); + expectedVxtAddressTypes.put("1400565c0", "/J6/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("1400565d8", "/J6/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("1400565e0", "/J6/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("140056670", "/T/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("140056698", "/U/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("1400566d0", "/AA3a/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400566d8", "/AA3b/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400566e0", "/AA3c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400566f0", "/AA3c/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("1400566f8", "/AA3d/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056710", "/AA3d/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("140056718", "/AA3d/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("140056720", "/AA3g/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056730", "/AA4a/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056738", "/AA4b/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056740", "/AA4c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056748", "/AA4c/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140056750", "/AA4d/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056760", "/AA4d/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("140056768", "/AA4e/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056778", "/AA4e/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("140056780", "/AA4f/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056790", "/AA4f/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("140056798", "/AA4f/!internal/VTABLE_00000030"); + expectedVxtAddressTypes.put("1400567a0", "/AA4g/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400567a8", "/AA4j/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400567b0", "/AA4k/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400567b8", "/AA4m/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400567c0", "/AA4n/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400567c8", "/AA4p/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400567d0", "/AA4q/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400567d8", "/AA4q/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("1400567e0", "/AA5e/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("1400567e8", "/AA5f/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("1400567f0", "/AA5g/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("140056800", "/AA5g/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("140056808", "/AA5h/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("140056818", "/AA5h/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("140056820", "/AA5j/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("140056838", "/AA5j/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("140056848", "/AA5j/!internal/VTABLE_00000048"); + expectedVxtAddressTypes.put("140056850", "/AA5j/!internal/VTABLE_00000068"); + expectedVxtAddressTypes.put("140056858", "/AA6c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056860", "/AA6g/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056868", "/AA6h/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056878", "/AA6h/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("140056880", "/AA6j/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056890", "/AA6j/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("140056940", "/AA7d/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("140056950", "/BB1c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056958", "/BB1d/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("140056960", "/BB2a/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056968", "/BB2b/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056970", "/BB2c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056980", "/BB2c/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("140056988", "/BB2d/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056998", "/BB2d/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("1400569a8", "/BB2d/!internal/VTABLE_00000038"); + expectedVxtAddressTypes.put("1400569b0", "/BB2e/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400569b8", "/BB3d/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("1400569c0", "/BB3e/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("1400569d0", "/BB3f/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("1400569e0", "/BB3f/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("1400569f0", "/BB3g/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("140056a00", "/BB3g/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("140056a08", "/CC1h/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056a28", "/DD1b/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056a30", "/DD1c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056a38", "/DD1d/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400565f0", "/P/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056600", "/Q/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056618", "/R/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056630", "/S/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056640", "/S/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140056658", "/T/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056668", "/T/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("140056680", "/U/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056690", "/U/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("1400566a8", "/V/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400566b8", "/W/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400566c8", "/WW/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400568a0", "/AA7a/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400568b8", "/AA7b/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400568d0", "/AA7c/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400568f0", "/AA7c/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140056908", "/AA7d/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140056918", "/AA7d/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("140056930", "/AA7d/!internal/VTABLE_00000028"); + } + //============================================================================================== //============================================================================================== //============================================================================================== @@ -18012,6 +18152,10 @@ public class Egray864ProgramCreator extends ProgramCreator { return speculatedVxtStructs; } + public Map getExpectedVxtAddressTypes() { + return expectedVxtAddressTypes; + } + @Override protected List getRegularTypes(DataTypeManager dtm) throws PdbException { return List.of(); 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 ae15f6728f..358073486f 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 @@ -2868,6 +2868,37 @@ public class Vftm32ProgramCreator extends ProgramCreator { speculatedVxtStructs.putAll(expectedVxtStructs); } + private static final Map expectedVxtAddressTypes = new LinkedHashMap<>(); + static { + expectedVxtAddressTypes.put("004503cc", "/Q4NS/Q4/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00450434", "/Q5NS/Q5/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("0045049c", "/Q6NS/Q6/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00450508", "/Q7NS/Q7/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("00450600", "/R1NS/R1/!internal/VTABLE_00000004"); + expectedVxtAddressTypes.put("004501e4", "/P1NS/P1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0045020c", "/P2NS/P2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00450240", "/Q1NS/Q1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00450270", "/Q1NS/Q1/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("004502a4", "/Q2NS/Q2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004502dc", "/Q2NS/Q2/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00450310", "/Q3NS/Q3/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0045033c", "/Q3NS/Q3/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("00450370", "/Q4NS/Q4/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004503a8", "/Q4NS/Q4/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("004503d8", "/Q5NS/Q5/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00450404", "/Q5NS/Q5/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("00450440", "/Q6NS/Q6/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("0045046c", "/Q6NS/Q6/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("004504a8", "/Q7NS/Q7/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("004504b0", "/Q7NS/Q7/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("004504d8", "/Q7NS/Q7/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00450518", "/R1NS/R1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("00450534", "/R1NS/R1/!internal/VTABLE_0000000c"); + expectedVxtAddressTypes.put("00450564", "/R1NS/R1/!internal/VTABLE_00000014"); + expectedVxtAddressTypes.put("00450598", "/R1NS/R1/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("004505d0", "/R1NS/R1/!internal/VTABLE_00000028"); + } + //============================================================================================== //============================================================================================== //============================================================================================== @@ -2909,6 +2940,10 @@ public class Vftm32ProgramCreator extends ProgramCreator { return speculatedVxtStructs; } + public Map getExpectedVxtAddressTypes() { + return expectedVxtAddressTypes; + } + @Override protected List getRegularTypes(DataTypeManager dtm) throws PdbException { return List.of(); 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 9f52a5ef18..d506bac200 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 @@ -2904,6 +2904,37 @@ public class Vftm64ProgramCreator extends ProgramCreator { speculatedVxtStructs.putAll(expectedVxtStructs); } + private static final Map expectedVxtAddressTypes = new LinkedHashMap<>(); + static { + expectedVxtAddressTypes.put("1400627d0", "/Q4NS/Q4/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140062898", "/Q5NS/Q5/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140062960", "/Q6NS/Q6/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140062a30", "/Q7NS/Q7/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("140062c18", "/R1NS/R1/!internal/VTABLE_00000008"); + expectedVxtAddressTypes.put("140062400", "/P1NS/P1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140062450", "/P2NS/P2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400624b8", "/Q1NS/Q1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140062518", "/Q1NS/Q1/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140062580", "/Q2NS/Q2/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400625f0", "/Q2NS/Q2/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140062658", "/Q3NS/Q3/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("1400626b0", "/Q3NS/Q3/!internal/VTABLE_00000010"); + expectedVxtAddressTypes.put("140062718", "/Q4NS/Q4/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140062788", "/Q4NS/Q4/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("1400627e0", "/Q5NS/Q5/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140062838", "/Q5NS/Q5/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("1400628a8", "/Q6NS/Q6/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140062900", "/Q6NS/Q6/!internal/VTABLE_00000020"); + expectedVxtAddressTypes.put("140062970", "/Q7NS/Q7/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140062980", "/Q7NS/Q7/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("1400629d0", "/Q7NS/Q7/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("140062a48", "/R1NS/R1/!internal/VTABLE_00000000"); + expectedVxtAddressTypes.put("140062a80", "/R1NS/R1/!internal/VTABLE_00000018"); + expectedVxtAddressTypes.put("140062ae0", "/R1NS/R1/!internal/VTABLE_00000028"); + expectedVxtAddressTypes.put("140062b48", "/R1NS/R1/!internal/VTABLE_00000040"); + expectedVxtAddressTypes.put("140062bb8", "/R1NS/R1/!internal/VTABLE_00000050"); + } + //============================================================================================== //============================================================================================== //============================================================================================== @@ -2945,6 +2976,10 @@ public class Vftm64ProgramCreator extends ProgramCreator { return speculatedVxtStructs; } + public Map getExpectedVxtAddressTypes() { + return expectedVxtAddressTypes; + } + @Override protected List getRegularTypes(DataTypeManager dtm) throws PdbException { return List.of(); diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/classtype/MsVxtManagerTest.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/classtype/MsVxtManagerTest.java index f5299d0ca9..a292e581fa 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/classtype/MsVxtManagerTest.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/classtype/MsVxtManagerTest.java @@ -293,7 +293,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { throws Exception { // vbt obtained by querying on parentage ProgramVirtualBaseTable pvbt = - (ProgramVirtualBaseTable) egray832VxtManager.findVbt(owner, parentage, null); + (ProgramVirtualBaseTable) egray832VxtManager.findCreateVbt(owner, parentage, null); assertEquals(egray832AddressesByMangled.get(pvbt.getMangledName()), pvbt.getAddress()); if (symParentage == null) { Msg.warn(this, @@ -303,7 +303,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { } // vbt obtained by querying on msft symbol info ProgramVirtualBaseTable mvbt = - (ProgramVirtualBaseTable) egray832VxtManager.findVbt(owner, symParentage, null); + (ProgramVirtualBaseTable) egray832VxtManager.findCreateVbt(owner, symParentage, null); // Check if exact same table; not just equivalence assertTrue(mvbt == pvbt); } @@ -329,7 +329,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { throws Exception { // vbt obtained by querying on parentage ProgramVirtualFunctionTable pvft = - (ProgramVirtualFunctionTable) egray832VxtManager.findVft(owner, parentage, null); + (ProgramVirtualFunctionTable) egray832VxtManager.findCreateVft(owner, parentage, null); assertEquals(egray832AddressesByMangled.get(pvft.getMangledName()), pvft.getAddress()); if (symParentage == null) { Msg.warn(this, @@ -339,7 +339,8 @@ public class MsVxtManagerTest extends AbstractGenericTest { } // vbt obtained by querying on msft symbol info ProgramVirtualFunctionTable mvft = - (ProgramVirtualFunctionTable) egray832VxtManager.findVft(owner, symParentage, null); + (ProgramVirtualFunctionTable) egray832VxtManager.findCreateVft(owner, symParentage, + null); // Check if exact same table; not just equivalence assertTrue(mvft == pvft); } @@ -365,7 +366,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { throws Exception { // vbt obtained by querying on parentage ProgramVirtualBaseTable pvbt = - (ProgramVirtualBaseTable) cfb432VxtManager.findVbt(owner, parentage, null); + (ProgramVirtualBaseTable) cfb432VxtManager.findCreateVbt(owner, parentage, null); assertEquals(cfb432AddressesByMangled.get(pvbt.getMangledName()), pvbt.getAddress()); if (symParentage == null) { Msg.warn(this, @@ -375,7 +376,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { } // vbt obtained by querying on msft symbol info ProgramVirtualBaseTable mvbt = - (ProgramVirtualBaseTable) cfb432VxtManager.findVbt(owner, symParentage, null); + (ProgramVirtualBaseTable) cfb432VxtManager.findCreateVbt(owner, symParentage, null); // Check if exact same table; not just equivalence assertTrue(mvbt == pvbt); } @@ -401,7 +402,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { throws Exception { // vbt obtained by querying on parentage ProgramVirtualFunctionTable pvft = - (ProgramVirtualFunctionTable) cfb432VxtManager.findVft(owner, parentage, null); + (ProgramVirtualFunctionTable) cfb432VxtManager.findCreateVft(owner, parentage, null); assertEquals(cfb432AddressesByMangled.get(pvft.getMangledName()), pvft.getAddress()); if (symParentage == null) { Msg.warn(this, @@ -411,7 +412,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { } // vbt obtained by querying on msft symbol info ProgramVirtualFunctionTable mvft = - (ProgramVirtualFunctionTable) cfb432VxtManager.findVft(owner, symParentage, null); + (ProgramVirtualFunctionTable) cfb432VxtManager.findCreateVft(owner, symParentage, null); // Check if exact same table; not just equivalence assertTrue(mvft == pvft); } @@ -437,7 +438,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { throws Exception { // vbt obtained by querying on parentage ProgramVirtualBaseTable pvbt = - (ProgramVirtualBaseTable) vftm32VxtManager.findVbt(owner, parentage, null); + (ProgramVirtualBaseTable) vftm32VxtManager.findCreateVbt(owner, parentage, null); assertEquals(vftm32AddressesByMangled.get(pvbt.getMangledName()), pvbt.getAddress()); if (symParentage == null) { Msg.warn(this, @@ -447,7 +448,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { } // vbt obtained by querying on msft symbol info ProgramVirtualBaseTable mvbt = - (ProgramVirtualBaseTable) vftm32VxtManager.findVbt(owner, symParentage, null); + (ProgramVirtualBaseTable) vftm32VxtManager.findCreateVbt(owner, symParentage, null); // Check if exact same table; not just equivalence assertTrue(mvbt == pvbt); } @@ -473,7 +474,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { throws Exception { // vbt obtained by querying on parentage ProgramVirtualFunctionTable pvft = - (ProgramVirtualFunctionTable) vftm32VxtManager.findVft(owner, parentage, null); + (ProgramVirtualFunctionTable) vftm32VxtManager.findCreateVft(owner, parentage, null); assertEquals(vftm32AddressesByMangled.get(pvft.getMangledName()), pvft.getAddress()); if (symParentage == null) { Msg.warn(this, @@ -483,7 +484,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { } // vbt obtained by querying on msft symbol info ProgramVirtualFunctionTable mvft = - (ProgramVirtualFunctionTable) vftm32VxtManager.findVft(owner, symParentage, null); + (ProgramVirtualFunctionTable) vftm32VxtManager.findCreateVft(owner, symParentage, null); // Check if exact same table; not just equivalence assertTrue(mvft == pvft); } @@ -912,7 +913,7 @@ public class MsVxtManagerTest extends AbstractGenericTest { // Spot-check a function from the table ProgramVirtualFunctionTable vft = - (ProgramVirtualFunctionTable) cfb432VxtManager.findVft(A, List.of(), null); + (ProgramVirtualFunctionTable) cfb432VxtManager.findCreateVft(A, List.of(), null); assertEquals(cfb432AddressesByMangled.get(vft.getMangledName()), vft.getAddress()); Address address = vft.getAddress(0); Symbol s = cfb432Program.getSymbolTable().getPrimarySymbol(address); 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 9090433f33..c668d785ca 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 @@ -32,7 +32,7 @@ import ghidra.program.model.data.*; import ghidra.program.model.data.DataUtilities.ClearDataMode; import ghidra.program.model.gclass.ClassID; import ghidra.program.model.gclass.ClassUtils; -import ghidra.program.model.listing.Program; +import ghidra.program.model.listing.*; import ghidra.util.Msg; import ghidra.util.exception.AssertException; import ghidra.util.task.TaskMonitor; @@ -2084,6 +2084,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { vxtManager.createTables(dtm, clearMode); }); checkVxtStructures(dtm, expectedVxtStructs); + Map expectedTableInfo = egray832Creator.getExpectedVxtAddressTypes(); + checkTables(program, vxtManager, expectedTableInfo); } /** @@ -2153,6 +2155,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { vxtManager.createTables(dtm, clearMode); }); checkVxtStructures(dtm, expectedVxtStructs); + Map expectedTableInfo = egray864Creator.getExpectedVxtAddressTypes(); + checkTables(program, vxtManager, expectedTableInfo); } /** @@ -2222,6 +2226,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { vxtManager.createTables(dtm, clearMode); }); checkVxtStructures(dtm, expectedVxtStructs); + Map expectedTableInfo = vftm32Creator.getExpectedVxtAddressTypes(); + checkTables(program, vxtManager, expectedTableInfo); } /** @@ -2291,6 +2297,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { vxtManager.createTables(dtm, clearMode); }); checkVxtStructures(dtm, expectedVxtStructs); + Map expectedTableInfo = vftm64Creator.getExpectedVxtAddressTypes(); + checkTables(program, vxtManager, expectedTableInfo); } /** @@ -2360,6 +2368,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { vxtManager.createTables(dtm, clearMode); }); checkVxtStructures(dtm, expectedVxtStructs); + Map expectedTableInfo = cfb432Creator.getExpectedVxtAddressTypes(); + checkTables(program, vxtManager, expectedTableInfo); } /** @@ -2429,6 +2439,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { vxtManager.createTables(dtm, clearMode); }); checkVxtStructures(dtm, expectedVxtStructs); + Map expectedTableInfo = cfb464Creator.getExpectedVxtAddressTypes(); + checkTables(program, vxtManager, expectedTableInfo); } /** @@ -2519,10 +2531,14 @@ public class CppCompositeTypeTest extends AbstractGenericTest { private void checkVxtStructures(DataTypeManager dtm, Map> expectedVxtStructs) { for (Map.Entry> entry : expectedVxtStructs.entrySet()) { + Map expectedTables = entry.getValue(); + if (expectedTables.isEmpty()) { + continue; + } ClassID id = entry.getKey(); CategoryPath cp = ClassUtils.getClassInternalsPath(id); Category category = dtm.getCategory(cp); - Map expectedTables = entry.getValue(); + assertNotNull(category); for (Map.Entry tableEntry : expectedTables.entrySet()) { String tableName = tableEntry.getKey(); String expectedTableDump = tableEntry.getValue(); @@ -2531,24 +2547,52 @@ public class CppCompositeTypeTest extends AbstractGenericTest { "Purposefully skipping table test that has bad result for " + tableName); continue; } - assertNotNull(category); Structure table = (Structure) category.getDataType(tableName); assertNotNull(table); CompositeTestUtils.assertExpectedComposite(this, expectedTableDump, table, true); } // Make sure there are no extra tables - if (category != null) { - int count = 0; - DataType[] types = category.getDataTypes(); - if (types != null) { - for (DataType type : category.getDataTypes()) { - if (ClassUtils.isVTable(type)) { - count++; - } + int count = 0; + DataType[] types = category.getDataTypes(); + if (types != null) { + for (DataType type : category.getDataTypes()) { + if (ClassUtils.isVTable(type)) { + count++; } } - assertEquals(expectedTables.size(), count); } + assertEquals(expectedTables.size(), count); + } + } + + private void checkTables(Program program, MsVxtManager vxtManager, + Map tableInfo) { + + // next lines for aiding in creating expected results +// for (Address a : vxtManager.dumpVbtAddresses()) { +// System.out.print(String.format(" expectedVxtAddressTypes.put(\"%s\", \"\");\n", +// a.toString())); +// } +// for (Address a : vxtManager.dumpVftAddresses()) { +// System.out.print(String.format(" expectedVxtAddressTypes.put(\"%s\", \"\");\n", +// a.toString())); +// } + + for (Map.Entry entry : tableInfo.entrySet()) { + String addr = entry.getKey(); + Address[] addresses = program.parseAddress(addr); + assertTrue(addresses.length == 1); + Address address = addresses[0]; + CodeUnit cu = program.getListing().getCodeUnitAt(address); + // assume not instruction... will fail if so + Data d = (Data) cu; + DataType dt = d.getBaseDataType(); + String pathName = dt.getPathName(); + String expectedResult = entry.getValue(); + // Following line is for aiding in creating expected results +// System.out.print(String.format(" expectedVxtAddressTypes.put(\"%s\", \"%s\");\n", +// addr, pathName)); + assertEquals(expectedResult, pathName); } }