From a8623b720256011640dd26aac07f7d9cfd8a0882 Mon Sep 17 00:00:00 2001 From: ghizard <50744617+ghizard@users.noreply.github.com> Date: Fri, 8 Nov 2024 15:30:05 -0500 Subject: [PATCH] GP-5039 - PDB CPP - Move redesigned but neutered VxtManager to master --- .../ghidra/app/util/pdb/classtype/Access.java | 107 + .../pdb/classtype/ClassFieldAttributes.java | 114 + .../app/util/pdb/classtype/ClassID.java | 31 + .../app/util/pdb/classtype/ClassKey.java | 64 + .../util/pdb/classtype/ClassTypeManager.java | 101 + .../util/pdb/classtype/MsftVxtManager.java | 501 ++++ .../util/pdb/classtype/ProgramClassID.java | 120 + .../classtype/ProgramVirtualBaseTable.java | 149 ++ .../ProgramVirtualFunctionTable.java | 82 + .../app/util/pdb/classtype/Property.java | 62 + .../app/util/pdb/classtype/VBTable.java | 23 + .../app/util/pdb/classtype/VBTableEntry.java | 47 + .../app/util/pdb/classtype/VFTable.java | 23 + .../util/pdb/classtype/VirtualBaseTable.java | 111 + .../pdb/classtype/VirtualBaseTableEntry.java | 59 + .../pdb/classtype/VirtualFunctionTable.java | 98 + .../app/util/pdb/classtype/VxtManager.java | 78 + .../pdbapplicator/ClassFieldAttributes.java | 238 -- .../pdbapplicator/CompositeTypeApplier.java | 27 +- .../pdb/pdbapplicator/CppCompositeType.java | 281 +-- .../pdbapplicator/DefaultPdbApplicator.java | 93 +- .../DefaultPdbUniversalMember.java | 5 +- .../pdb/classtype/MsftVxtManagerTest.java | 623 +++++ .../pdbapplicator/CppCompositeTypeTest.java | 2211 ++++++++--------- 24 files changed, 3620 insertions(+), 1628 deletions(-) create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/Access.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassFieldAttributes.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassID.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassKey.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassTypeManager.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/MsftVxtManager.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramClassID.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramVirtualBaseTable.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramVirtualFunctionTable.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/Property.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VBTable.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VBTableEntry.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VFTable.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualBaseTable.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualBaseTableEntry.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualFunctionTable.java create mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VxtManager.java delete mode 100644 Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ClassFieldAttributes.java create mode 100644 Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/classtype/MsftVxtManagerTest.java diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/Access.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/Access.java new file mode 100644 index 0000000000..ef466aef0f --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/Access.java @@ -0,0 +1,107 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.HashMap; +import java.util.Map; + +/** + * + */ +//---------------------------------------------------------------------------------------------- +// TODO: Consider expanding these beyond C++. +// See https://en.wikipedia.org/wiki/Access_modifiers +// These could then be: +// UNKNOWN("UNKNOWN_ACCESS ", -1), +// OPEN("open", 0), +// PUBLIC("internal", 1), +// INTERNAL("internal", 2), +// PACKAGE("package", 3), +// PROTECTED("protected", 4), +// PROTECTED_INTERNAL("protected internal", 5), +// PRIVATE_PROTECTED("private protected", 6), +// FILE("file", 7), +// FILE_PRIVATE("fileprivate", 8), +// PRIVATE("private", 9); +public enum Access { + UNKNOWN("UNKNOWN_ACCESS", -1), + BLANK("", 0), // eliminated 20230524... using defaultAccess on some methods. Could renumber + PUBLIC("public", 1), + PROTECTED("protected", 2), + PRIVATE("private", 3); + + private static final Map BY_VALUE = new HashMap<>(); + static { + for (Access val : values()) { + BY_VALUE.put(val.value, val); + } + } + private final String label; + private final int value; + + public String getString() { + return label; + } + + @Override + public String toString() { + return label; + } + + public int getValue() { + return value; + } + + public static Access fromValue(int val) { + return BY_VALUE.getOrDefault(val, UNKNOWN); + } + + private Access(String label, int value) { + this.label = label; + this.value = value; + } + + /** + * Merge two Access values, leaning toward more restrictive. UNKNOWN is only returned + * if both are UNKNOWN. + * @param other value to merge + * @return the merged value + */ + public Access mergeRestrictive(Access other) { + // No need to test for UNKNOWN as its value is on the permissive end. + if (this.value > other.value) { + return this; + } + return other; + } + + /** + * Merge two Access values, leaning toward more permissive. UNKNOWN is only returned + * if both are UNKNOWN. + * @param other value to merge + * @return the merged value + */ + public Access mergePermissive(Access other) { + if (this.value < other.value) { + // Only need special test for UNKNOWN here, as its value is on the permissive end. + if (this == UNKNOWN) { + return other; + } + return this; + } + return other; + } +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassFieldAttributes.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassFieldAttributes.java new file mode 100644 index 0000000000..f13d9da38d --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassFieldAttributes.java @@ -0,0 +1,114 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.*; + +import ghidra.app.util.bin.format.pdb2.pdbreader.type.ClassFieldMsAttributes; + +/** + * + */ +public class ClassFieldAttributes { + + private static final Map map = new HashMap<>(); + + // These initializations use the map above, so it must be initialized first + public static final ClassFieldAttributes UNKNOWN = get(Access.UNKNOWN, Property.UNKNOWN); + public static final ClassFieldAttributes BLANK = get(Access.BLANK, Property.BLANK); + + private final Access access; + private final Property property; + + public synchronized static ClassFieldAttributes get(Access access, Property property) { + ClassFieldAttributes key = new ClassFieldAttributes(access, property); + ClassFieldAttributes cfa = map.putIfAbsent(key, key); + return (cfa != null) ? cfa : key; + } + + public static ClassFieldAttributes convert(ClassFieldMsAttributes msAtts, + Access defaultAccess) { + Access myAccess = switch (msAtts.getAccess()) { + case PUBLIC -> Access.PUBLIC; + case PROTECTED -> Access.PROTECTED; + case PRIVATE -> Access.PRIVATE; + case BLANK -> defaultAccess; + default -> Access.UNKNOWN; + }; + Property myProperty = switch (msAtts.getProperty()) { + case VIRTUAL -> Property.VIRTUAL; + case STATIC -> Property.STATIC; + case FRIEND -> Property.FRIEND; + case BLANK -> Property.BLANK; + default -> Property.UNKNOWN; + }; + return get(myAccess, myProperty); + } + + private ClassFieldAttributes(Access access, Property property) { + this.access = access; + this.property = property; + } + + public Access getAccess() { + return access; + } + + public Property getProperty() { + return property; + } + + public void emit(StringBuilder builder) { + StringBuilder myBuilder = new StringBuilder(); + if (access.getValue() > Access.BLANK.getValue()) { + myBuilder.append(access); + myBuilder.append(' '); + } + if (property.getValue() > Property.BLANK.getValue()) { + myBuilder.append(property); + myBuilder.append(' '); + } + builder.append(myBuilder); + } + + @Override + public String toString() { + StringBuilder builder = new StringBuilder(); + emit(builder); + return builder.toString(); + } + + @Override + public int hashCode() { + return Objects.hash(access, property); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + ClassFieldAttributes other = (ClassFieldAttributes) obj; + return access == other.access && property == other.property; + } + +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassID.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassID.java new file mode 100644 index 0000000000..d10ee6a598 --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassID.java @@ -0,0 +1,31 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +/** + * Unique ID of a ClassType. Not sure if there will be different implementation for definition + * vs. compiled vs. program vs. debug. Need to come to grips with this + */ +public interface ClassID extends Comparable { + + // For compareTo() method of classes in this hierarchy (for Comparable) + /** + * For internal use + * @return hash of java class in ClassID hierarchy + */ + public int getClassNameHash(); + +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassKey.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassKey.java new file mode 100644 index 0000000000..fb0478c0b2 --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassKey.java @@ -0,0 +1,64 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.HashMap; +import java.util.Map; + +/** + * Class keys from perspective of C++ language + */ +public enum ClassKey { + UNKNOWN("UNKNOWN_TYPE", -1), + BLANK("", 1), + CLASS("class", 2), + STRUCT("struct", 3), + UNION("union", 4); + + private static final Map BY_VALUE = new HashMap<>(); + static { + for (ClassKey val : values()) { + BY_VALUE.put(val.value, val); + } + } + private final String label; + private final int value; + + public String getString() { + return label; + } + + @Override + public String toString() { + if (label.length() != 0) { + return label + " "; + } + return label; + } + + public int getValue() { + return value; + } + + public static ClassKey fromValue(int val) { + return BY_VALUE.getOrDefault(val, UNKNOWN); + } + + private ClassKey(String label, int value) { + this.label = label; + this.value = value; + } +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassTypeManager.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassTypeManager.java new file mode 100644 index 0000000000..52190a849f --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ClassTypeManager.java @@ -0,0 +1,101 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import ghidra.app.util.SymbolPath; +import ghidra.program.model.data.*; + +/** + * Class Type Manager + */ +public class ClassTypeManager { + + private static final String CLASS_TYPE_MANAGER_PROTOTYPE2 = "CLASS_TYPE_MANAGER_PROTOTYPE2"; + + private DataTypeManager dtm; + + private PointerDataType defaultPtrType; + private PointerDataType defaultVbtPtr; + private PointerDataType defaultVftPtr; + + /** + * Constructor + * @param dtm the data type manager + */ + public ClassTypeManager(DataTypeManager dtm) { + this.dtm = dtm; + + defaultPtrType = new PointerDataType(dtm); + defaultVbtPtr = new PointerDataType(new IntegerDataType(dtm)); + defaultVftPtr = new PointerDataType(new PointerDataType(dtm)); + } + + public SymbolPath getSymbolPath(ClassID classId) { + if (classId instanceof ProgramClassID gId) { + return gId.getSymbolPath(); + } + return null; + } + + /** + * Returns the underlying data type manager + * @return the data type manager + */ + public DataTypeManager getDataTypeManager() { + return dtm; + } + + /** + * Returns the default pointer type + * @return the pointer type + */ + public PointerDataType getDefaultPointerType() { + return defaultPtrType; + } + + /** + * Returns the default virtual base table pointer type + * @return the pointer type + */ + public PointerDataType getDefaultVbtPtr() { + return defaultVbtPtr; + } + + /** + * Returns the default virtual function table pointer type + * @return the pointer type + */ + public PointerDataType getDefaultVftPtr() { + return defaultVftPtr; + } + + /** + * Returns the default size of a virtual base table entry + * @return the size of the entry + */ + public int getDefaultVbtTableElementSize() { + return dtm.getDataOrganization().getIntegerSize(); + } + + /** + * Returns the default size of a virtual function table entry + * @return the size of the entry + */ + public int getDefaultVftTableElementSize() { + return dtm.getDataOrganization().getPointerSize(); + } + +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/MsftVxtManager.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/MsftVxtManager.java new file mode 100644 index 0000000000..c56ac0ca61 --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/MsftVxtManager.java @@ -0,0 +1,501 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.*; + +import ghidra.app.util.SymbolPath; +import ghidra.app.util.demangler.DemangledException; +import ghidra.app.util.demangler.DemangledObject; +import ghidra.app.util.demangler.microsoft.MicrosoftDemangler; +import ghidra.app.util.demangler.microsoft.MicrosoftMangledContext; +import ghidra.app.util.importer.MessageLog; +import ghidra.program.model.address.Address; +import ghidra.program.model.data.CategoryPath; +import ghidra.program.model.mem.Memory; +import ghidra.util.Msg; +import ghidra.util.exception.AssertException; +import ghidra.util.exception.CancelledException; +import ghidra.util.task.TaskMonitor; +import mdemangler.MDParsableItem; +import mdemangler.naming.MDQualification; +import mdemangler.naming.MDQualifier; +import mdemangler.object.MDObjectCPP; +import mdemangler.typeinfo.*; + +/** + * This class manages MSFT-compliant virtual function tables and virtual base tables for our + * program. + *

+ * This class also provide lookup mechanisms for locating the appropriate tables desired for + * for particular MSFT-compliant classes of the program. This is particularly useful for + * determining how classes are laid down in memory and for determining which virtual method + * gets called for a class. + *

