diff --git a/Ghidra/Features/PDB/developer_scripts/pdbquery/PdbQuery.java b/Ghidra/Features/PDB/developer_scripts/pdbquery/PdbQuery.java index 5a8adbdc55..b5358adac4 100644 --- a/Ghidra/Features/PDB/developer_scripts/pdbquery/PdbQuery.java +++ b/Ghidra/Features/PDB/developer_scripts/pdbquery/PdbQuery.java @@ -122,8 +122,8 @@ public class PdbQuery { TaskMonitor monitor = script.getMonitor(); monitor.initialize(num); println(script, "Searching " + num + " PDB data type components..."); - for (int indexNumber = - tpi.getTypeIndexMin(); indexNumber < tpi.getTypeIndexMaxExclusive(); indexNumber++) { + for (int indexNumber = tpi.getTypeIndexMin(); indexNumber < tpi + .getTypeIndexMaxExclusive(); indexNumber++) { monitor.checkCanceled(); RecordNumber recordNumber = RecordNumber.typeRecordNumber(indexNumber); AbstractMsType typeRecord = pdb.getTypeRecord(recordNumber); @@ -161,8 +161,8 @@ public class PdbQuery { TaskMonitor monitor = script.getMonitor(); monitor.initialize(num); println(script, "Searching " + num + " PDB item type components..."); - for (int indexNumber = - ipi.getTypeIndexMin(); indexNumber < ipi.getTypeIndexMaxExclusive(); indexNumber++) { + for (int indexNumber = ipi.getTypeIndexMin(); indexNumber < ipi + .getTypeIndexMaxExclusive(); indexNumber++) { monitor.checkCanceled(); RecordNumber recordNumber = RecordNumber.itemRecordNumber(indexNumber); AbstractMsType typeRecord = pdb.getTypeRecord(recordNumber); @@ -188,17 +188,21 @@ public class PdbQuery { public static void searchSymbols(GhidraScript script, AbstractPdb pdb, String searchString) throws CancelledException { + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } + StringBuilder results = new StringBuilder(); results.append('\n'); - int numModules = pdb.getDebugInfo().getNumModules(); + int numModules = debugInfo.getNumModules(); TaskMonitor monitor = script.getMonitor(); int numSymbols = 0; for (int module = 0; module <= numModules; module++) { monitor.checkCanceled(); try { - Map symbols = - pdb.getDebugInfo().getModuleSymbolsByOffset(module); + Map symbols = debugInfo.getModuleSymbolsByOffset(module); numSymbols += symbols.size(); } catch (PdbException e) { @@ -211,8 +215,7 @@ public class PdbQuery { for (int module = 0; module <= numModules; module++) { monitor.checkCanceled(); try { - Map symbols = - pdb.getDebugInfo().getModuleSymbolsByOffset(module); + Map symbols = debugInfo.getModuleSymbolsByOffset(module); numSymbols += symbols.size(); for (Map.Entry entry : symbols.entrySet()) { monitor.checkCanceled(); diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractPdb.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractPdb.java index cf4da71875..931d9666ee 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractPdb.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractPdb.java @@ -86,9 +86,6 @@ public abstract class AbstractPdb implements AutoCloseable { protected boolean substreamsDeserialized = false; - //============================================================================================== - private TypeParser typeParser; - private SymbolParser symbolParser; //============================================================================================== // Ghidra-specific: private PdbReaderMetrics pdbReaderMetrics = new PdbReaderMetrics(this); @@ -141,7 +138,7 @@ public abstract class AbstractPdb implements AutoCloseable { } /** - * Returns the main {@link PdbIdentifiers} found in the PDB Directory. + * Returns the main {@link PdbIdentifiers} found in the PDB Directory. * @return {@link PdbIdentifiers} of information. * @throws IOException On file seek or read, invalid parameters, bad file configuration, or * inability to read required bytes. @@ -151,7 +148,7 @@ public abstract class AbstractPdb implements AutoCloseable { parseDBI(); if (debugInfo != null) { try { - // dbiAge and targetProcessor set during deserialization of new DBI header + // dbiAge and targetProcessor set during deserialization of new DBI header debugInfo.deserialize(true, TaskMonitor.DUMMY); } catch (CancelledException e) { @@ -198,22 +195,6 @@ public abstract class AbstractPdb implements AutoCloseable { PdbLog.message(pdbReaderMetrics::getPostProcessingReport); } - /** - * Returns the {@link TypeParser} created for this PDB. - * @return {@link TypeParser} for this PDB. - */ - public TypeParser getTypeParser() { - return typeParser; - } - - /** - * Returns the {@link SymbolParser} created for this PDB. - * @return {@link SymbolParser} for this PDB. - */ - public SymbolParser getSymbolParser() { - return symbolParser; - } - /** * Returns the Version Number of the PDB. * @return Version Number of the PDB. @@ -281,7 +262,7 @@ public abstract class AbstractPdb implements AutoCloseable { // TODO: this method should be package protected public void setTargetProcessor(Processor targetProcessorIn) { /** - * Should we allow an overwrite? The {@link PdbNewDebugInfo} value (mapped from + * Should we allow an overwrite? The {@link PdbNewDebugInfo} value (mapped from * {@link ImageFileMachine}) should be processed and laid down first. Subsequent values * can come from {@link AbstractCompile2MsSymbol} and {@link Compile3MsSymbol}. Note: * {@link PdbDebugInfo} does not carry {@link ImageFileMachine}, and thus no mapping @@ -312,7 +293,7 @@ public abstract class AbstractPdb implements AutoCloseable { /** * Returns the ItemProgramInterface (of type {@link AbstractTypeProgramInterface}) * component. - * @return ItemProgramInterface (of type {@link AbstractTypeProgramInterface}) component + * @return ItemProgramInterface (of type {@link AbstractTypeProgramInterface}) component * or null if not available. */ public AbstractTypeProgramInterface getItemProgramInterface() { @@ -327,14 +308,6 @@ public abstract class AbstractPdb implements AutoCloseable { return debugInfo; } - /** - * Returns the {@link SymbolRecords} component of the PDB. - * @return {@link SymbolRecords} component. - */ - public SymbolRecords getSymbolRecords() { - return debugInfo.getSymbolRecords(); - } - /** * Returns the record for the associated record number, which is expected to match the * desired class @@ -441,7 +414,7 @@ public abstract class AbstractPdb implements AutoCloseable { * @param monitor {@link TaskMonitor} used for checking cancellation. * @return Version number. * @throws IOException on file I/O issues. - * @throws PdbException on parsing issues. + * @throws PdbException on parsing issues. * @throws CancelledException Upon user cancellation. */ static int deserializeVersionNumber(AbstractMsf msf, TaskMonitor monitor) @@ -469,14 +442,11 @@ public abstract class AbstractPdb implements AutoCloseable { strings = new ArrayList<>(); parameters = new ArrayList<>(); nameTable = new NameTable(this); - - typeParser = new TypeParser(this); - symbolParser = new SymbolParser(this); } /** * Deserializes the main {@link PdbIdentifiers} found in the PDB Directory from the - * {@link PdbByteReader}. + * {@link PdbByteReader}. * @param monitor {@link TaskMonitor} used for checking cancellation. * @throws IOException On file seek or read, invalid parameters, bad file configuration, or * inability to read required bytes. @@ -494,7 +464,7 @@ public abstract class AbstractPdb implements AutoCloseable { return msf; } - //TODO Not sure if we will keep this method or if more gets added to it. + //TODO Not sure if we will keep this method or if more gets added to it. /** * Deserializes the sub-streams for this {@link AbstractPdb} object. * @param monitor {@link TaskMonitor} used for checking cancellation. diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractSymbolInformation.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractSymbolInformation.java index a2a4808330..4c442b1328 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractSymbolInformation.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractSymbolInformation.java @@ -168,7 +168,11 @@ public abstract class AbstractSymbolInformation { protected void generateSymbolsList(TaskMonitor monitor) throws PdbException, CancelledException { symbols = new ArrayList<>(); - Map symbolsByOffset = pdb.getDebugInfo().getSymbolsByOffset(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } + Map symbolsByOffset = debugInfo.getSymbolsByOffset(); for (SymbolHashRecord record : hashRecords) { monitor.checkCanceled(); long offset = record.getOffset() - 2; // Modified offset @@ -353,7 +357,7 @@ public abstract class AbstractSymbolInformation { } /** - * + * * @param reader {@link PdbByteReader} containing the data buffer to process. * @param monitor {@link TaskMonitor} used for checking cancellation. * @throws PdbException Upon not enough data left to parse. diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractTypeProgramInterface.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractTypeProgramInterface.java index 403c1d73a1..52519c52d2 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractTypeProgramInterface.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/AbstractTypeProgramInterface.java @@ -265,7 +265,6 @@ public abstract class AbstractTypeProgramInterface implements TPI { throws PdbException, CancelledException { int recordLength; int recordNumber = typeIndexMin; - TypeParser parser = pdb.getTypeParser(); while (reader.hasMore()) { monitor.checkCanceled(); @@ -279,8 +278,8 @@ public abstract class AbstractTypeProgramInterface implements TPI { // know which of the two to call, and we'd have to create an AbstractTypeIndex: // parseTypeRecordNumber(recordReader, recordNumber); // parseItemRecordNumber(recordReader, recordNumber); - AbstractMsType type = - parser.parseRecord(recordReader, RecordNumber.make(recordCategory, recordNumber)); + AbstractMsType type = TypeParser.parseRecord(pdb, recordReader, + RecordNumber.make(recordCategory, recordNumber)); typeList.add(type); recordNumber++; } @@ -392,7 +391,7 @@ public abstract class AbstractTypeProgramInterface implements TPI { throws IOException, PdbException, CancelledException { // I don't believe we need to parse and process the hash table. They seemingly are // used to point from a TypeIndex to a raw (byte[]) Type Record. We are not - // currently maintaining our records in this raw form; we are processing (parsing) + // currently maintaining our records in this raw form; we are processing (parsing) // them as we read each record buffer. // Note that we have no evidence of how the Auxiliary stream is used. Its // contents might need to get concatenated with the contents of the primary diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/DebugData.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/DebugData.java index 98456ad68e..5c61ac46ea 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/DebugData.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/DebugData.java @@ -137,7 +137,7 @@ public class DebugData { * each particular debug type (e.g., the first stream number read is for the stream containing * Frame Pointer Omission debug data). A stream number of 0XFFFF says that there is no data * for that debug type; else the stream number represents the stream that should - * be deserialized to retrieve the debug data of that type. The + * be deserialized to retrieve the debug data of that type. The * {@link #deserialize(TaskMonitor)} method deserializes each of these streams * that are valid to the corresponding debug data type. * @param reader {@link PdbByteReader} from which to parse the header. @@ -323,9 +323,10 @@ public class DebugData { // } // TODO: More work possible. See XData processing and notes there. This is very // incomplete. - if (pdb.getDebugInfo() instanceof PdbNewDebugInfo) { + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo instanceof PdbNewDebugInfo) { //Processor target = pdb.getTargetProcessor(); - PdbNewDebugInfo dbi = (PdbNewDebugInfo) pdb.getDebugInfo(); + PdbNewDebugInfo dbi = (PdbNewDebugInfo) debugInfo; ImageFileMachine machine = dbi.getMachineType(); switch (machine) { case IA64: diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/PdbReaderMetrics.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/PdbReaderMetrics.java index dcedf173fa..93bc44b346 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/PdbReaderMetrics.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/PdbReaderMetrics.java @@ -877,8 +877,12 @@ public class PdbReaderMetrics { } public void witnessedSectionSegmentNumber(int segment) { + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } if (numSegments == -1) { - numSegments = pdb.getDebugInfo().getSegmentMapList().size(); + numSegments = debugInfo.getSegmentMapList().size(); } if (segment < 0 || segment > numSegments) { PdbLog.message("segment " + segment + " out of range [0," + numSegments + ")"); diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/SymbolParser.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/SymbolParser.java index 9601ed2649..c5e7fce084 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/SymbolParser.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/SymbolParser.java @@ -26,35 +26,30 @@ import ghidra.util.exception.CancelledException; */ public class SymbolParser { - //============================================================================================== - // Internals - //============================================================================================== - private AbstractPdb pdb; - //============================================================================================== // API //============================================================================================== /** * Constructor. - * @param pdb {@link AbstractPdb} that owns the Symbols to be parsed. */ - public SymbolParser(AbstractPdb pdb) { - Objects.requireNonNull(pdb, "pdb cannot be null"); - this.pdb = pdb; + private SymbolParser() { } /** * Deserializes an {@link AbstractMsSymbol} from the {@link PdbByteReader} and returns it. + * @param pdb {@link AbstractPdb} that owns the Symbols to be parsed. * @param reader {@link PdbByteReader} from which to deserialize the symbol record. * @return {@link AbstractMsSymbol} that was parsed. * @throws PdbException upon error parsing a field. * @throws CancelledException Upon user cancellation. */ - public AbstractMsSymbol parse(PdbByteReader reader) throws PdbException, CancelledException { + public static AbstractMsSymbol parse(AbstractPdb pdb, PdbByteReader reader) + throws PdbException, CancelledException { + Objects.requireNonNull(pdb, "pdb cannot be null"); int symbolTypeId = reader.parseUnsignedShortVal(); AbstractMsSymbol symbol; try { - symbol = parseRecord(symbolTypeId, reader); + symbol = parseRecord(pdb, symbolTypeId, reader); } catch (PdbException e) { symbol = new BadMsSymbol(pdb, symbolTypeId); @@ -64,14 +59,15 @@ public class SymbolParser { /** * Deserializes an {@link AbstractMsSymbol} from the {@link PdbByteReader} and returns it. + * @param pdb {@link AbstractPdb} that owns the Symbols to be parsed. * @param symbolTypeId the PDB ID for the symbol type to be parsed. * @param reader {@link PdbByteReader} from which to deserialize the symbol record. * @return {@link AbstractMsSymbol} that was parsed. * @throws PdbException upon error parsing a field. * @throws CancelledException Upon user cancellation. */ - private AbstractMsSymbol parseRecord(int symbolTypeId, PdbByteReader reader) - throws PdbException, CancelledException { + private static AbstractMsSymbol parseRecord(AbstractPdb pdb, int symbolTypeId, + PdbByteReader reader) throws PdbException, CancelledException { pdb.getPdbReaderMetrics().witnessSymbolTypeId(symbolTypeId); diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/SymbolRecords.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/SymbolRecords.java index d1ae2dd177..5901a104cd 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/SymbolRecords.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/SymbolRecords.java @@ -76,11 +76,19 @@ public class SymbolRecords { int streamNumber; PdbByteReader reader; - streamNumber = pdb.getDebugInfo().getSymbolRecordsStreamNumber(); - reader = pdb.getReaderForStreamNumber(streamNumber, monitor); - symbolsByOffset = deserializeSymbolRecords(reader, monitor); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } + streamNumber = debugInfo.getSymbolRecordsStreamNumber(); + if (streamNumber <= 0) { + return; + } - for (AbstractModuleInformation module : pdb.getDebugInfo().moduleInformationList) { + reader = pdb.getReaderForStreamNumber(streamNumber, monitor); + symbolsByOffset = deserializeSymbolRecords(pdb, reader, monitor); + + for (AbstractModuleInformation module : debugInfo.moduleInformationList) { streamNumber = module.getStreamNumberDebugInformation(); if (streamNumber != 0xffff) { // System.out.println("\n\nStreamNumber: " + streamNumber); @@ -90,7 +98,7 @@ public class SymbolRecords { sizeDebug -= x; //TODO: seems right, but need to evaluate this PdbByteReader debugReader = reader.getSubPdbByteReader(sizeDebug); Map oneModuleSymbolsByOffset = - deserializeSymbolRecords(debugReader, monitor); + deserializeSymbolRecords(pdb, debugReader, monitor); moduleSymbolsByOffset.add(oneModuleSymbolsByOffset); // TODO: figure out the rest of the bytes in the stream // As of 20190618: feel that this is where we will find C11Lines or C13Lines @@ -109,27 +117,28 @@ public class SymbolRecords { * Deserializes the {@link AbstractMsSymbol} symbols from the {@link PdbByteReader} and * returns a {@link Map}<{@link Long},{@link AbstractMsSymbol}> of buffer offsets to * symbols. + * @param pdb {@link AbstractPdb} that owns the Symbols to be parsed. * @param reader {@link PdbByteReader} containing the symbol records to deserialize. * @param monitor {@link TaskMonitor} used for checking cancellation. * @return map of buffer offsets to {@link AbstractMsSymbol symbols}. * @throws PdbException Upon not enough data left to parse. * @throws CancelledException Upon user cancellation. */ - public Map deserializeSymbolRecords(PdbByteReader reader, - TaskMonitor monitor) throws PdbException, CancelledException { + public static Map deserializeSymbolRecords(AbstractPdb pdb, + PdbByteReader reader, TaskMonitor monitor) throws PdbException, CancelledException { + Objects.requireNonNull(pdb, "pdb cannot be null"); //System.out.println(reader.dump(0x400)); - SymbolParser parser = pdb.getSymbolParser(); Map mySymbolsByOffset = new TreeMap<>(); while (reader.hasMore()) { monitor.checkCanceled(); - // Including length in byte array for alignment purposes. + // Including length in byte array for alignment purposes. int offset = reader.getIndex(); int recordLength = reader.parseUnsignedShortVal(); PdbByteReader recordReader = reader.getSubPdbByteReader(recordLength); recordReader.markAlign(2); - AbstractMsSymbol symbol = parser.parse(recordReader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, recordReader); mySymbolsByOffset.put((long) offset, symbol); } return mySymbolsByOffset; diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/TypeParser.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/TypeParser.java index a8b09f944a..74a5532a77 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/TypeParser.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/TypeParser.java @@ -26,34 +26,28 @@ import ghidra.util.exception.CancelledException; */ public class TypeParser { - //============================================================================================== - // Internals - //============================================================================================== - protected AbstractPdb pdb; - //============================================================================================== // API //============================================================================================== /** * Constructor. - * @param pdb {@link AbstractPdb} that owns the Symbols to be parsed. */ - public TypeParser(AbstractPdb pdb) { - Objects.requireNonNull(pdb, "pdb cannot be null"); - this.pdb = pdb; + private TypeParser() { } /** * Deserializes an {@link AbstractMsType} from the {@link PdbByteReader} and returns it. + * @param pdb {@link AbstractPdb} that owns the Types to be parsed. * @param reader {@link PdbByteReader} from which to deserialize the data. * @param recordNumber {@link RecordNumber} of the record. * @return {@link AbstractMsType} parsed. * @throws PdbException upon error parsing a field. * @throws CancelledException Upon user cancellation. */ - public AbstractMsType parseRecord(PdbByteReader reader, RecordNumber recordNumber) - throws PdbException, CancelledException { - AbstractMsType result = parse(reader, AbstractMsType.class); + public static AbstractMsType parseRecord(AbstractPdb pdb, PdbByteReader reader, + RecordNumber recordNumber) throws PdbException, CancelledException { + Objects.requireNonNull(pdb, "pdb cannot be null"); + AbstractMsType result = parse(pdb, reader, AbstractMsType.class); result.setRecordNumber(recordNumber); return result; } @@ -61,25 +55,29 @@ public class TypeParser { /** * Deserializes an {@link AbstractMsType} from the {@link PdbByteReader} and returns it * as a {@link MsTypeField}. + * @param pdb {@link AbstractPdb} that owns the Types to be parsed. * @param reader {@link PdbByteReader} from which to deserialize the data. * @return {@link MsTypeField} parsed. * @throws PdbException upon error parsing a field. * @throws CancelledException Upon user cancellation. */ - public MsTypeField parseField(PdbByteReader reader) throws PdbException, CancelledException { - MsTypeField result = parse(reader, MsTypeField.class); + public static MsTypeField parseField(AbstractPdb pdb, PdbByteReader reader) + throws PdbException, CancelledException { + MsTypeField result = parse(pdb, reader, MsTypeField.class); return result; } /** * Deserializes an {@link AbstractMsType} from the {@link PdbByteReader} and returns it. + * @param pdb {@link AbstractPdb} that owns the Types to be parsed. * @param reader {@link PdbByteReader} from which to deserialize the data. * @return {@link AbstractMsType} parsed. * @throws PdbException upon error parsing dataTypeId. * @throws CancelledException Upon user cancellation. */ - public AbstractMsType parse(PdbByteReader reader) throws PdbException, CancelledException { - AbstractMsType result = parse(reader, AbstractMsType.class); + public static AbstractMsType parse(AbstractPdb pdb, PdbByteReader reader) + throws PdbException, CancelledException { + AbstractMsType result = parse(pdb, reader, AbstractMsType.class); return result; } @@ -89,18 +87,19 @@ public class TypeParser { * @param the required type to be returned. IMPORTANT: T must only be one of: * {@link AbstractMsType} or {@link MsTypeField} or something else in common with * {@link BadMsType}, otherwise a Bad Cast Exception might occur. + * @param pdb {@link AbstractPdb} that owns the Types to be parsed. * @param reader {@link PdbByteReader} from which to deserialize the data. - * @param requiredClass the required type to be returned. + * @param requiredClass the required type to be returned. * @return an instance of type T or type T version of BadMsType. IMPORTANT: See restriction * on T. * @throws PdbException upon error parsing dataTypeId. * @throws CancelledException Upon user cancellation. */ - private T parse(PdbByteReader reader, Class requiredClass) + private static T parse(AbstractPdb pdb, PdbByteReader reader, Class requiredClass) throws PdbException, CancelledException { int dataTypeId = reader.parseUnsignedShortVal(); try { - IdMsParsable parsable = parse(reader, dataTypeId); + IdMsParsable parsable = parse(pdb, reader, dataTypeId); if (requiredClass.isInstance(parsable)) { return requiredClass.cast(parsable); } @@ -114,13 +113,14 @@ public class TypeParser { /** * Deserializes an {@link AbstractMsType} from the {@link PdbByteReader} and returns it. + * @param pdb {@link AbstractPdb} that owns the Types to be parsed. * @param reader {@link PdbByteReader} from which to deserialize the data. * @param dataTypeId the PDB ID for the symbol type to be parsed. * @return {@link AbstractMsType} parsed. * @throws PdbException upon error parsing a field. * @throws CancelledException Upon user cancellation. */ - private IdMsParsable parse(PdbByteReader reader, int dataTypeId) + private static IdMsParsable parse(AbstractPdb pdb, PdbByteReader reader, int dataTypeId) throws PdbException, CancelledException { pdb.getPdbReaderMetrics().witnessDataTypeId(dataTypeId); @@ -418,7 +418,7 @@ public class TypeParser { type = new ManagedStMsType(pdb, reader); break; - // 0x1500 block + // 0x1500 block case TypeServerMsType.PDB_ID: type = new TypeServerMsType(pdb, reader); break; @@ -507,7 +507,7 @@ public class TypeParser { type = new VirtualFunctionTableMsType(pdb, reader); break; - // 0x1600 block + // 0x1600 block case FunctionIdMsType.PDB_ID: type = new FunctionIdMsType(pdb, reader); break; diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/symbol/DiscardedByLinkMsSymbol.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/symbol/DiscardedByLinkMsSymbol.java index 4d7e68cbf1..37555d445f 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/symbol/DiscardedByLinkMsSymbol.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/symbol/DiscardedByLinkMsSymbol.java @@ -95,7 +95,7 @@ public class DiscardedByLinkMsSymbol extends AbstractMsSymbol { // SymbolParser parser = new SymbolParser(pdb); // symbolList = parser.deserializeSymbolRecords(dataReader); symbolList = getOrderedSymbols( - pdb.getSymbolRecords().deserializeSymbolRecords(dataReader, TaskMonitor.DUMMY)); + SymbolRecords.deserializeSymbolRecords(pdb, dataReader, TaskMonitor.DUMMY)); } /** diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/AbstractFieldListMsType.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/AbstractFieldListMsType.java index 363439cbf7..133c6e6ec8 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/AbstractFieldListMsType.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/AbstractFieldListMsType.java @@ -51,8 +51,7 @@ public abstract class AbstractFieldListMsType extends AbstractMsType { throws PdbException, CancelledException { super(pdb, reader); while (reader.hasMore()) { - MsTypeField type = pdb.getTypeParser().parseField(reader); -// AbstractMsType type = pdb.getTypeParser().parse(reader); + MsTypeField type = TypeParser.parseField(pdb, reader); if ((type instanceof AbstractBaseClassMsType) || (type instanceof AbstractVirtualBaseClassMsType) || (type instanceof AbstractIndirectVirtualBaseClassMsType)) { @@ -85,7 +84,7 @@ public abstract class AbstractFieldListMsType extends AbstractMsType { } /** - * Returns the (ordered?) {@link List}<{@link AbstractMsType}> of base class types. + * Returns the (ordered?) {@link List}<{@link AbstractMsType}> of base class types. * @return List of base class types. */ public List getBaseClassList() { @@ -94,7 +93,7 @@ public abstract class AbstractFieldListMsType extends AbstractMsType { /** * Returns the (ordered?) {@link List}<{@link AbstractMsType}> of type members types of - * this field list. + * this field list. * @return Field list. */ public List getMemberList() { @@ -103,7 +102,7 @@ public abstract class AbstractFieldListMsType extends AbstractMsType { /** * Returns the (ordered?) {@link List}<{@link AbstractMsType}> of other types. (We have - * separated these out, but are unsure about what they are at this time.) + * separated these out, but are unsure about what they are at this time.) * @return List of other types. */ public List getMethodList() { diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/ReferencedSymbolMsType.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/ReferencedSymbolMsType.java index d8d02a63a0..5e4e16b8a0 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/ReferencedSymbolMsType.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/ReferencedSymbolMsType.java @@ -45,7 +45,7 @@ public class ReferencedSymbolMsType extends AbstractMsType { super(pdb, reader); int recordLength = reader.parseUnsignedShortVal(); PdbByteReader recordReader = reader.getSubPdbByteReader(recordLength); - symbolRecord = pdb.getSymbolParser().parse(recordReader); + symbolRecord = SymbolParser.parse(pdb, recordReader); } @Override diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbAddressManager.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbAddressManager.java index bd38adcff2..c6222a0175 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbAddressManager.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbAddressManager.java @@ -327,10 +327,14 @@ public class PdbAddressManager { // } private void determineMemoryBlocks() { - PdbDebugInfo dbi = applicator.getPdb().getDebugInfo(); - segmentMapList = dbi.getSegmentMapList(); - if (dbi instanceof PdbNewDebugInfo) { - DebugData debugData = ((PdbNewDebugInfo) dbi).getDebugData(); + AbstractPdb pdb = applicator.getPdb(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } + segmentMapList = debugInfo.getSegmentMapList(); + if (debugInfo instanceof PdbNewDebugInfo) { + DebugData debugData = ((PdbNewDebugInfo) debugInfo).getDebugData(); imageSectionHeaders = debugData.getImageSectionHeadersOrig(); if (imageSectionHeaders != null) { omapFromSource = debugData.getOmapFromSource(); @@ -504,6 +508,10 @@ public class PdbAddressManager { // pdb.getDebugInfo().getDebugData().getImageSectionHeader(); AbstractPdb pdb = applicator.getPdb(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } Program program = applicator.getProgram(); if (program == null) { return; @@ -511,7 +519,7 @@ public class PdbAddressManager { Memory mem = program.getMemory(); MemoryBlock[] blocks = mem.getBlocks(); - List segmentMapList = pdb.getDebugInfo().getSegmentMapList(); + List segmentMapList = debugInfo.getSegmentMapList(); /** * Program has additional "Headers" block set up by the {@link PeLoader}. */ @@ -570,7 +578,9 @@ public class PdbAddressManager { @SuppressWarnings("unused") // for method not being called. private boolean garnerSectionSegmentInformation() throws PdbException { AbstractPdb pdb = applicator.getPdb(); - if (pdb.getDebugInfo() == null) { + + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { return false; } @@ -578,10 +588,13 @@ public class PdbAddressManager { // pdb.getDebugInfo().getDebugData().getImageSectionHeader(); int num = 1; - for (AbstractModuleInformation module : pdb.getDebugInfo().getModuleInformationList()) { + for (AbstractModuleInformation module : debugInfo.getModuleInformationList()) { if ("* Linker *".equals(module.getModuleName())) { - List linkerSymbolList = - applicator.getSymbolGroupForModule(num).getSymbols(); + SymbolGroup symbolGroup = applicator.getSymbolGroupForModule(num); + if (symbolGroup == null) { + continue; // should not happen + } + List linkerSymbolList = symbolGroup.getSymbols(); for (AbstractMsSymbol symbol : linkerSymbolList) { if (symbol instanceof PeCoffSectionMsSymbol) { PeCoffSectionMsSymbol section = (PeCoffSectionMsSymbol) symbol; diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbApplicator.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbApplicator.java index 4964cdf0f4..9c77020b11 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbApplicator.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbApplicator.java @@ -377,12 +377,16 @@ public class PdbApplicator { private List createSymbolGroups() throws CancelledException, PdbException { List mySymbolGroups = new ArrayList<>(); - int num = pdb.getDebugInfo().getNumModules(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return mySymbolGroups; + } + + int num = debugInfo.getNumModules(); // moduleNumber zero is our global/public group. for (int moduleNumber = 0; moduleNumber <= num; moduleNumber++) { monitor.checkCanceled(); - Map symbols = - pdb.getDebugInfo().getModuleSymbolsByOffset(moduleNumber); + Map symbols = debugInfo.getModuleSymbolsByOffset(moduleNumber); SymbolGroup symbolGroup = new SymbolGroup(symbols, moduleNumber); mySymbolGroups.add(symbolGroup); } @@ -585,11 +589,16 @@ public class PdbApplicator { throws CancelledException, PdbException { List categoryNames = new ArrayList<>(); - int num = pdb.getDebugInfo().getNumModules(); - for (int index = 1; index <= num; index++) { - monitor.checkCanceled(); - String moduleName = pdb.getDebugInfo().getModuleInformation(index).getModuleName(); - categoryNames.add(moduleName); + + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo != null) { + + int num = debugInfo.getNumModules(); + for (int index = 1; index <= num; index++) { + monitor.checkCanceled(); + String moduleName = debugInfo.getModuleInformation(index).getModuleName(); + categoryNames.add(moduleName); + } } int index = pdbFilename.lastIndexOf("\\"); @@ -655,7 +664,13 @@ public class PdbApplicator { //============================================================================================== //============================================================================================== int findModuleNumberBySectionOffsetContribution(int section, long offset) throws PdbException { - for (AbstractSectionContribution sectionContribution : pdb.getDebugInfo().getSectionContributionList()) { + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + throw new PdbException("PDB: DebugInfo is null"); + } + + for (AbstractSectionContribution sectionContribution : debugInfo + .getSectionContributionList()) { int sectionContributionOffset = sectionContribution.getOffset(); int maxSectionContributionOffset = sectionContributionOffset + sectionContribution.getLength(); @@ -675,8 +690,8 @@ public class PdbApplicator { int num = tpi.getTypeIndexMaxExclusive() - tpi.getTypeIndexMin(); monitor.initialize(num); setMonitorMessage("PDB: Processing " + num + " data type components..."); - for (int indexNumber = - tpi.getTypeIndexMin(); indexNumber < tpi.getTypeIndexMaxExclusive(); indexNumber++) { + for (int indexNumber = tpi.getTypeIndexMin(); indexNumber < tpi + .getTypeIndexMaxExclusive(); indexNumber++) { monitor.checkCanceled(); //PdbResearch.checkBreak(indexNumber); MsTypeApplier applier = getTypeApplier(RecordNumber.typeRecordNumber(indexNumber)); @@ -742,8 +757,8 @@ public class PdbApplicator { int num = ipi.getTypeIndexMaxExclusive() - ipi.getTypeIndexMin(); monitor.initialize(num); setMonitorMessage("PDB: Processing " + num + " item type components..."); - for (int indexNumber = - ipi.getTypeIndexMin(); indexNumber < ipi.getTypeIndexMaxExclusive(); indexNumber++) { + for (int indexNumber = ipi.getTypeIndexMin(); indexNumber < ipi + .getTypeIndexMaxExclusive(); indexNumber++) { monitor.checkCanceled(); MsTypeApplier applier = getTypeApplier(RecordNumber.itemRecordNumber(indexNumber)); applier.apply(); @@ -785,8 +800,8 @@ public class PdbApplicator { setMonitorMessage("PDB: Resolving " + num + " data type components..."); Date start = new Date(); long longStart = start.getTime(); - for (int indexNumber = - tpi.getTypeIndexMin(); indexNumber < tpi.getTypeIndexMaxExclusive(); indexNumber++) { + for (int indexNumber = tpi.getTypeIndexMin(); indexNumber < tpi + .getTypeIndexMaxExclusive(); indexNumber++) { monitor.checkCanceled(); //PdbResearch.checkBreak(indexNumber); MsTypeApplier applier = getTypeApplier(RecordNumber.typeRecordNumber(indexNumber)); @@ -822,6 +837,9 @@ public class PdbApplicator { } SymbolGroup getSymbolGroupForModule(int moduleNumber) { + if (moduleNumber < 0 || moduleNumber >= symbolGroups.size()) { + return null; + } return symbolGroups.get(moduleNumber); } @@ -992,7 +1010,7 @@ public class PdbApplicator { @SuppressWarnings("unused") // for method not being called. /** * Process all symbols. User should not then call other methods: - * {@link #processGlobalSymbols()}, (@link #processPublicSymbols()}, and + * {@link #processGlobalSymbolsNoTypedefs()}, (@link #processPublicSymbols()}, and * {@link #processNonPublicOrGlobalSymbols()}. * @throws CancelledException upon user cancellation * @throws PdbException upon issue processing the request @@ -1007,6 +1025,9 @@ public class PdbApplicator { private void processMainSymbols() throws CancelledException, PdbException { // Get a count SymbolGroup symbolGroup = getSymbolGroup(); + if (symbolGroup == null) { + return; + } int totalCount = symbolGroup.size(); setMonitorMessage("PDB: Applying " + totalCount + " main symbol components..."); monitor.initialize(totalCount); @@ -1016,11 +1037,19 @@ public class PdbApplicator { //============================================================================================== private void processModuleSymbols() throws CancelledException { + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } + int totalCount = 0; - int num = pdb.getDebugInfo().getNumModules(); + int num = debugInfo.getNumModules(); for (int moduleNumber = 1; moduleNumber <= num; moduleNumber++) { monitor.checkCanceled(); SymbolGroup symbolGroup = getSymbolGroupForModule(moduleNumber); + if (symbolGroup == null) { + continue; // should not happen + } totalCount += symbolGroup.size(); } setMonitorMessage("PDB: Applying " + totalCount + " module symbol components..."); @@ -1031,6 +1060,9 @@ public class PdbApplicator { monitor.checkCanceled(); // Process module symbols list SymbolGroup symbolGroup = getSymbolGroupForModule(moduleNumber); + if (symbolGroup == null) { + continue; // should not happen + } AbstractMsSymbolIterator iter = symbolGroup.iterator(); processSymbolGroup(moduleNumber, iter); // catelogSymbols(index, symbolGroup); @@ -1073,10 +1105,17 @@ public class PdbApplicator { */ private void processPublicSymbols() throws CancelledException, PdbException { - SymbolGroup symbolGroup = getSymbolGroup(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } - PublicSymbolInformation publicSymbolInformation = - pdb.getDebugInfo().getPublicSymbolInformation(); + SymbolGroup symbolGroup = getSymbolGroup(); + if (symbolGroup == null) { + return; + } + + PublicSymbolInformation publicSymbolInformation = debugInfo.getPublicSymbolInformation(); List offsets = publicSymbolInformation.getModifiedHashRecordSymbolOffsets(); setMonitorMessage("PDB: Applying " + offsets.size() + " public symbol components..."); monitor.initialize(offsets.size()); @@ -1103,10 +1142,17 @@ public class PdbApplicator { */ private void processGlobalSymbolsNoTypedefs() throws CancelledException, PdbException { - SymbolGroup symbolGroup = getSymbolGroup(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } - GlobalSymbolInformation globalSymbolInformation = - pdb.getDebugInfo().getGlobalSymbolInformation(); + SymbolGroup symbolGroup = getSymbolGroup(); + if (symbolGroup == null) { + return; + } + + GlobalSymbolInformation globalSymbolInformation = debugInfo.getGlobalSymbolInformation(); List offsets = globalSymbolInformation.getModifiedHashRecordSymbolOffsets(); setMonitorMessage("PDB: Applying global symbols..."); monitor.initialize(offsets.size()); @@ -1134,10 +1180,17 @@ public class PdbApplicator { */ private void processGlobalTypdefSymbols() throws CancelledException, PdbException { - SymbolGroup symbolGroup = getSymbolGroup(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } - GlobalSymbolInformation globalSymbolInformation = - pdb.getDebugInfo().getGlobalSymbolInformation(); + SymbolGroup symbolGroup = getSymbolGroup(); + if (symbolGroup == null) { + return; + } + + GlobalSymbolInformation globalSymbolInformation = debugInfo.getGlobalSymbolInformation(); List offsets = globalSymbolInformation.getModifiedHashRecordSymbolOffsets(); setMonitorMessage("PDB: Applying typedefs..."); monitor.initialize(offsets.size()); @@ -1166,12 +1219,24 @@ public class PdbApplicator { */ @SuppressWarnings("unused") // for method not being called. private void processNonPublicOrGlobalSymbols() throws CancelledException, PdbException { - Set offsetsRemaining = getSymbolGroup().getOffsets(); - for (long off : pdb.getDebugInfo().getPublicSymbolInformation().getModifiedHashRecordSymbolOffsets()) { + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } + + SymbolGroup symbolGroup = getSymbolGroup(); + if (symbolGroup == null) { + return; + } + + Set offsetsRemaining = symbolGroup.getOffsets(); + for (long off : debugInfo.getPublicSymbolInformation() + .getModifiedHashRecordSymbolOffsets()) { monitor.checkCanceled(); offsetsRemaining.remove(off); } - for (long off : pdb.getDebugInfo().getGlobalSymbolInformation().getModifiedHashRecordSymbolOffsets()) { + for (long off : debugInfo.getGlobalSymbolInformation() + .getModifiedHashRecordSymbolOffsets()) { monitor.checkCanceled(); offsetsRemaining.remove(off); } @@ -1181,7 +1246,6 @@ public class PdbApplicator { monitor.initialize(offsetsRemaining.size()); //getCategoryUtils().setModuleTypedefsCategory(null); - SymbolGroup symbolGroup = getSymbolGroup(); AbstractMsSymbolIterator iter = symbolGroup.iterator(); for (long offset : offsetsRemaining) { monitor.checkCanceled(); @@ -1194,9 +1258,10 @@ public class PdbApplicator { //============================================================================================== private int findLinkerModuleNumber() { - if (pdb.getDebugInfo() != null) { + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo != null) { int num = 1; - for (AbstractModuleInformation module : pdb.getDebugInfo().getModuleInformationList()) { + for (AbstractModuleInformation module : debugInfo.getModuleInformationList()) { if (isLinkerModule(module.getModuleName())) { return num; } @@ -1242,16 +1307,24 @@ public class PdbApplicator { //============================================================================================== private void processThunkSymbolsFromNonLinkerModules() throws CancelledException { + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } + int linkerModuleNumber = findLinkerModuleNumber(); int totalCount = 0; - int num = pdb.getDebugInfo().getNumModules(); + int num = debugInfo.getNumModules(); for (int index = 1; index <= num; index++) { monitor.checkCanceled(); if (index == linkerModuleNumber) { continue; } SymbolGroup symbolGroup = getSymbolGroupForModule(index); + if (symbolGroup == null) { + continue; // should not happen + } totalCount += symbolGroup.size(); } setMonitorMessage("PDB: Processing module thunks..."); @@ -1264,6 +1337,9 @@ public class PdbApplicator { continue; } SymbolGroup symbolGroup = getSymbolGroupForModule(index); + if (symbolGroup == null) { + continue; // should not happen + } AbstractMsSymbolIterator iter = symbolGroup.iterator(); while (iter.hasNext()) { monitor.checkCanceled(); diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbResearch.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbResearch.java index ddc3441c8e..669506b80d 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbResearch.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbResearch.java @@ -334,8 +334,8 @@ public class PdbResearch { static void checkBreak(int recordNumber, MsTypeApplier applier) { String nn = applier.getMsType().getName(); - if ("std::__1::__map_value_compare,std::__1::__value_type,std::__1::basic_string >,std::__1::less,1>".equals( - nn)) { + if ("std::__1::__map_value_compare,std::__1::__value_type,std::__1::basic_string >,std::__1::less,1>" + .equals(nn)) { doNothingSetBreakPointHere(); } if ("class std::__1::__iostream_category".equals(nn)) { @@ -411,9 +411,18 @@ public class PdbResearch { //============================================================================================== static void childWalk(PdbApplicator applicator, TaskMonitor monitor) throws CancelledException, PdbException { + + PdbDebugInfo debugInfo = applicator.getPdb().getDebugInfo(); + if (debugInfo == null) { + return; + } + SymbolGroup symbolGroup = applicator.getSymbolGroup(); - GlobalSymbolInformation globalSymbolInformation = - applicator.getPdb().getDebugInfo().getGlobalSymbolInformation(); + if (symbolGroup == null) { + return; + } + + GlobalSymbolInformation globalSymbolInformation = debugInfo.getGlobalSymbolInformation(); List offsets = globalSymbolInformation.getModifiedHashRecordSymbolOffsets(); applicator.setMonitorMessage("PDB: Applying typedefs..."); monitor.initialize(offsets.size()); @@ -449,6 +458,9 @@ public class PdbResearch { ReferenceSymbolApplier refSymbolApplier = (ReferenceSymbolApplier) applier; AbstractMsSymbolIterator refIter = refSymbolApplier.getInitializedReferencedSymbolGroupIterator(); + if (refIter == null) { + throw new PdbException("PDB: Referenced Symbol Error - not refIter"); + } // recursion childWalkSym(applicator, refIter.getModuleNumber(), refIter); } @@ -616,10 +628,18 @@ public class PdbResearch { private static void processPublicSymbols(PdbApplicator applicator, Map> map, TaskMonitor monitor) throws CancelledException { AbstractPdb pdb = applicator.getPdb(); - SymbolGroup symbolGroup = applicator.getSymbolGroup(); - PublicSymbolInformation publicSymbolInformation = - pdb.getDebugInfo().getPublicSymbolInformation(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } + + SymbolGroup symbolGroup = applicator.getSymbolGroup(); + if (symbolGroup == null) { + return; + } + + PublicSymbolInformation publicSymbolInformation = debugInfo.getPublicSymbolInformation(); List offsets = publicSymbolInformation.getModifiedHashRecordSymbolOffsets(); applicator.setMonitorMessage( "PDB: Applying " + offsets.size() + " public symbol components..."); @@ -643,10 +663,18 @@ public class PdbResearch { private static void processGlobalSymbols(PdbApplicator applicator, Map> map, TaskMonitor monitor) throws CancelledException { AbstractPdb pdb = applicator.getPdb(); - SymbolGroup symbolGroup = applicator.getSymbolGroup(); - GlobalSymbolInformation globalSymbolInformation = - pdb.getDebugInfo().getGlobalSymbolInformation(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } + + SymbolGroup symbolGroup = applicator.getSymbolGroup(); + if (symbolGroup == null) { + return; + } + + GlobalSymbolInformation globalSymbolInformation = debugInfo.getGlobalSymbolInformation(); List offsets = globalSymbolInformation.getModifiedHashRecordSymbolOffsets(); applicator.setMonitorMessage("PDB: Applying global symbols..."); monitor.initialize(offsets.size()); @@ -669,8 +697,13 @@ public class PdbResearch { private static void processModuleSymbols(PdbApplicator applicator, Map> map, TaskMonitor monitor) throws CancelledException { AbstractPdb pdb = applicator.getPdb(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return; + } + int totalCount = 0; - int num = pdb.getDebugInfo().getNumModules(); + int num = debugInfo.getNumModules(); for (int moduleNumber = 1; moduleNumber <= num; moduleNumber++) { monitor.checkCanceled(); SymbolGroup symbolGroup = applicator.getSymbolGroupForModule(moduleNumber); @@ -679,8 +712,8 @@ public class PdbResearch { } totalCount += symbolGroup.size(); } - applicator.setMonitorMessage( - "PDB: Applying " + totalCount + " module symbol components..."); + applicator + .setMonitorMessage("PDB: Applying " + totalCount + " module symbol components..."); monitor.initialize(totalCount); // Process symbols list for each module @@ -867,7 +900,8 @@ public class PdbResearch { // if count is zero for a definition, then, the field list record // number refers to an actual field list. // So... seems we can trust forward reference and ignore count. - if (compType.getFieldDescriptorListRecordNumber() == RecordNumber.NO_TYPE) { + if (compType + .getFieldDescriptorListRecordNumber() == RecordNumber.NO_TYPE) { doNothingSetBreakPointHere(); } } @@ -912,7 +946,8 @@ public class PdbResearch { // the field list record number refers to an actual field // list. So... seems we can trust forward reference and // ignore count. - if (compType.getFieldDescriptorListRecordNumber() == RecordNumber.NO_TYPE) { + if (compType + .getFieldDescriptorListRecordNumber() == RecordNumber.NO_TYPE) { doNothingSetBreakPointHere(); } } diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbVbtManager.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbVbtManager.java index de7ec03920..6f04d45692 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbVbtManager.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/PdbVbtManager.java @@ -53,11 +53,20 @@ public class PdbVbtManager extends VbtManager { throws CancelledException { TaskMonitor monitor = applicator.getMonitor(); - SymbolGroup symbolGroup = applicator.getSymbolGroup(); Map myAddressByMangledName = new HashMap<>(); - PublicSymbolInformation publicSymbolInformation = - applicator.getPdb().getDebugInfo().getPublicSymbolInformation(); + AbstractPdb pdb = applicator.getPdb(); + PdbDebugInfo debugInfo = pdb.getDebugInfo(); + if (debugInfo == null) { + return myAddressByMangledName; + } + + SymbolGroup symbolGroup = applicator.getSymbolGroup(); + if (symbolGroup == null) { + return myAddressByMangledName; + } + + PublicSymbolInformation publicSymbolInformation = debugInfo.getPublicSymbolInformation(); List offsets = publicSymbolInformation.getModifiedHashRecordSymbolOffsets(); applicator.setMonitorMessage("PDB: Searching for virtual base table symbols..."); monitor.initialize(offsets.size()); diff --git a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ReferenceSymbolApplier.java b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ReferenceSymbolApplier.java index 3a6335ef2d..61511823ac 100644 --- a/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ReferenceSymbolApplier.java +++ b/Ghidra/Features/PDB/src/main/java/ghidra/app/util/pdb/pdbapplicator/ReferenceSymbolApplier.java @@ -53,11 +53,17 @@ public class ReferenceSymbolApplier extends MsSymbolApplier { void apply() throws CancelledException, PdbException { // Potential recursive call via applicator.procSym(). AbstractMsSymbolIterator refIter = getInitializedReferencedSymbolGroupIterator(); + if (refIter == null) { + throw new PdbException("PDB: Referenced Symbol Error - null refIter"); + } applicator.procSym(refIter); } AbstractMsSymbolIterator getInitializedReferencedSymbolGroupIterator() { SymbolGroup refSymbolGroup = getReferencedSymbolGroup(); + if (refSymbolGroup == null) { + return null; + } AbstractMsSymbolIterator refIter = refSymbolGroup.iterator(); refIter.initGetByOffset(getOffsetInReferencedSymbolGroup()); return refIter; diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/bin/format/pdb2/pdbreader/symbol/SymbolsTest.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/bin/format/pdb2/pdbreader/symbol/SymbolsTest.java index c93d522862..3533719c30 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/bin/format/pdb2/pdbreader/symbol/SymbolsTest.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/bin/format/pdb2/pdbreader/symbol/SymbolsTest.java @@ -15,8 +15,7 @@ */ package ghidra.app.util.bin.format.pdb2.pdbreader.symbol; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.fail; +import static org.junit.Assert.*; import java.math.BigInteger; @@ -36,7 +35,6 @@ public class SymbolsTest extends AbstractGenericTest { // assignment block), but we do not know the order that any tests are run, so having the // same value will ensure consistent results. private static Processor processor; - private static SymbolParser symbolParser; @BeforeClass public static void setUp() { @@ -45,13 +43,9 @@ public class SymbolsTest extends AbstractGenericTest { processor = Processor.I8080; pdb.setTargetProcessor(processor); - symbolParser = pdb.getSymbolParser(); - AbstractMsType type; - AbstractMsType item; - //PdbByteReader reader; // Create records that will be used indirectly - type = new DummyMsType(pdb, null); - item = new DummyMsType(pdb, null, "Item"); + AbstractMsType type = new DummyMsType(pdb, null); + AbstractMsType item = new DummyMsType(pdb, null, "Item"); //================================= // TPI Records @@ -249,7 +243,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0xffff); writer.putBytes(new byte[] { (byte) 0xfe, (byte) 0xfd, (byte) 0xfc }); // dummy data PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof UnknownMsSymbol, true); String result = symbol.toString().trim(); assertEquals("UNKNOWN_SYMBOL (0XFFFF): Bytes:\n" + "000000 fe fd fc", result); @@ -262,7 +256,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(0x00); // Processor value. // Incomplete record should cause BadMsSymbol to be created. PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof BadMsSymbol, true); String result = symbol.toString().trim(); assertEquals("BAD_SYMBOL: ID=0X0001", result); @@ -276,7 +270,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(new byte[] { 0x00, 0x00, 0x00 }); // 3 bytes of flags writer.putByteLengthPrefixedString("CompilerVersionString"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof CompileFlagsMsSymbol, true); String result = symbol.toString().trim(); assertEquals("COMPILE:\n" + " Language: C\n" + " Target Processor: 8080\n" + @@ -302,7 +296,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putNullTerminatedUtf8String("optionalString2"); // These are null term. writer.putUnsignedByte(0); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Compile2StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("COMPILE2_ST:\n" + " Language: C\n" + " Target Processor: 8080\n" + @@ -334,7 +328,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putNullTerminatedUtf8String("optionalString2"); // These are null term. writer.putUnsignedByte(0); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Compile2MsSymbol, true); String result = symbol.toString().trim(); assertEquals("COMPILE2:\n" + " Language: C\n" + " Target Processor: 8080\n" + @@ -365,7 +359,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x0008); // back end QFE version number writer.putNullTerminatedUtf8String("CompilerVersionString"); // These are null term. PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Compile3MsSymbol, true); String result = symbol.toString().trim(); assertEquals("COMPILE3:\n" + " Language: C\n" + " Target Processor: 8080\n" + @@ -391,7 +385,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putNullTerminatedUtf8String("optionalString4"); writer.putUnsignedByte(0); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof EnvironmentBlockMsSymbol, true); String result = symbol.toString().trim(); assertEquals("ENVBLOCK:\n" + "Compiled for edit and continue: no\n" + "Command block: \n" + @@ -407,7 +401,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x0102); // Register enumerate writer.putByteLengthPrefixedUtf8String("registerSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Register16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("REGISTER_16: al:cl, Type: DummyMsType, registerSymbolName", result); @@ -421,7 +415,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Register enumerate writer.putByteLengthPrefixedUtf8String("registerSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof RegisterStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("REGISTER_ST: al, Type: DummyMsType, registerSymbolName", result); @@ -435,7 +429,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Register enumerate writer.putNullTerminatedUtf8String("registerSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof RegisterMsSymbol, true); String result = symbol.toString().trim(); assertEquals("REGISTER: al, Type: DummyMsType, registerSymbolName", result); @@ -449,7 +443,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Value writer.putByteLengthPrefixedUtf8String("constantSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Constant16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("CONSTANT_16: Type: DummyMsType, Value: 1, constantSymbolName", result); @@ -463,7 +457,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Value writer.putByteLengthPrefixedUtf8String("constantSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ConstantStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("CONSTANT_ST: Type: DummyMsType, Value: 1, constantSymbolName", result); @@ -477,7 +471,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Value writer.putNullTerminatedUtf8String("constantSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ConstantMsSymbol, true); String result = symbol.toString().trim(); assertEquals("CONSTANT: Type: DummyMsType, Value: 1, constantSymbolName", result); @@ -491,7 +485,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Value writer.putNullTerminatedUtf8String("constantSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManagedConstantMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANCONSTANT: Type: DummyMsType, Value: 1, constantSymbolName", result); @@ -504,7 +498,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index containing enum if enumerate writer.putByteLengthPrefixedUtf8String("UDTSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof UserDefinedType16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("UDT_16: DummyMsType, UDTSymbolName", result); @@ -517,7 +511,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // Type index containing enum if enumerate writer.putByteLengthPrefixedUtf8String("UDTSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof UserDefinedTypeStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("UDT_ST: DummyMsType, UDTSymbolName", result); @@ -530,7 +524,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // Type index containing enum if enumerate writer.putNullTerminatedUtf8String("UDTSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof UserDefinedTypeMsSymbol, true); String result = symbol.toString().trim(); assertEquals("UDT: DummyMsType, UDTSymbolName", result); @@ -543,7 +537,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index containing enum if enumerate writer.putByteLengthPrefixedUtf8String("CobolUDTSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof CobolUserDefinedType16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("COBOLUDT_16: DummyMsType, CobolUDTSymbolName", result); @@ -556,7 +550,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // Type index containing enum if enumerate writer.putByteLengthPrefixedUtf8String("CobolUDTSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof CobolUserDefinedTypeStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("COBOLUDT_ST: DummyMsType, CobolUDTSymbolName", result); @@ -569,7 +563,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // Type index containing enum if enumerate writer.putNullTerminatedUtf8String("CobolUDTSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof CobolUserDefinedTypeMsSymbol, true); String result = symbol.toString().trim(); assertEquals("COBOLUDT: DummyMsType, CobolUDTSymbolName", result); @@ -582,7 +576,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(0x100); // Offset of the procedure writer.putUnsignedShort(0x1); // Setment of the symbol PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof StartSearchMsSymbol, true); String result = symbol.toString().trim(); assertEquals("Start search for segment 0x1 at 0x100", result); @@ -593,7 +587,7 @@ public class SymbolsTest extends AbstractGenericTest { PdbByteWriter writer = new PdbByteWriter(); writer.putUnsignedShort(EndMsSymbol.PDB_ID); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof EndMsSymbol, true); String result = symbol.toString().trim(); assertEquals("END", result); @@ -605,7 +599,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(SkipMsSymbol.PDB_ID); writer.putBytes(new byte[] { 0x00, 0x00 }); // Putting data, but might never be any. PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof SkipMsSymbol, true); String result = symbol.toString().trim(); assertEquals("Skip Record, Length = 0x2", result); @@ -617,7 +611,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(CvReservedMsSymbol.PDB_ID); writer.putBytes(new byte[] { 0x00, 0x00 }); // Putting data, but might never be any. PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof CvReservedMsSymbol, true); String result = symbol.toString().trim(); assertEquals("CVRESERVE, Length = 0x2", result); @@ -630,7 +624,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // Type index containing enum if enumerate writer.putByteLengthPrefixedUtf8String("ObjectNameSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ObjectNameStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("OBJNAME_ST: Signature: 4096, ObjectNameSymbolName", result); @@ -643,7 +637,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // Type index containing enum if enumerate writer.putNullTerminatedUtf8String("ObjectNameSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ObjectNameMsSymbol, true); String result = symbol.toString().trim(); assertEquals("OBJNAME: Signature: 4096, ObjectNameSymbolName", result); @@ -655,7 +649,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(EndArgumentsListMsSymbol.PDB_ID); writer.putBytes(new byte[] { 0x00, 0x00 }); // Putting data, but might never be any. PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof EndArgumentsListMsSymbol, true); String result = symbol.toString().trim(); assertEquals("ENDARG, Length = 0x2", result); @@ -673,7 +667,7 @@ public class SymbolsTest extends AbstractGenericTest { } writer.putByteLengthPrefixedUtf8String("ManyRegisterVariableName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManyRegisterVariable16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANYREG_16: al, cl DummyMsType ManyRegisterVariableName", result); @@ -691,7 +685,7 @@ public class SymbolsTest extends AbstractGenericTest { } writer.putByteLengthPrefixedUtf8String("ManyRegisterVariableName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManyRegisterVariableStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANYREG_ST: al, cl DummyMsType ManyRegisterVariableName", result); @@ -709,7 +703,7 @@ public class SymbolsTest extends AbstractGenericTest { } writer.putNullTerminatedUtf8String("ManyRegisterVariableName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManyRegisterVariableMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANYREG: al, cl DummyMsType ManyRegisterVariableName", result); @@ -727,7 +721,7 @@ public class SymbolsTest extends AbstractGenericTest { } writer.putByteLengthPrefixedUtf8String("ManyRegisterVariable2Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManyRegisterVariable2StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANYREG2_ST: al, cl DummyMsType ManyRegisterVariable2Name", result); @@ -745,7 +739,7 @@ public class SymbolsTest extends AbstractGenericTest { } writer.putNullTerminatedUtf8String("ManyRegisterVariable2Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManyRegisterVariable2MsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANYREG2: al, cl DummyMsType ManyRegisterVariable2Name", result); @@ -758,7 +752,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x00); // Generic flags writer.putUnsignedByte(0x01); // Generic style. PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ReturnDescriptionMsSymbol, true); String result = symbol.toString().trim(); assertEquals( @@ -774,7 +768,7 @@ public class SymbolsTest extends AbstractGenericTest { // API: "Symbol describing this pointer on entry" TODO: made up data; what should it be? writer.putUnsignedByte(0x55); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof EntryThisMsSymbol, true); String result = symbol.toString().trim(); assertEquals("ENTRYTHIS, 'this' symbol: 55; byte length of remaining data = 0", result); @@ -788,7 +782,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("BasePointerRelativeName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof BasePointerRelative16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("BPREL16: [00000010], Type: DummyMsType, BasePointerRelativeName", result); @@ -802,7 +796,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("BasePointerRelativeName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof BasePointerRelative3216MsSymbol, true); String result = symbol.toString().trim(); assertEquals("BPREL32_16: [00000010], Type: DummyMsType, BasePointerRelativeName", result); @@ -816,7 +810,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // Type index writer.putByteLengthPrefixedUtf8String("BasePointerRelativeName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof BasePointerRelative32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("BPREL32_ST: [00000010], Type: DummyMsType, BasePointerRelativeName", result); @@ -830,7 +824,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // Type index writer.putNullTerminatedUtf8String("BasePointerRelativeName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof BasePointerRelative32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("BPREL32: [00000010], Type: DummyMsType, BasePointerRelativeName", result); @@ -845,7 +839,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("LocalDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalData16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LDATA16: [0001:00000010], Type: DummyMsType, LocalDataName", result); @@ -860,7 +854,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("LocalDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalData3216MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LDATA32_16: [0001:00000010], Type: DummyMsType, LocalDataName", result); @@ -875,7 +869,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment. writer.putByteLengthPrefixedUtf8String("LocalDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalData32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LDATA32_ST: [0001:00000010], Type: DummyMsType, LocalDataName", result); @@ -890,7 +884,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment. writer.putNullTerminatedUtf8String("LocalDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalData32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LDATA32: [0001:00000010], Type: DummyMsType, LocalDataName", result); @@ -905,7 +899,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("GlobalDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalData16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GDATA16: [0001:00000010], Type: DummyMsType, GlobalDataName", result); @@ -920,7 +914,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("GlobalDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalData3216MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GDATA32_16: [0001:00000010], Type: DummyMsType, GlobalDataName", result); @@ -935,7 +929,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment. writer.putByteLengthPrefixedUtf8String("GlobalDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalData32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GDATA32_ST: [0001:00000010], Type: DummyMsType, GlobalDataName", result); @@ -950,7 +944,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment. writer.putNullTerminatedUtf8String("GlobalDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalData32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GDATA32: [0001:00000010], Type: DummyMsType, GlobalDataName", result); @@ -965,7 +959,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("PublicName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Public16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("PUBSYM16: [0001:00000010], Type: DummyMsType, PublicName", result); @@ -980,7 +974,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("PublicName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Public3216MsSymbol, true); String result = symbol.toString().trim(); assertEquals("PUBSYM32_16: [0001:00000010], Type: DummyMsType, PublicName", result); @@ -995,7 +989,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment. writer.putByteLengthPrefixedUtf8String("PublicName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Public32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("PUBSYM32_ST: [0001:00000010], Flags: 0000000f, PublicName", result); @@ -1010,7 +1004,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment. writer.putNullTerminatedUtf8String("PublicName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Public32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("PUBSYM32: [0001:00000010], Flags: 0000000f, PublicName", result); @@ -1025,7 +1019,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment. writer.putByteLengthPrefixedString("LocalManagedDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalManagedDataStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LMANDATA32_ST: [0001:00000010], Token: 00001000, LocalManagedDataName", @@ -1041,7 +1035,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment. writer.putNullTerminatedUtf8String("LocalManagedDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalManagedDataMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LMANDATA32: [0001:00000010], Token: 00001000, LocalManagedDataName", result); @@ -1056,7 +1050,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment. writer.putByteLengthPrefixedString("GlobalManagedDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalManagedDataStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GMANDATA32_ST: [0001:00000010], Token: 00001000, GlobalManagedDataName", @@ -1072,7 +1066,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment. writer.putNullTerminatedUtf8String("GlobalManagedDataName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalManagedDataMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GMANDATA32: [0001:00000010], Token: 00001000, GlobalManagedDataName", result); @@ -1087,7 +1081,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("LocalThreadStorageName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalThreadStorage3216MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LTHREAD32_16: [0001:00000010], Type: DummyMsType, LocalThreadStorageName", @@ -1103,7 +1097,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment of thread storage. writer.putByteLengthPrefixedUtf8String("LocalThreadStorageName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalThreadStorage32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LTHREAD32_ST: [0001:00000010], Type: DummyMsType, LocalThreadStorageName", @@ -1119,7 +1113,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment of thread storage. writer.putNullTerminatedUtf8String("LocalThreadStorageName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalThreadStorage32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LTHREAD32: [0001:00000010], Type: DummyMsType, LocalThreadStorageName", @@ -1135,7 +1129,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("GlobalThreadStorageName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalThreadStorage3216MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GTHREAD32_16: [0001:00000010], Type: DummyMsType, GlobalThreadStorageName", @@ -1151,7 +1145,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment of thread storage. writer.putByteLengthPrefixedUtf8String("GlobalThreadStorageName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalThreadStorage32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GTHREAD32_ST: [0001:00000010], Type: DummyMsType, GlobalThreadStorageName", @@ -1167,7 +1161,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Segment of thread storage. writer.putNullTerminatedUtf8String("GlobalThreadStorageName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalThreadStorage32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GTHREAD32: [0001:00000010], Type: DummyMsType, GlobalThreadStorageName", @@ -1187,7 +1181,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x06); // UAV slot start writer.putNullTerminatedUtf8String("LocalDataHighLevelShaderLanguageSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalDataHLSLMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LDATA_HLSL: Type: DummyMsType. INPUT\n" + @@ -1208,7 +1202,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // HLSL register type writer.putNullTerminatedUtf8String("LocalDataHighLevelShaderLanguageSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalDataHLSL32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LDATA_HLSL32: Type: DummyMsType. INPUT\n" + @@ -1228,7 +1222,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // HLSL register type writer.putNullTerminatedUtf8String("LocalDataHighLevelShaderLanguageSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalDataHLSL32ExtMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LDATA_HLSL32_EX: Type: DummyMsType. INPUT\n" + @@ -1249,7 +1243,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x06); // UAV slot start writer.putNullTerminatedUtf8String("GlobalDataHighLevelShaderLanguageSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalDataHLSLMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GDATA_HLSL: Type: DummyMsType. INPUT\n" + @@ -1270,7 +1264,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // HLSL register type writer.putNullTerminatedUtf8String("GlobalDataHighLevelShaderLanguageSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalDataHLSL32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GDATA_HLSL32: Type: DummyMsType. INPUT\n" + @@ -1290,7 +1284,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // HLSL register type writer.putNullTerminatedUtf8String("GlobalDataHighLevelShaderLanguageSymbolName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalDataHLSL32ExtMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GDATA_HLSL32_EX: Type: DummyMsType. INPUT\n" + @@ -1316,7 +1310,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putByteLengthPrefixedUtf8String("LocalProcedureStartName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureStart16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROC16: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1344,7 +1338,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putByteLengthPrefixedUtf8String("LocalProcedureStartName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureStart3216MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROC32_16: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1372,7 +1366,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putByteLengthPrefixedUtf8String("LocalProcedureStartName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureStart32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROC32_ST: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1400,7 +1394,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("LocalProcedureStartName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureStart32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROC32: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1428,7 +1422,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putByteLengthPrefixedUtf8String("GlobalProcedureStartName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureStart16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROC16: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1456,7 +1450,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putByteLengthPrefixedUtf8String("GlobalProcedureStartName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureStart3216MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROC32_16: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1484,7 +1478,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putByteLengthPrefixedUtf8String("GlobalProcedureStartName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureStart32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROC32_ST: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1512,7 +1506,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("GlobalProcedureStartName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureStart32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROC32: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1540,7 +1534,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("LocalProcedure32IdName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedure32IdMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROC32_ID: [0001:00000030], Length: 00000100, ID: DummyMsType," + @@ -1568,7 +1562,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("GlobalProcedure32IdName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedure32IdMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROC32_ID: [0001:00000030], Length: 00000100, ID: DummyMsType," + @@ -1596,7 +1590,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("LocalProcedureStart32DeferredProcedureCallName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureStart32DeferredProcedureCallMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROC32_DPC: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1624,7 +1618,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("LocalProcedure32DeferredProcedureCallIdName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedure32DeferredProcedureCallIdMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROC32_DPC_ID: [0001:00000030], Length: 00000100, ID: DummyMsType," + @@ -1655,7 +1649,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(0x01); // Frame pointer register writer.putByteLengthPrefixedUtf8String("LocalProcedureStartMipsName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureStartMips16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROCMIPSSYM_16: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1686,7 +1680,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(0x01); // Frame pointer register writer.putByteLengthPrefixedUtf8String("LocalProcedureStartMipsName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureStartMipsStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROCMIPSSYM_ST: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1717,7 +1711,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(0x01); // Frame pointer register writer.putNullTerminatedUtf8String("LocalProcedureStartMipsName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureStartMipsMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROCMIPSSYM: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1748,7 +1742,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(0x01); // Frame pointer register writer.putByteLengthPrefixedUtf8String("GlobalProcedureStartMipsName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureStartMips16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROCMIPSSYM_16: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1779,7 +1773,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(0x01); // Frame pointer register writer.putByteLengthPrefixedUtf8String("GlobalProcedureStartMipsName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureStartMipsStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROCMIPSSYM_ST: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1810,7 +1804,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(0x01); // Frame pointer register writer.putNullTerminatedUtf8String("GlobalProcedureStartMipsName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureStartMipsMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROCMIPSSYM: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1841,7 +1835,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(0x01); // Frame pointer register writer.putNullTerminatedUtf8String("LocalProcedureMipsIdName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureMipsIdMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROCMIPSSYM_ID: [0001:00000030], Length: 00000100, ID: DummyMsType," + @@ -1872,7 +1866,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(0x01); // Frame pointer register writer.putNullTerminatedUtf8String("GlobalProcedureMipsIdName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureMipsIdMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROCMIPSSYM_ID: [0001:00000030], Length: 00000100, ID: DummyMsType," + @@ -1901,7 +1895,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putByteLengthPrefixedUtf8String("LocalProcedureStartIa64Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureStartIa64StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROCIA64_ST: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1931,7 +1925,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("LocalProcedureStartIa64Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureStartIa64MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROCIA64: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1961,7 +1955,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putByteLengthPrefixedUtf8String("GlobalProcedureStartIa64Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureStartIa64StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROCIA64_ST: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -1991,7 +1985,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("GlobalProcedureStartIa64Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureStartIa64MsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROCIA64: [0001:00000030], Length: 00000100, Type: DummyMsType," + @@ -2021,7 +2015,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("LocalProcedureIa64IdName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureIa64IdMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROCIA64_ID: [0001:00000030], Length: 00000100, ID: DummyMsType," + @@ -2051,7 +2045,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("GlobalProcedureIa64IdName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalProcedureIa64IdMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GPROCIA64_ID: [0001:00000030], Length: 00000100, ID: DummyMsType," + @@ -2078,7 +2072,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x02); // unsigned short (variant) writer.putByteLengthPrefixedUtf8String("VariantString"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Thunk16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("THUNK16: [0001:00000030], Length: 00000001, ThunkName\n" + @@ -2102,7 +2096,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x02); // unsigned short (variant) writer.putByteLengthPrefixedUtf8String("VariantString"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Thunk32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("THUNK32_ST: [0001:00000030], Length: 00000001, ThunkName\n" + @@ -2126,7 +2120,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x02); // unsigned short (variant) writer.putNullTerminatedUtf8String("VariantString"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Thunk32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("THUNK32: [0001:00000030], Length: 00000001, ThunkName\n" + @@ -2145,7 +2139,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Segment of symbol writer.putByteLengthPrefixedUtf8String("BlockName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Block16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("BLOCK16: [0001:00000030], Length: 00000010, BlockName\n" + @@ -2163,7 +2157,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Segment of symbol writer.putByteLengthPrefixedUtf8String("BlockName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Block32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("BLOCK32_ST: [0001:00000030], Length: 00000010, BlockName\n" + @@ -2181,7 +2175,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Segment of symbol writer.putNullTerminatedUtf8String("BlockName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Block32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("BLOCK32: [0001:00000030], Length: 00000010, BlockName\n" + @@ -2199,7 +2193,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Segment of symbol writer.putByteLengthPrefixedUtf8String("WithExpression"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof With16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("WITH16: [0001:00000030], Length: 00000010, WithExpression\n" + @@ -2217,7 +2211,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Segment of symbol writer.putByteLengthPrefixedUtf8String("WithExpression"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof With32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("WITH32_ST: [0001:00000030], Length: 00000010, WithExpression\n" + @@ -2235,7 +2229,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Segment of symbol writer.putNullTerminatedUtf8String("WithExpression"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof With32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("WITH32: [0001:00000030], Length: 00000010, WithExpression\n" + @@ -2253,7 +2247,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putByteLengthPrefixedUtf8String("LabelName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Label16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LABEL16: [0001:00000030], LabelName Flags: Frame Ptr Present, Interrupt," + @@ -2272,7 +2266,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putByteLengthPrefixedUtf8String("LabelName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Label32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LABEL32_ST: [0001:00000030], LabelName Flags: Frame Ptr Present, Interrupt," + @@ -2291,7 +2285,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(procflags); writer.putNullTerminatedUtf8String("LabelName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Label32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LABEL32: [0001:00000030], LabelName Flags: Frame Ptr Present, Interrupt," + @@ -2309,7 +2303,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x10); // pcode: offset to pcode function table writer.putUnsignedShort(0x20); // pcode: offset to segment pcode information PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ChangeExecutionModel16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("CEXMODEL16:\n" + " segment, offset = 0001:00000030, model = PCODE\n" + @@ -2327,7 +2321,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedInt(0x10); // pcode: offset to pcode function table writer.putUnsignedInt(0x20); // pcode: offset to segment pcode information PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ChangeExecutionModel32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("CEXMODEL32:\n" + " segment, offset = 0001:00000030, model = PCODE\n" + @@ -2344,7 +2338,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // root writer.putUnsignedShort(4096); // path PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof VirtualFunctionTable16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("VFTABLE16: [0001:00000010], DummyMsType:DummyMsType", result); @@ -2359,7 +2353,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // root writer.putUnsignedShort(4096); // path PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof VirtualFunctionTable3216MsSymbol, true); String result = symbol.toString().trim(); assertEquals("VFTABLE32_16: [0001:00000010], DummyMsType:DummyMsType", result); @@ -2374,7 +2368,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedInt(0x10); // offset of symbol writer.putUnsignedShort(1); // Segment of symbol PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof VirtualFunctionTable32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("VFTABLE32: [0001:00000010], DummyMsType:DummyMsType", result); @@ -2389,7 +2383,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("RegisterRelativeAddressName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof RegisterRelativeAddress16MsSymbol, true); String result = symbol.toString().trim(); assertEquals("REGREL16: al+00000030, Type: DummyMsType, RegisterRelativeAddressName", @@ -2405,7 +2399,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index writer.putByteLengthPrefixedUtf8String("RegisterRelativeAddressName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof RegisterRelativeAddress3216MsSymbol, true); String result = symbol.toString().trim(); assertEquals("REGREL32_16: al+00000030, Type: DummyMsType, RegisterRelativeAddressName", @@ -2421,7 +2415,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Register index writer.putByteLengthPrefixedUtf8String("RegisterRelativeAddressName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof RegisterRelativeAddress32StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("REGREL32_ST: al+00000030, Type: DummyMsType, RegisterRelativeAddressName", @@ -2437,7 +2431,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Register index writer.putNullTerminatedUtf8String("RegisterRelativeAddressName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof RegisterRelativeAddress32MsSymbol, true); String result = symbol.toString().trim(); assertEquals("REGREL32: al+00000030, Type: DummyMsType, RegisterRelativeAddressName", @@ -2452,7 +2446,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedInt(0x20); // offset of symbol writer.putUnsignedShort(1); // Register PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof StaticLinkForMipsExceptionHandlingMsSymbol, true); String result = symbol.toString().trim(); assertEquals("SLINK32: framesize = 00000010, offset = 00000020, register = al", result); @@ -2467,7 +2461,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // module containing the symbol writer.putAlign(0); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ProcedureReferenceStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("PROCREF_ST: 00000010: ( 1, 00000020)", result); @@ -2482,7 +2476,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // module containing the symbol writer.putAlign(0); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof DataReferenceStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("DATAREF_ST: 00000010: ( 1, 00000020)", result); @@ -2497,7 +2491,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // module containing the symbol writer.putAlign(0); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureReferenceStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROCREF_ST: 00000010: ( 1, 00000020)", result); @@ -2512,7 +2506,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // module containing the symbol writer.putNullTerminatedUtf8String("ProcedureReferenceName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ProcedureReferenceMsSymbol, true); String result = symbol.toString().trim(); assertEquals("PROCREF: 00000010: ( 1, 00000020) ProcedureReferenceName", result); @@ -2527,7 +2521,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // module containing the symbol writer.putNullTerminatedUtf8String("DataReferenceName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof DataReferenceMsSymbol, true); String result = symbol.toString().trim(); assertEquals("DATAREF: 00000010: ( 1, 00000020) DataReferenceName", result); @@ -2542,7 +2536,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // module containing the symbol writer.putNullTerminatedUtf8String("LocalProcedureReferenceName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalProcedureReferenceMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LPROCREF: 00000010: ( 1, 00000020) LocalProcedureReferenceName", result); @@ -2557,7 +2551,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // module containing the symbol writer.putNullTerminatedUtf8String("AnnotationReferenceName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof AnnotationReferenceMsSymbol, true); String result = symbol.toString().trim(); assertEquals("ANNOTATIONREF: 00000010: ( 1, 00000020) AnnotationReferenceName", result); @@ -2572,7 +2566,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // module containing the symbol writer.putNullTerminatedUtf8String("TokenReferenceName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof TokenReferenceToManagedProcedureMsSymbol, true); String result = symbol.toString().trim(); assertEquals("TOKENREF: 00000010: ( 1, 00000020) TokenReferenceName", result); @@ -2584,7 +2578,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(AlignMsSymbol.PDB_ID); writer.putBytes(new byte[] { 0x00, 0x00 }); // Putting data, but might never be any. PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof AlignMsSymbol, true); String result = symbol.toString().trim(); assertEquals("Align Record, Length = 0x2", result); @@ -2603,7 +2597,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // Type index writer.putBytes(new byte[] { 0x01, 0x02, 0x03, 0x04 }); // User data, with align 4 PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof OemDefinedMsSymbol, true); String result = symbol.toString().trim(); assertEquals( @@ -2619,7 +2613,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // type index or metadata token writer.putByteLengthPrefixedUtf8String("LocalSlotName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalSlotIndexFieldedLILStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LOCALSLOT_ST: [00000010], Type: DummyMsType, LocalSlotName", result); @@ -2633,7 +2627,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // type index or metadata token writer.putNullTerminatedUtf8String("LocalSlotName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalSlotIndexFieldedLILMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LOCALSLOT: [00000010], Type: DummyMsType, LocalSlotName", result); @@ -2647,7 +2641,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // type index or metadata token writer.putByteLengthPrefixedUtf8String("ParamSlotName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ParameterSlotIndexFieldedLILStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("PARAMSLOT_ST: [00000010], Type: DummyMsType, ParamSlotName", result); @@ -2661,7 +2655,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // type index or metadata token writer.putNullTerminatedUtf8String("ParamSlotName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ParameterSlotIndexFieldedLILMsSymbol, true); String result = symbol.toString().trim(); assertEquals("PARAMSLOT: [00000010], Type: DummyMsType, ParamSlotName", result); @@ -2678,7 +2672,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putNullTerminatedUtf8String("Annotation1Name"); writer.putNullTerminatedUtf8String("Annotation2Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof AnnotationMsSymbol, true); String result = symbol.toString().trim(); assertEquals("ANNOTATION: [0001:00003000]\n" + " 0: Annotation0Name\n" + @@ -2690,7 +2684,7 @@ public class SymbolsTest extends AbstractGenericTest { PdbByteWriter writer = new PdbByteWriter(); writer.putUnsignedShort(Reserved1MsSymbol.PDB_ID); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Reserved1MsSymbol, true); String result = symbol.toString().trim(); assertEquals("RESERVED1", result); @@ -2701,7 +2695,7 @@ public class SymbolsTest extends AbstractGenericTest { PdbByteWriter writer = new PdbByteWriter(); writer.putUnsignedShort(Reserved2MsSymbol.PDB_ID); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Reserved2MsSymbol, true); String result = symbol.toString().trim(); assertEquals("RESERVED2", result); @@ -2712,7 +2706,7 @@ public class SymbolsTest extends AbstractGenericTest { PdbByteWriter writer = new PdbByteWriter(); writer.putUnsignedShort(Reserved3MsSymbol.PDB_ID); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Reserved3MsSymbol, true); String result = symbol.toString().trim(); assertEquals("RESERVED3", result); @@ -2723,7 +2717,7 @@ public class SymbolsTest extends AbstractGenericTest { PdbByteWriter writer = new PdbByteWriter(); writer.putUnsignedShort(Reserved4MsSymbol.PDB_ID); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof Reserved4MsSymbol, true); String result = symbol.toString().trim(); assertEquals("RESERVED4", result); @@ -2748,7 +2742,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Return register writer.putByteLengthPrefixedUtf8String("LocalManagedProcedureName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalManagedProcedureStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LMANPROC_ST: [0001:00003000], Length: 00000100, Token: 65536," + @@ -2778,7 +2772,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Return register writer.putNullTerminatedUtf8String("LocalManagedProcedureName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalManagedProcedureMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LMANPROC: [0001:00003000], Length: 00000100, Token: 65536," + @@ -2808,7 +2802,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Return register writer.putByteLengthPrefixedUtf8String("GlobalManagedProcedureName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalManagedProcedureStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GMANPROC_ST: [0001:00003000], Length: 00000100, Token: 65536," + @@ -2838,7 +2832,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); // Return register writer.putNullTerminatedUtf8String("GlobalManagedProcedureName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof GlobalManagedProcedureMsSymbol, true); String result = symbol.toString().trim(); assertEquals("GMANPROC: [0001:00003000], Length: 00000100, Token: 65536," + @@ -2861,7 +2855,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(attributesBuffer); writer.putByteLengthPrefixedUtf8String("ManagedFrameName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManLocOrParamReltoVFPStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANFRAMEREL_ST: [00003000], [0001:00001000]: Param: 4096 Address Taken," + @@ -2881,7 +2875,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(attributesBuffer); writer.putNullTerminatedUtf8String("ManagedFrameName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManLocOrParamReltoVFPMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANFRAMEREL: [00003000], [0001:00001000]: Param: 4096 Address Taken," + @@ -2901,7 +2895,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(attributesBuffer); writer.putNullTerminatedUtf8String("AttributedFrameName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof AttribLocOrParamReltoVFPMsSymbol, true); String result = symbol.toString().trim(); assertEquals("ATTR_MANFRAMEREL: [00003000], [0001:00001000]: Param: 4096 Address Taken," + @@ -2921,7 +2915,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Register writer.putByteLengthPrefixedUtf8String("ManagedRegisterName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManagedLocalOrParameterSIRStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANREGISTER_ST: al, [0001:00001000]: Param: 4096 Address Taken," + @@ -2941,7 +2935,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Register writer.putNullTerminatedUtf8String("ManagedRegisterName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManagedLocalOrParameterSIRMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANREGISTER: al, [0001:00001000]: Param: 4096 Address Taken," + @@ -2961,7 +2955,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Register writer.putNullTerminatedUtf8String("AttributedRegisterName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof AttributedLocalOrParameterSIRMsSymbol, true); String result = symbol.toString().trim(); assertEquals("ATTR_REGISTER: al, [0001:00001000]: Param: 4096 Address Taken," + @@ -2981,7 +2975,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(attributesBuffer); writer.putByteLengthPrefixedUtf8String("ManagedSlotName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManagedSymbolWithSlotIndexFieldStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANSLOT_ST: 1, [0001:00001000]: Param: 4096 Address Taken," + @@ -3001,7 +2995,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(attributesBuffer); writer.putNullTerminatedUtf8String("ManagedSlotName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManagedSymbolWithSlotIndexFieldMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANSLOT: 1, [0001:00001000]: Param: 4096 Address Taken," + @@ -3024,7 +3018,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(3); // Register writer.putByteLengthPrefixedUtf8String("ManagedManyRegisterName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManagedLocalOrParameterSIMRStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANMANYREG_ST: al, cl, dl DummyMsType ManagedManyRegisterName", result); @@ -3045,7 +3039,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(3); // Register writer.putNullTerminatedUtf8String("ManagedManyRegisterName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManagedLocalOrParameterSIMRMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANMANYREG: al, cl, dl DummyMsType ManagedManyRegisterName", result); @@ -3066,7 +3060,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(3); // Register writer.putByteLengthPrefixedUtf8String("ManagedManyRegister2Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManagedLocalOrParameterSIMR2StMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANMANYREG2_ST: al, cl, dl DummyMsType ManagedManyRegister2Name", result); @@ -3087,7 +3081,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(3); // Register writer.putNullTerminatedUtf8String("ManagedManyRegister2Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManagedLocalOrParameterSIMR2MsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANMANYREG2: al, cl, dl DummyMsType ManagedManyRegister2Name", result); @@ -3108,7 +3102,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(3); // Register writer.putNullTerminatedUtf8String("ManagedManyRegister2Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof AttributedLocalOrParameterSIMRMsSymbol, true); String result = symbol.toString().trim(); assertEquals("ATTR_MANYREG: al, cl, dl DummyMsType ManagedManyRegister2Name", result); @@ -3127,7 +3121,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(attributesBuffer); writer.putByteLengthPrefixedUtf8String("ManagedAltFrameName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManLocOrParamReltoAMPStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANREGREL_ST: al+00003000, [0001:00001000]: Param: 4096 Address Taken," + @@ -3148,7 +3142,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(attributesBuffer); writer.putNullTerminatedUtf8String("ManagedAltFrameName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ManLocOrParamReltoAMPMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANREGREL: al+00003000, [0001:00001000]: Param: 4096 Address Taken," + @@ -3169,7 +3163,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(attributesBuffer); writer.putNullTerminatedUtf8String("AttributedAltFrameName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof AttribLocOrParamReltoAMPMsSymbol, true); String result = symbol.toString().trim(); assertEquals("ATTR_REGREL: al+00003000, [0001:00001000]: Param: 4096 Address Taken," + @@ -3183,7 +3177,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(IndexForTypeReferencedByNameFromMetadataMsSymbol.PDB_ID); writer.putInt(4096); // type index or mdatadata token PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof IndexForTypeReferencedByNameFromMetadataMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MANTYPEREF: DummyMsType", result); @@ -3195,7 +3189,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(UsingNamespaceStMsSymbol.PDB_ID); writer.putByteLengthPrefixedUtf8String("UsingNamespaceName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof UsingNamespaceStMsSymbol, true); String result = symbol.toString().trim(); assertEquals("UNAMESPACE_ST: UsingNamespaceName", result); @@ -3207,7 +3201,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(UsingNamespaceMsSymbol.PDB_ID); writer.putNullTerminatedUtf8String("UsingNamespaceName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof UsingNamespaceMsSymbol, true); String result = symbol.toString().trim(); assertEquals("UNAMESPACE: UsingNamespaceName", result); @@ -3224,7 +3218,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // section index of thunk writer.putUnsignedShort(1); // section index of thunk target PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof TrampolineMsSymbol, true); String result = symbol.toString().trim(); assertEquals( @@ -3246,7 +3240,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Section of separated code writer.putUnsignedShort(1); // Section of parent of enclosing scope PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof SeparatedCodeFromCompilerSupportMsSymbol, true); String result = symbol.toString().trim(); assertEquals( @@ -3266,7 +3260,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(localVarFlags); writer.putNullTerminatedUtf8String("LocalSymbolInOptimizedCode2005Name"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalSymbolInOptimizedCode2005MsSymbol, true); String result = symbol.toString().trim(); assertEquals("LOCAL_2005: Param: 00001000 Address Taken, Compiler Generated, aggregate," + @@ -3284,7 +3278,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(localVarFlags); writer.putNullTerminatedUtf8String("LocalSymbolInOptimizedCodeName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalSymbolInOptimizedCodeMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LOCAL: Param: 00001000 Address Taken, Compiler Generated, aggregate," + @@ -3299,7 +3293,7 @@ public class SymbolsTest extends AbstractGenericTest { // API not given; writing dummy data here. writer.putBytes(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof DefinedSingleAddressRange2005MsSymbol, true); String result = symbol.toString().trim(); assertEquals("DEFRAMGE_2005: ", result); @@ -3312,7 +3306,7 @@ public class SymbolsTest extends AbstractGenericTest { // API not given; writing dummy data here. writer.putBytes(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof DefinedMultipleAddressRanges2005MsSymbol, true); String result = symbol.toString().trim(); assertEquals("DEFRAMGE2_2005: ", result); @@ -3330,7 +3324,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedInt(0x05); // characteristics writer.putNullTerminatedUtf8String("PeCoffSectionName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof PeCoffSectionMsSymbol, true); String result = symbol.toString().trim(); assertEquals("SECTION: [0001], RVA = 00000000, Length = 00000100, Align = 00000010," + @@ -3347,7 +3341,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Segment writer.putNullTerminatedUtf8String("PeCoffGroupName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof PeCoffGroupMsSymbol, true); String result = symbol.toString().trim(); assertEquals("COFFGROUP: [0001:00001000], Length = 00000100, Characteristics = 00000005," + @@ -3362,7 +3356,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x2f); // flags writer.putNullTerminatedUtf8String("ExportName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ExportMsSymbol, true); String result = symbol.toString().trim(); assertEquals("EXPORT: Ordinal = 1 (implicit), CONSTANT, DATA, PRIVATE, NONAME," + @@ -3378,7 +3372,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x00); // Reserved (must be zero) writer.putUnsignedInt(4096); // type index PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof IndirectCallSiteInfoMsSymbol, true); String result = symbol.toString().trim(); assertEquals("CALLSITEINFO: [0001:00001000], Type = DummyMsType", result); @@ -3394,7 +3388,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedByte(0x00); // cookie type (valid values seem to be 0, 1, 2, 3) writer.putUnsignedByte(0x55); // flags PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof FrameSecurityCookieMsSymbol, true); String result = symbol.toString().trim(); assertEquals("FRAMECOOKIE: al+00001000, Type: COPY, 55", result); @@ -3414,7 +3408,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(symbolBuffer.length); writer.putBytes(symbolBuffer); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof DiscardedByLinkMsSymbol, true); String result = symbol.toString().trim(); assertEquals("DISCARDED: Not selected, FileId: 00000001, Line: 234\n" + @@ -3433,7 +3427,7 @@ public class SymbolsTest extends AbstractGenericTest { byte[] gap2 = createLocalVariableAddressGapBuffer(0x400, 0x100); writer.putBytes(gap2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof DefinedSingleAddressRangeMsSymbol, true); String result = symbol.toString().trim(); assertEquals( @@ -3455,7 +3449,7 @@ public class SymbolsTest extends AbstractGenericTest { byte[] gap2 = createLocalVariableAddressGapBuffer(0x400, 0x100); writer.putBytes(gap2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof SubfieldDARMsSymbol, true); String result = symbol.toString().trim(); assertEquals("DEFRANGE_SUBFIELD: offset at 0010, DIA Program NI: 0001," + @@ -3477,7 +3471,7 @@ public class SymbolsTest extends AbstractGenericTest { byte[] gap2 = createLocalVariableAddressGapBuffer(0x400, 0x100); writer.putBytes(gap2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof EnregisteredSymbolDARMsSymbol, true); String result = symbol.toString().trim(); assertEquals("DEFRANGE_REGISTER:Attributes: MayAvailable al" + @@ -3497,7 +3491,7 @@ public class SymbolsTest extends AbstractGenericTest { byte[] gap2 = createLocalVariableAddressGapBuffer(0x400, 0x100); writer.putBytes(gap2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof FramePointerRelativeDARMsSymbol, true); String result = symbol.toString().trim(); assertEquals("DEFRANGE_FRAMEPOINTER_REL: FrameOffset: 1000" + @@ -3521,7 +3515,7 @@ public class SymbolsTest extends AbstractGenericTest { byte[] gap2 = createLocalVariableAddressGapBuffer(0x400, 0x100); writer.putBytes(gap2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof EnregisteredFieldOfSymbolDARMsSymbol, true); String result = symbol.toString().trim(); assertEquals("DEFRANGE_SUBFIELD_REGISTER: offset at 0010: Attributes: MayAvailable al" + @@ -3535,7 +3529,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(FramePointerRelativeFullScopeDARMsSymbol.PDB_ID); writer.putInt(0x0100); // offset to frame pointer PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof FramePointerRelativeFullScopeDARMsSymbol, true); String result = symbol.toString().trim(); assertEquals("DEFRANGE_FRAMEPOINTER_REL_FULL_SCOPE: FrameOffset: 0100 FULL_SCOPE", result); @@ -3558,7 +3552,7 @@ public class SymbolsTest extends AbstractGenericTest { byte[] gap2 = createLocalVariableAddressGapBuffer(0x400, 0x100); writer.putBytes(gap2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof EnregisteredSymbolRelativeDARMsSymbol, true); String result = symbol.toString().trim(); assertEquals( @@ -3574,7 +3568,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(BuildInformationMsSymbol.PDB_ID); writer.putUnsignedInt(4096); // item id of build info PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof BuildInformationMsSymbol, true); String result = symbol.toString().trim(); assertEquals("BUILDINFO: ItemDummyMsType", result); @@ -3585,7 +3579,7 @@ public class SymbolsTest extends AbstractGenericTest { PdbByteWriter writer = new PdbByteWriter(); writer.putUnsignedShort(ProcedureIdEndMsSymbol.PDB_ID); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ProcedureIdEndMsSymbol, true); String result = symbol.toString().trim(); assertEquals("PROC_ID_END", result); @@ -3604,7 +3598,7 @@ public class SymbolsTest extends AbstractGenericTest { byte[] annotationBuf2 = createInstructionAnnotationBuffer(0x02, 0x20, 0x21); writer.putBytes(annotationBuf2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof InlinedFunctionCallsiteMsSymbol, true); String result = symbol.toString().trim(); assertEquals("INLINESITE2: Parent: 00001000, End: 00002000, Inlinee: ItemDummyMsType\n" + @@ -3625,7 +3619,7 @@ public class SymbolsTest extends AbstractGenericTest { byte[] annotationBuf2 = createInstructionAnnotationBuffer(0x02, 0x20, 0x21); writer.putBytes(annotationBuf2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof InlinedFunctionCallsiteExtendedMsSymbol, true); String result = symbol.toString().trim(); assertEquals("INLINESITE2: Parent: 00001000, End: 00002000, PGO Edge Count: 2," + @@ -3637,7 +3631,7 @@ public class SymbolsTest extends AbstractGenericTest { PdbByteWriter writer = new PdbByteWriter(); writer.putUnsignedShort(InlinedFunctionEndMsSymbol.PDB_ID); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof InlinedFunctionEndMsSymbol, true); String result = symbol.toString().trim(); assertEquals("INLINESITE_END", result); @@ -3654,7 +3648,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putBytes(localVarFlags); writer.putNullTerminatedUtf8String("FileStaticName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof FileStaticMsSymbol, true); String result = symbol.toString().trim(); assertEquals("FILESTATIC: Param: 00001000 Address Taken, Compiler Generated, aggregate," + @@ -3674,7 +3668,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(2); // base data offset writer.putNullTerminatedUtf8String("LocalDPCGroupSharedName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof LocalDeferredProcedureCallGroupSharedMsSymbol, true); String result = symbol.toString().trim(); assertEquals("LOCAL_DPC_GROUPSHARED: Param: 4096 Address Taken, Compiler Generated," + @@ -3706,7 +3700,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(i + 3); } PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof HighLevelShaderLanguageRegDimDARMsSymbol, true); String result = symbol.toString().trim(); assertEquals("DEFRANGE_HLSL: al, RegisterIndices = 2, SAMPLER" + @@ -3738,7 +3732,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(i + 3); } PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof DeferredProcedureCallPointerTagRegDimDARMsSymbol, true); String result = symbol.toString().trim(); assertEquals("DEFRANGE_DPC_PTR_TAG: al, RegisterIndices = 2, SAMPLER" + @@ -3757,7 +3751,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedInt(0x10 * (i + 1)); } PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof DeferredProcedureCallPointerTagToSymbolRecordMapMsSymbol, true); String result = symbol.toString().trim(); @@ -3777,7 +3771,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(1); // section index of the table writer.putUnsignedInt(0x5); // number of switch table entries PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ArmSwitchTableMsSymbol, true); String result = symbol.toString().trim(); assertEquals("ARMSWITCHTABLE:\n" + " Base address: [0001:00001000]\n" + @@ -3795,7 +3789,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedInt(4096); } PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof CallersMsSymbol, true); String result = symbol.toString().trim(); assertEquals("CALLERS: Count: 3\n" + @@ -3812,7 +3806,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedInt(4096); } PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof CalleesMsSymbol, true); String result = symbol.toString().trim(); assertEquals("CALLEES: Count: 3\n" + @@ -3829,7 +3823,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedInt(15); // static instruction count writer.putUnsignedInt(25); // final static instruction count (after inlining) PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ProfileGuidedOptimizationDataMsSymbol, true); String result = symbol.toString().trim(); assertEquals("POGOINFO:\n" + "Call Count: 5\n" + "Dynamic Instruction Count: 100\n" + @@ -3845,7 +3839,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(8); // Length of headp allocation call instruction writer.putUnsignedInt(4096); // Type index describing function signature PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof HeapAllocationSiteMsSymbol, true); String result = symbol.toString().trim(); assertEquals("HEAPALLOCSITE: [0001:00001000], instruction length = 8, type = DummyMsType", @@ -3870,7 +3864,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x01); writer.putUnsignedShort(0x02); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ModuleTypeReferenceMsSymbol, true); String result = symbol.toString().trim(); assertEquals("MODTYPEREF: /Zi TypeRef, StreamNumber=0001 (type), StreamNumber=0002 (ID)", @@ -3893,7 +3887,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(0x1f); // flags writer.putNullTerminatedUtf8String("MiniPdbName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof MiniPdbReferenceMsSymbol, true); String result = symbol.toString().trim(); assertEquals("REF_MINIPDB: (UDT) moduleIndex = 0001, TypeInformation = signed char," + @@ -3907,7 +3901,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putNullTerminatedWchartString("SourcePdbFileName"); writer.putNullTerminatedWchartString("DestinationPdbFileName"); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof MapToMiniPdbMsSymbol, true); String result = symbol.toString().trim(); assertEquals("PDBMAP: SourcePdbFileName -> DestinationPdbFileName", result); @@ -3929,7 +3923,7 @@ public class SymbolsTest extends AbstractGenericTest { // bit 2: function uses longjmp() // bit 3: function uses inline asm // bit 4: function has EH states - // bit 5: function was specified as inline + // bit 5: function was specified as inline // bit 6: function has SEH // bit 7: function is __declspec(naked) // bit 8: function has buffer security check introduced by /GS @@ -3938,8 +3932,8 @@ public class SymbolsTest extends AbstractGenericTest { // bit 11: function was inline within another function // bit 12: function is __declspec(strict_gs_check) // bit 13: function is __declspec(safebuffers) - // bits 14-15: record function's local pointer explicitly - // bits 16-17: record function's parameter pointer explicitly + // bits 14-15: record function's local pointer explicitly + // bits 16-17: record function's parameter pointer explicitly // bit 18: function was compiled with PGO/PGU // bit 19: function Do we have valid Pogo counts? // bit 20: function Did we optimized for speed? @@ -3948,7 +3942,7 @@ public class SymbolsTest extends AbstractGenericTest { // next 9 bits are reserved writer.putUnsignedInt(0x007fffff); // flags PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof ExtraFrameAndProcedureInformationMsSymbol, true); String result = symbol.toString().trim(); assertEquals("FRAMEPROCSYM:\n" + " Frame size = 00001000 bytes\n" + @@ -3968,7 +3962,7 @@ public class SymbolsTest extends AbstractGenericTest { // We have no idea of the symbol contents; just probable existence of symbol type x1166. writer.putBytes(new byte[] { 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08 }); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof UnknownX1166MsSymbol, true); String result = symbol.toString().trim(); assertEquals("UNKNOWN_SYMBOL_X1166: Bytes:\n" + "000000 01 02 03 04 05 06 07 08", result); @@ -3983,7 +3977,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putUnsignedShort(3); // unknown writer.putNullTerminatedUtf8String("UnknownX1167String"); // string PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof UnknownX1167MsSymbol, true); String result = symbol.toString().trim(); assertEquals("UNKNOWN_SYMBOL_X1167\n" + "unknownUnsignedShort1: 0001\n" + @@ -3999,7 +3993,7 @@ public class SymbolsTest extends AbstractGenericTest { writer.putInt(4096); // we are assuming this is a type record index writer.putInt(4096); // we are assuming this is a type record index PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsSymbol symbol = symbolParser.parse(reader); + AbstractMsSymbol symbol = SymbolParser.parse(pdb, reader); assertEquals(symbol instanceof UnknownX1168MsSymbol, true); String result = symbol.toString().trim(); assertEquals("UNKNOWN_SYMBOL_X1168: Type List: {DummyMsType, DummyMsType}", result); diff --git a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/TypesTest.java b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/TypesTest.java index 4001e78165..d278cbc5bc 100644 --- a/Ghidra/Features/PDB/src/test/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/TypesTest.java +++ b/Ghidra/Features/PDB/src/test/java/ghidra/app/util/bin/format/pdb2/pdbreader/type/TypesTest.java @@ -15,7 +15,7 @@ */ package ghidra.app.util.bin.format.pdb2.pdbreader.type; -import static org.junit.Assert.assertEquals; +import static org.junit.Assert.*; import java.math.BigInteger; @@ -45,7 +45,6 @@ public class TypesTest extends AbstractGenericTest { private static int methodList16MsType1; private static int methodListMsType1; private static int vtShapeMsType1; - private static TypeParser typeParser; @BeforeClass public static void setUp() { @@ -54,32 +53,30 @@ public class TypesTest extends AbstractGenericTest { processor = Processor.I8080; pdb.setTargetProcessor(processor); - typeParser = pdb.getTypeParser(); - AbstractMsType type; - AbstractMsType item; PdbByteReader reader; + // Create records that will be used indirectly - type = new DummyMsType(pdb, null); - item = new DummyMsType(pdb, null, "Item"); + AbstractMsType type = new DummyMsType(pdb, null); + AbstractMsType item = new DummyMsType(pdb, null, "Item"); //================================= // typeParser Records dummyPdb700.setTypeRecord(4096, type); reader = new PdbByteReader(createReferencedSymbolMsTypeBuffer()); - type = typeParser.parse(reader); + type = TypeParser.parse(pdb, reader); referencedSymbolMsType1 = dummyPdb700.addTypeRecord(type); reader = new PdbByteReader(createMethodList16MsTypeBuffer()); - type = typeParser.parse(reader); + type = TypeParser.parse(pdb, reader); methodList16MsType1 = dummyPdb700.addTypeRecord(type); reader = new PdbByteReader(createMethodListMsTypeBuffer()); - type = typeParser.parse(reader); + type = TypeParser.parse(pdb, reader); methodListMsType1 = dummyPdb700.addTypeRecord(type); reader = new PdbByteReader(createVtShapeMsTypeBuffer()); - type = typeParser.parse(reader); + type = TypeParser.parse(pdb, reader); vtShapeMsType1 = dummyPdb700.addTypeRecord(type); //================================= @@ -87,16 +84,16 @@ public class TypesTest extends AbstractGenericTest { dummyPdb700.setItemRecord(4096, item); reader = new PdbByteReader(createStringIdMsTypeBuffer(0, "String1")); - item = typeParser.parse(reader); + item = TypeParser.parse(pdb, reader); stringIdMsType1 = dummyPdb700.addItemRecord(item); reader = new PdbByteReader(createStringIdMsTypeBuffer(0, "String2")); - item = typeParser.parse(reader); + item = TypeParser.parse(pdb, reader); stringIdMsType2 = dummyPdb700.addItemRecord(item); reader = new PdbByteReader( createSubstringListMsTypeBuffer(new int[] { stringIdMsType1, stringIdMsType2 })); - item = typeParser.parse(reader); + item = TypeParser.parse(pdb, reader); substringListMsType1 = dummyPdb700.addItemRecord(item); } catch (Exception e) { @@ -173,7 +170,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(0xffff); writer.putBytes(new byte[] { (byte) 0xfe, (byte) 0xfd, (byte) 0xfc }); // dummy data PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof UnknownMsType, true); String result = type.toString().trim(); assertEquals("UNKNOWN_TYPE (0XFFFF): Bytes:\n" + "000000 fe fd fc", result); @@ -186,7 +183,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(0x07); // Incomplete record should cause BadMsType to be created. PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof BadMsType, true); String result = type.toString().trim(); assertEquals("BAD_TYPE: ID=0X0001", result); @@ -200,7 +197,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(4096); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Modifier16MsType, true); String result = type.toString().trim(); assertEquals("const volatile __unaligned DummyMsType", result); @@ -214,7 +211,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(0x07); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ModifierMsType, true); String result = type.toString().trim(); assertEquals("const volatile __unaligned DummyMsType", result); @@ -237,7 +234,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(5); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Pointer16MsType, true); String result = type.toString().trim(); assertEquals("DummyMsType flat ::* const volatile DummyMsType", result); @@ -268,7 +265,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(5); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof PointerMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType flat ::* const volatile DummyMsType", result); @@ -284,7 +281,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("name"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Array16MsType, true); String result = type.toString().trim(); assertEquals("DummyMsType [16]", result); @@ -300,7 +297,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("name"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ArrayStMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType [16]", result); @@ -316,7 +313,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("name"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ArrayMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType [16]", result); @@ -333,7 +330,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("name"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof StridedArrayMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType [16]", result); @@ -353,7 +350,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("ClassName16"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Class16MsType, true); String result = type.toString().trim(); assertEquals("class ClassName16<2,packed ctor>DummyMsType", result); @@ -374,7 +371,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("OtherNameSt"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ClassStMsType, true); String result = type.toString().trim(); assertEquals("class ClassNameSt<2,packed ctor>DummyMsType", result); @@ -395,7 +392,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("OtherName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ClassMsType, true); String result = type.toString().trim(); assertEquals("class ClassName<2,packed ctor>DummyMsType", result); @@ -418,7 +415,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("OtherName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Class19MsType, true); String result = type.toString().trim(); assertEquals("class ClassNameDummyMsType", result); @@ -438,7 +435,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("StructureName16"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Structure16MsType, true); String result = type.toString().trim(); assertEquals("struct StructureName16<2,packed ctor>DummyMsType", result); @@ -459,7 +456,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("OtherNameSt"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof StructureStMsType, true); String result = type.toString().trim(); assertEquals("struct StructureNameSt<2,packed ctor>DummyMsType", result); @@ -480,7 +477,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("OtherName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof StructureMsType, true); String result = type.toString().trim(); assertEquals("struct StructureName<2,packed ctor>DummyMsType", result); @@ -503,7 +500,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("OtherName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Structure19MsType, true); String result = type.toString().trim(); assertEquals("struct StructureNameDummyMsType", result); @@ -524,7 +521,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("OtherName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof InterfaceMsType, true); String result = type.toString().trim(); assertEquals("interface InterfaceName<2,packed ctor>DummyMsType", result); @@ -547,7 +544,7 @@ public class TypesTest extends AbstractGenericTest { // writer.putNullTerminatedString("OtherName"); // writer.putAlign(2); // PdbByteReader reader = new PdbByteReader(writer.get()); -// AbstractMsType type = typeParser.parse(reader); +// AbstractMsType type = TypeParser.parse(pdb, reader); // assertEquals(type instanceof Interface19MsType, true); // String result = type.toString().trim(); // assertEquals("interface InterfaceNameDummyMsType", result); @@ -565,7 +562,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("UnionName16"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Union16MsType, true); String result = type.toString().trim(); assertEquals("union UnionName16<2,packed ctor>DummyMsType", result); @@ -584,7 +581,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("OtherNameSt"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof UnionStMsType, true); String result = type.toString().trim(); assertEquals("union UnionNameSt<2,packed ctor>DummyMsType", result); @@ -603,7 +600,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("OtherName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof UnionMsType, true); String result = type.toString().trim(); assertEquals("union UnionName<2,packed ctor>DummyMsType", result); @@ -624,7 +621,7 @@ public class TypesTest extends AbstractGenericTest { // writer.putNullTerminatedString("OtherName"); // writer.putAlign(2); // PdbByteReader reader = new PdbByteReader(writer.get()); -// AbstractMsType type = typeParser.parse(reader); +// AbstractMsType type = TypeParser.parse(pdb, reader); // assertEquals(type instanceof Union19MsType, true); // String result = type.toString().trim(); // assertEquals("union UnionNameDummyMsType", result); @@ -642,7 +639,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("EnumName16"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Enum16MsType, true); String result = type.toString().trim(); assertEquals("enum EnumName16<2,DummyMsType,packed ctor>DummyMsType", result); @@ -661,7 +658,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("OtherNameSt"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof EnumStMsType, true); String result = type.toString().trim(); assertEquals("enum EnumNameSt<2,DummyMsType,packed ctor>DummyMsType", result); @@ -680,7 +677,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("OtherName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof EnumMsType, true); String result = type.toString().trim(); assertEquals("enum EnumName<2,DummyMsType,packed ctor>DummyMsType", result); @@ -700,7 +697,7 @@ public class TypesTest extends AbstractGenericTest { // writer.putNullTerminatedString("OtherName"); // writer.putAlign(2); // PdbByteReader reader = new PdbByteReader(writer.get()); -// AbstractMsType type = typeParser.parse(reader); +// AbstractMsType type = TypeParser.parse(pdb, reader); // assertEquals(type instanceof Enum19MsType, true); // String result = type.toString().trim(); // assertEquals("enum EnumNameDummyMsType", result); @@ -718,7 +715,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index arguments list. writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Procedure16MsType, true); String result = type.toString().trim(); assertEquals("DummyMsType DummyMsType", result); @@ -736,7 +733,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedInt(4096); // Type index of arguments list. writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ProcedureMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType DummyMsType", result); @@ -757,7 +754,7 @@ public class TypesTest extends AbstractGenericTest { writer.putInt(0x08); // This adjuster. writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof MemberFunction16MsType, true); String result = type.toString().trim(); assertEquals("DummyMsType DummyMsType::DummyMsType : DummyMsType] tableName:" + @@ -832,7 +829,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(new byte[] { 0x03, 0x02, 0x01, 0x00 }); //writer.putAlign(2); // TODO: Not sure PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Cobol016MsType, true); String result = type.toString().trim(); assertEquals( @@ -849,7 +846,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(new byte[] { 0x03, 0x02, 0x01, 0x00 }); writer.putAlign(2); // TODO: Not sure PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Cobol0MsType, true); String result = type.toString().trim(); assertEquals( @@ -865,7 +862,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(new byte[] { 0x03, 0x02, 0x01, 0x00 }); writer.putAlign(2); // TODO: Not sure PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Cobol1MsType, true); String result = type.toString().trim(); assertEquals("Cobol1MsType\n" + " additional data length: 4", result); @@ -878,7 +875,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Parent type index. writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof BasicArray16MsType, true); String result = type.toString().trim(); assertEquals("DummyMsType[]", result); @@ -891,7 +888,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedInt(4096); // Parent type index. writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof BasicArrayMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType[]", result); @@ -904,7 +901,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(4); // 0 = NEAR; 4 = FAR addressing mode. writer.putAlign(2); // TODO: Not sure PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof LabelMsType, true); String result = type.toString().trim(); assertEquals("<>", result); @@ -916,7 +913,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(NullMsType.PDB_ID); writer.putAlign(2); // TODO: Not sure PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof NullMsType, true); String result = type.toString().trim(); assertEquals("<>", result); @@ -928,7 +925,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(NotTranMsType.PDB_ID); writer.putAlign(2); // TODO: Not sure PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof NotTranMsType, true); String result = type.toString().trim(); assertEquals("<>", result); @@ -943,7 +940,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("name"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof DimensionedArray16MsType, true); String result = type.toString().trim(); assertEquals("DummyMsType []", result); @@ -958,7 +955,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("name"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof DimensionedArrayStMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType []", result); @@ -973,7 +970,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("name"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof DimensionedArrayMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType []", result); @@ -988,7 +985,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // a type index writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof VirtualFunctionTablePath16MsType, true); String result = type.toString().trim(); assertEquals("VFTPath: count=2\n" + " base[0]=DummyMsType\n" + " base[1]=DummyMsType", @@ -1004,7 +1001,7 @@ public class TypesTest extends AbstractGenericTest { writer.putInt(4096); // a type index writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof VirtualFunctionTablePathMsType, true); String result = type.toString().trim(); assertEquals("VFTPath: count=2\n" + " base[0]=DummyMsType\n" + " base[1]=DummyMsType", @@ -1021,7 +1018,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("filename"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof PrecompiledType16MsType, true); String result = type.toString().trim(); assertEquals( @@ -1039,7 +1036,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("filename"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof PrecompiledTypeStMsType, true); String result = type.toString().trim(); assertEquals( @@ -1057,7 +1054,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("filename"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof PrecompiledTypeMsType, true); String result = type.toString().trim(); assertEquals( @@ -1072,7 +1069,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedInt(0xfedcba98L); // made-up signature writer.putAlign(2); // TODO: Not sure PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof EndPrecompiledTypeMsType, true); String result = type.toString().trim(); assertEquals("EndPrecompiled: signature=0XFEDCBA98", result); @@ -1091,7 +1088,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(new byte[] { 0x03, 0x02, 0x01, 0x00 }); //writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof OemDefinableString16MsType, true); String result = type.toString().trim(); assertEquals("OEM Definable String\n" + " MSFT-assigned OEM Identifier: 8192\n" + @@ -1113,7 +1110,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(new byte[] { 0x03, 0x02, 0x01, 0x00 }); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof OemDefinableStringMsType, true); String result = type.toString().trim(); assertEquals("OEM Definable String\n" + " MSFT-assigned OEM Identifier: 8192\n" + @@ -1135,7 +1132,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(new byte[] { 0x03, 0x02, 0x01, 0x00 }); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof OemDefinableString2MsType, true); String result = type.toString().trim(); assertEquals("OEM Definable String 2\n" + " GUID: 0c0d0e0f-0a0b-0809-0706-050403020100\n" + @@ -1152,7 +1149,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("serverSt"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof TypeServerStMsType, true); String result = type.toString().trim(); assertEquals("<>", result); @@ -1167,7 +1164,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("server"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof TypeServerMsType, true); String result = type.toString().trim(); assertEquals("<>", result); @@ -1183,7 +1180,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("server"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof TypeServer2MsType, true); String result = type.toString().trim(); assertEquals("<>", result); @@ -1198,7 +1195,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(new byte[] { (byte) 0xf1, (byte) 0xf2 }); //writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Skip16MsType, true); String result = type.toString().trim(); assertEquals("Skip Record, nextValidTypeIndex = 0x2000, Length = 0x2", result); @@ -1213,7 +1210,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(new byte[] { 0x03, 0x02, 0x01, 0x00 }); //writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof SkipMsType, true); String result = type.toString().trim(); assertEquals("Skip Record, nextValidTypeIndex = 0x2000, Length = 0x4", result); @@ -1228,7 +1225,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // Type index of argument. writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ArgumentsList16MsType, true); String result = type.toString().trim(); assertEquals("(DummyMsType, DummyMsType)", result); @@ -1243,7 +1240,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedInt(4096); // Type index of argument. writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ArgumentsListMsType, true); String result = type.toString().trim(); assertEquals("(DummyMsType, DummyMsType)", result); @@ -1258,7 +1255,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedInt(stringIdMsType2); // Type index of element. writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof SubstringListMsType, true); String result = type.toString().trim(); assertEquals("String1String2", result); @@ -1273,7 +1270,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("TailOfString"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof StringIdMsType, true); String result = type.toString().trim(); assertEquals("String1String2TailOfString", result); @@ -1287,7 +1284,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("expression"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof DefaultArguments16MsType, true); String result = type.toString().trim(); assertEquals("DummyMsType expression", result); @@ -1301,7 +1298,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("expression"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof DefaultArgumentsStMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType expression", result); @@ -1315,7 +1312,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("expression"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof DefaultArgumentsMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType expression", result); @@ -1328,7 +1325,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedByte(0x41); //writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ListMsType, true); String result = type.toString().trim(); assertEquals("<>", result); @@ -1349,7 +1346,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(member16MsTypeBytes); writer.putPadding(0); // Records in FieldList align on their own basis PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof FieldList16MsType, true); String result = type.toString().trim(); assertEquals(": public static:DummyMsType<@16>, public" + @@ -1373,7 +1370,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(memberMsTypeBytes); writer.putPadding(0); // Records in FieldList align on their own basis PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof FieldListMsType, true); String result = type.toString().trim(); assertEquals(": public static:DummyMsType<@16>, public" + @@ -1391,7 +1388,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // type index writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof DerivedClassList16MsType, true); String result = type.toString().trim(); assertEquals("DummyMsType, DummyMsType", result); @@ -1406,7 +1403,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedInt(4096); // type index writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof DerivedClassListMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType, DummyMsType", result); @@ -1421,7 +1418,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // type index writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Bitfield16MsType, true); String result = type.toString().trim(); assertEquals("DummyMsType : 2 <@2>", result); @@ -1436,7 +1433,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedByte(2); // position writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof BitfieldMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType : 2 <@2>", result); @@ -1445,7 +1442,7 @@ public class TypesTest extends AbstractGenericTest { @Test public void testMethodList16MsType() throws Exception { PdbByteReader reader = new PdbByteReader(createMethodList16MsTypeBuffer()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof MethodList16MsType, true); String result = type.toString().trim(); assertEquals("{: DummyMsType>,: DummyMsType>,:DummyMsType<@16>", result); @@ -1626,7 +1623,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(symbolBytes); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof BaseClassMsType, true); String result = type.toString().trim(); assertEquals("public static:DummyMsType<@16>", result); @@ -1645,7 +1642,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNumeric(new BigInteger("10", 16), 0x8002); //offset of base class within class writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof BaseInterfaceMsType, true); String result = type.toString().trim(); assertEquals("public static:DummyMsType<@16>", result); @@ -1662,13 +1659,13 @@ public class TypesTest extends AbstractGenericTest { byte[] attributesBuffer = createClassFieldMsAttributesBuffer(attributes, property, true, true, true, true, true); writer.putBytes(attributesBuffer); - // Offset of virtual base pointer from address point + // Offset of virtual base pointer from address point writer.putNumeric(new BigInteger("10", 16), 0x8002); // Offset of virtual base from vbtable. writer.putNumeric(new BigInteger("10", 16), 0x8002); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof VirtualBaseClass16MsType, true); String result = type.toString().trim(); assertEquals("public static: < DummyMsType vbp;" + @@ -1686,13 +1683,13 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(attributesBuffer); writer.putInt(4096); // type index of direct virtual base class writer.putInt(4096); // type index of virtual base class - // Offset of virtual base pointer from address point + // Offset of virtual base pointer from address point writer.putNumeric(new BigInteger("10", 16), 0x8002); // Offset of virtual base from vbtable. writer.putNumeric(new BigInteger("10", 16), 0x8002); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof VirtualBaseClassMsType, true); String result = type.toString().trim(); assertEquals("public static: < DummyMsType vbp;" + @@ -1710,13 +1707,13 @@ public class TypesTest extends AbstractGenericTest { byte[] attributesBuffer = createClassFieldMsAttributesBuffer(attributes, property, true, true, true, true, true); writer.putBytes(attributesBuffer); - // Offset of virtual base pointer from address point + // Offset of virtual base pointer from address point writer.putNumeric(new BigInteger("10", 16), 0x8002); // Offset of virtual base from vbtable. writer.putNumeric(new BigInteger("10", 16), 0x8002); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof IndirectVirtualBaseClass16MsType, true); String result = type.toString().trim(); assertEquals(": DummyMsType vbp;" + @@ -1734,13 +1731,13 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(attributesBuffer); writer.putInt(4096); // type index of direct virtual base class writer.putInt(4096); // type index of virtual base class - // Offset of virtual base pointer from address point + // Offset of virtual base pointer from address point writer.putNumeric(new BigInteger("10", 16), 0x8002); // Offset of virtual base from vbtable. writer.putNumeric(new BigInteger("10", 16), 0x8002); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof IndirectVirtualBaseClassMsType, true); String result = type.toString().trim(); assertEquals(": DummyMsType vbp;" + @@ -1760,7 +1757,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("enumerateName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof EnumerateStMsType, true); String result = type.toString().trim(); assertEquals("public static: enumerateName=16", result); @@ -1779,7 +1776,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("enumerateName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof EnumerateMsType, true); String result = type.toString().trim(); assertEquals("public static: enumerateName=16", result); @@ -1793,7 +1790,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("friendFunctionName"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof FriendFunction16MsType, true); String result = type.toString().trim(); // TODO: probably need a type other than 4096... need something that emits like a function. @@ -1809,7 +1806,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("friendFunctionName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof FriendFunctionStMsType, true); String result = type.toString().trim(); // TODO: probably need a type other than 4096... need something that emits like a function. @@ -1825,7 +1822,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("friendFunctionName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof FriendFunctionMsType, true); String result = type.toString().trim(); // TODO: probably need a type other than 4096... need something that emits like a function. @@ -1839,7 +1836,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(4096); // type index of friend function. writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Index16MsType, true); assertEquals(((Index16MsType) type).getReferencedRecordNumber().getNumber(), 4096); String result = type.toString().trim(); @@ -1854,7 +1851,7 @@ public class TypesTest extends AbstractGenericTest { writer.putInt(4096); // type index of friend function. writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof IndexMsType, true); assertEquals(((AbstractIndexMsType) type).getReferencedRecordNumber().getNumber(), 4096); String result = type.toString().trim(); @@ -1868,7 +1865,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(symbolBytes); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof Member16MsType, true); String result = type.toString().trim(); assertEquals("public static: DummyMsType memberName<@16>", @@ -1882,7 +1879,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(symbolBytes); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof MemberStMsType, true); String result = type.toString().trim(); assertEquals("public static: DummyMsType memberName<@16>", @@ -1896,7 +1893,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(symbolBytes); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof MemberMsType, true); String result = type.toString().trim(); assertEquals("public static: DummyMsType memberName<@16>", @@ -1916,7 +1913,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("staticMemberName"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof StaticMember16MsType, true); String result = type.toString().trim(); assertEquals( @@ -1937,7 +1934,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("staticMemberName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof StaticMemberStMsType, true); String result = type.toString().trim(); assertEquals( @@ -1958,7 +1955,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("staticMemberName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof StaticMemberMsType, true); String result = type.toString().trim(); assertEquals( @@ -1970,14 +1967,15 @@ public class TypesTest extends AbstractGenericTest { public void testOverloadedMethod16MsType() throws Exception { PdbByteWriter writer = new PdbByteWriter(); writer.putUnsignedShort(OverloadedMethod16MsType.PDB_ID); - int count = ((AbstractMethodListMsType) pdb.getTypeRecord( - RecordNumber.make(RecordCategory.TYPE, methodList16MsType1))).getListSize(); + int count = ((AbstractMethodListMsType) pdb + .getTypeRecord(RecordNumber.make(RecordCategory.TYPE, methodList16MsType1))) + .getListSize(); writer.putUnsignedShort(count); writer.putUnsignedShort(methodList16MsType1); // type index of MethodList16MsType writer.putByteLengthPrefixedString("overloadedMethodName"); writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof OverloadedMethod16MsType, true); String result = type.toString().trim(); assertEquals("overloaded[2]:overloadedMethodName{: DummyMsType,0>", result); @@ -2205,7 +2205,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("methodName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof OneMethodStMsType, true); String result = type.toString().trim(); assertEquals(": DummyMsType,0>", result); @@ -2229,7 +2229,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("methodName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof OneMethodMsType, true); String result = type.toString().trim(); assertEquals(": DummyMsType,0>", result); @@ -2243,7 +2243,7 @@ public class TypesTest extends AbstractGenericTest { writer.putInt(8); // offset writer.putPadding(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof VirtualFunctionTablePointerWithOffset16MsType, true); String result = type.toString().trim(); assertEquals("VFTablePtr: DummyMsType", result); @@ -2258,7 +2258,7 @@ public class TypesTest extends AbstractGenericTest { writer.putInt(8); // offset writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof VirtualFunctionTablePointerWithOffsetMsType, true); String result = type.toString().trim(); assertEquals("VFTablePtr: DummyMsType", result); @@ -2277,7 +2277,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("memberName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof MemberModifyStMsType, true); String result = type.toString().trim(); assertEquals("public static: DummyMsType memberName", @@ -2297,7 +2297,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("memberName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof MemberModifyMsType, true); String result = type.toString().trim(); assertEquals("public static: DummyMsType memberName", @@ -2311,7 +2311,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedUtf8String("managedTypeName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ManagedStMsType, true); String result = type.toString().trim(); assertEquals("managedTypeName", result); @@ -2324,7 +2324,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedUtf8String("managedTypeName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ManagedMsType, true); String result = type.toString().trim(); assertEquals("managedTypeName", result); @@ -2338,7 +2338,7 @@ public class TypesTest extends AbstractGenericTest { writer.putByteLengthPrefixedString("aliasName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof AliasStMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType aliasName", result); @@ -2352,7 +2352,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("aliasName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof AliasMsType, true); String result = type.toString().trim(); assertEquals("DummyMsType aliasName", result); @@ -2376,7 +2376,7 @@ public class TypesTest extends AbstractGenericTest { writer.putBytes(new byte[] { 0x00, 0x00 }); // padding //writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof HighLevelShaderLanguageMsType, true); String result = type.toString().trim(); assertEquals("Built-In HLSL: InterfacePointer ", result); @@ -2398,7 +2398,7 @@ public class TypesTest extends AbstractGenericTest { } writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof ModifierExMsType, true); String result = type.toString().trim(); assertEquals("const volatile __unaligned __uniform__ __line__ __triangle__ __lineadj__" + @@ -2424,7 +2424,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("vectorName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof VectorMsType, true); String result = type.toString().trim(); assertEquals("vector: vectorName[ 5]", result); @@ -2449,7 +2449,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("matrixName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof MatrixMsType, true); String result = type.toString().trim(); assertEquals("matrix: matrixName[column 3][row 2]", result); @@ -2464,7 +2464,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("functionIdName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof FunctionIdMsType, true); String result = type.toString().trim(); assertEquals("FunctionId for: DummyMsType ItemDummyMsType::functionIdName", result); @@ -2479,7 +2479,7 @@ public class TypesTest extends AbstractGenericTest { writer.putNullTerminatedString("memberFunctionIdName"); writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof MemberFunctionIdMsType, true); String result = type.toString().trim(); assertEquals("MemberFunctionId for: DummyMsType DummyMsType::memberFunctionIdName", result); @@ -2494,7 +2494,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedInt(1000); // Line number writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof UserDefinedTypeSourceAndLineMsType, true); String result = type.toString().trim(); assertEquals( @@ -2513,7 +2513,7 @@ public class TypesTest extends AbstractGenericTest { writer.putUnsignedShort(1); // Module that contributes the UDT definition. writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof UserDefinedTypeModuleSourceAndLineMsType, true); String result = type.toString().trim(); assertEquals("UserDefinedTypeModuleSourceAndLineMsType, module: 1, line: 1000," + @@ -2532,7 +2532,7 @@ public class TypesTest extends AbstractGenericTest { writer.putInt(stringIdMsType1); // value for argument 4. writer.putAlign(2); PdbByteReader reader = new PdbByteReader(writer.get()); - AbstractMsType type = typeParser.parse(reader); + AbstractMsType type = TypeParser.parse(pdb, reader); assertEquals(type instanceof BuildInfoMsType, true); String result = type.toString().trim(); assertEquals("CurrentDirectory: String1, BuildTool: String2, SourceFile: String1," +