+ * The initial design has been shelved for now due to issues. For now, the design relies on + * a stinky solution that assumes the order of the tables in memory is that same as the order of + * the pointers to these tables in the owner class. This seems true based on limited experience. + * Hoping to revisit this soon. + */ +public class MsftVxtManager extends VxtManager { + + private Memory memory; + private Map vxtAddressByMangled; + private Map parentageNodeByMangled; + + // These two are for an interim solution where we believe that the order of these tables in + // memory are the same order that their pointers appear in the classes... this is based solely + // on limited experience. The solution stinks and would benefit from the original direction + // of using the parentage. We will try to use the parentage as a litmus test on retrieval + private Map> vbtsByOwner; + private Map> vftsByOwner; + + // Used for locating vft and vbt + // These are explicitly used for storing/retrieving the "program" versions which result from + // locating and parsing the mangled strings for these tables. It is possible that these + // could be used for placeholder or other versions... TBD + private ParentageNode mixedRoot; // originally had separate roots for VFT and VBT + + /** + * Constructor for this class + * @param ctm the class type manager + * @param memory the memory of the program + */ + public MsftVxtManager(ClassTypeManager ctm, Memory memory) { + super(ctm); + this.memory = memory; + vxtAddressByMangled = new HashMap<>(); + parentageNodeByMangled = new HashMap<>(); + vbtsByOwner = new HashMap<>(); + vftsByOwner = new HashMap<>(); + mixedRoot = new ParentageNode(null); + } + + /** + * Finds the putative {@link VBTable} in memory requested for the owning class + * @param owner the owning class of the table + * @return the table + */ + public VBTable findPrimaryVbt(ClassID owner) { + TreeMap map = vbtsByOwner.get(owner); + if (map == null) { + return null; + } + return map.firstEntry().getValue(); + } + + /** + * Finds the putative {@link VFTable} in memory requested for the owning class + * @param owner the owning class of the table + * @return the table + */ + public VFTable findPrimaryVft(ClassID owner) { + TreeMap map = vftsByOwner.get(owner); + if (map == null) { + return null; + } + return map.firstEntry().getValue(); + } + + /** + * Finds the putative {@link VBTable} in memory requested for the owning class and the + * specified parentage + * @param owner the owning class of the table + * @param parentage the parentage for the desired table. The parentage must start with the + * parent that contains the pointer to the table and should include the ordered lineage from + * that class through all of its decendents to the owner, excluding the owner + * @return the table + */ + public VBTable findVbt(ClassID owner, List parentage) { + ParentageNode node = findNode(owner, parentage); + if (node == null) { + return null; + } + VBTable vbTable = node.getVBTable(); + if (vbTable != null || !parentage.isEmpty()) { // see note below + return vbTable; + } + // Not 100% sure on this... needs more investigation as to why there are mangled strings + // that reference the owner in the parentage. Could there be a situation where there + // is one with the parentage and one without? We are treating them as the same for now + // unless we find counter-examples or difficulties with this. + // Above, we test of parentage.isEmpty, because this special case comes into play only + // if it was empty + node = findNode(owner, List.of(owner)); + if (node == null) { + return null; + } + return node.getVBTable(); + } + + /** + * Finds the putative {@link VFTable} in memory requested for the owning class and the + * specified parentage + * @param owner the owning class of the table + * @param parentage the parentage for the desired table. The parentage must start with the + * parent that contains the pointer to the table and should include the ordered lineage from + * that class through all of its decendents to the owner, excluding the owner + * @return the table + */ + public VFTable findVft(ClassID owner, List parentage) { + ParentageNode node = findNode(owner, parentage); + if (node == null) { + return null; + } + VFTable vfTable = node.getVFTable(); + if (vfTable != null || !parentage.isEmpty()) { // see note below + return vfTable; + } + // Not 100% sure on this... needs more investigation as to why there are mangled strings + // that reference the owner in the parentage. Could there be a situation where there + // is one with the parentage and one without? We are treating them as the same for now + // unless we find counter-examples or difficulties with this. + // Above, we test of parentage.isEmpty, because this special case comes into play only + // if it was empty + node = findNode(owner, List.of(owner)); + if (node == null) { + return null; + } + return node.getVFTable(); + } + + /** + * Creates a virtual function and base tables for the {@code Map} of + * addresses-by-mangled names. Any failures are logged + * + * @param categoryPath the base category path used for the collection of class-related + * types + * @param addressByMangledName the map of addresses-by-mangled-names + * @param log the message log + * @param monitor the task monitor + * @throws CancelledException upon user cancellation + */ + public void createVirtualTables(CategoryPath categoryPath, + Map addressByMangledName, MessageLog log, TaskMonitor monitor) + throws CancelledException { + for (Map.Entry entry : addressByMangledName.entrySet()) { + monitor.checkCancelled(); + String mangled = entry.getKey(); + Address address = entry.getValue(); + if (!createVirtualTable(categoryPath, mangled, address, monitor)) { + log.appendMsg("Could not create VxTable for " + mangled); + } + } + } + + /** + * Creates a virtual function or base table for the mangled symbol and its associated + * memory address + * + * @param categoryPath the base category path used for the collection of class-related + * types + * @param mangled the mangled name of the type + * @param address the address associated with the mangled name + * @param monitor the task monitor + * @return {@code true} if successful + */ + public boolean createVirtualTable(CategoryPath categoryPath, String mangled, Address address, + TaskMonitor monitor) { + + Address a = vxtAddressByMangled.get(mangled); + if (a != null) { + if (!a.equals(address)) { + Msg.warn(this, String.format("New address (%s) does not match existing %s for: %s", + a, address, mangled)); + } + else { + Msg.warn(this, + String.format("Entry already exists: address (%s), %s", address, mangled)); + } + return false; + } + vxtAddressByMangled.put(mangled, address); + + DemanglerResults demanglerResults = getOwnerAndUsersDtp(categoryPath, mangled); + if (demanglerResults == null) { + Msg.warn(this, "Problem obtaining path information from mangled symbol: " + mangled); + return false; + } + + OwnerAndParentage ownerAndParentage = demanglerResults.ownerAndParentage(); + ClassID owner = ownerAndParentage.owner(); + List parentage = ownerAndParentage.parentage(); + ParentageNode node = parentageNodeByMangled.get(mangled); + if (node == null) { + node = getOrAddParentageNode(categoryPath, mixedRoot, demanglerResults); + if (node == null) { + return false; + } + parentageNodeByMangled.put(mangled, node); + } + + switch (demanglerResults.vtType()) { + case VBT: + ProgramVirtualBaseTable prvbt = new ProgramVirtualBaseTable(owner, parentage, + memory, address, ctm.getDefaultVbtTableElementSize(), ctm, mangled); + if (node.getVBTable() != null) { + Msg.warn(this, "VBT already exists at node for " + mangled); + return false; + } + node.setVBTable(prvbt); + vbtByAddress.put(address, prvbt); + storeVbt(owner, address, prvbt); // temp solution? + break; + + case VFT: + ProgramVirtualFunctionTable vft = new ProgramVirtualFunctionTable(owner, parentage, + memory, address, ctm.getDefaultVftTableElementSize(), mangled); + if (node.getVFTable() != null) { + Msg.warn(this, "VFT already exists at node for " + mangled); + return false; + } + node.setVFTable(vft); + vftByAddress.put(address, vft); + storeVft(owner, address, vft); // temp solution? + break; + + default: + throw new AssertException("Unhandled VtType: " + demanglerResults.vtType()); + } + return true; + } + + private void storeVbt(ClassID owner, Address address, VBTable vbt) { + TreeMap map = vbtsByOwner.get(owner); + if (map == null) { + map = new TreeMap<>(); + vbtsByOwner.put(owner, map); + } + map.put(address, vbt); + } + + private void storeVft(ClassID owner, Address address, VFTable vft) { + TreeMap map = vftsByOwner.get(owner); + if (map == null) { + map = new TreeMap<>(); + vftsByOwner.put(owner, map); + } + map.put(address, vft); + } + + private ParentageNode findNode(ClassID owner, List parentage) { + if (!(owner instanceof ProgramClassID ownerGId)) { + return null; + } + SymbolPath ownerSp = ownerGId.getSymbolPath(); + ParentageNode ownerNode = mixedRoot.getBranch(ownerSp.toString()); + if (ownerNode == null) { + return null; + } + ParentageNode resultNode = null; + ParentageNode node = ownerNode; + for (ClassID id : parentage) { + if (!(id instanceof ProgramClassID gId)) { + return null; + } + SymbolPath sp = gId.getSymbolPath(); + ParentageNode next = node.getBranch(sp.toString()); + if (next != null) { + node = next; + resultNode = node; + } + // Regardless of found or not, go to next in parentage. + // Skips unnecessary peer-through parents + } + if (resultNode == null) { + return ownerNode; + } + // Need to have found at least one in parentage, but since the owner is part of our + // parentage tree, we cannot use the fact that we are still on owner (which can also + // be in our parentage list) as the flag for knowing if we found something in the + // parentage, so we have a separate found flag + return resultNode; + } + + private ParentageNode getOrAddParentageNode(CategoryPath categoryPath, ParentageNode root, + DemanglerResults demanglerResults) { + + ParentageNode node = root; + OwnerAndParentage ownerAndParentage = demanglerResults.ownerAndParentage(); + + ClassID owner = ownerAndParentage.owner(); // owner should be same as first on list + List parentage = ownerAndParentage.parentage(); + if (!(owner instanceof ProgramClassID)) { + Msg.error(this, "ClassID error for " + ownerAndParentage); + return null; + } + ProgramClassID gId = (ProgramClassID) owner; + node = node.getOrAddBranch(gId.getSymbolPath().toString()); + for (ClassID id : parentage) { + if (!(id instanceof ProgramClassID)) { + Msg.error(this, "ClassID error for " + ownerAndParentage); + return null; + } + gId = (ProgramClassID) id; + node = node.getOrAddBranch(gId.getSymbolPath().toString()); + } + return node; + } + + private static MDParsableItem doDemangle(String mangledString) { + MicrosoftDemangler demangler = new MicrosoftDemangler(); + // Options, Program, and Address will have no bearing on what we are looking for + MicrosoftMangledContext context = + demangler.createMangledContext(mangledString, null, null, null); + try { + DemangledObject demangledObject = demangler.demangle(context); + if (demangledObject == null) { + // Couldn't demangle. + return null; + } + return demangler.getMdItem(); + } + catch (DemangledException e) { + // Couldn't demangle. + return null; + } + } + + private enum VtType { + VFT, VBT + } + + private record OwnerAndParentage(ClassID owner, List parentage) {} + + private record DemanglerResults(VtType vtType, OwnerAndParentage ownerAndParentage) {} + + /** + * Gets the owner and users of the VxT from the mangled name + * @param categoryPath the base CategoryPath for types tree being used + * @param mangledString the mangled string to be decoded + * @return the associated complex type or null if the string couldn't be demangled + */ + private static DemanglerResults getOwnerAndUsersDtp(CategoryPath categoryPath, + String mangledString) { + MDParsableItem parsableItem = doDemangle(mangledString); + + if (!(parsableItem instanceof MDObjectCPP cppItem)) { + return null; + } + MDTypeInfo typeInfo = cppItem.getTypeInfo(); + if (!(typeInfo instanceof MDVxTable vxTable)) { + return null; + } + + SymbolPath ownerSp = getOwnerSymbolPath(cppItem.getQualification()); + List parentageSps = getParentageSymbolPaths(vxTable.getNestedQualifications()); + + List parentage = new ArrayList<>(); + ClassID owner = new ProgramClassID(categoryPath, ownerSp); + for (SymbolPath sp : parentageSps) { + ClassID user = new ProgramClassID(categoryPath, sp); + parentage.add(user); // owner is the parentage if parentageSps was empty + } + + OwnerAndParentage ownerAndParentage = new OwnerAndParentage(owner, parentage); + + return switch (typeInfo) { + case MDVFTable f -> new DemanglerResults(VtType.VFT, ownerAndParentage); + case MDVBTable b -> new DemanglerResults(VtType.VBT, ownerAndParentage); + default -> null; + }; + } + + private static List getParentageSymbolPaths(List qualifications) { + if (qualifications == null) { + return null; + } + List paths = new ArrayList<>(); + for (MDQualification qualification : qualifications) { + SymbolPath symbolPath = getOwnerSymbolPath(qualification); + paths.add(symbolPath); + } + return paths; + } + + private static SymbolPath getOwnerSymbolPath(MDQualification qualification) { + Iterator it = qualification.iterator(); + if (!it.hasNext()) { + return null; + } + List parts = new ArrayList<>(); + do { + MDQualifier qual = it.next(); + parts.add(0, qual.toString()); + } + while (it.hasNext()); + return new SymbolPath(parts); + } + + //============================================================================================== + + private static class ParentageNode { + private ParentageNode parent = null; + private Map branches; + private String name; + // Might want to store more than just one VXT... could store generic, pdb, program + // versions... could mix function and base too (one tree instead of two)? + private VFTable vft; + private VBTable vbt; + + private ParentageNode(String name) { + this.name = name; + branches = new HashMap<>(); + } + + private ParentageNode getOrAddBranch(String branchName) { + ParentageNode branch = branches.get(branchName); + if (branch == null) { + branch = new ParentageNode(branchName); + branch.parent = this; + branches.put(branchName, branch); + } + return branch; + } + + private ParentageNode getBranch(String branchName) { + return branches.get(branchName); + } + + private void setVFTable(VFTable vftArg) { + vft = vftArg; + } + + private void setVBTable(VBTable vbtArg) { + vbt = vbtArg; + } + + private VFTable getVFTable() { + return vft; + } + + private VBTable getVBTable() { + return vbt; + } + + @SuppressWarnings("unused") + private String getName() { + return name; + } + + @SuppressWarnings("unused") + private ParentageNode getParent() { + return parent; + } + + } + +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramClassID.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramClassID.java new file mode 100644 index 0000000000..c26c71afb7 --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramClassID.java @@ -0,0 +1,120 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.Objects; + +import ghidra.app.util.SymbolPath; +import ghidra.program.model.data.CategoryPath; + +/** + * Unique ID of a ProgramClassType. Not sure if there will be different implementation for + * definition vs. compiled vs. program vs. debug. See ClassID. + */ +public class ProgramClassID implements ClassID { + // All of the internals of this might change, but we need something to work with for now. + // It might end up being a hash/guid/long value. + // We were trying to use DataTypePath, but that doesn't work in light of conflicts, as we + // started with a DataTypePath for the type, which later got resolved to a .conflict (so + // DataTypePath changed out from underneath us). + private final SymbolPath symbolPath; + private final CategoryPath categoryPath; + static final int classNameHash = Objects.hash(ProgramClassID.class.getName()); + + /** + * Constructor + * @param categoryPath the category path for the claass + * @param symbolPath the symbol path for the class + */ + public ProgramClassID(CategoryPath categoryPath, SymbolPath symbolPath) { + this.categoryPath = categoryPath; + this.symbolPath = symbolPath; + } + + /** + * Returns the category path + * @return the category path + */ + public CategoryPath getCategoryPath() { + return categoryPath; + } + + /** + * Returns the symbol path + * @return the symbol path + */ + public SymbolPath getSymbolPath() { + return symbolPath; + } + + // Might want to do something with data type ID if resolved +// long doIt(DataTypeManager dtm, DataType dt) { +// int x = DataTypeUtilities.getConflictValue(dt); +// long dataTypeID; +// dataTypeID = dtm.getID(dt); +// UniversalID uid = dt.getUniversalID(); +// return dataTypeID; +// } + + @Override + public int getClassNameHash() { + return classNameHash; + } + + @Override + public String toString() { + return String.format("%s --- %s", categoryPath, symbolPath); + } + + @Override + public int compareTo(ClassID o) { + int ret; + if (!(o instanceof ProgramClassID oID)) { + ret = getClassNameHash() - o.getClassNameHash(); + if (ret != 0) { + throw new AssertionError("Logic problem with compareTo"); + } + return ret; + } + ret = symbolPath.compareTo(oID.symbolPath); + if (ret != 0) { + return ret; + } + return categoryPath.compareTo(oID.categoryPath); + } + + @Override + public int hashCode() { + return Objects.hash(categoryPath, symbolPath); + } + + @Override + public boolean equals(Object obj) { + if (this == obj) { + return true; + } + if (obj == null) { + return false; + } + if (getClass() != obj.getClass()) { + return false; + } + ProgramClassID other = (ProgramClassID) obj; + return Objects.equals(categoryPath, other.categoryPath) && + Objects.equals(symbolPath, other.symbolPath); + } + +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramVirtualBaseTable.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramVirtualBaseTable.java new file mode 100644 index 0000000000..a502a9647f --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramVirtualBaseTable.java @@ -0,0 +1,149 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.*; + +import ghidra.app.util.bin.format.pdb2.pdbreader.PdbException; +import ghidra.program.model.address.Address; +import ghidra.program.model.mem.Memory; +import ghidra.program.model.mem.MemoryAccessException; + +/** + * Virtual Base Table from perspective of program with memory. Values are read from memory + */ +public class ProgramVirtualBaseTable extends VirtualBaseTable { + + private Memory memory; + private Address address; + private int entrySize; + private String mangledName; // remove? + + private Boolean createdFromMemory = null; + private Boolean createdFromCompiled = null; + + private int numEntries = 0; + + private int maxIndexSeen = -1; + private Map entriesByIndex = new HashMap<>(); + + /** + * Constructor + * @param owner the class that owns the table + * @param parentage the parentage of the base class(es) of the table + * @param memory the program memory + * @param address the address of the table + * @param entrySize the size for each table entry + * @param ctm the class type manager + * @param mangledName the mangled name of the table + */ + public ProgramVirtualBaseTable(ClassID owner, List parentage, Memory memory, + Address address, int entrySize, ClassTypeManager ctm, String mangledName) { + super(owner, parentage); + if (entrySize != 4 && entrySize != 8) { + throw new IllegalArgumentException("Invalid size (" + entrySize + "): must be 4 or 8."); + } + this.memory = memory; + this.address = address; + this.entrySize = entrySize; + this.mangledName = mangledName; + createdFromMemory = true; + } + + /** + * Returns the address of the table in program memory + * @return the address + */ + public Address getAddress() { + return address; + } + + /** + * Returns the mangled name + * @return the mangled name + */ + String getMangledName() { + return mangledName; + } + + /* + * For the next method below... once we determine the number of virtual bases (virtual and + * indirect virtual) for each class (from PDB or other), we can determine the number of + * entries in each VBT. For a VBT for the main class, the number is equal... if for some + * parentage, then the number can reflect the number of the parent. TODO: can VBT overlay/extend one from parent???????????????????????????????????????????? + */ + /** + * TBD: need to determine table size to do this. Might want to place a symbol (diff method?). + */ + void placeTableDataType(int numEntries) { + + } + + int getMaxIndex() { + return maxIndexSeen; + } + + @Override + public Long getBaseOffset(int index) throws PdbException { + Address entryAddress = address.add(index * entrySize); + try { + Long offset = (entrySize == 4) ? (long) memory.getInt(entryAddress) + : memory.getLong(entryAddress); + return offset; + } + catch (MemoryAccessException e) { + throw new PdbException( + "MemoryAccessException while trying to parse virtual base table entry at address: " + + entryAddress); + } + finally { + maxIndexSeen = Integer.max(maxIndexSeen, index); + } + } + + @Override + public ClassID getBaseClassId(int index) throws PdbException { + VBTableEntry entry = entriesByIndex.get(index); + if (entry == null) { + throw new PdbException("No entry in Virtual Base Table for index: " + index); + } + maxIndexSeen = Integer.max(maxIndexSeen, index); + return entry.getClassId(); + } + + @Override + public VBTableEntry getBase(int index) throws PdbException { + VBTableEntry entry = entriesByIndex.get(index); + if (entry == null) { + throw new PdbException("No entry in Virtual Base Table for index: " + index); + } + maxIndexSeen = Integer.max(maxIndexSeen, index); + return entry; + } + + // Need to decide if we want to allow this to overwrite existing entry. + public void setBaseClassId(int index, ClassID baseId) throws PdbException { + VBTableEntry entry = entriesByIndex.get(index); + if (entry != null) { + throw new PdbException( + "Entry already exists in Virtual Base Table for index: " + index); + } + entry = new VirtualBaseTableEntry(baseId); + entriesByIndex.put(index, entry); + maxIndexSeen = Integer.max(maxIndexSeen, index); // do we want this here with a "set" method? + } + +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramVirtualFunctionTable.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramVirtualFunctionTable.java new file mode 100644 index 0000000000..9f73ea1296 --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/ProgramVirtualFunctionTable.java @@ -0,0 +1,82 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.List; + +import ghidra.app.util.SymbolPath; +import ghidra.app.util.bin.format.pdb2.pdbreader.PdbException; +import ghidra.program.model.address.Address; +import ghidra.program.model.mem.Memory; + +/** + * Manages virtual function table lookups. + */ +public class ProgramVirtualFunctionTable extends VirtualFunctionTable { + + private Memory memory; + private Address address; + private int defaultEntrySize; // Might go away, as would constructor param + private String mangledName; + + /** + * Constructor + * @param owner the owner class + * @param parentage the parentage for the table + * @param memory the program memory + * @param address the address of the table in memory + * @param defaultEntrySize the default entry size + * @param mangledName the mangled name for the table + */ + public ProgramVirtualFunctionTable(ClassID owner, List parentage, Memory memory, + Address address, int defaultEntrySize, String mangledName) { + super(owner, parentage); + if (defaultEntrySize != 4 && defaultEntrySize != 8) { + throw new IllegalArgumentException( + "Invalid size (" + defaultEntrySize + "): must be 4 or 8."); + } + this.memory = memory; + this.address = address; + this.defaultEntrySize = defaultEntrySize; + this.mangledName = mangledName; + } + + /** + * Returns the address of the table in program memory + * @return the address + */ + public Address getAddress() { + return address; + } + + /** + * Returns the mangled name + * @return the mangled name + */ + String getMangledName() { + return mangledName; + } + + @Override + public Address getAddress(int ordinal) throws PdbException { + throw new UnsupportedOperationException(); + } + + @Override + public SymbolPath getPath(int index) throws PdbException { + throw new UnsupportedOperationException(); + } +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/Property.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/Property.java new file mode 100644 index 0000000000..4b6357f2e3 --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/Property.java @@ -0,0 +1,62 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.HashMap; +import java.util.Map; + +/** + * + */ +public enum Property { + UNKNOWN("INVALID_PROPERTY", -1), + BLANK("", 0), // means non-virtual, non-static, non-friend + VIRTUAL("virtual", 1), + STATIC("static", 2), + FRIEND("friend", 3); + // Also consider , , . See MSFT. + + private static final Map BY_VALUE = new HashMap<>(); + static { + for (Property val : values()) { + BY_VALUE.put(val.value, val); + } + } + private final String label; + private final int value; + + public String getString() { + return label; + } + + @Override + public String toString() { + return label; + } + + public int getValue() { + return value; + } + + public static Property fromValue(int val) { + return BY_VALUE.getOrDefault(val, UNKNOWN); + } + + private Property(String label, int value) { + this.label = label; + this.value = value; + } +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VBTable.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VBTable.java new file mode 100644 index 0000000000..1fdea1cfda --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VBTable.java @@ -0,0 +1,23 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +/** + * Compiler-generated virtual base table + */ +public interface VBTable { + // empty for now +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VBTableEntry.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VBTableEntry.java new file mode 100644 index 0000000000..7d5878f535 --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VBTableEntry.java @@ -0,0 +1,47 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +/** + * Represents an entry within a virtual base table + */ +public interface VBTableEntry { + + /** + * Sets the entry offset value + * @param offset the offset + */ + public void setOffset(long offset); + + /** + * Gets the entry offset value + * @return the offset value + */ + public Long getOffset(); + + /** + * Sets the entry class ID + * @param baseId the ID + */ + public void setClassId(ClassID baseId); + + /** + * Gets the entry class ID + * @return the ID + */ + public ClassID getClassId(); + +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VFTable.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VFTable.java new file mode 100644 index 0000000000..a91d09fc64 --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VFTable.java @@ -0,0 +1,23 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +/** + * Compiler-generated virtual function table + */ +public interface VFTable { + // empty for now +} 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 new file mode 100644 index 0000000000..6b9666d20e --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualBaseTable.java @@ -0,0 +1,111 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.ArrayList; +import java.util.List; + +import ghidra.app.util.bin.format.pdb2.pdbreader.PdbException; + +/** + * Abstract class for virtual base tables + */ +public abstract class VirtualBaseTable implements VBTable { + protected ClassID owner; // Does this belong here in this abstract class? + protected List parentage; // Not sure this belongs in this abstract class + + /** + * Virtual Base Table for a base (parent) class within an owner class. The owner and parent + * class can be null if not known, but methods are offered to fill them in if/when this + * information becomes available + * @param owner class that owns this VBT (can own more than one). Can be null + * @param parentage class of parents for which this VBT is used (when "this" cast to parent). + */ + public VirtualBaseTable(ClassID owner, List parentage) { + this.owner = owner; + this.parentage = new ArrayList<>(parentage); + } + + /** + * Returns the offset of the base class in the layout class pertaining whose entry in the + * VBTable is at the index location + * VBTable + * @param index the index in the table + * @return the offset in the layout class + * @throws PdbException if problem retrieving the offset value + */ + public abstract Long getBaseOffset(int index) throws PdbException; + + /** + * Returns the ClassID of the base class in the layout class pertaining whose entry in the + * VBTable is at the index location + * @param index the index in the table + * @return the ClassID of the base class + * @throws PdbException if an entry does not exist for the index + */ + public abstract ClassID getBaseClassId(int index) throws PdbException; + + /** + * Returns a {@link VBTableEntry} for the base class in the layout class pertaining whose + * entry in the VBTable is at the index location + * @param index the index in the table + * @return the ClassID of the base class + * @throws PdbException if an entry does not exist for the index + */ + public abstract VBTableEntry getBase(int index) throws PdbException; + + /** + * Returns the owning class + * @return the owner + */ + public ClassID getOwner() { + return owner; + } + + /** + * Returns the parentage of the table + * @return the parentage + */ + public List getParentage() { + return parentage; + } + + /** + * Sets the owner of the table + * @param ownerArg the class to set as owner + */ + public void setOwner(ClassID ownerArg) { + owner = ownerArg; + } + + /** + * Sets the parentage of the parentage for the table + * @param parentage the parentage + */ + public void setParentage(List parentage) { + this.parentage = parentage; + } + + void emit(StringBuilder builder) { + builder.append("VBT for the following parentage within: " + owner); + builder.append("\n"); + for (ClassID id : parentage) { + builder.append(" " + id); + builder.append("\n"); + } + } + +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualBaseTableEntry.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualBaseTableEntry.java new file mode 100644 index 0000000000..b92a7e584b --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualBaseTableEntry.java @@ -0,0 +1,59 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +/** + * Represents the Entry for a Virtual Base Table + */ +public class VirtualBaseTableEntry implements VBTableEntry { + private Long offset; + private ClassID baseId; + + // Re-evaluate which constructors and setters we need + + VirtualBaseTableEntry(long offset) { + this(offset, null); + } + + VirtualBaseTableEntry(ClassID baseId) { + this(null, baseId); + } + + VirtualBaseTableEntry(Long offset, ClassID baseId) { + this.offset = offset; + this.baseId = baseId; + } + + @Override + public void setOffset(long offset) { + this.offset = offset; + } + + @Override + public Long getOffset() { + return offset; + } + + @Override + public void setClassId(ClassID baseId) { + this.baseId = baseId; + } + + @Override + public ClassID getClassId() { + return baseId; + } +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualFunctionTable.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualFunctionTable.java new file mode 100644 index 0000000000..a677fe8285 --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VirtualFunctionTable.java @@ -0,0 +1,98 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.ArrayList; +import java.util.List; + +import ghidra.app.util.SymbolPath; +import ghidra.app.util.bin.format.pdb2.pdbreader.PdbException; +import ghidra.program.model.address.Address; + +public abstract class VirtualFunctionTable implements VFTable { + + protected ClassID owner; + protected List parentage; + + /** + * Virtual Function Table for a base (parent) class within an owner class. The owner and parent + * class can be null if not known, but methods are offered to fill them in if/when this + * information becomes available + * @param owner class that owns this VBT (can own more than one). Can be null + * @param parentage parentage for which this VBT is used. Can be null + */ + VirtualFunctionTable(ClassID owner, List parentage) { + this.owner = owner; + this.parentage = new ArrayList<>(parentage); + } + + /** + * Returns the address value at the index in the table + * @param index the index + * @return the address + * @throws PdbException upon error retrieving the value + */ + public abstract Address getAddress(int index) throws PdbException; + + /** + * Returns the symbol path of the function at the index in the table + * @param index the index + * @return the symbol path + * @throws PdbException upon error retrieving the value + */ + public abstract SymbolPath getPath(int index) throws PdbException; + + /** + * Returns the owning class + * @return the owner + */ + public ClassID getOwner() { + return owner; + } + + /** + * Returns the parentage of the table + * @return the parentage + */ + public List getParentage() { + return parentage; + } + + /** + * Sets the owner of the table + * @param ownerArg the class to set as owner + */ + public void setOwner(ClassID ownerArg) { + owner = ownerArg; + } + + /** + * Sets the parentage of the parentage for the table + * @param parentage the parentage + */ + public void setParentage(List parentage) { + this.parentage = parentage; + } + + void emit(StringBuilder builder) { + builder.append("VBT for the following classes within: " + owner); + builder.append("\n"); + for (ClassID id : parentage) { + builder.append(" " + id); + builder.append("\n"); + } + } +} 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 new file mode 100644 index 0000000000..fc867d7dda --- /dev/null +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/classtype/VxtManager.java @@ -0,0 +1,78 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import java.util.HashMap; +import java.util.Map; + +import ghidra.program.model.address.Address; +import ghidra.program.model.data.PointerDataType; + +/** + * Manages virtual base table lookup for PDB classes. + */ +public class VxtManager { + + protected ClassTypeManager ctm; + + protected Map vbtByAddress; + protected Map vftByAddress; + + /** + * Virtual Base Table Lookup Manager + * @param ctm class type manager + */ + public VxtManager(ClassTypeManager ctm) { + this.ctm = ctm; + vbtByAddress = new HashMap<>(); + vftByAddress = new HashMap<>(); + } + + /** + * Returns the default VBT pointer type for the program + * @return the pointer type + */ + public PointerDataType getDefaultVbtPtr() { + return ctm.getDefaultVbtPtr(); + } + + /** + * Returns the default VFT pointer type for the program + * @return the pointer type + */ + public PointerDataType getDefaultVftPtr() { + return ctm.getDefaultVftPtr(); + } + + /** + * Returns the VBT located at the address + * @param address the address + * @return the VBT or null if a table is not found + */ + public VirtualBaseTable getVbt(Address address) { + return vbtByAddress.get(address); + } + + /** + * Returns the VFT located at the address + * @param address the address + * @return the VFT or null if a table is not found + */ + public VirtualFunctionTable getVft(Address address) { + return vftByAddress.get(address); + } + +} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ClassFieldAttributes.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ClassFieldAttributes.java deleted file mode 100644 index 7daf68c059..0000000000 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ClassFieldAttributes.java +++ /dev/null @@ -1,238 +0,0 @@ -/* ### - * IP: GHIDRA - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package ghidra.app.util.pdb.pdbapplicator; - -import java.util.*; - -import ghidra.app.util.bin.format.pdb2.pdbreader.type.ClassFieldMsAttributes; - -/** - * - */ -public class ClassFieldAttributes { - - private static final Map map = new HashMap<>(); - - // These initializations use the map above, so it must be initialized first - public static final ClassFieldAttributes UNKNOWN = get(Access.UNKNOWN, Property.UNKNOWN); - public static final ClassFieldAttributes BLANK = get(Access.BLANK, Property.BLANK); - - private final Access access; - private final Property property; - - public static ClassFieldAttributes get(Access access, Property property) { - ClassFieldAttributes key = new ClassFieldAttributes(access, property); - ClassFieldAttributes cfa = map.putIfAbsent(key, key); - return (cfa != null) ? cfa : key; - } - - static ClassFieldAttributes convert(ClassFieldMsAttributes msAtts, Access defaultAccess) { - Access myAccess = switch (msAtts.getAccess()) { - case PUBLIC -> Access.PUBLIC; - case PROTECTED -> Access.PROTECTED; - case PRIVATE -> Access.PRIVATE; - case BLANK -> defaultAccess; - default -> Access.UNKNOWN; - }; - Property myProperty = switch (msAtts.getProperty()) { - case VIRTUAL -> Property.VIRTUAL; - case STATIC -> Property.STATIC; - case FRIEND -> Property.FRIEND; - case BLANK -> Property.BLANK; - default -> Property.UNKNOWN; - }; - return get(myAccess, myProperty); - } - - private ClassFieldAttributes(Access access, Property property) { - this.access = access; - this.property = property; - } - - Access getAccess() { - return access; - } - - Property getProperty() { - return property; - } - - void emit(StringBuilder builder) { - StringBuilder myBuilder = new StringBuilder(); - if (access.getValue() > Access.BLANK.getValue()) { - myBuilder.append(access); - myBuilder.append(' '); - } - if (property.getValue() > Property.BLANK.getValue()) { - myBuilder.append(property); - myBuilder.append(' '); - } - builder.append(myBuilder); - } - - @Override - public String toString() { - StringBuilder builder = new StringBuilder(); - emit(builder); - return builder.toString(); - } - - @Override - public int hashCode() { - return Objects.hash(access, property); - } - - @Override - public boolean equals(Object obj) { - if (this == obj) { - return true; - } - if (obj == null) { - return false; - } - if (getClass() != obj.getClass()) { - return false; - } - ClassFieldAttributes other = (ClassFieldAttributes) obj; - return access == other.access && property == other.property; - } - - //---------------------------------------------------------------------------------------------- - // TODO: Consider expanding these beyond C++. - // See https://en.wikipedia.org/wiki/Access_modifiers - // These could then be: -// UNKNOWN("UNKNOWN_ACCESS ", -1), -// OPEN("open", 0), -// PUBLIC("internal", 1), -// INTERNAL("internal", 2), -// PACKAGE("package", 3), -// PROTECTED("protected", 4), -// PROTECTED_INTERNAL("protected internal", 5), -// PRIVATE_PROTECTED("private protected", 6), -// FILE("file", 7), -// FILE_PRIVATE("fileprivate", 8), -// PRIVATE("private", 9); - static enum Access { - UNKNOWN("UNKNOWN_ACCESS", -1), - BLANK("", 0), // eliminated 20230524... using defaultAccess on some methods. Could renumber - PUBLIC("public", 1), - PROTECTED("protected", 2), - PRIVATE("private", 3); - - private static final Map BY_VALUE = new HashMap<>(); - static { - for (Access val : values()) { - BY_VALUE.put(val.value, val); - } - } - private final String label; - private final int value; - - public String getString() { - return label; - } - - @Override - public String toString() { - return label; - } - - public int getValue() { - return value; - } - - public static Access fromValue(int val) { - return BY_VALUE.getOrDefault(val, UNKNOWN); - } - - private Access(String label, int value) { - this.label = label; - this.value = value; - } - - /** - * Merge two Access values, leaning toward more restrictive. UNKNOWN is only returned - * if both are UNKNOWN. - * @param other value to merge - * @return the merged value - */ - public Access mergeRestrictive(Access other) { - // No need to test for UNKNOWN as its value is on the permissive end. - if (this.value > other.value) { - return this; - } - return other; - } - - /** - * Merge two Access values, leaning toward more permissive. UNKNOWN is only returned - * if both are UNKNOWN. - * @param other value to merge - * @return the merged value - */ - public Access mergePermissive(Access other) { - if (this.value < other.value) { - // Only need special test for UNKNOWN here, as its value is on the permissive end. - if (this == UNKNOWN) { - return other; - } - return this; - } - return other; - } - } - - //---------------------------------------------------------------------------------------------- - static enum Property { - UNKNOWN("INVALID_PROPERTY", -1), - BLANK("", 0), // means non-virtual, non-static, non-friend - VIRTUAL("virtual", 1), - STATIC("static", 2), - FRIEND("friend", 3); - // Also consider , , . See MSFT. - - private static final Map BY_VALUE = new HashMap<>(); - static { - for (Property val : values()) { - BY_VALUE.put(val.value, val); - } - } - private final String label; - private final int value; - - public String getString() { - return label; - } - - @Override - public String toString() { - return label; - } - - public int getValue() { - return value; - } - - public static Property fromValue(int val) { - return BY_VALUE.getOrDefault(val, UNKNOWN); - } - - private Property(String label, int value) { - this.label = label; - this.value = value; - } - } -} diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/CompositeTypeApplier.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/CompositeTypeApplier.java index b9cf642f6d..301a583e89 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/CompositeTypeApplier.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/CompositeTypeApplier.java @@ -23,7 +23,8 @@ import ghidra.app.util.SymbolPath; import ghidra.app.util.bin.format.pdb.DefaultCompositeMember; import ghidra.app.util.bin.format.pdb2.pdbreader.*; import ghidra.app.util.bin.format.pdb2.pdbreader.type.*; -import ghidra.app.util.pdb.pdbapplicator.ClassFieldAttributes.Access; +import ghidra.app.util.pdb.classtype.Access; +import ghidra.app.util.pdb.classtype.ClassFieldAttributes; import ghidra.program.model.data.*; import ghidra.util.Msg; import ghidra.util.exception.AssertException; @@ -82,19 +83,25 @@ public class CompositeTypeApplier extends AbstractComplexTypeApplier { myApplicator.predefineClass(fixedSymbolPath); myComposite = new StructureDataType(categoryPath, fixedSymbolPath.getName(), size, myApplicator.getDataTypeManager()); - myClassType = new CppCompositeType(fixedSymbolPath, myComposite, mangledName); + myClassType = + new CppCompositeType(myApplicator.getRootPdbCategory(), fixedSymbolPath, + myComposite, mangledName); myClassType.setClass(); } else if (compositeMsType instanceof AbstractStructureMsType) { myComposite = new StructureDataType(categoryPath, fixedSymbolPath.getName(), size, myApplicator.getDataTypeManager()); - myClassType = new CppCompositeType(fixedSymbolPath, myComposite, mangledName); + myClassType = + new CppCompositeType(myApplicator.getRootPdbCategory(), fixedSymbolPath, + myComposite, mangledName); myClassType.setStruct(); } else if (compositeMsType instanceof AbstractUnionMsType) { myComposite = new UnionDataType(categoryPath, fixedSymbolPath.getName(), myApplicator.getDataTypeManager()); - myClassType = new CppCompositeType(fixedSymbolPath, myComposite, mangledName); + myClassType = + new CppCompositeType(myApplicator.getRootPdbCategory(), fixedSymbolPath, + myComposite, mangledName); myClassType.setUnion(); } else { // InterfaceMsType @@ -183,7 +190,7 @@ public class CompositeTypeApplier extends AbstractComplexTypeApplier { // we do it here. Set breakpoint here to investigate. } classType.createLayout(applicator.getPdbApplicatorOptions().getCompositeLayout(), - applicator.getVbtManager(), applicator.getCancelOnlyWrappingMonitor()); + applicator.getVxtManager(), applicator.getCancelOnlyWrappingMonitor()); } //============================================================================================== @@ -224,9 +231,8 @@ public class CompositeTypeApplier extends AbstractComplexTypeApplier { throws PdbException, CancelledException { AbstractCompositeMsType cType = (AbstractCompositeMsType) type; - ClassFieldAttributes.Access defaultAccess = - (type instanceof AbstractClassMsType) ? ClassFieldAttributes.Access.PRIVATE - : ClassFieldAttributes.Access.PUBLIC; + Access defaultAccess = (type instanceof AbstractClassMsType) ? Access.PRIVATE + : Access.PUBLIC; for (AbstractMsType baseType : msBases) { applicator.checkCancelled(); @@ -334,9 +340,8 @@ public class CompositeTypeApplier extends AbstractComplexTypeApplier { private void addMembers(Composite composite, CppCompositeType myClassType, List msMembers, AbstractCompositeMsType type, List myMembers) throws CancelledException, PdbException { - ClassFieldAttributes.Access defaultAccess = - (type instanceof AbstractClassMsType) ? ClassFieldAttributes.Access.PRIVATE - : ClassFieldAttributes.Access.PUBLIC; + Access defaultAccess = + (type instanceof AbstractClassMsType) ? Access.PRIVATE : Access.PUBLIC; for (int index = 0; index < msMembers.size(); index++) { applicator.checkCancelled(); AbstractMemberMsType memberType = msMembers.get(index); 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 f077fd5ec6..5b3eec0ece 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 @@ -4,9 +4,9 @@ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -24,7 +24,7 @@ import ghidra.app.util.SymbolPath; import ghidra.app.util.bin.format.pdb.*; import ghidra.app.util.bin.format.pdb2.pdbreader.PdbException; import ghidra.app.util.bin.format.pdb2.pdbreader.PdbLog; -import ghidra.app.util.pdb.pdbapplicator.PdbVbtManager.PdbVirtualBaseTable; +import ghidra.app.util.pdb.classtype.*; import ghidra.program.model.data.*; import ghidra.util.Msg; import ghidra.util.exception.AssertException; @@ -45,10 +45,11 @@ public class CppCompositeType { private List layoutMembers; private List layoutVftPtrMembers; private boolean isFinal; - private Type type; + private ClassKey classKey; private String className; // String for now. private String mangledName; private int size; + private CategoryPath baseCategoryPath; private SymbolPath symbolPath; private Composite composite; private CategoryPath categoryPath; @@ -80,7 +81,8 @@ public class CppCompositeType { private Map placeholderVirtualBaseTables; //---------------------------------------------------------------------------------------------- - public CppCompositeType(SymbolPath symbolPath, Composite composite, String mangledName) { + public CppCompositeType(CategoryPath baseCategoryPath, SymbolPath symbolPath, + Composite composite, String mangledName) { Objects.requireNonNull(symbolPath, "symbolPath may not be null"); Objects.requireNonNull(composite, "composite may not be null"); syntacticBaseClasses = new ArrayList<>(); @@ -92,7 +94,8 @@ public class CppCompositeType { layoutVftPtrMembers = new ArrayList<>(); isFinal = false; - type = Type.UNKNOWN; + classKey = ClassKey.UNKNOWN; + this.baseCategoryPath = baseCategoryPath; this.symbolPath = symbolPath; this.composite = composite; placeholderVirtualBaseTables = new HashMap<>(); @@ -100,47 +103,51 @@ public class CppCompositeType { this.mangledName = mangledName; } - public static CppClassType createCppClassType(SymbolPath symbolPath, Composite composite, - String mangledName) { - return new CppClassType(symbolPath, composite, mangledName); + public static CppClassType createCppClassType(CategoryPath baseCategoryPath, + SymbolPath symbolPath, Composite composite, String mangledName) { + return new CppClassType(baseCategoryPath, symbolPath, composite, mangledName); } - public static CppClassType createCppClassType(SymbolPath symbolPath, Composite composite, - String name, String mangledName, int size) { - CppClassType cppType = new CppClassType(symbolPath, composite, mangledName); + public static CppClassType createCppClassType(CategoryPath baseCategoryPath, + SymbolPath symbolPath, Composite composite, String name, String mangledName, int size) { + CppClassType cppType = + new CppClassType(baseCategoryPath, symbolPath, composite, mangledName); cppType.setName(name); cppType.setSize(size); return cppType; } - public static CppStructType createCppStructType(SymbolPath symbolPath, Composite composite, - String mangledName) { - return new CppStructType(symbolPath, composite, mangledName); + public static CppStructType createCppStructType(CategoryPath baseCategoryPath, + SymbolPath symbolPath, Composite composite, String mangledName) { + return new CppStructType(baseCategoryPath, symbolPath, composite, mangledName); } - public static CppStructType createCppStructType(SymbolPath symbolPath, Composite composite, - String name, String mangledName, int size) { - CppStructType cppType = new CppStructType(symbolPath, composite, mangledName); + public static CppStructType createCppStructType(CategoryPath baseCategoryPath, + SymbolPath symbolPath, Composite composite, String name, String mangledName, int size) { + CppStructType cppType = + new CppStructType(baseCategoryPath, symbolPath, composite, mangledName); cppType.setName(name); cppType.setSize(size); return cppType; } private static class CppClassType extends CppCompositeType { - private CppClassType(SymbolPath symbolPath, Composite composite, String mangledName) { - super(symbolPath, composite, mangledName); + private CppClassType(CategoryPath baseCategoryPath, SymbolPath symbolPath, + Composite composite, String mangledName) { + super(baseCategoryPath, symbolPath, composite, mangledName); setClass(); } } private static class CppStructType extends CppCompositeType { - private CppStructType(SymbolPath symbolPath, Composite composite, String mangledName) { - super(symbolPath, composite, mangledName); + private CppStructType(CategoryPath baseCategoryPath, SymbolPath symbolPath, + Composite composite, String mangledName) { + super(composite.getCategoryPath(), symbolPath, composite, mangledName); setStruct(); } } - static boolean validateMangledCompositeName(String mangledCompositeTypeName, Type type) { + static boolean validateMangledCompositeName(String mangledCompositeTypeName, ClassKey type) { if (mangledCompositeTypeName == null) { return false; } @@ -155,17 +162,20 @@ public class CppCompositeType { } switch (mangledCompositeTypeName.charAt(3)) { case 'T': - if ((type.compareTo(Type.UNION) != 0) && (type.compareTo(Type.UNKNOWN) != 0)) { + if ((type.compareTo(ClassKey.UNION) != 0) && + (type.compareTo(ClassKey.UNKNOWN) != 0)) { PdbLog.message("Warning: Mismatched complex type 'T' for " + type); } break; case 'U': - if ((type.compareTo(Type.STRUCT) != 0) && (type.compareTo(Type.UNKNOWN) != 0)) { + if ((type.compareTo(ClassKey.STRUCT) != 0) && + (type.compareTo(ClassKey.UNKNOWN) != 0)) { PdbLog.message("Warning: Mismatched complex type 'U' for " + type); } break; case 'V': - if ((type.compareTo(Type.CLASS) != 0) && (type.compareTo(Type.UNKNOWN) != 0)) { + if ((type.compareTo(ClassKey.CLASS) != 0) && + (type.compareTo(ClassKey.UNKNOWN) != 0)) { PdbLog.message("Warning: Mismatched complex type 'V' for " + type); } break; @@ -200,7 +210,7 @@ public class CppCompositeType { return composite; } - private CategoryPath getCategoryPath() { + public CategoryPath getCategoryPath() { return categoryPath; } @@ -213,20 +223,20 @@ public class CppCompositeType { } public void setClass() { - type = Type.CLASS; + classKey = ClassKey.CLASS; } public void setStruct() { - type = Type.STRUCT; + classKey = ClassKey.STRUCT; } public void setUnion() { - type = Type.UNION; + classKey = ClassKey.UNION; } // not sure if user can see Type when returned. - public Type getType() { - return type; + public ClassKey getType() { + return classKey; } public void setName(String className) { @@ -237,6 +247,10 @@ public class CppCompositeType { return className; } + public DataTypePath getDataTypePath() { + return composite.getDataTypePath(); + } + public void setMangledName(String mangledName) { this.mangledName = mangledName; } @@ -563,7 +577,7 @@ public class CppCompositeType { @Override public String toString() { StringBuilder builder = new StringBuilder(); - builder.append(type); + builder.append(classKey); builder.append(className); if (isFinal) { builder.append(" final"); @@ -615,7 +629,7 @@ public class CppCompositeType { //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- - public void createLayoutFromSyntacticDescription(VbtManager vbtManager, TaskMonitor monitor) { + public void createLayoutFromSyntacticDescription(VxtManager vxtManager, TaskMonitor monitor) { for (SyntacticBaseClass base : syntacticBaseClasses) { if (base instanceof DirectSyntacticBaseClass) { @@ -628,21 +642,21 @@ public class CppCompositeType { //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- - public void createLayout(ObjectOrientedClassLayout layoutOptions, VbtManager vbtManager, + public void createLayout(ObjectOrientedClassLayout layoutOptions, VxtManager vxtManager, TaskMonitor monitor) throws PdbException, CancelledException { - if (vbtManager instanceof PdbVbtManager) { // Information from PDB/program symbols + if (vxtManager instanceof MsftVxtManager) { // Information from PDB/program symbols // TODO: both same for now - //doSpeculativeLayout(vbtManager, monitor); - createVbtBasedLayout(layoutOptions, vbtManager, monitor); + //doSpeculativeLayout(vxtManager, monitor); + createVbtBasedLayout(layoutOptions, vxtManager, monitor); } else { - createSpeculativeLayout(layoutOptions, vbtManager, monitor); + createSpeculativeLayout(layoutOptions, vxtManager, monitor); } } //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- - public void createVbtBasedLayout(ObjectOrientedClassLayout layoutOptions, VbtManager vbtManager, + public void createVbtBasedLayout(ObjectOrientedClassLayout layoutOptions, VxtManager vxtManager, TaskMonitor monitor) throws PdbException, CancelledException { CategoryPath cn; hasDirect = false; @@ -667,7 +681,7 @@ public class CppCompositeType { // TODO: consider moving down below next line. boolean allVbtFound = - reconcileVirtualBaseTables(composite.getDataTypeManager(), vbtManager); + reconcileVirtualBaseTables(composite.getDataTypeManager(), vxtManager); addLayoutPdbMembers(directClassPdbMembers, layoutMembers); insertVirtualFunctionTablePointers(directClassPdbMembers); @@ -772,7 +786,7 @@ public class CppCompositeType { //---------------------------------------------------------------------------------------------- //---------------------------------------------------------------------------------------------- public void createSpeculativeLayout(ObjectOrientedClassLayout layoutOptions, - VbtManager vbtManager, TaskMonitor monitor) throws PdbException, CancelledException { + VxtManager vxtManager, TaskMonitor monitor) throws PdbException, CancelledException { // Speculative Layout uses recursion to try to know the order of members. However, MSFT // rearranges the order of the Base Class records such that they are not necessarily in // the order that the class was declared, and it seems that the member order follows the @@ -807,7 +821,7 @@ public class CppCompositeType { // TODO: consider moving down below next line. boolean allVbtFound = - reconcileVirtualBaseTables(composite.getDataTypeManager(), vbtManager); + reconcileVirtualBaseTables(composite.getDataTypeManager(), vxtManager); addLayoutPdbMembers(directClassPdbMembers, layoutMembers); insertVirtualFunctionTablePointers(directClassPdbMembers); @@ -943,7 +957,7 @@ public class CppCompositeType { return placeholderVirtualBaseTables; } - private boolean reconcileVirtualBaseTables(DataTypeManager dtm, VbtManager vbtManager) + private boolean reconcileVirtualBaseTables(DataTypeManager dtm, VxtManager vxtManager) throws PdbException { if (placeholderVirtualBaseTables.size() > 1) { // study this. @@ -957,14 +971,14 @@ public class CppCompositeType { if (!table.validateOffset()) { // TODO study this. } - DataType vbptr = getVbptrDataType(dtm, vbtManager, table); + DataType vbptr = getVbptrDataType(dtm, vxtManager, table); allVbtFound &= - addOrUpdateVbtAndVbtptrMember(vbtManager, table, vbptr, vbtptrOffset, getName()); + addOrUpdateVbtAndVbtptrMember(vxtManager, table, vbptr, vbtptrOffset, getName()); } return allVbtFound; } - private DataType getVbptrDataType(DataTypeManager dtm, VbtManager vbtManager, + private DataType getVbptrDataType(DataTypeManager dtm, VxtManager vxtManager, PlaceholderVirtualBaseTable table) { DataType vbptr = null; for (int index = 1; index < table.getMaxOffset(); index++) { @@ -975,106 +989,67 @@ public class CppCompositeType { } } if (vbptr == null) { - vbptr = vbtManager.getFallbackVbptr(); + vbptr = vxtManager.getDefaultVbtPtr(); } return vbptr; } - private class CppCompositeAndMember { - private CppCompositeType cppType; - private Member member; + private record CppParentageAndMember(List parentage, Member member) {} - private CppCompositeAndMember(CppCompositeType cppType, Member member) { - this.cppType = cppType; - this.member = member; - } - - private CppCompositeType getComposite() { - return cppType; - } - - private Member getMember() { - return member; - } - } - - private boolean addOrUpdateVbtAndVbtptrMember(VbtManager vbtManager, + private boolean addOrUpdateVbtAndVbtptrMember(VxtManager vxtManager, PlaceholderVirtualBaseTable table, DataType vbptr, int vbtptrOffset, String myClass) throws PdbException { - List subMangled = new ArrayList<>(); - //subMangled.add(getMangledName()); - CppCompositeAndMember cAndM = findDirectBaseCompositeAndMember(this, 0, vbtptrOffset); - if (cAndM == null) { + // TODO: if we want to match vbtables with the pointers in *virtual* base classes, we are + // not currently doing the work... we are only looking for direct bases, as they are + // what dictate the placement for our current class (though cross-checks could be done + // with all vbtables (at some point)) + + List parentage = new ArrayList<>(); + + CppParentageAndMember cAndP = findDirectBaseParentageAndMember(this, 0, vbtptrOffset); + + if (cAndP == null) { insertMember("{vbptr}", vbptr, false, vbtptrOffset, "{vbptr} for " + myClass); } - else if (!"{vbptr}".equals(cAndM.getMember().getName())) { + else if (!"{vbptr}".equals(cAndP.member().getName())) { String message = "PDB: Collision of non-{vbptr}."; PdbLog.message(message); Msg.info(this, message); return false; } else { - CppCompositeType compositeThatContainsMember = cAndM.getComposite(); - String mangled = compositeThatContainsMember.getMangledName(); - subMangled.add(mangled); + parentage = cAndP.parentage(); } - if (!(vbtManager instanceof PdbVbtManager)) { + if (!(vxtManager instanceof MsftVxtManager mvxtManager)) { return false; } int entrySize = 4; // Default to something (could be wrong) if (vbptr instanceof PointerDataType) { entrySize = ((PointerDataType) vbptr).getDataType().getLength(); } - - return findVbtBySymbolConstruction(table, (PdbVbtManager) vbtManager, entrySize, - getMangledName(), type, subMangled); + boolean x = findVbt(table, mvxtManager, entrySize, symbolPath, parentage); + return x; } - private boolean findVbtBySymbolConstruction(PlaceholderVirtualBaseTable table, - PdbVbtManager vbtm, int entrySize, String mangledCompositeTypeName, Type mainType, - List subMangledCompositeTypeNames) { - if (!validateMangledCompositeName(mangledCompositeTypeName, mainType)) { - return false; - } - for (String mangled : subMangledCompositeTypeNames) { - if (!validateMangledCompositeName(mangled, Type.UNKNOWN)) { - return false; - } - } - StringBuilder builder = new StringBuilder(); - builder.append("??_8"); - builder.append(mangledCompositeTypeName.substring(4)); - builder.append("7B"); // Hope will always be 'B' ("const") - builder.append("@"); - String possibleName = builder.toString(); - if (findAndUpdate(table, vbtm, entrySize, possibleName)) { - return true; - } - for (String mangled : subMangledCompositeTypeNames) { - builder.deleteCharAt(builder.length() - 1); - builder.append(mangled.substring(4)); - builder.append("@"); - possibleName = builder.toString(); - if (findAndUpdate(table, vbtm, entrySize, possibleName)) { - return true; - } - } - return false; - } + private boolean findVbt(PlaceholderVirtualBaseTable table, MsftVxtManager mvbtm, int entrySize, + SymbolPath ownerSp, List parentage) { - boolean findAndUpdate(PlaceholderVirtualBaseTable table, PdbVbtManager vbtm, int entrySize, - String mangledTableName) { - PdbVirtualBaseTable vbt = vbtm.createVirtualBaseTableByName(mangledTableName, entrySize); - if (vbt == null) { - return false; + ClassID mId = new ProgramClassID(baseCategoryPath, ownerSp); + List cIdParentage = new ArrayList<>(); + for (CppCompositeType t : parentage) { + ClassID id = new ProgramClassID(t.baseCategoryPath, t.getSymbolPath()); + cIdParentage.add(id); } - table.setName(mangledTableName); + ProgramVirtualBaseTable vbt = (ProgramVirtualBaseTable) mvbtm.findPrimaryVbt(mId); + //ProgramVirtualBaseTable vbt = (ProgramVirtualBaseTable) mvbtm.findVbt(mId, cIdParentage); + table.setVirtualBaseTable(vbt); - return true; + + return vbt != null; } - private CppCompositeAndMember findDirectBaseCompositeAndMember(CppCompositeType cppType, + private CppParentageAndMember findDirectBaseParentageAndMember(CppCompositeType cppType, int offsetCppType, int vbtptrOffset) throws PdbException { for (LayoutBaseClass base : cppType.layoutBaseClasses) { if (!(base instanceof DirectLayoutBaseClass)) { @@ -1086,16 +1061,18 @@ public class CppCompositeType { if (vbtptrOffset >= directBaseOffset && vbtptrOffset < directBaseOffset + directBaseLength) { CppCompositeType childCppType = directBase.getBaseClassType(); - CppCompositeAndMember cAndM = - findDirectBaseCompositeAndMember(childCppType, directBaseOffset, vbtptrOffset); - if (cAndM == null) { + CppParentageAndMember cAndP = + findDirectBaseParentageAndMember(childCppType, directBaseOffset, vbtptrOffset); + if (cAndP == null) { Member member = childCppType.findLayoutMemberOrVftPtrMember(vbtptrOffset); if (member == null) { return null; } - cAndM = new CppCompositeAndMember(childCppType, member); + cAndP = new CppParentageAndMember(new ArrayList<>(), member); } - return cAndM; + List parentage = cAndP.parentage(); + parentage.add(childCppType); + return cAndP; } } return null; @@ -1674,7 +1651,7 @@ public class CppCompositeType { //---------------------------------------------------------------------------------------------- static class PlaceholderVirtualBaseTable { private String name; - private PdbVirtualBaseTable pdbVirtualBaseTable = null; + private ProgramVirtualBaseTable vbt = null; // We do not know if every index will be given. We can check after the fact, and once // the set of sequential integers is assured, we could create a list. @@ -1697,19 +1674,19 @@ public class CppCompositeType { this.name = name; } - void setVirtualBaseTable(PdbVirtualBaseTable pdbVirtualBaseTable) { - this.pdbVirtualBaseTable = pdbVirtualBaseTable; + void setVirtualBaseTable(ProgramVirtualBaseTable vbt) { + this.vbt = vbt; } boolean canLookupOffset() { - return pdbVirtualBaseTable != null; + return vbt != null; } long getOffset(int ordinal) throws PdbException { - if (pdbVirtualBaseTable == null) { - throw new PdbException("pdbVirtualBaseTable not initialized"); + if (vbt != null) { + return vbt.getBaseOffset(ordinal); } - return pdbVirtualBaseTable.getOffset(ordinal); + throw new PdbException("pdbVirtualBaseTable not initialized"); } Map getEntries() { @@ -1751,50 +1728,4 @@ public class CppCompositeType { } } - //---------------------------------------------------------------------------------------------- - //---------------------------------------------------------------------------------------------- - //---------------------------------------------------------------------------------------------- - //---------------------------------------------------------------------------------------------- - static enum Type { - UNKNOWN("UNKNOWN_TYPE", -1), - BLANK("", 1), - CLASS("class", 2), - STRUCT("struct", 3), - UNION("union", 4); - - private static final Map BY_VALUE = new HashMap<>(); - static { - for (Type val : values()) { - BY_VALUE.put(val.value, val); - } - } - private final String label; - private final int value; - - public String getString() { - return label; - } - - @Override - public String toString() { - if (label.length() != 0) { - return label + " "; - } - return label; - } - - public int getValue() { - return value; - } - - public static Type fromValue(int val) { - return BY_VALUE.getOrDefault(val, UNKNOWN); - } - - private Type(String label, int value) { - this.label = label; - this.value = value; - } - } - } diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/DefaultPdbApplicator.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/DefaultPdbApplicator.java index 072a52f152..9e5b61fe99 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/DefaultPdbApplicator.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/DefaultPdbApplicator.java @@ -36,6 +36,7 @@ import ghidra.app.util.bin.format.pdb2.pdbreader.type.PrimitiveMsType; import ghidra.app.util.bin.format.pe.cli.tables.CliAbstractTableRow; import ghidra.app.util.importer.MessageLog; import ghidra.app.util.pdb.PdbCategories; +import ghidra.app.util.pdb.classtype.*; import ghidra.framework.options.Options; import ghidra.program.database.data.DataTypeUtilities; import ghidra.program.disassemble.DisassemblerContextImpl; @@ -190,6 +191,7 @@ public class DefaultPdbApplicator implements PdbApplicator { private Address imageBase; private int linkerModuleNumber = -1; private DataTypeManager dataTypeManager; + private ClassTypeManager classTypeManager; private PdbAddressManager pdbAddressManager; private List symbolGroups; @@ -204,14 +206,14 @@ public class DefaultPdbApplicator implements PdbApplicator { //============================================================================================== // If we have symbols and memory with VBTs in them, then a better VbtManager is created. - VbtManager vbtManager; - PdbRegisterNameToProgramRegisterMapper registerNameToRegisterMapper; + private VxtManager vxtManager; + private PdbRegisterNameToProgramRegisterMapper registerNameToRegisterMapper; //============================================================================================== private MultiphaseDataTypeResolver multiphaseResolver; private int resolveCount; private int conflictCount; - private PdbCategories categoryUtils; + private PdbCategories pdbCategories; private PdbPrimitiveTypeApplicator pdbPrimitiveTypeApplicator; private TypeApplierFactory typeApplierParser; // We may need to put the following map into the "analysis state" for access by @@ -589,6 +591,9 @@ public class DefaultPdbApplicator implements PdbApplicator { pdbPeHeaderInfoManager = new PdbPeHeaderInfoManager(this); multiphaseResolver = new MultiphaseDataTypeResolver(this); + + classTypeManager = new ClassTypeManager(dataTypeManager); + pdbPrimitiveTypeApplicator = new PdbPrimitiveTypeApplicator(dataTypeManager); typeApplierParser = new TypeApplierFactory(this); @@ -627,17 +632,21 @@ public class DefaultPdbApplicator implements PdbApplicator { if (!pdbAddressManager.isInitialized()) { pdbAddressManager.initialize(this, imageBase); } - categoryUtils = setPdbCatogoryUtils(pdb.getFilename()); + pdbCategories = setPdbCatogoryUtils(pdb.getFilename()); symbolGroups = createSymbolGroups(); linkerModuleNumber = findLinkerModuleNumber(); if (program != null) { // Currently, this must happen after symbolGroups are created. - PdbVbtManager pdbVbtManager = new PdbVbtManager(this); - vbtManager = pdbVbtManager; + MsftVxtManager msftVxtManager = + new MsftVxtManager(getClassTypeManager(), program.getMemory()); + msftVxtManager.createVirtualTables(getRootPdbCategory(), findVirtualTableSymbols(), log, + monitor); + vxtManager = msftVxtManager; + registerNameToRegisterMapper = new PdbRegisterNameToProgramRegisterMapper(program); } else { - vbtManager = new VbtManager(getDataTypeManager()); + vxtManager = new VxtManager(getClassTypeManager()); } preWorkDone = true; } @@ -689,6 +698,47 @@ public class DefaultPdbApplicator implements PdbApplicator { return mySymbolGroups; } + private Map findVirtualTableSymbols() throws CancelledException, PdbException { + + Map myAddressByVxtMangledName = new HashMap<>(); + + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return myAddressByVxtMangledName; + } + + SymbolGroup symbolGroup = getSymbolGroup(); + if (symbolGroup == null) { + return myAddressByVxtMangledName; + } + + PublicSymbolInformation publicSymbolInformation = debugInfo.getPublicSymbolInformation(); + List offsets = publicSymbolInformation.getModifiedHashRecordSymbolOffsets(); + monitor.setMessage("PDB: Searching for VxT symbols..."); + monitor.initialize(offsets.size()); + + MsSymbolIterator iter = symbolGroup.getSymbolIterator(); + for (long offset : offsets) { + monitor.checkCancelled(); + iter.initGetByOffset(offset); + if (!iter.hasNext()) { + break; + } + AbstractMsSymbol symbol = iter.peek(); + if (symbol instanceof AbstractPublicMsSymbol pubSymbol) { + String name = pubSymbol.getName(); + if (name.startsWith("??_7") || name.startsWith("??_8")) { + Address address = getAddress(pubSymbol); + if (!isInvalidAddress(address, name)) { + myAddressByVxtMangledName.put(name, address); + } + } + } + monitor.incrementProgress(1); + } + return myAddressByVxtMangledName; + } + //============================================================================================== // Basic utility methods. //============================================================================================== @@ -807,6 +857,10 @@ public class DefaultPdbApplicator implements PdbApplicator { return dataTypeManager; } + ClassTypeManager getClassTypeManager() { + return classTypeManager; + } + // for PdbTypeApplicator (new) DataOrganization getDataOrganization() { return dataTypeManager.getDataOrganization(); @@ -819,6 +873,14 @@ public class DefaultPdbApplicator implements PdbApplicator { //============================================================================================== // CategoryPath-related methods. //============================================================================================== + /** + * Get root CategoryPath for the PDB + * @return the root CategoryPath + */ + CategoryPath getRootPdbCategory() { + return pdbCategories.getRootCategoryPath(); + } + /** * Get the {@link CategoryPath} associated with the {@link SymbolPath} specified, rooting * it either at the PDB Category @@ -827,7 +889,7 @@ public class DefaultPdbApplicator implements PdbApplicator { * @return {@link CategoryPath} created for the input */ CategoryPath getCategory(SymbolPath symbolPath) { - return categoryUtils.getCategory(symbolPath); + return pdbCategories.getCategory(symbolPath); } /** @@ -839,7 +901,7 @@ public class DefaultPdbApplicator implements PdbApplicator { * @return the CategoryPath */ CategoryPath getTypedefsCategory(int moduleNumber, SymbolPath symbolPath) { - return categoryUtils.getTypedefsCategory(moduleNumber, symbolPath); + return pdbCategories.getTypedefsCategory(moduleNumber, symbolPath); } /** @@ -847,7 +909,7 @@ public class DefaultPdbApplicator implements PdbApplicator { * @return the {@link CategoryPath} */ CategoryPath getAnonymousFunctionsCategory() { - return categoryUtils.getAnonymousFunctionsCategory(); + return pdbCategories.getAnonymousFunctionsCategory(); } /** @@ -855,7 +917,7 @@ public class DefaultPdbApplicator implements PdbApplicator { * @return the {@link CategoryPath} */ CategoryPath getAnonymousTypesCategory() { - return categoryUtils.getAnonymousTypesCategory(); + return pdbCategories.getAnonymousTypesCategory(); } // /** @@ -1482,10 +1544,10 @@ public class DefaultPdbApplicator implements PdbApplicator { } //============================================================================================== - // Virtual-Base-Table-related methods. + // Virtual-Base/Function-Table-related methods. //============================================================================================== - VbtManager getVbtManager() { - return vbtManager; + VxtManager getVxtManager() { + return vxtManager; } //============================================================================================== @@ -2299,8 +2361,7 @@ public class DefaultPdbApplicator implements PdbApplicator { } private Symbol createSymbolInternal(Address address, SymbolPath symbolPath, - boolean isNewFunctionSignature, - String plateAddition) { + boolean isNewFunctionSignature, String plateAddition) { Symbol existingSymbol = program.getSymbolTable().getPrimarySymbol(address); if (existingSymbol == null || isNewFunctionSignature) { diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/DefaultPdbUniversalMember.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/DefaultPdbUniversalMember.java index 55ba1cf70c..a64f0756b7 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/DefaultPdbUniversalMember.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/DefaultPdbUniversalMember.java @@ -4,9 +4,9 @@ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -16,6 +16,7 @@ package ghidra.app.util.pdb.pdbapplicator; import ghidra.app.util.bin.format.pdb.*; +import ghidra.app.util.pdb.classtype.ClassFieldAttributes; import ghidra.program.model.data.DataType; import ghidra.util.exception.CancelledException; diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/classtype/MsftVxtManagerTest.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/classtype/MsftVxtManagerTest.java new file mode 100644 index 0000000000..5da04ca257 --- /dev/null +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/pdb/classtype/MsftVxtManagerTest.java @@ -0,0 +1,623 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.app.util.pdb.classtype; + +import static org.junit.Assert.*; + +import java.util.*; + +import generic.test.AbstractGenericTest; +import ghidra.app.plugin.core.checksums.MyTestMemory; +import ghidra.app.util.SymbolPath; +import ghidra.app.util.SymbolPathParser; +import ghidra.app.util.importer.MessageLog; +import ghidra.program.model.address.Address; +import ghidra.program.model.address.AddressIterator; +import ghidra.program.model.data.*; +import ghidra.program.model.mem.Memory; +import ghidra.program.model.mem.MemoryAccessException; +import ghidra.util.LittleEndianDataConverter; +import ghidra.util.exception.AssertException; +import ghidra.util.exception.CancelledException; +import ghidra.util.task.TaskMonitor; + +/** + * Unit tests for the {@link MsftVxtManager}. + *

+ * See {@link MsftVxtManager} for a description of what tests need to work + */ +public class MsftVxtManagerTest extends AbstractGenericTest { + + private static MessageLog log = new MessageLog(); + private static TaskMonitor monitor = TaskMonitor.DUMMY; + + private static DataTypeManager dtm32; + private static DataTypeManager dtm64; + // Didn't intend to modify this class to need these, but need them while modifying PdbVxtManager + // to use them + private static ClassTypeManager ctm32; + private static ClassTypeManager ctm64; + + private ClassID a1Id = new ProgramClassID(CategoryPath.ROOT, sp("A1NS::A1")); + private ClassID a2Id = new ProgramClassID(CategoryPath.ROOT, sp("A2NS::A2")); + private ClassID aId = new ProgramClassID(CategoryPath.ROOT, sp("ANS::A")); + private ClassID b1Id = new ProgramClassID(CategoryPath.ROOT, sp("B1NS::B1")); + private ClassID b2Id = new ProgramClassID(CategoryPath.ROOT, sp("B2NS::B2")); + private ClassID bId = new ProgramClassID(CategoryPath.ROOT, sp("BNS::B")); + private ClassID cId = new ProgramClassID(CategoryPath.ROOT, sp("CNS::C")); + private ClassID dId = new ProgramClassID(CategoryPath.ROOT, sp("DNS::D")); + private ClassID eId = new ProgramClassID(CategoryPath.ROOT, sp("ENS::E")); + private ClassID fId = new ProgramClassID(CategoryPath.ROOT, sp("FNS::F")); + private ClassID gId = new ProgramClassID(CategoryPath.ROOT, sp("GNS::G")); + private ClassID hId = new ProgramClassID(CategoryPath.ROOT, sp("HNS::H")); + private ClassID iId = new ProgramClassID(CategoryPath.ROOT, sp("INS::I")); + private ClassID jId = new ProgramClassID(CategoryPath.ROOT, sp("JNS::J")); + private ClassID kId = new ProgramClassID(CategoryPath.ROOT, sp("KNS::K")); + private ClassID lId = new ProgramClassID(CategoryPath.ROOT, sp("LNS::L")); + private ClassID mId = new ProgramClassID(CategoryPath.ROOT, sp("MNS::M")); + + private static Memory memory32; + private static Memory memory64; + + private static List vbtSymbols = new ArrayList<>(); + private static List vftSymbols = new ArrayList<>(); + private static List

vxtAddresses32; + private static List
vxtAddresses64; + + private static Map addressByVxtMangledName32; + private static Map addressByVxtMangledName64; + +// private static PointerDataType vftptr32; +// private static PointerDataType vftptr64; +// private static PointerDataType vbtptr32; +// private static PointerDataType vbtptr64; + + private static MsftVxtManager mVxtManager32; + private static MsftVxtManager mVxtManager64; + + static { + BitFieldPackingImpl bitFieldPacking = new BitFieldPackingImpl(); + bitFieldPacking.setUseMSConvention(true); + + // DataOrganization based on x86win.cspec + // The DataOrganizationImpl currently has defaults of a 32-bit windows cspec, but could + // change in the future. + DataOrganizationImpl dataOrg32 = DataOrganizationImpl.getDefaultOrganization(null); + + dtm32 = new TestDummyDataTypeManager() { + HashMap dataTypeMap = new HashMap<>(); + + @Override + public DataOrganization getDataOrganization() { + return dataOrg32; + } + + @Override + public DataType addDataType(DataType dataType, DataTypeConflictHandler handler) { + // handler ignored - tests should not induce conflicts + String pathname = dataType.getPathName(); + DataType myDt = dataTypeMap.get(pathname); + if (myDt != null) { + return myDt; + } + DataType dt = dataType.clone(this); + dataTypeMap.put(pathname, dt); + return dt; + } + + @Override + public DataType findDataType(String dataTypePath) { + return dataTypeMap.get(dataTypePath); + } + + @Override + public DataType getDataType(CategoryPath path, String name) { + return super.getDataType(new DataTypePath(path, name).getPath()); + } + + @Override + public DataType getDataType(String dataTypePath) { + return dataTypeMap.get(dataTypePath); + } + }; + + // DataOrganization based on x86-64-win.cspec + DataOrganizationImpl dataOrg64 = DataOrganizationImpl.getDefaultOrganization(null); + DataOrganizationTestUtils.initDataOrganizationWindows64BitX86(dataOrg64); + + dtm64 = new TestDummyDataTypeManager() { + HashMap dataTypeMap = new HashMap<>(); + + @Override + public DataOrganization getDataOrganization() { + return dataOrg64; + } + + @Override + public DataType addDataType(DataType dataType, DataTypeConflictHandler handler) { + // handler ignored - tests should not induce conflicts + String pathname = dataType.getPathName(); + DataType myDt = dataTypeMap.get(pathname); + if (myDt != null) { + return myDt; + } + DataType dt = dataType.clone(this); + dataTypeMap.put(pathname, dt); + return dt; + } + + @Override + public DataType findDataType(String dataTypePath) { + return dataTypeMap.get(dataTypePath); + } + + @Override + public DataType getDataType(CategoryPath path, String name) { + return super.getDataType(new DataTypePath(path, name).getPath()); + } + + @Override + public DataType getDataType(String dataTypePath) { + return dataTypeMap.get(dataTypePath); + } + }; + + // Didn't intend to modify this class to need these, but need them while modifying + // PdbVxtManager to use them + ctm32 = new ClassTypeManager(dtm32); + ctm64 = new ClassTypeManager(dtm64); +// vftptr32 = new PointerDataType(new PointerDataType(dtm32)); +// vftptr64 = new PointerDataType(new PointerDataType(dtm64)); +// vbtptr32 = new PointerDataType(new IntegerDataType(dtm32)); +// vbtptr64 = new PointerDataType(new IntegerDataType(dtm64)); + + createVxTables(); + + mVxtManager32 = new MsftVxtManager(ctm32, memory32); + mVxtManager64 = new MsftVxtManager(ctm64, memory64); + + try { + mVxtManager32.createVirtualTables(CategoryPath.ROOT, addressByVxtMangledName32, log, + monitor); + mVxtManager64.createVirtualTables(CategoryPath.ROOT, addressByVxtMangledName64, log, + monitor); + } + catch (CancelledException e) { + // do nothing + } + + } + + //============================================================================================== + private static SymbolPath sp(String s) { + return new SymbolPath(SymbolPathParser.parse(s)); + } + + //============================================================================================== + + private static void addBytesForIntegers(int[] ints, byte[] bytes, int startOffset) { + int maxOffset = startOffset + 4 * ints.length; + int index = 0; + for (int offset = startOffset; offset < maxOffset; offset += 4) { + LittleEndianDataConverter.INSTANCE.getBytes(ints[index++], bytes, offset); + } + } + + static class MemoryPreparer { + private int nextOffset = 0; + private List intArrays = new ArrayList<>(); + private List offsets = new ArrayList<>(); + private List
addresses = new ArrayList<>(); + private MyTestMemory memory = null; + private int mockAddressCounter = 0; + + void addAddresses(int numAddresses, boolean is64bit) { + int[] integers; + if (is64bit) { + integers = new int[numAddresses * 2]; + for (int i = 0; i < numAddresses; i++) { + integers[i * 2] = mockAddressCounter; + integers[i * 2 + 1] = 0; + } + } + else { + integers = new int[numAddresses * 2]; + for (int i = 0; i < numAddresses; i++) { + integers[i] = mockAddressCounter; + } + } + addIntegers(integers); + } + + void addIntegers(int[] integers) { + offsets.add(nextOffset); + intArrays.add(integers); + nextOffset += 4 * integers.length; + } + + List getOffsets() { + return offsets; + } + + void finalizeMemory() { + byte[] bytes = new byte[nextOffset]; + for (int index = 0; index < offsets.size(); index++) { + addBytesForIntegers(intArrays.get(index), bytes, offsets.get(index)); + } + memory = new CppCompositeTestMemory(bytes); + AddressIterator iter = memory.getAddresses(true); + if (!iter.hasNext()) { + return; + } + Address address = iter.next(); + for (Integer offset : offsets) { + addresses.add(address.add(offset)); + } + } + + Memory getMemory() { + return memory; + } + + List
getAddresses() { + return addresses; + } + + private static class CppCompositeTestMemory extends MyTestMemory { + public CppCompositeTestMemory(byte[] bytes) { + super(bytes); + } + + @Override + public int getInt(Address addr) throws MemoryAccessException { + byte bytes[] = new byte[4]; + int num = getBytes(addr, bytes, 0, 4); + assertEquals(num, 4); + return LittleEndianDataConverter.INSTANCE.getInt(bytes); + } + + @Override + public long getLong(Address addr) throws MemoryAccessException { + byte bytes[] = new byte[8]; + int num = getBytes(addr, bytes, 0, 8); + assertEquals(num, 8); + return LittleEndianDataConverter.INSTANCE.getLong(bytes); + } + } + } + + static void createVxTables() { + MemoryPreparer preparer32 = new MemoryPreparer(); + MemoryPreparer preparer64 = new MemoryPreparer(); + + vbtSymbols = new ArrayList<>(); + vftSymbols = new ArrayList<>(); + + //========================================================================================== + + vbtSymbols.add("??_8A@ANS@@7B@"); + preparer32.addIntegers(new int[] { -4, 8, 16 }); + preparer64.addIntegers(new int[] { -8, 16, 32 }); + + vbtSymbols.add("??_8B@BNS@@7B@"); + preparer32.addIntegers(new int[] { -4, 8, 16 }); + preparer64.addIntegers(new int[] { -8, 16, 32 }); + + vbtSymbols.add("??_8C@CNS@@7B@"); + preparer32.addIntegers(new int[] { -4, 8, 16, 24, 32 }); + preparer64.addIntegers(new int[] { -8, 16, 32, 48, 64 }); + + vbtSymbols.add("??_8D@DNS@@7BC@CNS@@@"); + preparer32.addIntegers(new int[] { -4, 36, 44, 52, 60 }); + preparer64.addIntegers(new int[] { -8, 72, 88, 104, 120 }); + + vbtSymbols.add("??_8D@DNS@@7BA@ANS@@@"); + preparer32.addIntegers(new int[] { -4, 24, 32 }); + preparer64.addIntegers(new int[] { -8, 48, 64 }); + + vbtSymbols.add("??_8D@DNS@@7BB@BNS@@@"); + preparer32.addIntegers(new int[] { -4, 28, 36 }); + preparer64.addIntegers(new int[] { -8, 56, 72 }); + + vbtSymbols.add("??_8E@ENS@@7BA@ANS@@@"); + preparer32.addIntegers(new int[] { -4, 12, 20, 28, 36, 44 }); + preparer64.addIntegers(new int[] { -8, 24, 40, 56, 72, 88 }); + + vbtSymbols.add("??_8E@ENS@@7BB@BNS@@@"); + preparer32.addIntegers(new int[] { -4, -20, -12 }); + preparer64.addIntegers(new int[] { -8, -40, -24 }); + + vbtSymbols.add("??_8F@FNS@@7B@"); + preparer32.addIntegers(new int[] { 0, 8 }); + preparer64.addIntegers(new int[] { 0, 16 }); + + vbtSymbols.add("??_8G@GNS@@7B@"); + preparer32.addIntegers(new int[] { 0, 12 }); + preparer64.addIntegers(new int[] { 0, 24 }); + + vbtSymbols.add("??_8H@HNS@@7B@"); + preparer32.addIntegers(new int[] { 0, 12 }); + preparer64.addIntegers(new int[] { 0, 24 }); + + vbtSymbols.add("??_8I@INS@@7BG@GNS@@@"); + preparer32.addIntegers(new int[] { 0, 28 }); + preparer64.addIntegers(new int[] { 0, 56 }); + + vbtSymbols.add("??_8I@INS@@7BH@HNS@@@"); + preparer32.addIntegers(new int[] { 0, 16 }); + preparer64.addIntegers(new int[] { 0, 32 }); + + vbtSymbols.add("??_8J@JNS@@7B@"); + preparer32.addIntegers(new int[] { 0, 8 }); + preparer64.addIntegers(new int[] { 0, 16 }); + + vbtSymbols.add("??_8K@KNS@@7B@"); + preparer32.addIntegers(new int[] { 0, 12 }); + preparer64.addIntegers(new int[] { 0, 24 }); + + vbtSymbols.add("??_8L@LNS@@7B@"); + preparer32.addIntegers(new int[] { 0, 16 }); + preparer64.addIntegers(new int[] { 0, 32 }); + + vbtSymbols.add("??_8M@MNS@@7BA@ANS@@E@ENS@@@"); + preparer32.addIntegers(new int[] { -4, 100, 108, 116, 124, 132 }); + preparer64.addIntegers(new int[] { -8, 200, 216, 232, 248, 264 }); + + vbtSymbols.add("??_8M@MNS@@7BC@CNS@@@"); + preparer32.addIntegers(new int[] { -4, 84, 92, 100, 108 }); + preparer64.addIntegers(new int[] { -8, 168, 184, 200, 216 }); + + vbtSymbols.add("??_8M@MNS@@7BA@ANS@@D@DNS@@@"); + preparer32.addIntegers(new int[] { -4, 72, 80 }); + preparer64.addIntegers(new int[] { -8, 144, 160 }); + + vbtSymbols.add("??_8M@MNS@@7BB@BNS@@D@DNS@@@"); + preparer32.addIntegers(new int[] { -4, 76, 84 }); + preparer64.addIntegers(new int[] { -8, 152, 168 }); + + vbtSymbols.add("??_8M@MNS@@7BG@GNS@@@"); + preparer32.addIntegers(new int[] { 0, 48 }); + preparer64.addIntegers(new int[] { 0, 96 }); + + vbtSymbols.add("??_8M@MNS@@7BH@HNS@@@"); + preparer32.addIntegers(new int[] { 0, 36 }); + preparer64.addIntegers(new int[] { 0, 72 }); + + vbtSymbols.add("??_8M@MNS@@7B@"); + preparer32.addIntegers(new int[] { 0, 20 }); + preparer64.addIntegers(new int[] { 0, 40 }); + + vbtSymbols.add("??_8M@MNS@@7BB@BNS@@E@ENS@@@"); + preparer32.addIntegers(new int[] { -4, -20, -12 }); + preparer64.addIntegers(new int[] { -8, -40, -24 }); + + //========================================================================================== + // Below: writing one int to simulate one address for 32-bit and tow ints for 64-bit (lsb) + // Later... mock up even better + + vftSymbols.add("??_7A1@A1NS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7A2@A2NS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7A@ANS@@6B01@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7A@ANS@@6BA1@A1NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7A@ANS@@6BA2@A2NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7B1@B1NS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7B2@B2NS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7B@BNS@@6B01@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7B@BNS@@6BB1@B1NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7B@BNS@@6BB2@B2NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7C@CNS@@6B01@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7C@CNS@@6BA1@A1NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7C@CNS@@6BA2@A2NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7C@CNS@@6BB1@B1NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7C@CNS@@6BB2@B2NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7D@DNS@@6BC@CNS@@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7D@DNS@@6BA@ANS@@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7D@DNS@@6BB@BNS@@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7D@DNS@@6BA1@A1NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7D@DNS@@6BA2@A2NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7D@DNS@@6BB1@B1NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7D@DNS@@6BB2@B2NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7E@ENS@@6BA@ANS@@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7E@ENS@@6BA1@A1NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7E@ENS@@6BA2@A2NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7E@ENS@@6BB1@B1NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7E@ENS@@6BB2@B2NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7E@ENS@@6BB@BNS@@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7F@FNS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7G@GNS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7H@HNS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7I@INS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7J@JNS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7K@KNS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7L@LNS@@6B@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7M@MNS@@6BA@ANS@@E@ENS@@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7M@MNS@@6BC@CNS@@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7M@MNS@@6BA@ANS@@D@DNS@@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7M@MNS@@6BB@BNS@@D@DNS@@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + vftSymbols.add("??_7M@MNS@@6BA1@A1NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7M@MNS@@6BA2@A2NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7M@MNS@@6BB1@B1NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7M@MNS@@6BB2@B2NS@@@"); + preparer32.addAddresses(3, false); + preparer64.addAddresses(3, true); + + vftSymbols.add("??_7M@MNS@@6BB@BNS@@E@ENS@@@"); + preparer32.addAddresses(1, false); + preparer64.addAddresses(1, true); + + //========================================================================================== + + preparer32.finalizeMemory(); + preparer64.finalizeMemory(); + + memory32 = preparer32.getMemory(); + memory64 = preparer64.getMemory(); + + vxtAddresses32 = preparer32.getAddresses(); + vxtAddresses64 = preparer64.getAddresses(); + + addressByVxtMangledName32 = new HashMap<>(); + addressByVxtMangledName64 = new HashMap<>(); + + if (vbtSymbols.size() + vftSymbols.size() != vxtAddresses32.size() || + vbtSymbols.size() + vftSymbols.size() != vxtAddresses64.size()) { + throw new AssertException("Fatal: list sizes do not match"); + } + int aCount = 0; + for (String vbtSymbol : vbtSymbols) { + addressByVxtMangledName32.put(vbtSymbol, vxtAddresses32.get(aCount)); + addressByVxtMangledName64.put(vbtSymbol, vxtAddresses64.get(aCount)); + aCount++; + } + for (String vftSymbol : vftSymbols) { + addressByVxtMangledName32.put(vftSymbol, vxtAddresses32.get(aCount)); + addressByVxtMangledName64.put(vftSymbol, vxtAddresses64.get(aCount)); + aCount++; + } + } + + //============================================================================================== + //============================================================================================== + + // No tests at this point because of need to rework the design + +} 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 57dca93678..74b5bfd3c6 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 @@ -4,9 +4,9 @@ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at - * + * * http://www.apache.org/licenses/LICENSE-2.0 - * + * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. @@ -25,6 +25,8 @@ import org.junit.Test; import generic.test.AbstractGenericTest; import ghidra.app.plugin.core.checksums.MyTestMemory; import ghidra.app.util.SymbolPath; +import ghidra.app.util.importer.MessageLog; +import ghidra.app.util.pdb.classtype.*; import ghidra.program.model.address.Address; import ghidra.program.model.address.AddressIterator; import ghidra.program.model.data.*; @@ -33,6 +35,7 @@ import ghidra.program.model.mem.MemoryAccessException; import ghidra.util.LittleEndianDataConverter; import ghidra.util.Msg; import ghidra.util.exception.AssertException; +import ghidra.util.exception.CancelledException; import ghidra.util.task.TaskMonitor; /** @@ -40,36 +43,49 @@ import ghidra.util.task.TaskMonitor; */ public class CppCompositeTypeTest extends AbstractGenericTest { + private static MessageLog log = new MessageLog(); + private static TaskMonitor monitor = TaskMonitor.DUMMY; + private static DataTypeManager dtm32; private static DataTypeManager dtm64; + // Didn't intend to modify this class to need these, but need them while modifying MsftVxtManager + // to use them + private static ClassTypeManager ctm32; + private static ClassTypeManager ctm64; private static Memory memory32; private static Memory memory64; private static Map addressByMangledName32; private static Map addressByMangledName64; - private static DataType vbptr32; - private static DataType vbptr64; - private static PdbVbtManager pdbVbtManager32; - private static PdbVbtManager pdbVbtManager64; - private static VbtManager vbtManager32; - private static VbtManager vbtManager64; + private static DataType vftptr32; + private static DataType vftptr64; + private static DataType vbtptr32; + private static DataType vbtptr64; + private static MsftVxtManager msftVxtManager32; + private static MsftVxtManager msftVxtManager64; + private static VxtManager vxtManager32; + private static VxtManager vxtManager64; // Note: Currently all test have expected results based on up the COMPLEX layout. private static ObjectOrientedClassLayout classLayoutChoice = ObjectOrientedClassLayout.COMPLEX; + // Note that we would not normally want to share these attributes amongst classes and their + // members, as we might want to change one without changing all. However, we are using this + // for testing, and thus are creating this static item. + private static ClassFieldAttributes publicVirtualAttributes = + ClassFieldAttributes.get(Access.PUBLIC, Property.VIRTUAL); + private static ClassFieldAttributes publicDirectAttributes = + ClassFieldAttributes.get(Access.PUBLIC, Property.BLANK); + + static ClassFieldAttributes TEST_ATTS = + ClassFieldAttributes.get(Access.PUBLIC, Property.UNKNOWN); + static { BitFieldPackingImpl bitFieldPacking = new BitFieldPackingImpl(); bitFieldPacking.setUseMSConvention(true); - // DataOrganization based on x86-64.cspec + // DataOrganization based on x86win.cspec + // The DataOrganizationImpl currently has defaults of a 32-bit windows cspec, but could + // change in the future. DataOrganizationImpl dataOrg32 = DataOrganizationImpl.getDefaultOrganization(null); - dataOrg32.setBigEndian(false); - dataOrg32.setAbsoluteMaxAlignment(0); - dataOrg32.setMachineAlignment(2); - dataOrg32.setDefaultPointerAlignment(4); - dataOrg32.setPointerSize(4); - - dataOrg32.setSizeAlignment(4, 4); - - dataOrg32.setBitFieldPacking(bitFieldPacking); dtm32 = new TestDummyDataTypeManager() { HashMap dataTypeMap = new HashMap<>(); @@ -107,17 +123,9 @@ public class CppCompositeTypeTest extends AbstractGenericTest { return dataTypeMap.get(dataTypePath); } }; - // DataOrganization based on x86-64.cspec + // DataOrganization based on x86-64-win.cspec DataOrganizationImpl dataOrg64 = DataOrganizationImpl.getDefaultOrganization(null); - dataOrg64.setBigEndian(false); - dataOrg64.setAbsoluteMaxAlignment(0); - dataOrg64.setMachineAlignment(2); - dataOrg64.setDefaultPointerAlignment(8); - dataOrg64.setPointerSize(8); - - dataOrg64.setSizeAlignment(8, 8); - - dataOrg64.setBitFieldPacking(bitFieldPacking); + DataOrganizationTestUtils.initDataOrganizationWindows64BitX86(dataOrg64); dtm64 = new TestDummyDataTypeManager() { HashMap dataTypeMap = new HashMap<>(); @@ -155,17 +163,37 @@ public class CppCompositeTypeTest extends AbstractGenericTest { return dataTypeMap.get(dataTypePath); } }; - vbptr32 = new PointerDataType(new IntegerDataType(dtm32)); - vbptr64 = new PointerDataType(new IntegerDataType(dtm64)); - System.out.println("vbptr32 size: " + vbptr32.getLength()); - System.out.println("vbptr64 size: " + vbptr64.getLength()); + // Didn't intend to modify this class to need these, but need them while modifying + // MsftVxtManager to use them + ctm32 = new ClassTypeManager(dtm32); + ctm64 = new ClassTypeManager(dtm64); + + vftptr32 = new PointerDataType(new PointerDataType(dtm32)); + vftptr64 = new PointerDataType(new PointerDataType(dtm64)); + vbtptr32 = new PointerDataType(new IntegerDataType(dtm32)); + vbtptr64 = new PointerDataType(new IntegerDataType(dtm64)); +// // might not be accurate lengths because not yet resolved +// System.out.println("vftptr32 size: " + vftptr32.getLength()); +// System.out.println("vftptr64 size: " + vftptr64.getLength()); +// System.out.println("vbtptr32 size: " + vbtptr32.getLength()); +// System.out.println("vbtptr64 size: " + vbtptr64.getLength()); createVbTables(); - pdbVbtManager32 = new PdbVbtManager(dtm32, memory32, addressByMangledName32); - pdbVbtManager64 = new PdbVbtManager(dtm64, memory64, addressByMangledName64); - vbtManager32 = new VbtManager(dtm32); - vbtManager64 = new VbtManager(dtm64); + msftVxtManager32 = new MsftVxtManager(ctm32, memory32); + msftVxtManager64 = new MsftVxtManager(ctm64, memory64); + try { + msftVxtManager32.createVirtualTables(CategoryPath.ROOT, addressByMangledName32, log, + monitor); + msftVxtManager64.createVirtualTables(CategoryPath.ROOT, addressByMangledName64, log, + monitor); + } + catch (CancelledException e) { + // do nothing + } + vxtManager32 = new VxtManager(ctm32); + vxtManager64 = new VxtManager(ctm64); + } private static void addBytesForIntegers(int[] ints, byte[] bytes, int startOffset) { @@ -265,9 +293,9 @@ public class CppCompositeTypeTest extends AbstractGenericTest { preparer32.addIntegers(new int[] { 0, 8 }); preparer64.addIntegers(new int[] { 0, 16 }); -// vbtSymbols.add("??_8GG4@@7B@"); -// preparer32.addIntegers(new int[] { 0, 8}); -// preparer64.addIntegers(new int[] { 0, 16}); + vbtSymbols.add("??_8GG4@@7B@"); + preparer32.addIntegers(new int[] { 0, 8 }); + preparer64.addIntegers(new int[] { 0, 16 }); vbtSymbols.add("??_8I@@7BG@@@"); preparer32.addIntegers(new int[] { 0, 20 }); @@ -478,21 +506,23 @@ public class CppCompositeTypeTest extends AbstractGenericTest { private static CppCompositeType createStruct32(String name, int size) { Composite composite = new StructureDataType(CategoryPath.ROOT, name, 0, dtm32); SymbolPath symbolPath = new SymbolPath(name); - String mangledName = createMangledName(name, CppCompositeType.Type.STRUCT); - return CppCompositeType.createCppStructType(symbolPath, composite, name, mangledName, size); + String mangledName = createMangledName(name, ClassKey.STRUCT); + return CppCompositeType.createCppStructType(CategoryPath.ROOT, symbolPath, composite, name, + mangledName, size); } private static CppCompositeType createStruct64(String name, int size) { Composite composite = new StructureDataType(CategoryPath.ROOT, name, 0, dtm64); SymbolPath symbolPath = new SymbolPath(name); - String mangledName = createMangledName(name, CppCompositeType.Type.STRUCT); - return CppCompositeType.createCppStructType(symbolPath, composite, name, mangledName, 0); + String mangledName = createMangledName(name, ClassKey.STRUCT); + return CppCompositeType.createCppStructType(CategoryPath.ROOT, symbolPath, composite, name, + mangledName, 0); } - private static String createMangledName(String className, CppCompositeType.Type type) { + private static String createMangledName(String className, ClassKey key) { StringBuilder builder = new StringBuilder(); builder.append(".?A"); - switch (type) { + switch (key) { case UNION: builder.append('T'); break; @@ -503,7 +533,7 @@ public class CppCompositeTypeTest extends AbstractGenericTest { builder.append('V'); break; default: - String msg = "Cannot handle type during testing" + type; + String msg = "Cannot handle type during testing" + key; Msg.error(null, msg); throw new AssertException(msg); } @@ -586,28 +616,21 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * int i; * }; */ - static CppCompositeType createA_syntactic_struct32(VbtManager vbtManager) { + static CppCompositeType createA_syntactic_struct32(VxtManager vxtManager) { CppCompositeType A_struct = createStruct32("A", 0); A_struct.addMember("c", u1, false, 0); A_struct.addMember("i", u4, false, 0); return A_struct; } - static CppCompositeType createA_struct32(VbtManager vbtManager) { + static CppCompositeType createA_struct32(VxtManager vxtManager) { CppCompositeType A_struct = createStruct32("A", 8); A_struct.addMember("c", u1, false, 0); A_struct.addMember("i", u4, false, 4); return A_struct; } - //============================================================================================== - /* - * struct A { - * char c; - * int i; - * }; - */ - static CppCompositeType createA_struct64(VbtManager vbtManager) { + static CppCompositeType createA_struct64(VxtManager vxtManager) { CppCompositeType A_struct = createStruct64("A", 8); A_struct.addMember("c", u1, false, 0); A_struct.addMember("i", u4, false, 4); @@ -621,26 +644,19 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void cf(); * }; */ - static CppCompositeType createC_syntactic_struct32(VbtManager vbtManager) { + static CppCompositeType createC_syntactic_struct32(VxtManager vxtManager) { CppCompositeType C_struct = createStruct32("C", 0); C_struct.addMember("c1", u4, false, 0); return C_struct; } - static CppCompositeType createC_struct32(VbtManager vbtManager) { + static CppCompositeType createC_struct32(VxtManager vxtManager) { CppCompositeType C_struct = createStruct32("C", 4); C_struct.addMember("c1", u4, false, 0); return C_struct; } - //============================================================================================== - /* - * struct C { - * int c1; - * void cf(); - * }; - */ - static CppCompositeType createC_struct64(VbtManager vbtManager) { + static CppCompositeType createC_struct64(VxtManager vxtManager) { CppCompositeType C_struct = createStruct64("C", 4); C_struct.addMember("c1", u4, false, 0); return C_struct; @@ -653,26 +669,19 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void cc1f(); * }; */ - static CppCompositeType createCC1_syntactic_struct32(VbtManager vbtManager) { + static CppCompositeType createCC1_syntactic_struct32(VxtManager vxtManager) { CppCompositeType CC1_struct = createStruct32("CC1", 0); CC1_struct.addMember("cc11", u4, false, 0); return CC1_struct; } - static CppCompositeType createCC1_struct32(VbtManager vbtManager) { + static CppCompositeType createCC1_struct32(VxtManager vxtManager) { CppCompositeType CC1_struct = createStruct32("CC1", 4); CC1_struct.addMember("cc11", u4, false, 0); return CC1_struct; } - //============================================================================================== - /* - * struct CC1 { - * int cc11; - * void cc1f(); - * }; - */ - static CppCompositeType createCC1_struct64(VbtManager vbtManager) { + static CppCompositeType createCC1_struct64(VxtManager vxtManager) { CppCompositeType CC1_struct = createStruct64("CC1", 4); CC1_struct.addMember("cc11", u4, false, 0); return CC1_struct; @@ -685,26 +694,19 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void cc2f(); * }; */ - static CppCompositeType createCC2_syntactic_struct32(VbtManager vbtManager) { + static CppCompositeType createCC2_syntactic_struct32(VxtManager vxtManager) { CppCompositeType CC2_struct = createStruct32("CC2", 0); CC2_struct.addMember("cc21", u4, false, 0); return CC2_struct; } - static CppCompositeType createCC2_struct32(VbtManager vbtManager) { + static CppCompositeType createCC2_struct32(VxtManager vxtManager) { CppCompositeType CC2_struct = createStruct32("CC2", 4); CC2_struct.addMember("cc21", u4, false, 0); return CC2_struct; } - //============================================================================================== - /* - * struct CC2 { - * int cc21; - * void cc2f(); - * }; - */ - static CppCompositeType createCC2_struct64(VbtManager vbtManager) { + static CppCompositeType createCC2_struct64(VxtManager vxtManager) { CppCompositeType CC2_struct = createStruct64("CC2", 4); CC2_struct.addMember("cc21", u4, false, 0); return CC2_struct; @@ -716,18 +718,12 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void cc3f(); * }; */ - static CppCompositeType createCC3_struct32(VbtManager vbtManager) { + static CppCompositeType createCC3_struct32(VxtManager vxtManager) { CppCompositeType CC3_struct = createStruct32("CC3", 0); //TODO size 1 or 0? return CC3_struct; } - //============================================================================================== - /* - * struct CC3 { - * void cc3f(); - * }; - */ - static CppCompositeType createCC3_struct64(VbtManager vbtManager) { + static CppCompositeType createCC3_struct64(VxtManager vxtManager) { CppCompositeType CC3_struct = createStruct64("CC3", 0); //TODO size 1 or 0? return CC3_struct; } @@ -739,51 +735,44 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void df(); * }; */ - static CppCompositeType createD_struct32(VbtManager vbtManager) { - return createD_struct32(vbtManager, null); + static CppCompositeType createD_struct32(VxtManager vxtManager) { + return createD_struct32(vxtManager, null); } - static CppCompositeType createD_struct32(VbtManager vbtManager, CppCompositeType C_struct) { + static CppCompositeType createD_struct32(VxtManager vxtManager, CppCompositeType C_struct) { CppCompositeType D_struct = createStruct32("D", 8); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } D_struct.addDirectBaseClass(C_struct, 0); D_struct.addMember("d1", u4, false, 4); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return D_struct; } - //============================================================================================== - /* - * struct D : C { - * int d1; - * void df(); - * }; - */ - static CppCompositeType createD_struct64(VbtManager vbtManager) { - return createD_struct64(vbtManager, null); + static CppCompositeType createD_struct64(VxtManager vxtManager) { + return createD_struct64(vxtManager, null); } - static CppCompositeType createD_struct64(VbtManager vbtManager, CppCompositeType C_struct) { + static CppCompositeType createD_struct64(VxtManager vxtManager, CppCompositeType C_struct) { CppCompositeType D_struct = createStruct64("D", 8); try { if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } D_struct.addDirectBaseClass(C_struct, 0); D_struct.addMember("d1", u4, false, 4); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -797,26 +786,19 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void ef(); * }; */ - static CppCompositeType createE_syntactic_struct32(VbtManager vbtManager) { + static CppCompositeType createE_syntactic_struct32(VxtManager vxtManager) { CppCompositeType E_struct = createStruct32("E", 0); E_struct.addMember("e1", u4, false, 0); return E_struct; } - static CppCompositeType createE_struct32(VbtManager vbtManager) { + static CppCompositeType createE_struct32(VxtManager vxtManager) { CppCompositeType E_struct = createStruct32("E", 4); E_struct.addMember("e1", u4, false, 0); return E_struct; } - //============================================================================================== - /* - * struct E { - * int e1; - * void ef(); - * }; - */ - static CppCompositeType createE_struct64(VbtManager vbtManager) { + static CppCompositeType createE_struct64(VxtManager vxtManager) { CppCompositeType E_struct = createStruct64("E", 4); E_struct.addMember("e1", u4, false, 0); return E_struct; @@ -829,63 +811,56 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void ff(); * }; */ - static CppCompositeType createF_struct32(VbtManager vbtManager) { - return createF_struct32(vbtManager, null, null); + static CppCompositeType createF_struct32(VxtManager vxtManager) { + return createF_struct32(vxtManager, null, null); } - static CppCompositeType createF_struct32(VbtManager vbtManager, CppCompositeType C_struct, + static CppCompositeType createF_struct32(VxtManager vxtManager, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType F_struct = createStruct32("F", 12); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } F_struct.addDirectBaseClass(C_struct, 0); F_struct.addDirectBaseClass(E_struct, 4); F_struct.addMember("f1", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return F_struct; } - //============================================================================================== - /* - * struct F : C, E { - * int f1; - * void ff(); - * }; - */ - static CppCompositeType createF_struct64(VbtManager vbtManager) { - return createF_struct64(vbtManager, null, null); + static CppCompositeType createF_struct64(VxtManager vxtManager) { + return createF_struct64(vxtManager, null, null); } - static CppCompositeType createF_struct64(VbtManager vbtManager, CppCompositeType C_struct, + static CppCompositeType createF_struct64(VxtManager vxtManager, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType F_struct = createStruct64("F", 12); try { if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } F_struct.addDirectBaseClass(C_struct, 0); F_struct.addDirectBaseClass(E_struct, 4); F_struct.addMember("f1", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -899,73 +874,66 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void gf(); * }; */ - static CppCompositeType createG_syntactic_struct32(VbtManager vbtManager) { - return createG_syntactic_struct32(vbtManager, null); + static CppCompositeType createG_syntactic_struct32(VxtManager vxtManager) { + return createG_syntactic_struct32(vxtManager, null); } - static CppCompositeType createG_syntactic_struct32(VbtManager vbtManager, + static CppCompositeType createG_syntactic_struct32(VxtManager vxtManager, CppCompositeType C_struct) { CppCompositeType G_struct = createStruct32("G", 0); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); + C_struct = createC_struct32(vxtManager); } G_struct.addVirtualSyntacticBaseClass(C_struct); G_struct.addMember("g1", u4, false, 0); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return G_struct; } - static CppCompositeType createG_struct32(VbtManager vbtManager) { - return createG_struct32(vbtManager, null); + static CppCompositeType createG_struct32(VxtManager vxtManager) { + return createG_struct32(vxtManager, null); } - static CppCompositeType createG_struct32(VbtManager vbtManager, CppCompositeType C_struct) { + static CppCompositeType createG_struct32(VxtManager vxtManager, CppCompositeType C_struct) { CppCompositeType G_struct = createStruct32("G", 12); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - G_struct.addDirectVirtualBaseClass(C_struct, 0, vbptr32, 1); + G_struct.addDirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); G_struct.addMember("g1", u4, false, 4); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return G_struct; } - //============================================================================================== - /* - * struct G : virtual C { - * int g1; - * void gf(); - * }; - */ - static CppCompositeType createG_struct64(VbtManager vbtManager) { - return createG_struct64(vbtManager, null); + static CppCompositeType createG_struct64(VxtManager vxtManager) { + return createG_struct64(vxtManager, null); } - static CppCompositeType createG_struct64(VbtManager vbtManager, CppCompositeType C_struct) { + static CppCompositeType createG_struct64(VxtManager vxtManager, CppCompositeType C_struct) { CppCompositeType G_struct = createStruct64("G", 20); try { if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - G_struct.addDirectVirtualBaseClass(C_struct, 0, vbptr64, 1); + G_struct.addDirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); G_struct.addMember("g1", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -979,73 +947,66 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void hf(); * }; */ - static CppCompositeType createH_syntactic_struct32(VbtManager vbtManager) { - return createH_syntactic_struct32(vbtManager, null); + static CppCompositeType createH_syntactic_struct32(VxtManager vxtManager) { + return createH_syntactic_struct32(vxtManager, null); } - static CppCompositeType createH_syntactic_struct32(VbtManager vbtManager, + static CppCompositeType createH_syntactic_struct32(VxtManager vxtManager, CppCompositeType C_struct) { CppCompositeType H_struct = createStruct32("H", 0); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); + C_struct = createC_struct32(vxtManager); } H_struct.addVirtualSyntacticBaseClass(C_struct); H_struct.addMember("h1", u4, false, 0); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return H_struct; } - static CppCompositeType createH_struct32(VbtManager vbtManager) { - return createH_struct32(vbtManager, null); + static CppCompositeType createH_struct32(VxtManager vxtManager) { + return createH_struct32(vxtManager, null); } - static CppCompositeType createH_struct32(VbtManager vbtManager, CppCompositeType C_struct) { + static CppCompositeType createH_struct32(VxtManager vxtManager, CppCompositeType C_struct) { CppCompositeType H_struct = createStruct32("H", 12); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - H_struct.addDirectVirtualBaseClass(C_struct, 0, vbptr32, 1); + H_struct.addDirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); H_struct.addMember("h1", u4, false, 4); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return H_struct; } - //============================================================================================== - /* - * struct H : virtual C { - * int h1; - * void hf(); - * }; - */ - static CppCompositeType createH_struct64(VbtManager vbtManager) { - return createH_struct64(vbtManager, null); + static CppCompositeType createH_struct64(VxtManager vxtManager) { + return createH_struct64(vxtManager, null); } - static CppCompositeType createH_struct64(VbtManager vbtManager, CppCompositeType C_struct) { + static CppCompositeType createH_struct64(VxtManager vxtManager, CppCompositeType C_struct) { CppCompositeType H_struct = createStruct64("H", 20); try { if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - H_struct.addDirectVirtualBaseClass(C_struct, 0, vbptr64, 1); + H_struct.addDirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); H_struct.addMember("h1", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1059,89 +1020,82 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void g1f(); * }; */ - static CppCompositeType createG1_syntactic_struct32(VbtManager vbtManager) { - return createG1_syntactic_struct32(vbtManager, null, null); + static CppCompositeType createG1_syntactic_struct32(VxtManager vxtManager) { + return createG1_syntactic_struct32(vxtManager, null, null); } - static CppCompositeType createG1_syntactic_struct32(VbtManager vbtManager, + static CppCompositeType createG1_syntactic_struct32(VxtManager vxtManager, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType G1_struct = createStruct32("G1", 0); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); + C_struct = createC_struct32(vxtManager); } if (E_struct == null) { - E_struct = createE_struct32(vbtManager); + E_struct = createE_struct32(vxtManager); } G1_struct.addVirtualSyntacticBaseClass(C_struct); G1_struct.addVirtualSyntacticBaseClass(E_struct); G1_struct.addMember("g11", u4, false, 0); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return G1_struct; } - static CppCompositeType createG1_struct32(VbtManager vbtManager) { - return createG1_struct32(vbtManager, null, null); + static CppCompositeType createG1_struct32(VxtManager vxtManager) { + return createG1_struct32(vxtManager, null, null); } - static CppCompositeType createG1_struct32(VbtManager vbtManager, CppCompositeType C_struct, + static CppCompositeType createG1_struct32(VxtManager vxtManager, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType G1_struct = createStruct32("G1", 16); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - G1_struct.addDirectVirtualBaseClass(C_struct, 0, vbptr32, 1); - G1_struct.addDirectVirtualBaseClass(E_struct, 0, vbptr32, 2); + G1_struct.addDirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); + G1_struct.addDirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); G1_struct.addMember("g11", u4, false, 4); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return G1_struct; } - //============================================================================================== - /* - * struct G1 : virtual C, virtual E { - * int g11; - * void g1f(); - * }; - */ - static CppCompositeType createG1_struct64(VbtManager vbtManager) { - return createG1_struct64(vbtManager, null, null); + static CppCompositeType createG1_struct64(VxtManager vxtManager) { + return createG1_struct64(vxtManager, null, null); } - static CppCompositeType createG1_struct64(VbtManager vbtManager, CppCompositeType C_struct, + static CppCompositeType createG1_struct64(VxtManager vxtManager, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType G1_struct = createStruct64("G1", 24); try { if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - G1_struct.addDirectVirtualBaseClass(C_struct, 0, vbptr64, 1); - G1_struct.addDirectVirtualBaseClass(E_struct, 0, vbptr64, 2); + G1_struct.addDirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); + G1_struct.addDirectVirtualBaseClass(E_struct, 0, vbtptr64, 2); G1_struct.addMember("g11", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1155,89 +1109,82 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void h1f(); * }; */ - static CppCompositeType createH1_syntactic_struct32(VbtManager vbtManager) { - return createH1_syntactic_struct32(vbtManager, null, null); + static CppCompositeType createH1_syntactic_struct32(VxtManager vxtManager) { + return createH1_syntactic_struct32(vxtManager, null, null); } - static CppCompositeType createH1_syntactic_struct32(VbtManager vbtManager, + static CppCompositeType createH1_syntactic_struct32(VxtManager vxtManager, CppCompositeType E_struct, CppCompositeType C_struct) { CppCompositeType H1_struct = createStruct32("H1", 0); try { if (E_struct == null) { - E_struct = createE_struct32(vbtManager); + E_struct = createE_struct32(vxtManager); } if (C_struct == null) { - C_struct = createC_struct32(vbtManager); + C_struct = createC_struct32(vxtManager); } H1_struct.addVirtualSyntacticBaseClass(E_struct); H1_struct.addVirtualSyntacticBaseClass(C_struct); H1_struct.addMember("h11", u4, false, 0); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return H1_struct; } - static CppCompositeType createH1_struct32(VbtManager vbtManager) { - return createH1_struct32(vbtManager, null, null); + static CppCompositeType createH1_struct32(VxtManager vxtManager) { + return createH1_struct32(vxtManager, null, null); } - static CppCompositeType createH1_struct32(VbtManager vbtManager, CppCompositeType E_struct, + static CppCompositeType createH1_struct32(VxtManager vxtManager, CppCompositeType E_struct, CppCompositeType C_struct) { CppCompositeType H1_struct = createStruct32("H1", 16); try { if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - H1_struct.addDirectVirtualBaseClass(E_struct, 0, vbptr32, 1); - H1_struct.addDirectVirtualBaseClass(C_struct, 0, vbptr32, 2); + H1_struct.addDirectVirtualBaseClass(E_struct, 0, vbtptr32, 1); + H1_struct.addDirectVirtualBaseClass(C_struct, 0, vbtptr32, 2); H1_struct.addMember("h11", u4, false, 4); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return H1_struct; } - //============================================================================================== - /* - * struct H1 : virtual E, virtual C { //order reversed from G1 - * int h11; - * void h1f(); - * }; - */ - static CppCompositeType createH1_struct64(VbtManager vbtManager) { - return createH1_struct64(vbtManager, null, null); + static CppCompositeType createH1_struct64(VxtManager vxtManager) { + return createH1_struct64(vxtManager, null, null); } - static CppCompositeType createH1_struct64(VbtManager vbtManager, CppCompositeType E_struct, + static CppCompositeType createH1_struct64(VxtManager vxtManager, CppCompositeType E_struct, CppCompositeType C_struct) { CppCompositeType H1_struct = createStruct64("H1", 24); try { if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - H1_struct.addDirectVirtualBaseClass(E_struct, 0, vbptr64, 1); - H1_struct.addDirectVirtualBaseClass(C_struct, 0, vbptr64, 2); + H1_struct.addDirectVirtualBaseClass(E_struct, 0, vbtptr64, 1); + H1_struct.addDirectVirtualBaseClass(C_struct, 0, vbtptr64, 2); H1_struct.addMember("h11", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1251,73 +1198,66 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void gg1f(); * }; */ - static CppCompositeType createGG1_syntactic_struct32(VbtManager vbtManager) { - return createGG1_syntactic_struct32(vbtManager, null); + static CppCompositeType createGG1_syntactic_struct32(VxtManager vxtManager) { + return createGG1_syntactic_struct32(vxtManager, null); } - static CppCompositeType createGG1_syntactic_struct32(VbtManager vbtManager, + static CppCompositeType createGG1_syntactic_struct32(VxtManager vxtManager, CppCompositeType CC1_struct) { CppCompositeType GG1_struct = createStruct32("GG1", 0); try { if (CC1_struct == null) { - CC1_struct = createCC1_struct32(vbtManager); + CC1_struct = createCC1_struct32(vxtManager); } GG1_struct.addVirtualSyntacticBaseClass(CC1_struct); GG1_struct.addMember("gg11", u4, false, 0); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return GG1_struct; } - static CppCompositeType createGG1_struct32(VbtManager vbtManager) { - return createGG1_struct32(vbtManager, null); + static CppCompositeType createGG1_struct32(VxtManager vxtManager) { + return createGG1_struct32(vxtManager, null); } - static CppCompositeType createGG1_struct32(VbtManager vbtManager, CppCompositeType CC1_struct) { + static CppCompositeType createGG1_struct32(VxtManager vxtManager, CppCompositeType CC1_struct) { CppCompositeType GG1_struct = createStruct32("GG1", 12); try { if (CC1_struct == null) { - CC1_struct = createCC1_struct32(vbtManager); - CC1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CC1_struct = createCC1_struct32(vxtManager); + CC1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - GG1_struct.addDirectVirtualBaseClass(CC1_struct, 0, vbptr32, 1); + GG1_struct.addDirectVirtualBaseClass(CC1_struct, 0, vbtptr32, 1); GG1_struct.addMember("gg11", u4, false, 4); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return GG1_struct; } - //============================================================================================== - /* - * struct GG1 : virtual CC1 { - * int gg11; - * void gg1f(); - * }; - */ - static CppCompositeType createGG1_struct64(VbtManager vbtManager) { - return createGG1_struct64(vbtManager, null); + static CppCompositeType createGG1_struct64(VxtManager vxtManager) { + return createGG1_struct64(vxtManager, null); } - static CppCompositeType createGG1_struct64(VbtManager vbtManager, CppCompositeType CC1_struct) { + static CppCompositeType createGG1_struct64(VxtManager vxtManager, CppCompositeType CC1_struct) { CppCompositeType GG1_struct = createStruct64("GG1", 20); try { if (CC1_struct == null) { - CC1_struct = createCC1_struct64(vbtManager); - CC1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CC1_struct = createCC1_struct64(vxtManager); + CC1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - GG1_struct.addDirectVirtualBaseClass(CC1_struct, 0, vbptr64, 1); + GG1_struct.addDirectVirtualBaseClass(CC1_struct, 0, vbtptr64, 1); GG1_struct.addMember("gg11", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1331,73 +1271,66 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void gg2f(); * }; */ - static CppCompositeType createGG2_syntactic_struct32(VbtManager vbtManager) { - return createGG2_syntactic_struct32(vbtManager, null); + static CppCompositeType createGG2_syntactic_struct32(VxtManager vxtManager) { + return createGG2_syntactic_struct32(vxtManager, null); } - static CppCompositeType createGG2_syntactic_struct32(VbtManager vbtManager, + static CppCompositeType createGG2_syntactic_struct32(VxtManager vxtManager, CppCompositeType CC2_struct) { CppCompositeType GG2_struct = createStruct32("GG2", 0); try { if (CC2_struct == null) { - CC2_struct = createCC2_struct32(vbtManager); + CC2_struct = createCC2_struct32(vxtManager); } GG2_struct.addVirtualSyntacticBaseClass(CC2_struct); GG2_struct.addMember("gg21", u4, false, 0); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return GG2_struct; } - static CppCompositeType createGG2_struct32(VbtManager vbtManager) { - return createGG2_struct32(vbtManager, null); + static CppCompositeType createGG2_struct32(VxtManager vxtManager) { + return createGG2_struct32(vxtManager, null); } - static CppCompositeType createGG2_struct32(VbtManager vbtManager, CppCompositeType CC2_struct) { + static CppCompositeType createGG2_struct32(VxtManager vxtManager, CppCompositeType CC2_struct) { CppCompositeType GG2_struct = createStruct32("GG2", 12); try { if (CC2_struct == null) { - CC2_struct = createCC2_struct32(vbtManager); - CC2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CC2_struct = createCC2_struct32(vxtManager); + CC2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - GG2_struct.addDirectVirtualBaseClass(CC2_struct, 0, vbptr32, 1); + GG2_struct.addDirectVirtualBaseClass(CC2_struct, 0, vbtptr32, 1); GG2_struct.addMember("gg21", u4, false, 4); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return GG2_struct; } - //============================================================================================== - /* - * struct GG2 : virtual CC2 { - * int gg21; - * void gg2f(); - * }; - */ - static CppCompositeType createGG2_struct64(VbtManager vbtManager) { - return createGG2_struct64(vbtManager, null); + static CppCompositeType createGG2_struct64(VxtManager vxtManager) { + return createGG2_struct64(vxtManager, null); } - static CppCompositeType createGG2_struct64(VbtManager vbtManager, CppCompositeType CC2_struct) { + static CppCompositeType createGG2_struct64(VxtManager vxtManager, CppCompositeType CC2_struct) { CppCompositeType GG2_struct = createStruct64("GG2", 20); try { if (CC2_struct == null) { - CC2_struct = createCC2_struct64(vbtManager); - CC2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CC2_struct = createCC2_struct64(vxtManager); + CC2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - GG2_struct.addDirectVirtualBaseClass(CC2_struct, 0, vbptr64, 1); + GG2_struct.addDirectVirtualBaseClass(CC2_struct, 0, vbtptr64, 1); GG2_struct.addMember("gg21", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1411,73 +1344,66 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void gg3f(); * }; */ - static CppCompositeType createGG3_syntactic_struct32(VbtManager vbtManager) { - return createGG3_syntactic_struct32(vbtManager, null); + static CppCompositeType createGG3_syntactic_struct32(VxtManager vxtManager) { + return createGG3_syntactic_struct32(vxtManager, null); } - static CppCompositeType createGG3_syntactic_struct32(VbtManager vbtManager, + static CppCompositeType createGG3_syntactic_struct32(VxtManager vxtManager, CppCompositeType CC2_struct) { CppCompositeType GG3_struct = createStruct32("GG3", 0); try { if (CC2_struct == null) { - CC2_struct = createCC2_struct32(vbtManager); + CC2_struct = createCC2_struct32(vxtManager); } GG3_struct.addVirtualSyntacticBaseClass(CC2_struct); GG3_struct.addMember("gg31", u4, false, 0); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return GG3_struct; } - static CppCompositeType createGG3_struct32(VbtManager vbtManager) { - return createGG3_struct32(vbtManager, null); + static CppCompositeType createGG3_struct32(VxtManager vxtManager) { + return createGG3_struct32(vxtManager, null); } - static CppCompositeType createGG3_struct32(VbtManager vbtManager, CppCompositeType CC2_struct) { + static CppCompositeType createGG3_struct32(VxtManager vxtManager, CppCompositeType CC2_struct) { CppCompositeType GG3_struct = createStruct32("GG3", 12); try { if (CC2_struct == null) { - CC2_struct = createCC2_struct32(vbtManager); - CC2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CC2_struct = createCC2_struct32(vxtManager); + CC2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - GG3_struct.addDirectVirtualBaseClass(CC2_struct, 0, vbptr32, 1); + GG3_struct.addDirectVirtualBaseClass(CC2_struct, 0, vbtptr32, 1); GG3_struct.addMember("gg31", u4, false, 4); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return GG3_struct; } - //============================================================================================== - /* - * struct GG3 : virtual CC2 { - * int gg31; - * void gg3f(); - * }; - */ - static CppCompositeType createGG3_struct64(VbtManager vbtManager) { - return createGG3_struct64(vbtManager, null); + static CppCompositeType createGG3_struct64(VxtManager vxtManager) { + return createGG3_struct64(vxtManager, null); } - static CppCompositeType createGG3_struct64(VbtManager vbtManager, CppCompositeType CC2_struct) { + static CppCompositeType createGG3_struct64(VxtManager vxtManager, CppCompositeType CC2_struct) { CppCompositeType GG3_struct = createStruct64("GG3", 20); try { if (CC2_struct == null) { - CC2_struct = createCC2_struct64(vbtManager); - CC2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CC2_struct = createCC2_struct64(vxtManager); + CC2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - GG3_struct.addDirectVirtualBaseClass(CC2_struct, 0, vbptr64, 1); + GG3_struct.addDirectVirtualBaseClass(CC2_struct, 0, vbtptr64, 1); GG3_struct.addMember("gg31", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1491,51 +1417,44 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void gg5f(); * }; */ - static CppCompositeType createGG4_struct32(VbtManager vbtManager) { - return createGG4_struct32(vbtManager, null); + static CppCompositeType createGG4_struct32(VxtManager vxtManager) { + return createGG4_struct32(vxtManager, null); } - static CppCompositeType createGG4_struct32(VbtManager vbtManager, CppCompositeType CC3_struct) { + static CppCompositeType createGG4_struct32(VxtManager vxtManager, CppCompositeType CC3_struct) { CppCompositeType GG4_struct = createStruct32("GG4", 8); try { if (CC3_struct == null) { - CC3_struct = createCC3_struct32(vbtManager); - CC3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CC3_struct = createCC3_struct32(vxtManager); + CC3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - GG4_struct.addDirectVirtualBaseClass(CC3_struct, 0, vbptr32, 1); + GG4_struct.addDirectVirtualBaseClass(CC3_struct, 0, vbtptr32, 1); GG4_struct.addMember("gg41", u4, false, 4); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return GG4_struct; } - //============================================================================================== - /* - * struct GG4 : virtual CC3 { - * int gg41; - * void gg5f(); - * }; - */ - static CppCompositeType createGG4_struct64(VbtManager vbtManager) { - return createGG4_struct64(vbtManager, null); + static CppCompositeType createGG4_struct64(VxtManager vxtManager) { + return createGG4_struct64(vxtManager, null); } - static CppCompositeType createGG4_struct64(VbtManager vbtManager, CppCompositeType CC3_struct) { + static CppCompositeType createGG4_struct64(VxtManager vxtManager, CppCompositeType CC3_struct) { CppCompositeType GG4_struct = createStruct64("GG4", 16); try { if (CC3_struct == null) { - CC3_struct = createCC3_struct64(vbtManager); - CC3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CC3_struct = createCC3_struct64(vxtManager); + CC3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } - GG4_struct.addDirectVirtualBaseClass(CC3_struct, 0, vbptr64, 1); + GG4_struct.addDirectVirtualBaseClass(CC3_struct, 0, vbtptr64, 1); GG4_struct.addMember("gg41", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1549,105 +1468,98 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void _if(); * }; */ - static CppCompositeType createI_syntactic_struct32(VbtManager vbtManager) { - return createI_syntactic_struct32(vbtManager, null, null, null); + static CppCompositeType createI_syntactic_struct32(VxtManager vxtManager) { + return createI_syntactic_struct32(vxtManager, null, null, null); } - static CppCompositeType createI_syntactic_struct32(VbtManager vbtManager, + static CppCompositeType createI_syntactic_struct32(VxtManager vxtManager, CppCompositeType G_struct, CppCompositeType H_struct, CppCompositeType C_struct) { CppCompositeType I_struct = createStruct32("I", 0); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); + C_struct = createC_struct32(vxtManager); } // Could be problem if only one of G or H is null: won't have same C. if (G_struct == null) { - G_struct = createG_struct32(vbtManager, C_struct); + G_struct = createG_struct32(vxtManager, C_struct); } if (H_struct == null) { - H_struct = createH_struct32(vbtManager, C_struct); + H_struct = createH_struct32(vxtManager, C_struct); } I_struct.addDirectSyntacticBaseClass(G_struct); I_struct.addDirectSyntacticBaseClass(H_struct); I_struct.addMember("i1", u4, false, 0); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return I_struct; } - static CppCompositeType createI_struct32(VbtManager vbtManager) { - return createI_struct32(vbtManager, null, null, null); + static CppCompositeType createI_struct32(VxtManager vxtManager) { + return createI_struct32(vxtManager, null, null, null); } - static CppCompositeType createI_struct32(VbtManager vbtManager, CppCompositeType G_struct, + static CppCompositeType createI_struct32(VxtManager vxtManager, CppCompositeType G_struct, CppCompositeType H_struct, CppCompositeType C_struct) { CppCompositeType I_struct = createStruct32("I", 24); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } // Could be problem if only one of G or H is null: won't have same C. if (G_struct == null) { - G_struct = createG_struct32(vbtManager, C_struct); - G_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + G_struct = createG_struct32(vxtManager, C_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (H_struct == null) { - H_struct = createH_struct32(vbtManager, C_struct); - H_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + H_struct = createH_struct32(vxtManager, C_struct); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I_struct.addDirectBaseClass(G_struct, 0); I_struct.addDirectBaseClass(H_struct, 8); - I_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); + I_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); I_struct.addMember("i1", u4, false, 16); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return I_struct; } - //============================================================================================== - /* - * struct I : G, H { - * int i1; - * void _if(); - * }; - */ - static CppCompositeType createI_struct64(VbtManager vbtManager) { - return createI_struct64(vbtManager, null, null, null); + static CppCompositeType createI_struct64(VxtManager vxtManager) { + return createI_struct64(vxtManager, null, null, null); } - static CppCompositeType createI_struct64(VbtManager vbtManager, CppCompositeType G_struct, + static CppCompositeType createI_struct64(VxtManager vxtManager, CppCompositeType G_struct, CppCompositeType H_struct, CppCompositeType C_struct) { CppCompositeType I_struct = createStruct64("I", 44); try { if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } // Could be problem if only one of G or H is null: won't have same C. if (G_struct == null) { - G_struct = createG_struct64(vbtManager, C_struct); - G_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + G_struct = createG_struct64(vxtManager, C_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (H_struct == null) { - H_struct = createH_struct64(vbtManager, C_struct); - H_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + H_struct = createH_struct64(vxtManager, C_struct); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I_struct.addDirectBaseClass(G_struct, 0); I_struct.addDirectBaseClass(H_struct, 16); - I_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr64, 1); + I_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); I_struct.addMember("i1", u4, false, 32); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1661,83 +1573,76 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void _i1f(); * }; */ - static CppCompositeType createI1_struct32(VbtManager vbtManager) { - return createI1_struct32(vbtManager, null, null, null, null); + static CppCompositeType createI1_struct32(VxtManager vxtManager) { + return createI1_struct32(vxtManager, null, null, null, null); } - static CppCompositeType createI1_struct32(VbtManager vbtManager, CppCompositeType G1_struct, + static CppCompositeType createI1_struct32(VxtManager vxtManager, CppCompositeType G1_struct, CppCompositeType H_struct, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType I1_struct = createStruct32("I1", 28); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (G1_struct == null) { - G1_struct = createG1_struct32(vbtManager, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + G1_struct = createG1_struct32(vxtManager, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (H_struct == null) { - H_struct = createH_struct32(vbtManager, C_struct); - H_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + H_struct = createH_struct32(vxtManager, C_struct); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I1_struct.addDirectBaseClass(G1_struct, 0); I1_struct.addDirectBaseClass(H_struct, 8); - I1_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); - I1_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr32, 2); + I1_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); + I1_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); I1_struct.addMember("i11", u4, false, 16); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return I1_struct; } - //============================================================================================== - /* - * struct I1 : G1, H { - * int i11; - * void _i1f(); - * }; - */ - static CppCompositeType createI1_struct64(VbtManager vbtManager) { - return createI1_struct64(vbtManager, null, null, null, null); + static CppCompositeType createI1_struct64(VxtManager vxtManager) { + return createI1_struct64(vxtManager, null, null, null, null); } - static CppCompositeType createI1_struct64(VbtManager vbtManager, CppCompositeType G1_struct, + static CppCompositeType createI1_struct64(VxtManager vxtManager, CppCompositeType G1_struct, CppCompositeType H_struct, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType I1_struct = createStruct64("I1", 48); try { if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (G1_struct == null) { - G1_struct = createG1_struct64(vbtManager, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + G1_struct = createG1_struct64(vxtManager, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (H_struct == null) { - H_struct = createH_struct64(vbtManager, C_struct); - H_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + H_struct = createH_struct64(vxtManager, C_struct); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I1_struct.addDirectBaseClass(G1_struct, 0); I1_struct.addDirectBaseClass(H_struct, 16); - I1_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr64, 1); - I1_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr64, 2); + I1_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); + I1_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr64, 2); I1_struct.addMember("i11", u4, false, 32); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1751,83 +1656,76 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void _i2f(); * }; */ - static CppCompositeType createI2_struct32(VbtManager vbtManager) { - return createI2_struct32(vbtManager, null, null, null, null); + static CppCompositeType createI2_struct32(VxtManager vxtManager) { + return createI2_struct32(vxtManager, null, null, null, null); } - static CppCompositeType createI2_struct32(VbtManager vbtManager, CppCompositeType G_struct, + static CppCompositeType createI2_struct32(VxtManager vxtManager, CppCompositeType G_struct, CppCompositeType H1_struct, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType I2_struct = createStruct32("I2", 28); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (G_struct == null) { - G_struct = createG_struct32(vbtManager, C_struct); - G_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + G_struct = createG_struct32(vxtManager, C_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (H1_struct == null) { - H1_struct = createH1_struct32(vbtManager, E_struct, C_struct); - H1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + H1_struct = createH1_struct32(vxtManager, E_struct, C_struct); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I2_struct.addDirectBaseClass(G_struct, 0); I2_struct.addDirectBaseClass(H1_struct, 8); - I2_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); - I2_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr32, 2); + I2_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); + I2_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); I2_struct.addMember("i21", u4, false, 16); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return I2_struct; } - //============================================================================================== - /* - * struct I2 : G, H1 { - * int i21; - * void _i2f(); - * }; - */ - static CppCompositeType createI2_struct64(VbtManager vbtManager) { - return createI2_struct64(vbtManager, null, null, null, null); + static CppCompositeType createI2_struct64(VxtManager vxtManager) { + return createI2_struct64(vxtManager, null, null, null, null); } - static CppCompositeType createI2_struct64(VbtManager vbtManager, CppCompositeType G_struct, + static CppCompositeType createI2_struct64(VxtManager vxtManager, CppCompositeType G_struct, CppCompositeType H1_struct, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType I2_struct = createStruct64("I2", 48); try { if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (G_struct == null) { - G_struct = createG_struct64(vbtManager, C_struct); - G_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + G_struct = createG_struct64(vxtManager, C_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (H1_struct == null) { - H1_struct = createH1_struct64(vbtManager, E_struct, C_struct); - H1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + H1_struct = createH1_struct64(vxtManager, E_struct, C_struct); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I2_struct.addDirectBaseClass(G_struct, 0); I2_struct.addDirectBaseClass(H1_struct, 16); - I2_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr64, 1); - I2_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr64, 2); + I2_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); + I2_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr64, 2); I2_struct.addMember("i21", u4, false, 32); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1841,116 +1739,109 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void _i3f(); * }; */ - static CppCompositeType createI3_syntactic_struct32(VbtManager vbtManager) { - return createI3_syntactic_struct32(vbtManager, null, null, null, null); + static CppCompositeType createI3_syntactic_struct32(VxtManager vxtManager) { + return createI3_syntactic_struct32(vxtManager, null, null, null, null); } - static CppCompositeType createI3_syntactic_struct32(VbtManager vbtManager, + static CppCompositeType createI3_syntactic_struct32(VxtManager vxtManager, CppCompositeType G1_struct, CppCompositeType H1_struct, CppCompositeType E_struct, CppCompositeType C_struct) { CppCompositeType I3_struct = createStruct32("I3", 8); try { if (E_struct == null) { - E_struct = createE_struct32(vbtManager); + E_struct = createE_struct32(vxtManager); } if (C_struct == null) { - C_struct = createC_struct32(vbtManager); + C_struct = createC_struct32(vxtManager); } if (G1_struct == null) { - G1_struct = createG1_struct32(vbtManager, C_struct, E_struct); + G1_struct = createG1_struct32(vxtManager, C_struct, E_struct); } if (H1_struct == null) { - H1_struct = createH1_struct32(vbtManager, E_struct, C_struct); + H1_struct = createH1_struct32(vxtManager, E_struct, C_struct); } I3_struct.addDirectSyntacticBaseClass(G1_struct); I3_struct.addDirectSyntacticBaseClass(H1_struct); I3_struct.addMember("i31", u4, false, 0); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return I3_struct; } - static CppCompositeType createI3_struct32(VbtManager vbtManager) { - return createI3_struct32(vbtManager, null, null, null, null); + static CppCompositeType createI3_struct32(VxtManager vxtManager) { + return createI3_struct32(vxtManager, null, null, null, null); } - static CppCompositeType createI3_struct32(VbtManager vbtManager, CppCompositeType G1_struct, + static CppCompositeType createI3_struct32(VxtManager vxtManager, CppCompositeType G1_struct, CppCompositeType H1_struct, CppCompositeType E_struct, CppCompositeType C_struct) { CppCompositeType I3_struct = createStruct32("I3", 28); try { if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (G1_struct == null) { - G1_struct = createG1_struct32(vbtManager, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + G1_struct = createG1_struct32(vxtManager, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (H1_struct == null) { - H1_struct = createH1_struct32(vbtManager, E_struct, C_struct); - H1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + H1_struct = createH1_struct32(vxtManager, E_struct, C_struct); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I3_struct.addDirectBaseClass(G1_struct, 0); I3_struct.addDirectBaseClass(H1_struct, 8); - I3_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); - I3_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr32, 2); + I3_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); + I3_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); I3_struct.addMember("i31", u4, false, 16); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return I3_struct; } - //============================================================================================== - /* - * struct I3 : G1, H1 { - * int i31; - * void _i3f(); - * }; - */ - static CppCompositeType createI3_struct64(VbtManager vbtManager) { - return createI3_struct64(vbtManager, null, null, null, null); + static CppCompositeType createI3_struct64(VxtManager vxtManager) { + return createI3_struct64(vxtManager, null, null, null, null); } - static CppCompositeType createI3_struct64(VbtManager vbtManager, CppCompositeType G1_struct, + static CppCompositeType createI3_struct64(VxtManager vxtManager, CppCompositeType G1_struct, CppCompositeType H1_struct, CppCompositeType E_struct, CppCompositeType C_struct) { CppCompositeType I3_struct = createStruct64("I3", 48); try { if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (G1_struct == null) { - G1_struct = createG1_struct64(vbtManager, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + G1_struct = createG1_struct64(vxtManager, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (H1_struct == null) { - H1_struct = createH1_struct64(vbtManager, E_struct, C_struct); - H1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + H1_struct = createH1_struct64(vxtManager, E_struct, C_struct); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I3_struct.addDirectBaseClass(G1_struct, 0); I3_struct.addDirectBaseClass(H1_struct, 16); - I3_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr64, 1); - I3_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr64, 2); + I3_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); + I3_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr64, 2); I3_struct.addMember("i31", u4, false, 32); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -1964,33 +1855,33 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void _i4f(); * }; */ - static CppCompositeType createI4_struct32(VbtManager vbtManager) { - return createI4_struct32(vbtManager, null, null, null); + static CppCompositeType createI4_struct32(VxtManager vxtManager) { + return createI4_struct32(vxtManager, null, null, null); } - static CppCompositeType createI4_struct32(VbtManager vbtManager, CppCompositeType G1_struct, + static CppCompositeType createI4_struct32(VxtManager vxtManager, CppCompositeType G1_struct, CppCompositeType E_struct, CppCompositeType C_struct) { CppCompositeType I4_struct = createStruct32("I4", 20); try { if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (G1_struct == null) { - G1_struct = createG1_struct32(vbtManager, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + G1_struct = createG1_struct32(vxtManager, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I4_struct.addDirectBaseClass(G1_struct, 0); - I4_struct.addDirectVirtualBaseClass(E_struct, 0, vbptr32, 2); - I4_struct.addDirectVirtualBaseClass(C_struct, 0, vbptr32, 1); + I4_struct.addDirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); + I4_struct.addDirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); I4_struct.addMember("i41", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -2004,73 +1895,66 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void _i4f(); * }; */ - static CppCompositeType createI4_struct64(VbtManager vbtManager) { - return createI4_struct64(vbtManager, null, null, null); + static CppCompositeType createI4_struct64(VxtManager vxtManager) { + return createI4_struct64(vxtManager, null, null, null); } - static CppCompositeType createI4_struct64(VbtManager vbtManager, CppCompositeType G1_struct, + static CppCompositeType createI4_struct64(VxtManager vxtManager, CppCompositeType G1_struct, CppCompositeType E_struct, CppCompositeType C_struct) { CppCompositeType I4_struct = createStruct64("I4", 32); try { if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (G1_struct == null) { - G1_struct = createG1_struct64(vbtManager, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + G1_struct = createG1_struct64(vxtManager, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I4_struct.addDirectBaseClass(G1_struct, 0); - I4_struct.addDirectVirtualBaseClass(E_struct, 0, vbptr64, 2); - I4_struct.addDirectVirtualBaseClass(C_struct, 0, vbptr64, 1); + I4_struct.addDirectVirtualBaseClass(E_struct, 0, vbtptr64, 2); + I4_struct.addDirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); I4_struct.addMember("i41", u4, false, 16); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return I4_struct; } - //============================================================================================== - /* - * struct I5 : virtual E, virtual C, G1 { - * int i51; - * void _i5f(); - * }; - */ - static CppCompositeType createI5_struct32(VbtManager vbtManager) { - return createI5_struct32(vbtManager, null, null, null); + static CppCompositeType createI5_struct32(VxtManager vxtManager) { + return createI5_struct32(vxtManager, null, null, null); } - static CppCompositeType createI5_struct32(VbtManager vbtManager, CppCompositeType G1_struct, + static CppCompositeType createI5_struct32(VxtManager vxtManager, CppCompositeType G1_struct, CppCompositeType E_struct, CppCompositeType C_struct) { CppCompositeType I5_struct = createStruct32("I5", 20); try { if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (G1_struct == null) { - G1_struct = createG1_struct32(vbtManager, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + G1_struct = createG1_struct32(vxtManager, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I5_struct.addDirectBaseClass(G1_struct, 0); - I5_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr32, 2); // check this and I4...TODO - I5_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); + I5_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); // check this and I4...TODO + I5_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); I5_struct.addMember("i51", u4, false, 8); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -2084,86 +1968,79 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void _i5f(); * }; */ - static CppCompositeType createI5_struct64(VbtManager vbtManager) { - return createI5_struct64(null, null, null, vbtManager); + static CppCompositeType createI5_struct64(VxtManager vxtManager) { + return createI5_struct64(null, null, null, vxtManager); } static CppCompositeType createI5_struct64(CppCompositeType G1_struct, CppCompositeType E_struct, - CppCompositeType C_struct, VbtManager vbtManager) { + CppCompositeType C_struct, VxtManager vxtManager) { CppCompositeType I5_struct = createStruct64("I5", 32); try { if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (G1_struct == null) { - G1_struct = createG1_struct64(vbtManager, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + G1_struct = createG1_struct64(vxtManager, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } I5_struct.addDirectBaseClass(G1_struct, 0); - I5_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr64, 2); // check this and I4...TODO - I5_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr64, 1); + I5_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr64, 2); // check this and I4...TODO + I5_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); I5_struct.addMember("i51", u4, false, 16); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return I5_struct; } - //============================================================================================== - /* - * struct J1 : I1, I2 { - * int j11; - * void j1f(); - * }; - */ - static CppCompositeType createJ1_struct32(VbtManager vbtManager) { - return createJ1_struct32(vbtManager, null, null, null, null); + static CppCompositeType createJ1_struct32(VxtManager vxtManager) { + return createJ1_struct32(vxtManager, null, null, null, null); } - static CppCompositeType createJ1_struct32(VbtManager vbtManager, CppCompositeType I1_struct, + static CppCompositeType createJ1_struct32(VxtManager vxtManager, CppCompositeType I1_struct, CppCompositeType I2_struct, CppCompositeType E_struct, CppCompositeType C_struct) { CppCompositeType J1_struct = createStruct32("J1", 52); try { if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I1_struct == null) { - CppCompositeType G1_struct = createG1_struct32(vbtManager, C_struct, E_struct); - CppCompositeType H_struct = createH_struct32(vbtManager, C_struct); - I1_struct = createI1_struct32(vbtManager, G1_struct, H_struct, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - H_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - I1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct32(vxtManager, C_struct, E_struct); + CppCompositeType H_struct = createH_struct32(vxtManager, C_struct); + I1_struct = createI1_struct32(vxtManager, G1_struct, H_struct, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I2_struct == null) { - CppCompositeType G_struct = createG_struct32(vbtManager, C_struct); - CppCompositeType H1_struct = createH1_struct32(vbtManager, E_struct, C_struct); - I2_struct = createI2_struct32(vbtManager, G_struct, H1_struct, C_struct, E_struct); - G_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - H1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - I2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct32(vxtManager, C_struct); + CppCompositeType H1_struct = createH1_struct32(vxtManager, E_struct, C_struct); + I2_struct = createI2_struct32(vxtManager, G_struct, H1_struct, C_struct, E_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J1_struct.addDirectBaseClass(I1_struct, 0); J1_struct.addDirectBaseClass(I2_struct, 20); - J1_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); - J1_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr32, 2); + J1_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); + J1_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); J1_struct.addMember("j11", u4, false, 40); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -2177,100 +2054,93 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void j1f(); * }; */ - static CppCompositeType createJ1_struct64(VbtManager vbtManager) { - return createJ1_struct64(null, null, null, null, vbtManager); + static CppCompositeType createJ1_struct64(VxtManager vxtManager) { + return createJ1_struct64(null, null, null, null, vxtManager); } static CppCompositeType createJ1_struct64(CppCompositeType I1_struct, CppCompositeType I2_struct, CppCompositeType E_struct, CppCompositeType C_struct, - VbtManager vbtManager) { + VxtManager vxtManager) { CppCompositeType J1_struct = createStruct64("J1", 96); try { if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I1_struct == null) { - CppCompositeType G1_struct = createG1_struct64(vbtManager, C_struct, E_struct); - CppCompositeType H_struct = createH_struct64(vbtManager, C_struct); - I1_struct = createI1_struct64(vbtManager, G1_struct, H_struct, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - H_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - I1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct64(vxtManager, C_struct, E_struct); + CppCompositeType H_struct = createH_struct64(vxtManager, C_struct); + I1_struct = createI1_struct64(vxtManager, G1_struct, H_struct, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I2_struct == null) { - CppCompositeType G_struct = createG_struct64(vbtManager, C_struct); - CppCompositeType H1_struct = createH1_struct64(vbtManager, E_struct, C_struct); - I2_struct = createI2_struct64(vbtManager, G_struct, H1_struct, C_struct, E_struct); - G_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - H1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - I2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct64(vxtManager, C_struct); + CppCompositeType H1_struct = createH1_struct64(vxtManager, E_struct, C_struct); + I2_struct = createI2_struct64(vxtManager, G_struct, H1_struct, C_struct, E_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J1_struct.addDirectBaseClass(I1_struct, 0); J1_struct.addDirectBaseClass(I2_struct, 40); - J1_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr64, 1); - J1_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr64, 2); + J1_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); + J1_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr64, 2); J1_struct.addMember("j11", u4, false, 80); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return J1_struct; } - //============================================================================================== - /* - * struct J2 : I2, I1 { - * int j21; - * void j2f(); - * }; - */ - static CppCompositeType createJ2_struct32(VbtManager vbtManager) { - return createJ2_struct32(vbtManager, null, null, null, null); + static CppCompositeType createJ2_struct32(VxtManager vxtManager) { + return createJ2_struct32(vxtManager, null, null, null, null); } - static CppCompositeType createJ2_struct32(VbtManager vbtManager, CppCompositeType I2_struct, + static CppCompositeType createJ2_struct32(VxtManager vxtManager, CppCompositeType I2_struct, CppCompositeType I1_struct, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType J2_struct = createStruct32("J2", 52); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I2_struct == null) { - CppCompositeType G_struct = createG_struct32(vbtManager, C_struct); - CppCompositeType H1_struct = createH1_struct32(vbtManager, E_struct, C_struct); - I2_struct = createI2_struct32(vbtManager, G_struct, H1_struct, C_struct, E_struct); - G_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - H1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - I2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct32(vxtManager, C_struct); + CppCompositeType H1_struct = createH1_struct32(vxtManager, E_struct, C_struct); + I2_struct = createI2_struct32(vxtManager, G_struct, H1_struct, C_struct, E_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I1_struct == null) { - CppCompositeType G1_struct = createG1_struct32(vbtManager, C_struct, E_struct); - CppCompositeType H_struct = createH_struct32(vbtManager, C_struct); - I1_struct = createI1_struct32(vbtManager, G1_struct, H_struct, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - H_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - I1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct32(vxtManager, C_struct, E_struct); + CppCompositeType H_struct = createH_struct32(vxtManager, C_struct); + I1_struct = createI1_struct32(vxtManager, G1_struct, H_struct, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J2_struct.addDirectBaseClass(I2_struct, 0); J2_struct.addDirectBaseClass(I1_struct, 20); - J2_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); - J2_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr32, 2); + J2_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); + J2_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); J2_struct.addMember("j21", u4, false, 40); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -2284,105 +2154,98 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void j2f(); * }; */ - static CppCompositeType createJ2_struct64(VbtManager vbtManager) { - return createJ2_struct64(vbtManager, null, null, null, null); + static CppCompositeType createJ2_struct64(VxtManager vxtManager) { + return createJ2_struct64(vxtManager, null, null, null, null); } - static CppCompositeType createJ2_struct64(VbtManager vbtManager, CppCompositeType I2_struct, + static CppCompositeType createJ2_struct64(VxtManager vxtManager, CppCompositeType I2_struct, CppCompositeType I1_struct, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType J2_struct = createStruct64("J2", 96); try { if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I2_struct == null) { - CppCompositeType G_struct = createG_struct64(vbtManager, C_struct); - CppCompositeType H1_struct = createH1_struct64(vbtManager, E_struct, C_struct); - I2_struct = createI2_struct64(vbtManager, G_struct, H1_struct, C_struct, E_struct); - G_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - H1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - I2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct64(vxtManager, C_struct); + CppCompositeType H1_struct = createH1_struct64(vxtManager, E_struct, C_struct); + I2_struct = createI2_struct64(vxtManager, G_struct, H1_struct, C_struct, E_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I1_struct == null) { - CppCompositeType G1_struct = createG1_struct64(vbtManager, C_struct, E_struct); - CppCompositeType H_struct = createH_struct64(vbtManager, C_struct); - I1_struct = createI1_struct64(vbtManager, G1_struct, H_struct, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - H_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - I1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct64(vxtManager, C_struct, E_struct); + CppCompositeType H_struct = createH_struct64(vxtManager, C_struct); + I1_struct = createI1_struct64(vxtManager, G1_struct, H_struct, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J2_struct.addDirectBaseClass(I2_struct, 0); J2_struct.addDirectBaseClass(I1_struct, 40); - J2_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr64, 1); - J2_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr64, 2); + J2_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); + J2_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr64, 2); J2_struct.addMember("j21", u4, false, 80); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return J2_struct; } - //============================================================================================== - /* - * struct J3 : I2, I1, A { - * int j31; - * void j3f(); - * }; - */ - static CppCompositeType createJ3_struct32(VbtManager vbtManager) { - return createJ3_struct32(vbtManager, null, null, null, null, null); + static CppCompositeType createJ3_struct32(VxtManager vxtManager) { + return createJ3_struct32(vxtManager, null, null, null, null, null); } - static CppCompositeType createJ3_struct32(VbtManager vbtManager, CppCompositeType I2_struct, + static CppCompositeType createJ3_struct32(VxtManager vxtManager, CppCompositeType I2_struct, CppCompositeType I1_struct, CppCompositeType A_struct, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType J3_struct = createStruct32("J3", 60); try { if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I2_struct == null) { - CppCompositeType G_struct = createG_struct32(vbtManager, C_struct); - CppCompositeType H1_struct = createH1_struct32(vbtManager, E_struct, C_struct); - I2_struct = createI2_struct32(vbtManager, G_struct, H1_struct, C_struct, E_struct); - G_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - H1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - I2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct32(vxtManager, C_struct); + CppCompositeType H1_struct = createH1_struct32(vxtManager, E_struct, C_struct); + I2_struct = createI2_struct32(vxtManager, G_struct, H1_struct, C_struct, E_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I1_struct == null) { - CppCompositeType G1_struct = createG1_struct32(vbtManager, C_struct, E_struct); - CppCompositeType H_struct = createH_struct32(vbtManager, C_struct); - I1_struct = createI1_struct32(vbtManager, G1_struct, H_struct, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - H_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - I1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct32(vxtManager, C_struct, E_struct); + CppCompositeType H_struct = createH_struct32(vxtManager, C_struct); + I1_struct = createI1_struct32(vxtManager, G1_struct, H_struct, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (A_struct == null) { - A_struct = createA_struct32(vbtManager); - A_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + A_struct = createA_struct32(vxtManager); + A_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J3_struct.addDirectBaseClass(I2_struct, 0); J3_struct.addDirectBaseClass(I1_struct, 20); J3_struct.addDirectBaseClass(A_struct, 40); - J3_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); - J3_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr32, 2); + J3_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); + J3_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); J3_struct.addMember("j31", u4, false, 48); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -2396,138 +2259,131 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void j3f(); * }; */ - static CppCompositeType createJ3_struct64(VbtManager vbtManager) { - return createJ3_struct64(vbtManager, null, null, null, null, null); + static CppCompositeType createJ3_struct64(VxtManager vxtManager) { + return createJ3_struct64(vxtManager, null, null, null, null, null); } - static CppCompositeType createJ3_struct64(VbtManager vbtManager, CppCompositeType I2_struct, + static CppCompositeType createJ3_struct64(VxtManager vxtManager, CppCompositeType I2_struct, CppCompositeType I1_struct, CppCompositeType A_struct, CppCompositeType C_struct, CppCompositeType E_struct) { CppCompositeType J3_struct = createStruct64("J3", 104); try { if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I2_struct == null) { - CppCompositeType G_struct = createG_struct64(vbtManager, C_struct); - CppCompositeType H1_struct = createH1_struct64(vbtManager, E_struct, C_struct); - I2_struct = createI2_struct64(vbtManager, G_struct, H1_struct, C_struct, E_struct); - G_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - H1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - I2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct64(vxtManager, C_struct); + CppCompositeType H1_struct = createH1_struct64(vxtManager, E_struct, C_struct); + I2_struct = createI2_struct64(vxtManager, G_struct, H1_struct, C_struct, E_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I1_struct == null) { - CppCompositeType G1_struct = createG1_struct64(vbtManager, C_struct, E_struct); - CppCompositeType H_struct = createH_struct64(vbtManager, C_struct); - I1_struct = createI1_struct32(vbtManager, G1_struct, H_struct, C_struct, E_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - H_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - I1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct64(vxtManager, C_struct, E_struct); + CppCompositeType H_struct = createH_struct64(vxtManager, C_struct); + I1_struct = createI1_struct64(vxtManager, G1_struct, H_struct, C_struct, E_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (A_struct == null) { - A_struct = createA_struct64(vbtManager); - A_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + A_struct = createA_struct64(vxtManager); + A_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J3_struct.addDirectBaseClass(I2_struct, 0); J3_struct.addDirectBaseClass(I1_struct, 40); J3_struct.addDirectBaseClass(A_struct, 80); - J3_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr64, 1); - J3_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr64, 2); + J3_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); + J3_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr64, 2); J3_struct.addMember("j31", u4, false, 88); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return J3_struct; } - //============================================================================================== - /* - * struct J4 : I3, GG1, I, A, virtual GG2, virtual GG3 { - * int j41; - * void j4f(); - * }; - */ - static CppCompositeType createJ4_struct32(VbtManager vbtManager) { - return createJ4_struct32(vbtManager, null, null, null, null, null, null, null, null, null, + static CppCompositeType createJ4_struct32(VxtManager vxtManager) { + return createJ4_struct32(vxtManager, null, null, null, null, null, null, null, null, null, null); } - static CppCompositeType createJ4_struct32(VbtManager vbtManager, CppCompositeType I3_struct, + static CppCompositeType createJ4_struct32(VxtManager vxtManager, CppCompositeType I3_struct, CppCompositeType GG1_struct, CppCompositeType I_struct, CppCompositeType A_struct, CppCompositeType GG2_struct, CppCompositeType GG3_struct, CppCompositeType C_struct, CppCompositeType E_struct, CppCompositeType CC1_struct, CppCompositeType CC2_struct) { CppCompositeType J4_struct = createStruct32("J4", 92); try { if (A_struct == null) { - A_struct = createA_struct32(vbtManager); - A_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + A_struct = createA_struct32(vxtManager); + A_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC1_struct == null) { - CC1_struct = createCC1_struct32(vbtManager); - CC1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CC1_struct = createCC1_struct32(vxtManager); + CC1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC2_struct == null) { - CC2_struct = createCC2_struct32(vbtManager); - CC2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CC2_struct = createCC2_struct32(vxtManager); + CC2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I3_struct == null) { - CppCompositeType G1_struct = createG1_struct32(vbtManager, C_struct, E_struct); - CppCompositeType H1_struct = createH1_struct32(vbtManager, E_struct, C_struct); - I3_struct = createI3_struct32(vbtManager, G1_struct, H1_struct, E_struct, C_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - H1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - I3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct32(vxtManager, C_struct, E_struct); + CppCompositeType H1_struct = createH1_struct32(vxtManager, E_struct, C_struct); + I3_struct = createI3_struct32(vxtManager, G1_struct, H1_struct, E_struct, C_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG1_struct == null) { - GG1_struct = createGG1_struct32(vbtManager, CC1_struct); - GG1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + GG1_struct = createGG1_struct32(vxtManager, CC1_struct); + GG1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I_struct == null) { - CppCompositeType G_struct = createG_struct32(vbtManager, C_struct); - CppCompositeType H_struct = createH_struct32(vbtManager, C_struct); - I_struct = createI_struct32(vbtManager, G_struct, H_struct, C_struct); - G_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - H_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - I_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct32(vxtManager, C_struct); + CppCompositeType H_struct = createH_struct32(vxtManager, C_struct); + I_struct = createI_struct32(vxtManager, G_struct, H_struct, C_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG2_struct == null) { - GG2_struct = createGG2_struct32(vbtManager, CC2_struct); - GG2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + GG2_struct = createGG2_struct32(vxtManager, CC2_struct); + GG2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG3_struct == null) { - GG3_struct = createGG3_struct32(vbtManager, CC2_struct); - GG3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + GG3_struct = createGG3_struct32(vxtManager, CC2_struct); + GG3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J4_struct.addDirectBaseClass(I3_struct, 0); J4_struct.addDirectBaseClass(GG1_struct, 20); J4_struct.addDirectBaseClass(I_struct, 28); J4_struct.addDirectBaseClass(A_struct, 48); - J4_struct.addDirectVirtualBaseClass(GG2_struct, 0, vbptr32, 5); - J4_struct.addDirectVirtualBaseClass(GG3_struct, 0, vbptr32, 6); - J4_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); - J4_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr32, 2); - J4_struct.addIndirectVirtualBaseClass(CC1_struct, 0, vbptr32, 3); - J4_struct.addIndirectVirtualBaseClass(CC2_struct, 0, vbptr32, 4); + J4_struct.addDirectVirtualBaseClass(GG2_struct, 0, vbtptr32, 5); + J4_struct.addDirectVirtualBaseClass(GG3_struct, 0, vbtptr32, 6); + J4_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); + J4_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); + J4_struct.addIndirectVirtualBaseClass(CC1_struct, 0, vbtptr32, 3); + J4_struct.addIndirectVirtualBaseClass(CC2_struct, 0, vbtptr32, 4); J4_struct.addMember("j41", u4, false, 56); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -2541,98 +2397,91 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void j4f(); * }; */ - static CppCompositeType createJ4_struct64(VbtManager vbtManager) { - return createJ4_struct64(vbtManager, null, null, null, null, null, null, null, null, null, + static CppCompositeType createJ4_struct64(VxtManager vxtManager) { + return createJ4_struct64(vxtManager, null, null, null, null, null, null, null, null, null, null); } - static CppCompositeType createJ4_struct64(VbtManager vbtManager, CppCompositeType I3_struct, + static CppCompositeType createJ4_struct64(VxtManager vxtManager, CppCompositeType I3_struct, CppCompositeType GG1_struct, CppCompositeType I_struct, CppCompositeType A_struct, CppCompositeType GG2_struct, CppCompositeType GG3_struct, CppCompositeType C_struct, CppCompositeType E_struct, CppCompositeType CC1_struct, CppCompositeType CC2_struct) { CppCompositeType J4_struct = createStruct64("J4", 160); try { if (A_struct == null) { - A_struct = createA_struct64(vbtManager); - A_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + A_struct = createA_struct64(vxtManager); + A_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC1_struct == null) { - CC1_struct = createCC1_struct64(vbtManager); - CC1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CC1_struct = createCC1_struct64(vxtManager); + CC1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC2_struct == null) { - CC2_struct = createCC2_struct64(vbtManager); - CC2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CC2_struct = createCC2_struct64(vxtManager); + CC2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I3_struct == null) { - CppCompositeType G1_struct = createG1_struct64(vbtManager, C_struct, E_struct); - CppCompositeType H1_struct = createH1_struct64(vbtManager, E_struct, C_struct); - I3_struct = createI3_struct32(vbtManager, G1_struct, H1_struct, E_struct, C_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - H1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - I3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct64(vxtManager, C_struct, E_struct); + CppCompositeType H1_struct = createH1_struct64(vxtManager, E_struct, C_struct); + I3_struct = createI3_struct64(vxtManager, G1_struct, H1_struct, E_struct, C_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG1_struct == null) { - GG1_struct = createGG1_struct64(vbtManager, CC1_struct); - GG1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + GG1_struct = createGG1_struct64(vxtManager, CC1_struct); + GG1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I_struct == null) { - CppCompositeType G_struct = createG_struct64(vbtManager, C_struct); - CppCompositeType H_struct = createH_struct64(vbtManager, C_struct); - I_struct = createI_struct32(vbtManager, G_struct, H_struct, C_struct); - G_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - H_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - I_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct64(vxtManager, C_struct); + CppCompositeType H_struct = createH_struct64(vxtManager, C_struct); + I_struct = createI_struct64(vxtManager, G_struct, H_struct, C_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG2_struct == null) { - GG2_struct = createGG2_struct64(vbtManager, CC2_struct); - GG2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + GG2_struct = createGG2_struct64(vxtManager, CC2_struct); + GG2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG3_struct == null) { - GG3_struct = createGG3_struct64(vbtManager, CC2_struct); - GG3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + GG3_struct = createGG3_struct64(vxtManager, CC2_struct); + GG3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J4_struct.addDirectBaseClass(I3_struct, 0); J4_struct.addDirectBaseClass(GG1_struct, 40); J4_struct.addDirectBaseClass(I_struct, 56); J4_struct.addDirectBaseClass(A_struct, 96); - J4_struct.addDirectVirtualBaseClass(GG2_struct, 0, vbptr64, 5); - J4_struct.addDirectVirtualBaseClass(GG3_struct, 0, vbptr64, 6); - J4_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr64, 1); - J4_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr64, 2); - J4_struct.addIndirectVirtualBaseClass(CC1_struct, 0, vbptr64, 3); - J4_struct.addIndirectVirtualBaseClass(CC2_struct, 0, vbptr64, 4); + J4_struct.addDirectVirtualBaseClass(GG2_struct, 0, vbtptr64, 5); + J4_struct.addDirectVirtualBaseClass(GG3_struct, 0, vbtptr64, 6); + J4_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr64, 1); + J4_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr64, 2); + J4_struct.addIndirectVirtualBaseClass(CC1_struct, 0, vbtptr64, 3); + J4_struct.addIndirectVirtualBaseClass(CC2_struct, 0, vbtptr64, 4); J4_struct.addMember("j41", u4, false, 104); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return J4_struct; } - //============================================================================================== - /* - * struct J4 : virtual GG2, virtual GG3, I3, GG1, I, A { - * int j51; - * void j5f(); - * }; - */ - static CppCompositeType createJ5_syntactic_struct32(VbtManager vbtManager) { - return createJ5_syntactic_struct32(vbtManager, null, null, null, null, null, null, null, + static CppCompositeType createJ5_syntactic_struct32(VxtManager vxtManager) { + return createJ5_syntactic_struct32(vxtManager, null, null, null, null, null, null, null, null, null, null); } - static CppCompositeType createJ5_syntactic_struct32(VbtManager vbtManager, + static CppCompositeType createJ5_syntactic_struct32(VxtManager vxtManager, CppCompositeType I3_struct, CppCompositeType GG1_struct, CppCompositeType I_struct, CppCompositeType A_struct, CppCompositeType GG2_struct, CppCompositeType GG3_struct, CppCompositeType C_struct, CppCompositeType E_struct, CppCompositeType CC1_struct, @@ -2640,41 +2489,41 @@ public class CppCompositeTypeTest extends AbstractGenericTest { CppCompositeType J5_struct = createStruct32("J5", 0); // TODO need without size try { if (A_struct == null) { - A_struct = createA_syntactic_struct32(vbtManager); + A_struct = createA_syntactic_struct32(vxtManager); } if (C_struct == null) { - C_struct = createC_syntactic_struct32(vbtManager); + C_struct = createC_syntactic_struct32(vxtManager); } if (E_struct == null) { - E_struct = createE_syntactic_struct32(vbtManager); + E_struct = createE_syntactic_struct32(vxtManager); } if (CC1_struct == null) { - CC1_struct = createCC1_syntactic_struct32(vbtManager); + CC1_struct = createCC1_syntactic_struct32(vxtManager); } if (CC2_struct == null) { - CC2_struct = createCC2_syntactic_struct32(vbtManager); + CC2_struct = createCC2_syntactic_struct32(vxtManager); } if (I3_struct == null) { CppCompositeType G1_struct = - createG1_syntactic_struct32(vbtManager, C_struct, E_struct); + createG1_syntactic_struct32(vxtManager, C_struct, E_struct); CppCompositeType H1_struct = - createH1_syntactic_struct32(vbtManager, E_struct, C_struct); - I3_struct = createI3_syntactic_struct32(vbtManager, G1_struct, H1_struct, E_struct, + createH1_syntactic_struct32(vxtManager, E_struct, C_struct); + I3_struct = createI3_syntactic_struct32(vxtManager, G1_struct, H1_struct, E_struct, C_struct); } if (GG1_struct == null) { - GG1_struct = createGG1_syntactic_struct32(vbtManager, CC1_struct); + GG1_struct = createGG1_syntactic_struct32(vxtManager, CC1_struct); } if (I_struct == null) { - CppCompositeType G_struct = createG_syntactic_struct32(vbtManager, C_struct); - CppCompositeType H_struct = createH_syntactic_struct32(vbtManager, C_struct); - I_struct = createI_syntactic_struct32(vbtManager, G_struct, H_struct, C_struct); + CppCompositeType G_struct = createG_syntactic_struct32(vxtManager, C_struct); + CppCompositeType H_struct = createH_syntactic_struct32(vxtManager, C_struct); + I_struct = createI_syntactic_struct32(vxtManager, G_struct, H_struct, C_struct); } if (GG2_struct == null) { - GG2_struct = createGG2_syntactic_struct32(vbtManager, CC2_struct); + GG2_struct = createGG2_syntactic_struct32(vxtManager, CC2_struct); } if (GG3_struct == null) { - GG3_struct = createGG3_syntactic_struct32(vbtManager, CC2_struct); + GG3_struct = createGG3_syntactic_struct32(vxtManager, CC2_struct); } J5_struct.addVirtualSyntacticBaseClass(GG2_struct); J5_struct.addVirtualSyntacticBaseClass(GG3_struct); @@ -2685,7 +2534,7 @@ public class CppCompositeTypeTest extends AbstractGenericTest { J5_struct.addMember("j51", u4, false, 0); // TODO nned syntactic without index } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -2694,170 +2543,163 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //============================================================================================== /* - * struct J4 : virtual GG2, virtual GG3, I3, GG1, I, A { + * struct J5 : virtual GG2, virtual GG3, I3, GG1, I, A { * int j51; * void j5f(); * }; */ - static CppCompositeType createJ5_struct32(VbtManager vbtManager) { - return createJ5_struct32(vbtManager, null, null, null, null, null, null, null, null, null, + static CppCompositeType createJ5_struct32(VxtManager vxtManager) { + return createJ5_struct32(vxtManager, null, null, null, null, null, null, null, null, null, null); } - static CppCompositeType createJ5_struct32(VbtManager vbtManager, CppCompositeType I3_struct, + static CppCompositeType createJ5_struct32(VxtManager vxtManager, CppCompositeType I3_struct, CppCompositeType GG1_struct, CppCompositeType I_struct, CppCompositeType A_struct, CppCompositeType GG2_struct, CppCompositeType GG3_struct, CppCompositeType C_struct, CppCompositeType E_struct, CppCompositeType CC1_struct, CppCompositeType CC2_struct) { CppCompositeType J5_struct = createStruct32("J5", 92); try { if (A_struct == null) { - A_struct = createA_struct32(vbtManager); - A_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + A_struct = createA_struct32(vxtManager); + A_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct32(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + C_struct = createC_struct32(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct32(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + E_struct = createE_struct32(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC1_struct == null) { - CC1_struct = createCC1_struct32(vbtManager); - CC1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CC1_struct = createCC1_struct32(vxtManager); + CC1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC2_struct == null) { - CC2_struct = createCC2_struct32(vbtManager); - CC2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CC2_struct = createCC2_struct32(vxtManager); + CC2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I3_struct == null) { - CppCompositeType G1_struct = createG1_struct32(vbtManager, C_struct, E_struct); - CppCompositeType H1_struct = createH1_struct32(vbtManager, E_struct, C_struct); - I3_struct = createI3_struct32(vbtManager, G1_struct, H1_struct, E_struct, C_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - H1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - I3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct32(vxtManager, C_struct, E_struct); + CppCompositeType H1_struct = createH1_struct32(vxtManager, E_struct, C_struct); + I3_struct = createI3_struct32(vxtManager, G1_struct, H1_struct, E_struct, C_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG1_struct == null) { - GG1_struct = createGG1_struct32(vbtManager, CC1_struct); - GG1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + GG1_struct = createGG1_struct32(vxtManager, CC1_struct); + GG1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I_struct == null) { - CppCompositeType G_struct = createG_struct32(vbtManager, C_struct); - CppCompositeType H_struct = createH_struct32(vbtManager, C_struct); - I_struct = createI_struct32(vbtManager, G_struct, H_struct, C_struct); - G_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - H_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); - I_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct32(vxtManager, C_struct); + CppCompositeType H_struct = createH_struct32(vxtManager, C_struct); + I_struct = createI_struct32(vxtManager, G_struct, H_struct, C_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG2_struct == null) { - GG2_struct = createGG2_struct32(vbtManager, CC2_struct); - GG2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + GG2_struct = createGG2_struct32(vxtManager, CC2_struct); + GG2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG3_struct == null) { - GG3_struct = createGG3_struct32(vbtManager, CC2_struct); - GG3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + GG3_struct = createGG3_struct32(vxtManager, CC2_struct); + GG3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J5_struct.addDirectBaseClass(I3_struct, 0); J5_struct.addDirectBaseClass(GG1_struct, 20); J5_struct.addDirectBaseClass(I_struct, 28); J5_struct.addDirectBaseClass(A_struct, 48); - J5_struct.addDirectVirtualBaseClass(GG2_struct, 0, vbptr32, 4); - J5_struct.addDirectVirtualBaseClass(GG3_struct, 0, vbptr32, 5); - J5_struct.addIndirectVirtualBaseClass(CC2_struct, 0, vbptr32, 3); - J5_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); - J5_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr32, 2); - J5_struct.addIndirectVirtualBaseClass(CC1_struct, 0, vbptr32, 6); + J5_struct.addDirectVirtualBaseClass(GG2_struct, 0, vbtptr32, 4); + J5_struct.addDirectVirtualBaseClass(GG3_struct, 0, vbtptr32, 5); + J5_struct.addIndirectVirtualBaseClass(CC2_struct, 0, vbtptr32, 3); + J5_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); + J5_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); + J5_struct.addIndirectVirtualBaseClass(CC1_struct, 0, vbtptr32, 6); J5_struct.addMember("j51", u4, false, 56); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return J5_struct; } - //============================================================================================== - /* - * struct J4 : virtual GG2, virtual GG3, I3, GG1, I, A { - * int j51; - * void j5f(); - * }; - */ - static CppCompositeType createJ5_struct64(VbtManager vbtManager) { - return createJ5_struct64(vbtManager, null, null, null, null, null, null, null, null, null, + static CppCompositeType createJ5_struct64(VxtManager vxtManager) { + return createJ5_struct64(vxtManager, null, null, null, null, null, null, null, null, null, null); } - static CppCompositeType createJ5_struct64(VbtManager vbtManager, CppCompositeType I3_struct, + static CppCompositeType createJ5_struct64(VxtManager vxtManager, CppCompositeType I3_struct, CppCompositeType GG1_struct, CppCompositeType I_struct, CppCompositeType A_struct, CppCompositeType GG2_struct, CppCompositeType GG3_struct, CppCompositeType C_struct, CppCompositeType E_struct, CppCompositeType CC1_struct, CppCompositeType CC2_struct) { CppCompositeType J5_struct = createStruct64("J5", 164); try { if (A_struct == null) { - A_struct = createA_struct64(vbtManager); - A_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + A_struct = createA_struct64(vxtManager); + A_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (C_struct == null) { - C_struct = createC_struct64(vbtManager); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + C_struct = createC_struct64(vxtManager); + C_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (E_struct == null) { - E_struct = createE_struct64(vbtManager); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + E_struct = createE_struct64(vxtManager); + E_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC1_struct == null) { - CC1_struct = createCC1_struct64(vbtManager); - CC1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CC1_struct = createCC1_struct64(vxtManager); + CC1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC2_struct == null) { - CC2_struct = createCC2_struct64(vbtManager); - CC2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CC2_struct = createCC2_struct64(vxtManager); + CC2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I3_struct == null) { - CppCompositeType G1_struct = createG1_struct64(vbtManager, C_struct, E_struct); - CppCompositeType H1_struct = createH1_struct64(vbtManager, E_struct, C_struct); - I3_struct = createI3_struct32(vbtManager, G1_struct, H1_struct, E_struct, C_struct); - G1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - H1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - I3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct64(vxtManager, C_struct, E_struct); + CppCompositeType H1_struct = createH1_struct64(vxtManager, E_struct, C_struct); + I3_struct = createI3_struct64(vxtManager, G1_struct, H1_struct, E_struct, C_struct); + G1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG1_struct == null) { - GG1_struct = createGG1_struct32(vbtManager, CC1_struct); - GG1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + GG1_struct = createGG1_struct64(vxtManager, CC1_struct); + GG1_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (I_struct == null) { - CppCompositeType G_struct = createG_struct64(vbtManager, C_struct); - CppCompositeType H_struct = createH_struct64(vbtManager, C_struct); - I_struct = createI_struct32(vbtManager, G_struct, H_struct, C_struct); - G_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - H_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); - I_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct64(vxtManager, C_struct); + CppCompositeType H_struct = createH_struct64(vxtManager, C_struct); + I_struct = createI_struct64(vxtManager, G_struct, H_struct, C_struct); + G_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + H_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); + I_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG2_struct == null) { - GG2_struct = createGG2_struct64(vbtManager, CC2_struct); - GG2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + GG2_struct = createGG2_struct64(vxtManager, CC2_struct); + GG2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG3_struct == null) { - GG3_struct = createGG3_struct64(vbtManager, CC2_struct); - GG3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + GG3_struct = createGG3_struct64(vxtManager, CC2_struct); + GG3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J5_struct.addDirectBaseClass(I3_struct, 0); J5_struct.addDirectBaseClass(GG1_struct, 40); J5_struct.addDirectBaseClass(I_struct, 56); J5_struct.addDirectBaseClass(A_struct, 96); - J5_struct.addDirectVirtualBaseClass(GG2_struct, 0, vbptr32, 4); - J5_struct.addDirectVirtualBaseClass(GG3_struct, 0, vbptr32, 5); - J5_struct.addIndirectVirtualBaseClass(CC2_struct, 0, vbptr32, 3); - J5_struct.addIndirectVirtualBaseClass(C_struct, 0, vbptr32, 1); - J5_struct.addIndirectVirtualBaseClass(E_struct, 0, vbptr32, 2); - J5_struct.addIndirectVirtualBaseClass(CC1_struct, 0, vbptr32, 6); + J5_struct.addDirectVirtualBaseClass(GG2_struct, 0, vbtptr32, 4); + J5_struct.addDirectVirtualBaseClass(GG3_struct, 0, vbtptr32, 5); + J5_struct.addIndirectVirtualBaseClass(CC2_struct, 0, vbtptr32, 3); + J5_struct.addIndirectVirtualBaseClass(C_struct, 0, vbtptr32, 1); + J5_struct.addIndirectVirtualBaseClass(E_struct, 0, vbtptr32, 2); + J5_struct.addIndirectVirtualBaseClass(CC1_struct, 0, vbtptr32, 6); J5_struct.addMember("j51", u4, false, 104); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -2871,95 +2713,88 @@ public class CppCompositeTypeTest extends AbstractGenericTest { * void j6f(); * }; */ - static CppCompositeType createJ6_struct32(VbtManager vbtManager) { - return createJ6_struct32(vbtManager, null, null, null, null, null); + static CppCompositeType createJ6_struct32(VxtManager vxtManager) { + return createJ6_struct32(vxtManager, null, null, null, null, null); } - static CppCompositeType createJ6_struct32(VbtManager vbtManager, CppCompositeType A_struct, + static CppCompositeType createJ6_struct32(VxtManager vxtManager, CppCompositeType A_struct, CppCompositeType GG4_struct, CppCompositeType GG3_struct, CppCompositeType CC2_struct, CppCompositeType CC3_struct) { CppCompositeType J6_struct = createStruct32("J6", 36); try { if (A_struct == null) { - A_struct = createA_struct32(vbtManager); - A_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + A_struct = createA_struct32(vxtManager); + A_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC2_struct == null) { - CC2_struct = createCC2_struct32(vbtManager); - CC2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CC2_struct = createCC2_struct32(vxtManager); + CC2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC3_struct == null) { - CC3_struct = createCC3_struct32(vbtManager); - CC3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CC3_struct = createCC3_struct32(vxtManager); + CC3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG4_struct == null) { - GG4_struct = createGG4_struct32(vbtManager, CC3_struct); - GG4_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + GG4_struct = createGG4_struct32(vxtManager, CC3_struct); + GG4_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG3_struct == null) { - GG3_struct = createGG3_struct32(vbtManager, CC2_struct); - GG3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + GG3_struct = createGG3_struct32(vxtManager, CC2_struct); + GG3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J6_struct.addDirectBaseClass(A_struct, 0); - J6_struct.addDirectVirtualBaseClass(GG4_struct, 8, vbptr32, 2); - J6_struct.addDirectVirtualBaseClass(GG3_struct, 8, vbptr32, 4); - J6_struct.addIndirectVirtualBaseClass(CC3_struct, 8, vbptr32, 1); - J6_struct.addIndirectVirtualBaseClass(CC2_struct, 8, vbptr32, 3); + J6_struct.addDirectVirtualBaseClass(GG4_struct, 8, vbtptr32, 2); + J6_struct.addDirectVirtualBaseClass(GG3_struct, 8, vbtptr32, 4); + J6_struct.addIndirectVirtualBaseClass(CC3_struct, 8, vbtptr32, 1); + J6_struct.addIndirectVirtualBaseClass(CC2_struct, 8, vbtptr32, 3); J6_struct.addMember("j61", u4, false, 12); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } return J6_struct; } - //============================================================================================== - /* - * struct J6 : virtual GG4, virtual GG3, A { //GG4 has no members - * int j61; - * void j6f(); - * }; - */ - static CppCompositeType createJ6_struct64(VbtManager vbtManager) { - return createJ6_struct64(vbtManager, null, null, null, null, null); + static CppCompositeType createJ6_struct64(VxtManager vxtManager) { + return createJ6_struct64(vxtManager, null, null, null, null, null); } - static CppCompositeType createJ6_struct64(VbtManager vbtManager, CppCompositeType A_struct, + static CppCompositeType createJ6_struct64(VxtManager vxtManager, CppCompositeType A_struct, CppCompositeType GG4_struct, CppCompositeType GG3_struct, CppCompositeType CC2_struct, CppCompositeType CC3_struct) { CppCompositeType J6_struct = createStruct64("J6", 64); try { if (A_struct == null) { - A_struct = createA_struct64(vbtManager); - A_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + A_struct = createA_struct64(vxtManager); + A_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC2_struct == null) { - CC2_struct = createCC2_struct64(vbtManager); - CC2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CC2_struct = createCC2_struct64(vxtManager); + CC2_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (CC3_struct == null) { - CC3_struct = createCC3_struct64(vbtManager); - CC3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CC3_struct = createCC3_struct64(vxtManager); + CC3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG4_struct == null) { - GG4_struct = createGG4_struct64(vbtManager, CC3_struct); - GG4_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + GG4_struct = createGG4_struct64(vxtManager, CC3_struct); + GG4_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } if (GG3_struct == null) { - GG3_struct = createGG3_struct64(vbtManager, CC2_struct); - GG3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + GG3_struct = createGG3_struct64(vxtManager, CC2_struct); + GG3_struct.createLayout(classLayoutChoice, vxtManager, TaskMonitor.DUMMY); } J6_struct.addDirectBaseClass(A_struct, 0); - J6_struct.addDirectVirtualBaseClass(GG4_struct, 8, vbptr64, 2); - J6_struct.addDirectVirtualBaseClass(GG3_struct, 8, vbptr64, 4); - J6_struct.addIndirectVirtualBaseClass(CC3_struct, 8, vbptr64, 1); - J6_struct.addIndirectVirtualBaseClass(CC2_struct, 8, vbptr64, 3); + J6_struct.addDirectVirtualBaseClass(GG4_struct, 8, vbtptr64, 2); + J6_struct.addDirectVirtualBaseClass(GG3_struct, 8, vbtptr64, 4); + J6_struct.addIndirectVirtualBaseClass(CC3_struct, 8, vbtptr64, 1); + J6_struct.addIndirectVirtualBaseClass(CC2_struct, 8, vbtptr64, 3); J6_struct.addMember("j61", u4, false, 16); } catch (Exception e) { - String msg = "Error in static initialization of testt: " + e; + String msg = "Error in static initialization of test: " + e; Msg.error(null, msg); throw new AssertException(msg); } @@ -2986,16 +2821,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testA_32_vbt() throws Exception { - CppCompositeType A_struct = createA_struct32(pdbVbtManager32); - A_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType A_struct = createA_struct32(msftVxtManager32); + A_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = A_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedA_32(), composite, true); } @Test public void testA_32_speculative() throws Exception { - CppCompositeType A_struct = createA_struct32(vbtManager32); - A_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType A_struct = createA_struct32(vxtManager32); + A_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = A_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedA_32(), composite, true); } @@ -3042,16 +2877,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testA_64_vbt() throws Exception { - CppCompositeType A_struct = createA_struct64(pdbVbtManager64); - A_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType A_struct = createA_struct64(msftVxtManager64); + A_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = A_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedA_64(), composite, true); } @Test public void testA_64_speculative() throws Exception { - CppCompositeType A_struct = createA_struct64(vbtManager64); - A_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType A_struct = createA_struct64(vxtManager64); + A_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = A_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedA_64(), composite, true); } @@ -3096,16 +2931,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testC_32_vbt() throws Exception { - CppCompositeType C_struct = createC_struct32(pdbVbtManager32); - C_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType C_struct = createC_struct32(msftVxtManager32); + C_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = C_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedC_32(), composite, true); } @Test public void testC_32_speculative() throws Exception { - CppCompositeType C_struct = createC_struct32(vbtManager32); - C_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType C_struct = createC_struct32(vxtManager32); + C_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = C_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedC_32(), composite, true); } @@ -3149,16 +2984,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testC_64_vbt() throws Exception { - CppCompositeType C_struct = createC_struct64(pdbVbtManager64); - C_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType C_struct = createC_struct64(msftVxtManager64); + C_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = C_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedC_64(), composite, true); } @Test public void testC_64_speculative() throws Exception { - CppCompositeType C_struct = createC_struct64(vbtManager64); - C_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType C_struct = createC_struct64(vxtManager64); + C_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = C_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedC_64(), composite, true); } @@ -3202,16 +3037,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testCC1_32_vbt() throws Exception { - CppCompositeType CC1_struct = createCC1_struct32(pdbVbtManager32); - CC1_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType CC1_struct = createCC1_struct32(msftVxtManager32); + CC1_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = CC1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedCC1_32(), composite, true); } @Test public void testCC1_32_speculative() throws Exception { - CppCompositeType CC1_struct = createCC1_struct32(vbtManager32); - CC1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType CC1_struct = createCC1_struct32(vxtManager32); + CC1_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = CC1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedCC1_32(), composite, true); } @@ -3255,16 +3090,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testCC1_64_vbt() throws Exception { - CppCompositeType CC1_struct = createCC1_struct64(pdbVbtManager64); - CC1_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType CC1_struct = createCC1_struct64(msftVxtManager64); + CC1_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = CC1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedCC1_64(), composite, true); } @Test public void testCC1_64_speculative() throws Exception { - CppCompositeType CC1_struct = createCC1_struct64(vbtManager64); - CC1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType CC1_struct = createCC1_struct64(vxtManager64); + CC1_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = CC1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedCC1_64(), composite, true); } @@ -3308,16 +3143,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testCC2_32_vbt() throws Exception { - CppCompositeType CC2_struct = createCC2_struct32(pdbVbtManager32); - CC2_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType CC2_struct = createCC2_struct32(msftVxtManager32); + CC2_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = CC2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedCC2_32(), composite, true); } @Test public void testCC2_32_speculative() throws Exception { - CppCompositeType CC2_struct = createCC2_struct32(vbtManager32); - CC2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType CC2_struct = createCC2_struct32(vxtManager32); + CC2_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = CC2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedCC2_32(), composite, true); } @@ -3361,16 +3196,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testCC2_64_vbt() throws Exception { - CppCompositeType CC2_struct = createCC2_struct64(pdbVbtManager64); - CC2_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType CC2_struct = createCC2_struct64(msftVxtManager64); + CC2_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = CC2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedCC2_64(), composite, true); } @Test public void testCC2_64_speculative() throws Exception { - CppCompositeType CC2_struct = createCC2_struct64(vbtManager64); - CC2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType CC2_struct = createCC2_struct64(vxtManager64); + CC2_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = CC2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedCC2_64(), composite, true); } @@ -3412,16 +3247,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testCC3_32_vbt() throws Exception { - CppCompositeType CC3_struct = createCC3_struct32(pdbVbtManager32); - CC3_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType CC3_struct = createCC3_struct32(msftVxtManager32); + CC3_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = CC3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedCC3_32(), composite, true); } @Test public void testCC3_32_speculative() throws Exception { - CppCompositeType CC3_struct = createCC3_struct32(vbtManager32); - CC3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType CC3_struct = createCC3_struct32(vxtManager32); + CC3_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = CC3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedCC3_32(), composite, true); } @@ -3456,16 +3291,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testCC3_64_vbt() throws Exception { - CppCompositeType CC3_struct = createCC3_struct64(pdbVbtManager64); - CC3_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType CC3_struct = createCC3_struct64(msftVxtManager64); + CC3_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = CC3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedCC3_64(), composite, true); } @Test public void testCC3_64_speculative() throws Exception { - CppCompositeType CC3_struct = createCC3_struct64(vbtManager64); - CC3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType CC3_struct = createCC3_struct64(vxtManager64); + CC3_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = CC3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedCC3_64(), composite, true); } @@ -3505,16 +3340,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testD_32_vbt() throws Exception { - CppCompositeType D_struct = createD_struct32(pdbVbtManager32); - D_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType D_struct = createD_struct32(msftVxtManager32); + D_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = D_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedD_32(), composite, true); } @Test public void testD_32_speculative() throws Exception { - CppCompositeType D_struct = createD_struct32(vbtManager32); - D_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType D_struct = createD_struct32(vxtManager32); + D_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = D_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedD_32(), composite, true); } @@ -3568,16 +3403,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testD_64_vbt() throws Exception { - CppCompositeType D_struct = createD_struct64(pdbVbtManager64); - D_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType D_struct = createD_struct64(msftVxtManager64); + D_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = D_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedD_64(), composite, true); } @Test public void testD_64_speculative() throws Exception { - CppCompositeType D_struct = createD_struct64(vbtManager64); - D_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType D_struct = createD_struct64(vxtManager64); + D_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = D_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedD_64(), composite, true); } @@ -3628,16 +3463,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testE_32_vbt() throws Exception { - CppCompositeType E_struct = createE_struct32(pdbVbtManager32); - E_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType E_struct = createE_struct32(msftVxtManager32); + E_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = E_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedE_32(), composite, true); } @Test public void testE_32_speculative() throws Exception { - CppCompositeType E_struct = createE_struct32(vbtManager32); - E_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType E_struct = createE_struct32(vxtManager32); + E_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = E_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedE_32(), composite, true); } @@ -3681,16 +3516,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testE_64_vbt() throws Exception { - CppCompositeType E_struct = createE_struct64(pdbVbtManager64); - E_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType E_struct = createE_struct64(msftVxtManager64); + E_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = E_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedE_64(), composite, true); } @Test public void testE_64_speculative() throws Exception { - CppCompositeType E_struct = createE_struct64(vbtManager64); - E_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType E_struct = createE_struct64(vxtManager64); + E_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = E_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedE_64(), composite, true); } @@ -3740,16 +3575,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testF_32_vbt() throws Exception { - CppCompositeType F_struct = createF_struct32(pdbVbtManager32); - F_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType F_struct = createF_struct32(msftVxtManager32); + F_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = F_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedF_32(), composite, true); } @Test public void testF_32_speculative() throws Exception { - CppCompositeType F_struct = createF_struct32(vbtManager32); - F_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType F_struct = createF_struct32(vxtManager32); + F_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = F_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedF_32(), composite, true); } @@ -3813,16 +3648,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testF_64_vbt() throws Exception { - CppCompositeType F_struct = createF_struct64(pdbVbtManager64); - F_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType F_struct = createF_struct64(msftVxtManager64); + F_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = F_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedF_64(), composite, true); } @Test public void testF_64_speculative() throws Exception { - CppCompositeType F_struct = createF_struct64(vbtManager64); - F_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType F_struct = createF_struct64(vxtManager64); + F_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = F_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedF_64(), composite, true); } @@ -3890,16 +3725,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testG_32_vbt() throws Exception { - CppCompositeType G_struct = createG_struct32(pdbVbtManager32); - G_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct32(msftVxtManager32); + G_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = G_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedG_32(), composite, true); } @Test public void testG_32_speculative() throws Exception { - CppCompositeType G_struct = createG_struct32(vbtManager32); - G_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct32(vxtManager32); + G_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = G_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedG_32(), composite, true); } @@ -3962,16 +3797,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testG_64_vbt() throws Exception { - CppCompositeType G_struct = createG_struct64(pdbVbtManager64); - G_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct64(msftVxtManager64); + G_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = G_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedG_64(), composite, true); } @Test public void testG_64_speculative() throws Exception { - CppCompositeType G_struct = createG_struct64(vbtManager64); - G_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G_struct = createG_struct64(vxtManager64); + G_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = G_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedG_64(), composite, true); } @@ -4033,16 +3868,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testH_32_vbt() throws Exception { - CppCompositeType H_struct = createH_struct32(pdbVbtManager32); - H_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType H_struct = createH_struct32(msftVxtManager32); + H_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = H_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedH_32(), composite, true); } @Test public void testH_32_speculative() throws Exception { - CppCompositeType H_struct = createH_struct32(vbtManager32); - H_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType H_struct = createH_struct32(vxtManager32); + H_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = H_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedH_32(), composite, true); } @@ -4105,16 +3940,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testH_64_vbt() throws Exception { - CppCompositeType H_struct = createH_struct64(pdbVbtManager64); - H_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType H_struct = createH_struct64(msftVxtManager64); + H_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = H_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedH_64(), composite, true); } @Test public void testH_64_speculative() throws Exception { - CppCompositeType H_struct = createH_struct64(vbtManager64); - H_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType H_struct = createH_struct64(vxtManager64); + H_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = H_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedH_64(), composite, true); } @@ -4181,16 +4016,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testG1_32_vbt() throws Exception { - CppCompositeType G1_struct = createG1_struct32(pdbVbtManager32); - G1_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct32(msftVxtManager32); + G1_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = G1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedG1_32(), composite, true); } @Test public void testG1_32_speculative() throws Exception { - CppCompositeType G1_struct = createG1_struct32(vbtManager32); - G1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct32(vxtManager32); + G1_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = G1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedG1_32(), composite, true); } @@ -4265,16 +4100,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testG1_64_vbt() throws Exception { - CppCompositeType G1_struct = createG1_struct64(pdbVbtManager64); - G1_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct64(msftVxtManager64); + G1_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = G1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedG1_64(), composite, true); } @Test public void testG1_64_speculative() throws Exception { - CppCompositeType G1_struct = createG1_struct64(vbtManager64); - G1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType G1_struct = createG1_struct64(vxtManager64); + G1_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = G1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedG1_64(), composite, true); } @@ -4348,16 +4183,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testH1_32_vbt() throws Exception { - CppCompositeType H1_struct = createH1_struct32(pdbVbtManager32); - H1_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType H1_struct = createH1_struct32(msftVxtManager32); + H1_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = H1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedH1_32(), composite, true); } @Test public void testH1_32_speculative() throws Exception { - CppCompositeType H1_struct = createH1_struct32(vbtManager32); - H1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType H1_struct = createH1_struct32(vxtManager32); + H1_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = H1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedH1_32(), composite, true); } @@ -4432,16 +4267,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testH1_64_vbt() throws Exception { - CppCompositeType H1_struct = createH1_struct64(pdbVbtManager64); - H1_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType H1_struct = createH1_struct64(msftVxtManager64); + H1_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = H1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedH1_64(), composite, true); } @Test public void testH1_64_speculative() throws Exception { - CppCompositeType H1_struct = createH1_struct64(vbtManager64); - H1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType H1_struct = createH1_struct64(vxtManager64); + H1_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = H1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedH1_64(), composite, true); } @@ -4510,16 +4345,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testGG1_32_vbt() throws Exception { - CppCompositeType GG1_struct = createGG1_struct32(pdbVbtManager32); - GG1_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType GG1_struct = createGG1_struct32(msftVxtManager32); + GG1_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = GG1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedGG1_32(), composite, true); } @Test public void testGG1_32_speculative() throws Exception { - CppCompositeType GG1_struct = createGG1_struct32(vbtManager32); - GG1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType GG1_struct = createGG1_struct32(vxtManager32); + GG1_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = GG1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedGG1_32(), composite, true); } @@ -4582,16 +4417,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testGG1_64_vbt() throws Exception { - CppCompositeType GG1_struct = createGG1_struct64(pdbVbtManager64); - GG1_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType GG1_struct = createGG1_struct64(msftVxtManager64); + GG1_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = GG1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedGG1_64(), composite, true); } @Test public void testGG1_64_speculative() throws Exception { - CppCompositeType GG1_struct = createGG1_struct64(vbtManager64); - GG1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType GG1_struct = createGG1_struct64(vxtManager64); + GG1_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = GG1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedGG1_64(), composite, true); } @@ -4653,16 +4488,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testGG2_32_vbt() throws Exception { - CppCompositeType GG2_struct = createGG2_struct32(pdbVbtManager32); - GG2_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType GG2_struct = createGG2_struct32(msftVxtManager32); + GG2_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = GG2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedGG2_32(), composite, true); } @Test public void testGG2_32_speculative() throws Exception { - CppCompositeType GG2_struct = createGG2_struct32(vbtManager32); - GG2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType GG2_struct = createGG2_struct32(vxtManager32); + GG2_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = GG2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedGG2_32(), composite, true); } @@ -4725,16 +4560,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testGG2_64_vbt() throws Exception { - CppCompositeType GG2_struct = createGG2_struct64(pdbVbtManager64); - GG2_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType GG2_struct = createGG2_struct64(msftVxtManager64); + GG2_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = GG2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedGG2_64(), composite, true); } @Test public void testGG2_64_speculative() throws Exception { - CppCompositeType GG2_struct = createGG2_struct64(vbtManager64); - GG2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType GG2_struct = createGG2_struct64(vxtManager64); + GG2_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = GG2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedGG2_64(), composite, true); } @@ -4796,16 +4631,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testGG3_32_vbt() throws Exception { - CppCompositeType GG3_struct = createGG3_struct32(pdbVbtManager32); - GG3_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType GG3_struct = createGG3_struct32(msftVxtManager32); + GG3_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = GG3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedGG3_32(), composite, true); } @Test public void testGG3_32_speculative() throws Exception { - CppCompositeType GG3_struct = createGG3_struct32(vbtManager32); - GG3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType GG3_struct = createGG3_struct32(vxtManager32); + GG3_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = GG3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedGG3_32(), composite, true); } @@ -4868,16 +4703,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testGG3_64_vbt() throws Exception { - CppCompositeType GG3_struct = createGG3_struct64(pdbVbtManager64); - GG3_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType GG3_struct = createGG3_struct64(msftVxtManager64); + GG3_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = GG3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedGG3_64(), composite, true); } @Test public void testGG3_64_speculative() throws Exception { - CppCompositeType GG3_struct = createGG3_struct64(vbtManager64); - GG3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType GG3_struct = createGG3_struct64(vxtManager64); + GG3_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = GG3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedGG3_64(), composite, true); } @@ -4942,16 +4777,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { // the fact that CC3 is a zero-sized virtual parent. @Test public void testGG4_32_vbt() throws Exception { - CppCompositeType GG4_struct = createGG4_struct32(pdbVbtManager32); - GG4_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType GG4_struct = createGG4_struct32(msftVxtManager32); + GG4_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = GG4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedGG4_32(), composite, true); } @Test public void testGG4_32_speculative() throws Exception { - CppCompositeType GG4_struct = createGG4_struct32(vbtManager32); - GG4_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType GG4_struct = createGG4_struct32(vxtManager32); + GG4_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = GG4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedGG4_32(), composite, true); } @@ -5010,16 +4845,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { // the fact that CC3 is a zero-sized virtual parent. @Test public void testGG4_64_vbt() throws Exception { - CppCompositeType GG4_struct = createGG4_struct64(pdbVbtManager64); - GG4_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType GG4_struct = createGG4_struct64(msftVxtManager64); + GG4_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = GG4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedGG4_64(), composite, true); } @Test public void testGG4_64_speculative() throws Exception { - CppCompositeType GG4_struct = createGG4_struct64(vbtManager64); - GG4_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType GG4_struct = createGG4_struct64(vxtManager64); + GG4_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = GG4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedGG4_64(), composite, true); } @@ -5086,16 +4921,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI_32_vbt() throws Exception { - CppCompositeType I_struct = createI_struct32(pdbVbtManager32); - I_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType I_struct = createI_struct32(msftVxtManager32); + I_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = I_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI_32(), composite, true); } @Test public void testI_32_speculative() throws Exception { - CppCompositeType I_struct = createI_struct32(vbtManager32); - I_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType I_struct = createI_struct32(vxtManager32); + I_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = I_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI_32(), composite, true); } @@ -5188,16 +5023,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI_64_vbt() throws Exception { - CppCompositeType I_struct = createI_struct64(pdbVbtManager64); - I_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType I_struct = createI_struct64(msftVxtManager64); + I_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = I_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI_64(), composite, true); } @Test public void testI_64_speculative() throws Exception { - CppCompositeType I_struct = createI_struct64(vbtManager64); - I_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType I_struct = createI_struct64(vxtManager64); + I_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = I_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI_64(), composite, true); } @@ -5290,16 +5125,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI1_32_vbt() throws Exception { - CppCompositeType I1_struct = createI1_struct32(pdbVbtManager32); - I1_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType I1_struct = createI1_struct32(msftVxtManager32); + I1_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = I1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI1_32(), composite, true); } @Test public void testI1_32_speculative() throws Exception { - CppCompositeType I1_struct = createI1_struct32(vbtManager32); - I1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType I1_struct = createI1_struct32(vxtManager32); + I1_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = I1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI1_32(), composite, true); } @@ -5403,16 +5238,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI1_64_vbt() throws Exception { - CppCompositeType I1_struct = createI1_struct64(pdbVbtManager64); - I1_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType I1_struct = createI1_struct64(msftVxtManager64); + I1_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = I1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI1_64(), composite, true); } @Test public void testI1_64_speculative() throws Exception { - CppCompositeType I1_struct = createI1_struct64(vbtManager64); - I1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType I1_struct = createI1_struct64(vxtManager64); + I1_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = I1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI1_64(), composite, true); } @@ -5513,16 +5348,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI2_32_vbt() throws Exception { - CppCompositeType I2_struct = createI2_struct32(pdbVbtManager32); - I2_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType I2_struct = createI2_struct32(msftVxtManager32); + I2_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = I2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI2_32(), composite, true); } @Test public void testI2_32_speculative() throws Exception { - CppCompositeType I2_struct = createI2_struct32(vbtManager32); - I2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType I2_struct = createI2_struct32(vxtManager32); + I2_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = I2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI2_32(), composite, true); } @@ -5627,16 +5462,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI2_64_vbt() throws Exception { - CppCompositeType I2_struct = createI2_struct64(pdbVbtManager64); - I2_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType I2_struct = createI2_struct64(msftVxtManager64); + I2_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = I2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI2_64(), composite, true); } @Test public void testI2_64_speculative() throws Exception { - CppCompositeType I2_struct = createI2_struct64(vbtManager64); - I2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType I2_struct = createI2_struct64(vxtManager64); + I2_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = I2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI2_64(), composite, true); } @@ -5737,16 +5572,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI3_32_vbt() throws Exception { - CppCompositeType I3_struct = createI3_struct32(pdbVbtManager32); - I3_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType I3_struct = createI3_struct32(msftVxtManager32); + I3_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = I3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI3_32(), composite, true); } @Test public void testI3_32_speculative() throws Exception { - CppCompositeType I3_struct = createI3_struct32(vbtManager32); - I3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType I3_struct = createI3_struct32(vxtManager32); + I3_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = I3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI3_32(), composite, true); } @@ -5850,16 +5685,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI3_64_vbt() throws Exception { - CppCompositeType I3_struct = createI3_struct64(pdbVbtManager64); - I3_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType I3_struct = createI3_struct64(msftVxtManager64); + I3_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = I3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI3_64(), composite, true); } @Test public void testI3_64_speculative() throws Exception { - CppCompositeType I3_struct = createI3_struct64(vbtManager64); - I3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType I3_struct = createI3_struct64(vxtManager64); + I3_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = I3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI3_64(), composite, true); } @@ -5951,16 +5786,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI4_32_vbt() throws Exception { - CppCompositeType I4_struct = createI4_struct32(pdbVbtManager32); - I4_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType I4_struct = createI4_struct32(msftVxtManager32); + I4_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = I4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI4_32(), composite, true); } @Test public void testI4_32_speculative() throws Exception { - CppCompositeType I4_struct = createI4_struct32(vbtManager32); - I4_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType I4_struct = createI4_struct32(vxtManager32); + I4_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = I4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI4_32(), composite, true); } @@ -6046,16 +5881,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI4_64_vbt() throws Exception { - CppCompositeType I4_struct = createI4_struct64(pdbVbtManager64); - I4_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType I4_struct = createI4_struct64(msftVxtManager64); + I4_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = I4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI4_64(), composite, true); } @Test public void testI4_64_speculative() throws Exception { - CppCompositeType I4_struct = createI4_struct64(vbtManager64); - I4_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType I4_struct = createI4_struct64(vxtManager64); + I4_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = I4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI4_64(), composite, true); } @@ -6139,16 +5974,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI5_32_vbt() throws Exception { - CppCompositeType I5_struct = createI5_struct32(pdbVbtManager32); - I5_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType I5_struct = createI5_struct32(msftVxtManager32); + I5_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = I5_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedtI5_32(), composite, true); } @Test public void testI5_32_speculative() throws Exception { - CppCompositeType I5_struct = createI5_struct32(vbtManager32); - I5_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType I5_struct = createI5_struct32(vxtManager32); + I5_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = I5_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedtI5_32(), composite, true); } @@ -6276,16 +6111,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testI5_64_vbt() throws Exception { - CppCompositeType I5_struct = createI5_struct64(pdbVbtManager64); - I5_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType I5_struct = createI5_struct64(msftVxtManager64); + I5_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = I5_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedI5_64(), composite, true); } @Test public void testI5_64_speculative() throws Exception { - CppCompositeType I5_struct = createI5_struct64(vbtManager64); - I5_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType I5_struct = createI5_struct64(vxtManager64); + I5_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = I5_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedI5_64(), composite, true); } @@ -6443,16 +6278,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ1_32_vbt() throws Exception { - CppCompositeType J1_struct = createJ1_struct32(pdbVbtManager32); - J1_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType J1_struct = createJ1_struct32(msftVxtManager32); + J1_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = J1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ1_32(), composite, true); } @Test public void testJ1_32_speculative() throws Exception { - CppCompositeType J1_struct = createJ1_struct32(vbtManager32); - J1_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType J1_struct = createJ1_struct32(vxtManager32); + J1_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = J1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ1_32(), composite, true); } @@ -6615,16 +6450,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ1_64_vbt() throws Exception { - CppCompositeType J1_struct = createJ1_struct64(pdbVbtManager64); - J1_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType J1_struct = createJ1_struct64(msftVxtManager64); + J1_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = J1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ1_64(), composite, true); } @Test public void testJ1_64_speculative() throws Exception { - CppCompositeType J1_struct = createJ1_struct64(vbtManager64); - J1_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType J1_struct = createJ1_struct64(vxtManager64); + J1_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = J1_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ1_64(), composite, true); } @@ -6778,16 +6613,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ2_32_vbt() throws Exception { - CppCompositeType J2_struct = createJ2_struct32(pdbVbtManager32); - J2_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType J2_struct = createJ2_struct32(msftVxtManager32); + J2_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = J2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ2_32(), composite, true); } @Test public void testJ2_32_speculative() throws Exception { - CppCompositeType J2_struct = createJ2_struct32(vbtManager32); - J2_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType J2_struct = createJ2_struct32(vxtManager32); + J2_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = J2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ2_32(), composite, true); } @@ -6950,16 +6785,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ2_64_vbt() throws Exception { - CppCompositeType J2_struct = createJ2_struct64(pdbVbtManager64); - J2_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType J2_struct = createJ2_struct64(msftVxtManager64); + J2_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = J2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ2_64(), composite, true); } @Test public void testJ2_64_speculative() throws Exception { - CppCompositeType J2_struct = createJ2_struct64(vbtManager64); - J2_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType J2_struct = createJ2_struct64(vxtManager64); + J2_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = J2_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ2_64(), composite, true); } @@ -7118,16 +6953,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ3_32_vbt() throws Exception { - CppCompositeType J3_struct = createJ3_struct32(pdbVbtManager32); - J3_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType J3_struct = createJ3_struct32(msftVxtManager32); + J3_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = J3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ3_32(), composite, true); } @Test public void testJ3_32_speculative() throws Exception { - CppCompositeType J3_struct = createJ3_struct32(vbtManager32); - J3_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType J3_struct = createJ3_struct32(vxtManager32); + J3_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = J3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ3_32(), composite, true); } @@ -7303,16 +7138,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ3_64_vbt() throws Exception { - CppCompositeType J3_struct = createJ3_struct64(pdbVbtManager64); - J3_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType J3_struct = createJ3_struct64(msftVxtManager64); + J3_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = J3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ3_64(), composite, true); } @Test public void testJ3_64_speculative() throws Exception { - CppCompositeType J3_struct = createJ3_struct64(vbtManager64); - J3_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType J3_struct = createJ3_struct64(vxtManager64); + J3_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = J3_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ3_64(), composite, true); } @@ -7516,16 +7351,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ4_32_vbt() throws Exception { - CppCompositeType J4_struct = createJ4_struct32(pdbVbtManager32); - J4_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType J4_struct = createJ4_struct32(msftVxtManager32); + J4_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = J4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ4_32(), composite, true); } @Test public void testJ4_32_speculative() throws Exception { - CppCompositeType J4_struct = createJ4_struct32(vbtManager32); - J4_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType J4_struct = createJ4_struct32(vxtManager32); + J4_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = J4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ4_32(), composite, true); } @@ -7783,16 +7618,16 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ4_64_vbt() throws Exception { - CppCompositeType J4_struct = createJ4_struct64(pdbVbtManager64); - J4_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType J4_struct = createJ4_struct64(msftVxtManager64); + J4_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = J4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ4_64(), composite, true); } @Test public void testJ4_64_speculative() throws Exception { - CppCompositeType J4_struct = createJ4_struct64(vbtManager64); - J4_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType J4_struct = createJ4_struct64(vxtManager64); + J4_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = J4_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ4_64(), composite, true); } @@ -8034,8 +7869,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ5_32_vbt() throws Exception { - CppCompositeType J5_struct = createJ5_struct32(pdbVbtManager32); - J5_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType J5_struct = createJ5_struct32(msftVxtManager32); + J5_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = J5_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ5_32(), composite, true); } @@ -8044,8 +7879,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { // a decision on the best speculative results yet. // @Test public void testJ5_32_speculative() throws Exception { - CppCompositeType J5_struct = createJ5_struct32(vbtManager32); - J5_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType J5_struct = createJ5_struct32(vxtManager32); + J5_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = J5_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ5_32(), composite, true); } @@ -8309,8 +8144,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ5_64_vbt() throws Exception { - CppCompositeType J5_struct = createJ5_struct64(pdbVbtManager64); - J5_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType J5_struct = createJ5_struct64(msftVxtManager64); + J5_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = J5_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ5_64(), composite, true); } @@ -8319,8 +8154,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { // a decision on the best speculative results yet. // @Test public void testJ5_64_speculative() throws Exception { - CppCompositeType J5_struct = createJ5_struct64(vbtManager64); - J5_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType J5_struct = createJ5_struct64(vxtManager64); + J5_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = J5_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ5_64(), composite, true); } @@ -8514,8 +8349,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ6_32_vbt() throws Exception { - CppCompositeType J6_struct = createJ6_struct32(pdbVbtManager32); - J6_struct.createLayout(classLayoutChoice, pdbVbtManager32, TaskMonitor.DUMMY); + CppCompositeType J6_struct = createJ6_struct32(msftVxtManager32); + J6_struct.createLayout(classLayoutChoice, msftVxtManager32, TaskMonitor.DUMMY); Composite composite = J6_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ6_32(), composite, true); } @@ -8524,8 +8359,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { // a decision on the best speculative results yet. // @Test public void testJ6_32_speculative() throws Exception { - CppCompositeType J6_struct = createJ6_struct32(vbtManager32); - J6_struct.createLayout(classLayoutChoice, vbtManager32, TaskMonitor.DUMMY); + CppCompositeType J6_struct = createJ6_struct32(vxtManager32); + J6_struct.createLayout(classLayoutChoice, vxtManager32, TaskMonitor.DUMMY); Composite composite = J6_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ6_32(), composite, true); } @@ -8650,8 +8485,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { //@formatter:on @Test public void testJ6_64_vbt() throws Exception { - CppCompositeType J6_struct = createJ6_struct64(pdbVbtManager64); - J6_struct.createLayout(classLayoutChoice, pdbVbtManager64, TaskMonitor.DUMMY); + CppCompositeType J6_struct = createJ6_struct64(msftVxtManager64); + J6_struct.createLayout(classLayoutChoice, msftVxtManager64, TaskMonitor.DUMMY); Composite composite = J6_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getExpectedJ6_64(), composite, true); } @@ -8660,8 +8495,8 @@ public class CppCompositeTypeTest extends AbstractGenericTest { // a decision on the best speculative results yet. // @Test public void testJ6_64_speculative() throws Exception { - CppCompositeType J6_struct = createJ6_struct64(vbtManager64); - J6_struct.createLayout(classLayoutChoice, vbtManager64, TaskMonitor.DUMMY); + CppCompositeType J6_struct = createJ6_struct64(vxtManager64); + J6_struct.createLayout(classLayoutChoice, vxtManager64, TaskMonitor.DUMMY); Composite composite = J6_struct.getComposite(); CompositeTestUtils.assertExpectedComposite(this, getSpeculatedJ6_64(), composite, true); } @@ -8733,10 +8568,14 @@ public class CppCompositeTypeTest extends AbstractGenericTest { // @Test @Ignore public void testJ5_32_syntactic_layout() throws Exception { - CppCompositeType J5_struct = createJ5_syntactic_struct32(pdbVbtManager32); - J5_struct.createLayoutFromSyntacticDescription(pdbVbtManager32, TaskMonitor.DUMMY); +// SyntacticClass structJ5 = createSyntacticStructJ5(MsftVxtManager32); + // TODO: determine if we need a builder that inputs a SyntacticClass along with a + // data type manager (w/ data organization), along with layout options for creating + // data type (/class). + //structJ5.createLayoutFromSyntacticDescription(MsftVxtManager32, TaskMonitor.DUMMY); + // - //Composite composite = J5_struct.getComposite(); + //Composite composite = structJ5.getComposite(); //CompositeTestUtils.assertExpectedComposite(this, getExpectedJ5_32(), composite, true); }