Ghidra is a software reverse engineering (SRE) framework
GP-3947: Created an importer for the decompiler debug format which is produced by the decompiler
ghidravision38541a7ac67b
diff --git a/Ghidra/Features/Base/certification.manifest b/Ghidra/Features/Base/certification.manifestindex 66ddb236cb..74fa75a598 100644--- a/Ghidra/Features/Base/certification.manifest+++ b/Ghidra/Features/Base/certification.manifest@@ -1086,4 +1086,5 @@ src/test.slow/resources/filterTestDirList.txt||GHIDRA||||END|src/test.slow/resources/ghidra/app/plugin/core/datamgr/TestDataType.txt||GHIDRA||||END|src/test.slow/resources/ghidra/app/script/GhidraScriptAsk.properties||GHIDRA||||END|src/test/resources/defaultTools/TestCodeBrowser.tool||GHIDRA||||END|+src/test/resources/ghidra/app/util/opinion/decompile_debug_test.xml||GHIDRA||||END|src/test/resources/ghidra/app/util/opinion/test.ord||GHIDRA||||END|diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugByteManager.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugByteManager.javanew file mode 100644index 0000000000..ea0279f57c--- /dev/null+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugByteManager.java@@ -0,0 +1,114 @@+/* ###+ * IP: GHIDRA+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+/**+ *+ */+package ghidra.app.util.opinion;++import static ghidra.program.model.pcode.AttributeId.*;++import java.util.HexFormat;++import ghidra.framework.store.LockException;+import ghidra.program.model.address.Address;+import ghidra.program.model.address.AddressOverflowException;+import ghidra.program.model.listing.Program;+import ghidra.program.model.mem.*;+import ghidra.util.exception.CancelledException;+import ghidra.util.task.TaskMonitor;+import ghidra.xml.*;++/**+ * Manager to hold byte information from the <bytechunk> tags inside the Decompiler Debug's XML.+ */+public class DecompileDebugByteManager {++ TaskMonitor monitor;+ Program prog;+ String programName;++ /**+ * @param monitor TaskMonitor+ * @param prog main program+ * @param programName name of program+ */+ public DecompileDebugByteManager(TaskMonitor monitor,+ Program prog, String programName) {+ this.monitor = monitor;+ this.prog = prog;+ this.programName = programName;+ }++ /**+ * Parse the <bytechunk> tag - has the memory offset and the raw bytes+ *+ * @param parser XmlPullParser+ * @param log Xml+ */+ public void parse(XmlPullParser parser, XmlMessageLog log) {++ while (parser.peek().getName().equals("bytechunk") && !monitor.isCancelled()) {+ processByteChunk(parser, log);+ }+ }++ /**+ * Handle parsing and creating bytechunks & pulling out the byte string as a byte array.+ *+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ */+ private void processByteChunk(XmlPullParser parser, XmlMessageLog log) {++ XmlElement byteChunkElement = parser.start("bytechunk");+ Address address =+ prog.getAddressFactory()+ .getAddress(byteChunkElement.getAttribute(ATTRIB_OFFSET.name()));++ // end element contains the byte content+ byteChunkElement = parser.end(byteChunkElement);+ String hexString = byteChunkElement.getText().trim().replaceAll("\n", "");+ byte[] rawBytes = HexFormat.of().parseHex(hexString);++ if (!generateMemoryChunk(rawBytes, address, log)) {+ log.appendMsg("Error attempting to load memory chunk");+ }+ }++ /**+ * Create memory blocks with the raw bytes from the central function and any other blocks+ * such as for pointers or other data types that the Decompile.xml file was generated from.+ *+ * @param rawBytes raw program bytes+ * @param address memory offset+ * @param log XmlMessageLog+ */+ private boolean generateMemoryChunk(byte[] rawBytes, Address address, XmlMessageLog log) {+ Memory memory = prog.getMemory();+ try {+ memory.createInitializedBlock(programName, address, rawBytes.length, (byte) 0,+ monitor, false);+ memory.setBytes(address, rawBytes);+ }+ catch (LockException | IllegalArgumentException | MemoryConflictException+ | AddressOverflowException | CancelledException | MemoryAccessException e) {+ log.appendException(e);+ return false;+ }+ return true;+ }++}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugDataTypeManager.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugDataTypeManager.javanew file mode 100644index 0000000000..bf7d506138--- /dev/null+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugDataTypeManager.java@@ -0,0 +1,470 @@+/* ###+ * IP: GHIDRA+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+/**+ *+ */+package ghidra.app.util.opinion;++import static ghidra.program.model.pcode.AttributeId.*;++import java.math.BigInteger;+import java.util.Map;+import java.util.TreeMap;++import ghidra.program.model.data.*;+import ghidra.program.model.data.Enum;+import ghidra.program.model.listing.Program;+import ghidra.program.model.pcode.AttributeId;+import ghidra.util.task.TaskMonitor;+import ghidra.util.xml.SpecXmlUtils;+import ghidra.xml.*;++/**+ * Manager for parsing and storing data type objects from the XML - identified by+ * the <coretypes> and <typegrp> tags.+ *+ * NOTE: In the typegrp subtree, ID is often on a different line from the element's name and+ * metatype, so we need a way to reference this for use in the map -- String idHolder var+ * helps with this.+ */+public class DecompileDebugDataTypeManager {++ TaskMonitor monitor;+ Program prog;+ Map<DataTypeKey, DataType> dataTypeMap;+ DataTypeManager programDataManager;+ BuiltInDataTypeManager builtInMngr = BuiltInDataTypeManager.getDataTypeManager();+ private String idHolder;++ /**+ * @param monitor TaskMonitor+ * @param prog main program info+ */+ public DecompileDebugDataTypeManager(TaskMonitor monitor, Program prog) {+ this.monitor = monitor;+ this.prog = prog;+ this.dataTypeMap = new TreeMap<DataTypeKey, DataType>();+ programDataManager = this.prog.getListing().getDataTypeManager();+ }++ /**+ * Parse Data Type tag, handling types:+ * <type>+ * <typeref>+ * <def>+ * <void>+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ *+ * @return retrieved DataType+ */+ public DataType parseDataTypeTag(XmlPullParser parser, XmlMessageLog log) {++ String tagName = parser.peek().getName();+ DataType retrieved = null;+ switch (tagName) {+ case "type":+ retrieved = parseType(parser, log);+ break;+ case "typeref":+ retrieved = parseRefType(parser, log);+ break;+ case "def":+ retrieved = parseDef(parser, log);+ break;+ case "void":+ XmlElement voidElement = parser.start("void");+ parser.end(voidElement);+ return new VoidDataType();+ default:+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + tagName);+ parser.discardSubTree();+ }+ return retrieved;+ }++ /**+ * Parse the <type> tag+ *+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ */+ private DataType parseType(XmlPullParser parser, XmlMessageLog log) {++ DataType retrieved = null;+ String metatype = parser.peek().getAttribute("metatype");+ if (metatype == null) { // in the typegrp subtree, metatype and name/id are not on the same line+ retrieved = retreiveBaseType(parser, log);+ return retrieved;+ }+ switch (metatype) {+ case "ptr":+ retrieved = parsePointer(parser, log);+ break;+ case "ptrrel":+ retrieved = parsePointerRelative(parser, log);+ break;+ case "array":+ retrieved = parseArray(parser, log);+ break;+ case "struct":+ retrieved = parseStruct(parser, log);+ break;+ case "union":+ retrieved = parseUnion(parser, log);+ break;+ case "enum_int":+ case "enum_uint":+ retrieved = parseEnum(parser, log);+ break;+ default:+ retrieved = retreiveBaseType(parser, log);+ }+ return retrieved;+ }++ /**+ * TypeDefs (<def> tags) are new definitions of types - basically, a re-naming.+ *+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ *+ * @return retrieved DataType+ */+ private DataType parseDef(XmlPullParser parser, XmlMessageLog log) {+ XmlElement defElement = parser.start("def");+ DataTypeKey key = new DataTypeKey(defElement);++ if (!dataTypeMap.containsKey(key)) {+ DataType typeDefedType = parseDataTypeTag(parser, log);+ TypedefDataType generatedTypeDef = new TypedefDataType(+ new CategoryPath(CategoryPath.ROOT + key.name()), key.name(), typeDefedType,+ programDataManager);+ DataType resolvedDT = resolveAndMapDataType(key, generatedTypeDef);+ parser.end(defElement);+ return resolvedDT;+ }+ return dataTypeMap.get(key);+ }++ /**+ * Parse and handle enum types - signed/unsigned+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ *+ * @return resolved DataType+ */+ private DataType parseEnum(XmlPullParser parser, XmlMessageLog log) {+ XmlElement enumElement = parser.start("type");+ DataTypeKey key = new DataTypeKey(enumElement);+ int length = SpecXmlUtils.decodeInt(enumElement.getAttribute(ATTRIB_SIZE.name()));+ Enum enumDT = null;++ if (dataTypeMap.containsKey(key) == false) {+ enumDT = new EnumDataType(new CategoryPath(CategoryPath.ROOT + key.name()), key.name(),+ length,+ programDataManager);+ enumDT =+ (Enum) resolveAndMapDataType(key, enumDT);+ }+ else {+ enumDT = (Enum) dataTypeMap.get(key);+ }++ while (parser.peek().getName().equals(ATTRIB_VAL.name())) {+ XmlElement valElement = parser.start(ATTRIB_VAL.name());++ enumDT.add(valElement.getAttribute(ATTRIB_NAME.name()),+ SpecXmlUtils.decodeInt(valElement.getAttribute(ATTRIB_VALUE.name())), "");+ parser.end(valElement);+ }+ parser.end(enumElement);+ return enumDT;+ }++ /**+ * Parse & create union types+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ *+ * @return resolved DataType+ */+ private DataType parseUnion(XmlPullParser parser, XmlMessageLog log) {+ XmlElement unionElement = parser.start("type");+ DataTypeKey key = new DataTypeKey(unionElement);+ int size = SpecXmlUtils.decodeInt(unionElement.getAttribute(ATTRIB_SIZE.name()));+ Union unionDT = null;++ if (dataTypeMap.containsKey(key) == false) {+ unionDT =+ new UnionDataType(new CategoryPath(CategoryPath.ROOT + key.name()), key.name(),+ programDataManager);+ unionDT = (Union) resolveAndMapDataType(key, unionDT);+ }+ else {+ unionDT = (Union) dataTypeMap.get(key);+ }++ if (unionElement.hasAttribute(ATTRIB_INCOMPLETE.name()) || size == 0) {+ parser.end(unionElement);+ return unionDT;+ }++ while (parser.peek().getName().equals("field")) {+ XmlElement fieldElement = parser.start("field");+ DataType fieldDT = parseDataTypeTag(parser, log);+ unionDT.add(fieldDT, fieldDT.getLength(), key.name(), "");+ parser.end(fieldElement);+ }+ parser.end(unionElement);+ return unionDT;+ }++ /**+ * Parse and process Array Data Type+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ *+ * @return DataType+ */+ private DataType parseArray(XmlPullParser parser, XmlMessageLog log) {+ XmlElement arrayElement = parser.start("type");+ int arraySize =+ SpecXmlUtils.decodeInt(arrayElement.getAttribute(AttributeId.ATTRIB_ARRAYSIZE.name()));++ DataType baseType = parseDataTypeTag(parser, log);+ ArrayDataType arrayDT =+ new ArrayDataType(baseType, arraySize, baseType.getLength(), programDataManager);+ DataType resolved = resolveAndMapDataType(+ new DataTypeKey(baseType.getName() + "array", idHolder), arrayDT);+ parser.end(arrayElement);+ return resolved;+ }++ /**+ * Handle parsing and creating a pointer data type. Add to the programDataManager and the+ * DataTypeMap for use later.+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ * @return generated pointer data type+ */+ private DataType parsePointer(XmlPullParser parser, XmlMessageLog log) {+ XmlElement pointerElement = parser.start("type");+ int size = SpecXmlUtils.decodeInt(pointerElement.getAttribute(ATTRIB_SIZE.name()));++ DataType baseType = parseDataTypeTag(parser, log);+ PointerDataType pointerDT = new PointerDataType(baseType, size, programDataManager);+ DataType resolved =+ resolveAndMapDataType(new DataTypeKey(baseType.getName() + "ptr", idHolder),+ pointerDT);++ parser.end(pointerElement);+ return resolved;+ }++ /**+ * Parse and handle 'pointer with offset' data types: PointerTypeDef {@PointerTypedef.java line #91}.+ * These are useful for labeling a variable that points into the interior of a structure,+ * but where the compiler still knows it can access the whole structure.+ *+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ * @return DataType - PointerTypeDef+ */+ private DataType parsePointerRelative(XmlPullParser parser, XmlMessageLog log) {+ XmlElement pointerRelElement = parser.start("type");+ int size = SpecXmlUtils.decodeInt(pointerRelElement.getAttribute(ATTRIB_SIZE.name()));+ Long offset = SpecXmlUtils.decodeLong(pointerRelElement.getAttribute(ATTRIB_OFF.name()));++ DataType baseType = parseDataTypeTag(parser, log);+ PointerTypedef relPointerDT =+ new PointerTypedef(baseType.getName(), baseType, size, programDataManager, offset);++ DataType resolved = resolveAndMapDataType(new DataTypeKey(baseType.getName()+"relptr", idHolder), relPointerDT);+ parser.end(pointerRelElement);++ return resolved;+ }++ /**+ * Handle parsing and generating a struct type; populating it with fields.+ *+ * @param parser XmlPullParser+ * @param log XmlMessageLog++ * @return Structure data type - either an empty one or completed one with fields+ */+ private DataType parseStruct(XmlPullParser parser, XmlMessageLog log) {+ XmlElement structElement = parser.start("type");+ DataTypeKey key = new DataTypeKey(structElement);+ int size = SpecXmlUtils.decodeInt(structElement.getAttribute(ATTRIB_SIZE.name()));+ Structure createdStruct = null;++ if (dataTypeMap.containsKey(key) == false) {+ StructureDataType newStruct =+ new StructureDataType(key.name(), size, programDataManager);+ createdStruct = (Structure) resolveAndMapDataType(key, newStruct);+ }+ else {+ createdStruct =+ (Structure) dataTypeMap.get(key);+ }++ if (structElement.hasAttribute(ATTRIB_INCOMPLETE.name()) || size == 0) {+ parser.end(structElement);+ return createdStruct;+ }++ while (parser.peek().getName().equals("field")) {+ XmlElement fieldElement = parser.start("field");+ int fieldOffset =+ SpecXmlUtils.decodeInt(fieldElement.getAttribute(ATTRIB_OFFSET.name()));++ DataType fieldDT = parseDataTypeTag(parser, log);+ createdStruct.replaceAtOffset(fieldOffset, fieldDT, fieldDT.getLength(),+ fieldElement.getAttribute(ATTRIB_NAME.name()), "");+ parser.end(fieldElement);+ }+ parser.end(structElement);++ return createdStruct;++ }++ /**+ * The type should already exist in the map and in the Program's data type manager.+ * If it's not there, this is an error.+ *+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ *+ * @return retrieved DataType or null if it's not actually in the map (this should never happen)+ */+ private DataType parseRefType(XmlPullParser parser, XmlMessageLog log) {+ XmlElement typeRefElement = parser.start("typeref");+ DataTypeKey key = new DataTypeKey(typeRefElement);+ DataType dt = dataTypeMap.get(key);++ if (dt == null) {+ log.appendMsg("Data Type referenced without first being created.");+ }+ parser.end(typeRefElement);+ return dt;+ }++ /**+ * Pull the core type from the data type map+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ *+ * @return Retrieved DataType+ */+ private DataType retreiveBaseType(XmlPullParser parser, XmlMessageLog log) {+ XmlElement typeElement = parser.start("type");+ DataType retrieved = null;+ DataTypeKey key = new DataTypeKey(typeElement);+ // We need to be able to reference the current ID when building composite DTs+ idHolder = key.id();++ if (dataTypeMap.containsKey(key)) {+ retrieved = dataTypeMap.get(key);+ }+ else {+ retrieved = builtInMngr.getDataType(CategoryPath.ROOT, key.name().toLowerCase()); // there are some cases where the DT name is defined in lowercase and then later referred inconsistently+ if (retrieved != null) {+ retrieved = resolveAndMapDataType(key, retrieved);+ }+ else {+ log.appendMsg("Type tag " + key.name() + " didn't resolve");+ }+ }+ parser.end(typeElement);+ return retrieved;+ }++ /**+ * Resolve the provided DataType against the Program Manager then add it to the DataTypeMap+ * for referencing later.+ * @param key DataTypeKey consisting of a name and ID for referencing+ * @param generatedTypeDef DataType identified Data Type for resolving and mapping+ *+ * @return resolved DataType+ */+ private DataType resolveAndMapDataType(DataTypeKey key, DataType generatedTypeDef) {++ DataType resolvedDT = programDataManager.resolve(generatedTypeDef, dtConflictHandler);+ dataTypeMap.put(key, resolvedDT);+ return resolvedDT;+ }++ public static DataTypeConflictHandler dtConflictHandler = new DataTypeConflictHandler() {++ @Override+ public ConflictResult resolveConflict(DataType addedDataType, DataType existingDataType) {+ return ConflictResult.RENAME_AND_ADD;+ }++ @Override+ public boolean shouldUpdate(DataType sourceDataType, DataType localDataType) {+ return true;+ }++ @Override+ public DataTypeConflictHandler getSubsequentHandler() {+ return DEFAULT_HANDLER;+ }++ };++ /**+ * Data Types are organized by their name and ID; utilize a combo key structure for this organization+ * Name, ID -> DataType+ * @param name String data type name+ * @param id String data type id+ * @param val BigInteger to account for ID's that aren't written in Hex.+ */+ static record DataTypeKey(String name, String id, BigInteger val)+ implements Comparable<DataTypeKey> {++ public DataTypeKey(XmlElement typeRefElement) {+ this(typeRefElement.getAttribute(ATTRIB_NAME.name()),+ typeRefElement.getAttribute(ATTRIB_ID.name()));+ }++ public DataTypeKey(String name, String id) {+ this(name, id,+ (id.startsWith("0x") ? new BigInteger(id.substring(2), 16)+ : new BigInteger(id, 10)));+ }++ public DataTypeKey(String name, String id, BigInteger val) {+ this.name = name;+ this.id = id;+ this.val = val;+ }++ @Override+ public int compareTo(DataTypeKey other) {+ int nameCompare = this.name.compareTo(other.name);+ if (nameCompare != 0) {+ return nameCompare;+ }+ return (int) (this.val.longValue() - other.val.longValue());+ }+ }++}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugFormatManager.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugFormatManager.javanew file mode 100644index 0000000000..6aab6903a4--- /dev/null+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugFormatManager.java@@ -0,0 +1,722 @@+/* ###+ * IP: GHIDRA+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+/**+ *+ */+package ghidra.app.util.opinion;++import static ghidra.program.model.pcode.AttributeId.*;++import java.io.File;+import java.io.IOException;+import java.math.BigInteger;+import java.util.*;++import org.xml.sax.*;++import ghidra.app.util.bin.ByteProvider;+import ghidra.app.util.importer.MessageLog;+import ghidra.app.util.opinion.DecompileDebugXmlLoader.DecompileDebugProgramInfo;+import ghidra.framework.store.LockException;+import ghidra.program.model.address.Address;+import ghidra.program.model.address.AddressOverflowException;+import ghidra.program.model.data.DataType;+import ghidra.program.model.lang.Register;+import ghidra.program.model.listing.*;+import ghidra.program.model.mem.*;+import ghidra.program.model.pcode.AddressXML;+import ghidra.program.model.symbol.*;+import ghidra.program.model.util.CodeUnitInsertionException;+import ghidra.util.exception.*;+import ghidra.util.task.TaskMonitor;+import ghidra.util.xml.SpecXmlUtils;+import ghidra.xml.*;++/**+ * Main manager for handling the coordination of the parsing of the XML and loading of the program+ * details into Ghidra.+ */+public class DecompileDebugFormatManager {++ private File file;+ private DecompileDebugProgramInfo progInfo;+ private Map<Long, Namespace> scopeMap;++ /**+ * Constructs a new program Decompiler Debug XML manager using the provided file.+ * The file should be an XML file generated by the Ghidra Decompiler as a debug file.+ *+ * @param file generated XML Decompile Debug file+ */+ public DecompileDebugFormatManager(File file) {+ this.file = file;+ }++ /*+ * Constructs a new program Decompiler Debug XML manager using the provided ByteProvider.+ * <p>+ * If {@link ByteProvider} has a {@link FSRL} and it is a simple local filepath,+ * convert that to a normal local java.io.File instance instead of using the+ * {@link ByteProvider}'s File property which is probably located in the+ * {@link FileSystemService} filecache directory, which will break the ability+ * to find the *.bytes file associated with this .xml file.+ * <p>+ * @param provider+ */+ public DecompileDebugFormatManager(ByteProvider provider) {+ this.file = (provider.getFSRL() != null && provider.getFSRL().getNestingDepth() == 1)+ ? new File(provider.getFSRL().getPath())+ : provider.getFile();+ }++ /*+ * Initial parsing of the XML file to obtain the binary image info with load specs.+ *+ * @return DecompileDebugProgramInfo binary image / load spec details+ */+ public DecompileDebugProgramInfo getProgramInfo() throws SAXException, IOException {+ XmlPullParser parser =+ XmlPullParserFactory.create(file, new MyErrorHandler(new MessageLog()), false);++ String loadSpecString = "";+ String offset = "";++ while (parser.hasNext()) {+ XmlElement element = parser.next();+ if (element.isStart("binaryimage")) {+ loadSpecString = element.getAttribute("arch");+ }+ else if (element.isStart("bytechunk")) {+ offset = element.getAttribute(ATTRIB_OFFSET.name());+ break;+ }++ }+ String compilerString =+ loadSpecString.substring(loadSpecString.lastIndexOf(':') + 1, loadSpecString.length());+ loadSpecString = loadSpecString.substring(0, loadSpecString.lastIndexOf(':'));++ progInfo = new DecompileDebugProgramInfo(offset, compilerString, loadSpecString);+ parser.dispose();+ return progInfo;+ }++ /**+ * Perform the parsing from the underlying decompile debug XML file and populates the program fields.+ * See @DecompileDebug.java for reference on the generation of the XML file.+ * Tags currently supported/expected:+ * - <binaryimage>+ * - <coretypes>+ * - <typegrp>+ * - <save_state>+ * - <db>+ * - <commentdb>+ * - <stringmanage>+ *+ * NOTE: the following subtree tags are not yet supported:+ * - <context_points>+ * - <optionslist>+ *+ * @param prog created program+ * @param monitor task monitor+ * @param programName name of program+ *@return MessageLog+ * @throws LoadException If there is a parsing issue with the XML file.+ */+ public MessageLog read(Program prog, TaskMonitor monitor, String programName)+ throws LoadException {+ XmlMessageLog log = new XmlMessageLog();+ MyErrorHandler errorHandler = new MyErrorHandler(log);+ scopeMap = new TreeMap<Long, Namespace>();+ scopeMap.put((long) 0, prog.getGlobalNamespace());+ int transactionId = prog.startTransaction("Loading");+ XmlPullParser parser = null;+ try {+ parser = XmlPullParserFactory.create(file, errorHandler, false);+ log.setParser(parser);+ monitor.setMessage("Beginning Load");+ log.appendMsg("Beginning Load");+ XmlElement startSavefileElement = parser.start("xml_savefile");+ XmlElement saveStateElement = null;+ DecompileDebugDataTypeManager dataTypeManager =+ new DecompileDebugDataTypeManager(monitor, prog);+ while (parser.peek().isStart() && !monitor.isCancelled()) {+ XmlElement element = null;+ String name = parser.peek().getName();+ switch (name) {++ case "binaryimage":+ element = parser.start("binaryimage");+ handleBinaryImageElements(parser, monitor, prog, programName, log);+ parser.end(element);+ break;++ case "coretypes":+ monitor.setMessage("Processing Core Data Types");+ element = parser.start("coretypes");+ parseDataTypes(parser, monitor, prog, dataTypeManager, log);+ parser.end(element);+ break;++ case "typegrp":+ monitor.setMessage("Processing Composite Data Types");+ element = parser.start("typegrp");+ parseDataTypes(parser, monitor, prog, dataTypeManager, log);+ parser.end(element);+ break;++ case "save_state":+ saveStateElement = parser.start("save_state"); // wrapper tag holds all the program details aside from the binaryimage/memory+ break;++ case "db":+ element = parser.start("db");+ handleDBElements(parser, monitor, prog, dataTypeManager, programName, log);+ parser.end(element);+ break;++ case "commentdb":+ element = parser.start("commentdb");+ parseComments(parser, monitor, prog, log);+ parser.end(element);+ break;++ case "stringmanage":+ element = parser.start("stringmanage");+ parseStrings(parser, monitor, prog, log);+ parser.end(element);+ break;++ case "context_points":+ element = parser.start("context_points");+ parseContextPoints(parser, monitor, prog, log);+ parser.end(element);+ break;++ default:+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + name);+ parser.discardSubTree(name);+ break;+ }+ }++ parser.end(saveStateElement);+ parser.end(startSavefileElement);+ }++ catch (SAXException | IOException e) {+ log.appendException(e);+ throw new LoadException("File read error.");+ }++ finally {+ monitor.setMessage("Finished import");+ log.appendMsg("Finished import");+ prog.endTransaction(transactionId, true);+ parser.dispose();+ }++ return log;+ }++ /**+ * Parse elements in the <db> subtree. Elements we currently handle include:+ * - <scope>+ *+ * @param parser XmlPullParser+ * @param monitor TaskMonitor+ * @param prog Program+ */+ private void handleDBElements(XmlPullParser parser, TaskMonitor monitor, Program prog,+ DecompileDebugDataTypeManager dataTypeManager, String programName,+ XmlMessageLog log) {++ while (parser.peek().isStart() && !monitor.isCancelled()) {+ if (parser.peek().getName().equals("scope")) {+ XmlElement scopeElement = parser.start("scope");+ Long scopeId =+ SpecXmlUtils.decodeLong(scopeElement.getAttribute(ATTRIB_ID.name()));+ String namespaceName = scopeElement.getAttribute(ATTRIB_NAME.name());++ long parentId = 0;+ if (parser.peek().getName().equals("parent")) {+ XmlElement parentElement = parser.start("parent");+ parentId =+ SpecXmlUtils.decodeLong(parentElement.getAttribute(ATTRIB_ID.name()));+ parser.end(parentElement);+ }++ // scopeMap is initialized with the global namespace, the first <scope> tag will be the global one if it doesn't have a parent tag+ Namespace namespace = scopeMap.get(scopeId);++ if (namespace == null) {+ Namespace parentNamespace = scopeMap.get(parentId);+ try {+ namespace = prog.getSymbolTable()+ .createNameSpace(parentNamespace, namespaceName,+ SourceType.IMPORTED);+ scopeMap.put(scopeId, namespace);+ }+ catch (DuplicateNameException | InvalidInputException e) {+ log.appendException(e);+ }+ }++ handleScopeSubtree(namespace, parser, monitor, prog, dataTypeManager, programName,+ log);+ parser.end(scopeElement);++ }+ else {+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + parser.peek().getName());+ parser.discardSubTree();+ }+ }++ }++ /**+ * Parse element subtrees within the scope tag.+ *+ * NOTE: The scope tag must be parsed prior to a call to this message with the value+ * of the namespace object sent as the first parameter.+ *+ * NOTE: it is expected that the wrapper <symbollist> tag is being used around the collection of+ * <mapsymp> tags.+ *+ * @param namespace Namespace+ * @param parser XmlPullParser+ * @param monitor TaskMonitor+ * @param prog Program+ * @param log XmlMessageLog+ */+ private void handleScopeSubtree(Namespace namespace, XmlPullParser parser, TaskMonitor monitor,+ Program prog, DecompileDebugDataTypeManager dataTypeManager, String programName,+ XmlMessageLog log) {+ XmlElement symbollistElement = null;+ DecompileDebugFunctionManager functionManager =+ new DecompileDebugFunctionManager(prog, monitor, dataTypeManager);++ while (parser.peek().isStart() && !monitor.isCancelled()) {+ String name = parser.peek().getName();+ switch (name) {+ case "symbollist": // this is a wrapper tag for <mapsym> tags+ symbollistElement = parser.start("symbollist");+ break;+ case "mapsym":+ XmlElement mapsymTypeElement = parser.start("mapsym");+ monitor.setMessage("Processing Symbols");+ String symbolType = parser.peek().getName();+ if (symbolType.equals("function")) {+ functionManager.parseFunctionSignature(parser, scopeMap, log);+ while (parser.peek().isStart()) {+ log.appendMsg(parser.getLineNumber(),+ "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + name);+ parser.discardSubTree(); // any extra tags after the function tag before mapsym can be thrown away for now+ }+ }+ else if (symbolType.equals("labelsym")) {+ parseLabelSymbol(prog, parser, log);+ }+ else if (symbolType.equals("symbol")) {+ try {+ parseSymbol(prog, parser, dataTypeManager, namespace, programName,+ monitor, log);+ }+ catch (LoadException e) {+ log.appendException(e);+ }+ }+ parser.end(mapsymTypeElement);+ break;+ default:+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + name);+ parser.discardSubTree();+ }+ }+ parser.end(symbollistElement);+ }++ /**+ * Handle the <binaryimage> tag and subtree which includes the <bytechunk> tag(s).+ *+ * @param parser XmlPullparser+ * @param monitor TaskMonitor+ * @param prog Program+ * @param programName String+ * @param log MessageLog+ */+ private void handleBinaryImageElements(XmlPullParser parser, TaskMonitor monitor, Program prog,+ String programName, XmlMessageLog log) {+ monitor.setMessage("Processing binary image");+ while (parser.peek().isStart() && !monitor.isCancelled()) {+ if (parser.peek().getName().equals("bytechunk")) {+ monitor.setMessage("Processing Byte Chunk(s)");+ DecompileDebugByteManager byteMngr =+ new DecompileDebugByteManager(monitor, prog, programName);+ byteMngr.parse(parser, log);+ }+ else {+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + parser.peek().getName());+ parser.discardSubTree();+ }+ }+ }++ /**+ * Handle generation of labels from the <labelsym> tag+ * @param prog program+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ */+ private void parseLabelSymbol(Program prog, XmlPullParser parser, XmlMessageLog log) {+ XmlElement symbolElement = parser.start("labelsym");+ String symbolName = symbolElement.getAttribute(ATTRIB_NAME.name());+ parser.end(symbolElement);+ XmlElement addrElement = parser.start("addr");+ Address symbolAddr;+ try {+ symbolAddr =+ AddressXML.restoreXml(addrElement, prog.getCompilerSpec()).getFirstAddress();+ SymbolTable st = prog.getSymbolTable();+ Symbol createdSymbol =+ st.createLabel(symbolAddr, symbolName, SourceType.IMPORTED);+ createdSymbol.setPrimary();++ parser.end(addrElement);+ while (parser.peek().isStart()) {+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + parser.peek().getName());+ parser.discardSubTree();+ }+ }+ catch (XmlParseException | InvalidInputException e) {+ log.appendException(e);+ }++ }++ /**+ * Parse <symbol> tag under the <mapsym> tag -- meaning, they are outside of a function,+ * most likely these are data references.+ *+ * NOTE: We are currently not pulling the bytes for referenced functions or data, as a result+ * we need to generate an initialized memory block for data references to avoid errors+ * in the Listing pane.+ *+ * @param prog program+ * @param parser XmlPullParser+ * @param dataTypeManager DecompileDebugDataTypeManager+ * @param namespace Namespace+ * @param log XmlMessageLog+ *+ * @throws LoadException Memory allocation will block program load.+ */+ private void parseSymbol(Program prog, XmlPullParser parser,+ DecompileDebugDataTypeManager dataTypeManager, Namespace namespace, String programName,+ TaskMonitor monitor, XmlMessageLog log) throws LoadException {+ XmlElement symbolElement = parser.start("symbol");+ String symbolName = symbolElement.getAttribute(ATTRIB_NAME.name());+ DataType dt = dataTypeManager.parseDataTypeTag(parser, log);+ Boolean readOnly = symbolElement.hasAttribute(ATTRIB_READONLY.name()); // readOnly is only present if it's true+ parser.end(symbolElement);+ XmlElement addrElement = parser.start("addr");+ Address symbolAddr = null; // make available for display in the error dialog below++ try {+ AddressXML xmlAddr = AddressXML.restoreXml(addrElement, prog.getCompilerSpec());+ symbolAddr = xmlAddr.getFirstAddress();+ Symbol createdSymbol =+ SymbolUtilities.createPreferredLabelOrFunctionSymbol(prog,+ symbolAddr, namespace, symbolName, SourceType.IMPORTED);+ createdSymbol.setPrimary();++ Memory memory = prog.getMemory();+ Address end = symbolAddr.addNoWrap(xmlAddr.getSize() - 1);+ // check to see if the data element would overlap existing blocks+ if (!memory.contains(symbolAddr, end)) {+ MemoryBlock generatedBlock = memory.createInitializedBlock(programName, symbolAddr,+ xmlAddr.getSize(), (byte) 0,+ monitor, false);+ generatedBlock.setWrite(!readOnly); // if readOnly is true, write should be false+ prog.getListing().createData(symbolAddr, dt, (int) xmlAddr.getSize());+ }++ else { // just generate the symbol+ prog.getListing().createData(symbolAddr, dt, (int) xmlAddr.getSize());+ }+ }++ catch (MemoryConflictException mce) {+ log.appendMsg("Attempted to allocate overlapping memory block for data: " ++ dt.getDisplayName() + " at address: " + symbolAddr);+ log.appendException(mce);+ }++ catch (LockException | IllegalArgumentException+ | AddressOverflowException | CancelledException | InvalidInputException+ | XmlParseException | CodeUnitInsertionException e) {+ log.appendException(e);+ }++ parser.end(addrElement);+ while (parser.peek().isStart()) {+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + parser.peek().getName());+ parser.discardSubTree(); // skip rangelist tag and any others not yet handled+ }+ }++ /**+ * Handle parsing and loading of comments.+ * @param parser XmlPullParser+ * @param monitor TaskMonitor+ * @param prog Ghidra Program+ * @param log XmlMessageLog+ */+ private void parseComments(XmlPullParser parser, TaskMonitor monitor, Program prog,+ XmlMessageLog log) {+ while (parser.peek().isStart("comment") && !monitor.isCancelled()) {+ parseAndAddComment(parser, prog, log);+ }+ }++ /**+ * Parse comments from the <commentdb> tag and add to listing via setupComments method.+ *+ * Note: <commentdb> has two <addr> tags. The first is the function address, and the second+ * is the (CodeUnit) address where the comment should be placed. Discard the first address.+ *+ * @param parser XmlPullParser+ * @param prog Program+ * @param log XmlMessageLog+ */+ private void parseAndAddComment(XmlPullParser parser, Program prog, XmlMessageLog log) {+ XmlElement commentElement = parser.start("comment");+ String commentType = commentElement.getAttribute(ATTRIB_TYPE.name());+ CommentType decodedType = decodeCommentType(commentType);+ parser.discardSubTree("addr"); // this is the address of the function+ XmlElement addrElement = parser.start("addr"); // this is the CodeUnit address where the comment goes++ try {+ Address commentAddr =+ AddressXML.restoreXml(addrElement, prog.getCompilerSpec()).getFirstAddress();+ parser.end(addrElement);++ parser.start("text");+ String commentText = parser.end().getText();+ setupComments(decodedType, commentAddr, commentText, prog);+ parser.end(commentElement);+ }++ catch (XmlParseException e) {+ log.appendException(e);+ }+ }++ /**+ * Setup comments from the <comment> tag. Follows the comment type constants found in+ * @CodeUnit.java.+ *+ * @param decodedType int+ * @param commentAddr Address+ * @param commentText String+ * @param prog Program+ */+ private void setupComments(CommentType decodedType, Address commentAddr, String commentText,+ Program prog) {++ CodeUnit cu = prog.getListing().getCodeUnitAt(commentAddr);+ cu.setComment(decodedType, commentText);+ }++ /**+ * See @DecompileCallback.java for the encoding of the comments by @DecompileDebug.java.+ * The method <encodeCommentsType> encodes the comment types found in @CodeUnit.java+ * in 4 alternative labels:+ * CodeUnit.EOL_COMMENT = "user1"+ * CodeUnit.PRE_COMMENT = "user2"+ * CodeUnit.POST_COMMENT = "user3"+ * CodeUnit.PLATE_COMMENT = "header"+ *+ * In order to generate comments using @CodeUnit.java, we will need to re-encode the user<1-3>+ * and header type labels from the DecompileDebug XML back into the CodeUnit constant values of:+ * 0-3 (respectively).+ *+ * @param typeName String label from DecompileDebug.java and DecompileCallback.java+ *+ * @return CodeUnit comment type (0-3)+ */+ private CommentType decodeCommentType(String typeName) {+ CommentType commentType;+ switch (typeName) {+ case "user1":+ commentType = CommentType.EOL;+ break;+ case "user2":+ commentType = CommentType.PRE;+ break;+ case "user3":+ commentType = CommentType.POST;+ break;+ case "header":+ commentType = CommentType.PLATE;+ break;+ default:+ commentType = CommentType.valueOf("");+ break;+ }+ return commentType;+ }++ /**+ * Loop through the <type> tags in the <coretypes> subtree+ *+ * @param parser XmlPullParser+ * @param prog built program+ * @param monitor TaskMonitor+ * @param dataTypeManager Program's DataTypeManager for parsing and managing the DataTypeManager Map+ * @param log XmlMessageLog+ */+ private void parseDataTypes(XmlPullParser parser, TaskMonitor monitor, Program prog,+ DecompileDebugDataTypeManager dataTypeManager, XmlMessageLog log) {++ while (parser.peek().isStart() && !monitor.isCancelled()) {+ dataTypeManager.parseDataTypeTag(parser, log);+ }+ }++ /**+ * Parse the <stringmanage> subtree+ *+ * @param parser XmlPullParser+ * @param monitor TaskMonitor+ * @param prog Program+ * @param log XmlMessageLog+ */+ private void parseStrings(XmlPullParser parser, TaskMonitor monitor, Program prog,+ XmlMessageLog log) {+ while (parser.peek().isStart("string") && !monitor.isCancelled()) {+ parseAndAddStrings(parser, monitor, prog, log);+ }+ }++ /**+ * Parse the <string> tag and insert into the program+ *+ * @param parser XmlPullParser+ * @param monitor TaskMonitor+ * @param prog Program+ * @param log XmlMessageLog+ */+ private void parseAndAddStrings(XmlPullParser parser, TaskMonitor monitor, Program prog,+ XmlMessageLog log) {+ XmlElement stringElement = parser.start("string");+ XmlElement addrElement = parser.start("addr");+ try {+ Address stringAddr =+ AddressXML.restoreXml(addrElement, prog.getCompilerSpec()).getFirstAddress();+ parser.end(addrElement);++ parser.start("bytes");+ String hexString = parser.end().getText().trim().replaceAll("\n", "");+ hexString = hexString.replaceAll(" ", "");+ byte[] rawBytes = HexFormat.of().parseHex(hexString);+ Memory memory = prog.getMemory();+ memory.setBytes(stringAddr, rawBytes);+ }+ catch (XmlParseException | IllegalArgumentException | MemoryAccessException e) {+ log.appendException(e);+ }+ parser.end(stringElement);+ }++ /**+ * Handle the parsing of the context pointset inside of the <contextpointset> subtree+ *+ * @param parser XmlPullParser+ * @param monitor TaskMonitor+ * @param prog Program+ * @param log XmlMessageLog+ */+ private void parseContextPoints(XmlPullParser parser, TaskMonitor monitor, Program prog,+ XmlMessageLog log) {+ while (parser.peek().isStart("context_pointset")) {+ XmlElement contextElement = parser.start("context_pointset");+ Address addr;++ try {+ addr =+ AddressXML.restoreXml(contextElement, prog.getCompilerSpec()).getFirstAddress();++ ProgramContext pc = prog.getProgramContext();+ while (parser.peek().isStart("set") && !monitor.isCancelled()) {+ XmlElement setElement = parser.start("set");+ String regName = setElement.getAttribute(ATTRIB_NAME.name());+ BigInteger regVal = new BigInteger(setElement.getAttribute(ATTRIB_VAL.name()));+ Register reg = pc.getRegister(regName);+ pc.setValue(reg, addr, addr, regVal);+ parser.end(setElement);+ }+ }+ catch (XmlParseException | ContextChangeException e) {+ log.appendException(e);+ }+ parser.end(contextElement);+ }++ while (parser.peek().isStart("tracked_pointset")) {+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + parser.peek().getName());+ parser.discardSubTree();+ }++ }++ /**+ * Simple handling of error messages+ */+ class MyErrorHandler implements ErrorHandler {+ private MessageLog log;++ MyErrorHandler(MessageLog log) {+ this.log = log;+ }++ @Override+ public void warning(SAXParseException exception) throws SAXException {+ log.appendMsg(exception.getMessage());++ }++ @Override+ public void error(SAXParseException exception) throws SAXException {+ log.appendMsg(exception.getMessage());++ }++ @Override+ public void fatalError(SAXParseException exception) throws SAXException {+ log.appendMsg(exception.getMessage());++ }+ }+}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugFunctionManager.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugFunctionManager.javanew file mode 100644index 0000000000..301d211378--- /dev/null+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugFunctionManager.java@@ -0,0 +1,347 @@+/* ###+ * IP: GHIDRA+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package ghidra.app.util.opinion;++import static ghidra.program.model.pcode.AttributeId.*;++import java.util.ArrayList;+import java.util.Map;++import ghidra.framework.store.LockException;+import ghidra.program.database.function.OverlappingFunctionException;+import ghidra.program.model.address.*;+import ghidra.program.model.data.DataType;+import ghidra.program.model.listing.*;+import ghidra.program.model.listing.Function.FunctionUpdateType;+import ghidra.program.model.mem.Memory;+import ghidra.program.model.mem.MemoryConflictException;+import ghidra.program.model.pcode.AddressXML;+import ghidra.program.model.symbol.Namespace;+import ghidra.program.model.symbol.SourceType;+import ghidra.util.exception.*;+import ghidra.util.task.TaskMonitor;+import ghidra.util.xml.SpecXmlUtils;+import ghidra.xml.*;++/**+ * Manage the parsing and population of function objects. All functions are loaded the same way,+ * even if it's only referenced by the "central function" (the function that was in the decompiler+ * pane when the Decompile Debug (@DecompileDebug.java) feature was used).+ */+public class DecompileDebugFunctionManager {++ Program prog;+ TaskMonitor monitor;+ DecompileDebugDataTypeManager dataTypeManager;++ /**+ * Each function requires a program, task monitor and the program's Data Type Manager in order+ * to be generated.+ *+ * @param prog Program+ * @param monitor TaskMonitor+ * @param dataTypeManager Program's DataTypeManager+ */+ public DecompileDebugFunctionManager(Program prog, TaskMonitor monitor,+ DecompileDebugDataTypeManager dataTypeManager) {+ this.prog = prog;+ this.monitor = monitor;+ this.dataTypeManager = dataTypeManager;+ }++ /**+ * Setup functions from within the <symbollist> tag.+ * Functions referenced by the central function are loaded the same except we do not+ * (currently) have the memory/program context for them. Thus, they will show up in the Listing+ * with a red "X".+ * NOTE: This is the expected functionality.+ *+ * @param parser XmlPullParser+ * @param scopeMap Map<String, Namespace> used for getting parent namespace+ * @param log XmlMessageLog+ */+ public void parseFunctionSignature(XmlPullParser parser, Map<Long, Namespace> scopeMap,+ XmlMessageLog log) {+ XmlElement functionElement = parser.start("function");+ String functionName = functionElement.getAttribute(ATTRIB_NAME.name());+ boolean noReturn = functionElement.hasAttribute(ATTRIB_NORETURN.name());++ Function createdFunction = null;+ XmlElement localdb = null;+ Address functionAddr = null;+ while (parser.peek().isStart()) {+ String tagName = parser.peek().getName();+ switch (tagName) {+ case "addr":+ try {+ XmlElement addressTag = parser.start("addr");+ functionAddr =+ AddressXML.restoreXml(addressTag, prog.getCompilerSpec())+ .getFirstAddress();+ parser.end(addressTag);+ break;+ }+ catch (XmlParseException e) {+ log.appendException(e);+ }+ case "scope":++ XmlElement scopeElement = parser.start("scope");+ String scopeName = scopeElement.getAttribute(ATTRIB_NAME.name());++ Namespace functionNamespace =+ getParentNamespace(parser, scopeMap, scopeName);++ createdFunction =+ setFunctionNamespaceAndStorage(functionName, functionAddr,+ functionNamespace,+ log);+ createdFunction.setNoReturn(noReturn);+ handleScopeSubtags(createdFunction, parser, log);++ parser.end(scopeElement);+ parser.end(localdb);++ break;+ case "prototype":+ XmlElement prototypeElement = parser.start("prototype");+ try {+ createdFunction+ .setCallingConvention(prototypeElement.getAttribute("model"));+ createdFunction.setReturnType(retrieveReturnType(parser, log),+ SourceType.IMPORTED);++ if (parser.peek().isStart("inject")) {+ parser.start("inject");+ String callFixup = parser.end().getText();+ createdFunction.setCallFixup(callFixup);+ log.appendMsg("Found an inject tag on the function: " ++ createdFunction.getName());+ }+ }+ catch (InvalidInputException e) {+ log.appendException(e);+ }++ while (!parser.peek().isEnd()) {+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + parser.peek().getName());+ parser.discardSubTree();+ }+ parser.end(prototypeElement);+ break;+ case "localdb":+ localdb = parser.start("localdb"); // this is a wrapper, it ends after the scope tag+ break;+ default:+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + parser.peek().getName());+ parser.discardSubTree();+ }+ }+ parser.end(functionElement);+ }++ /**+ * Parse the <parent> subtag under <scope> and generate the function's Namespace.+ *+ * @param parser XmlPullParser+ * @param scopeMap Map<String, Namespace> used for looking up parent Namespace based on ID from <parent> tag+ * @param scopeName String from <scope> tag+ *+ * @return Namespace generated namespace+ */+ private Namespace getParentNamespace(XmlPullParser parser, Map<Long, Namespace> scopeMap,+ String scopeName) {+ XmlElement parentTag = parser.start("parent");+ Long parentId = SpecXmlUtils.decodeLong(parentTag.getAttribute(ATTRIB_ID.name()));+ Namespace parentNamespace = scopeMap.get(parentId);+ parser.end(parentTag);+ return parentNamespace;+ }++ /**+ * Step through the <scope> subtags, including:+ * - <parent>+ * - <rangelist>+ * - <symbollist>+ *+ * NOTE: A populated <rangelist> is not currently supported.+ *+ * @param createdFunction Function+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ */+ private void handleScopeSubtags(Function createdFunction,+ XmlPullParser parser, XmlMessageLog log) {++ while (parser.peek().isStart()) {+ String tagName = parser.peek().getName();+ switch (tagName) {+ case "rangelist":+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + tagName);+ parser.discardSubTree(); // we currently do not support a populated rangelist+ break;+ case "symbollist":+ XmlElement symbollistElement = parser.start("symbollist");+ findFunctionVariables(parser, createdFunction, log);+ parser.end(symbollistElement);+ break;+ default:+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + tagName);+ parser.discardSubTree();+ }+ }+ }++ /**+ * Parse and retrieve the return type from the program's data type manager.+ *+ * @param parser XmlPullParser+ * @param log XmlMessageLog+ *+ * @return DataType return type+ */+ private DataType retrieveReturnType(XmlPullParser parser, XmlMessageLog log) {+ XmlElement returnElement = parser.start("returnsym");+ XmlElement addrElement = parser.start("addr");+ //Address address = AddressXML.restoreXml(addrElement, prog.getCompilerSpec()).getFirstAddress();+ parser.end(addrElement);++ DataType returnType = dataTypeManager.parseDataTypeTag(parser, log);+ parser.end(returnElement);+ return returnType;+ }++ /**+ * Parse and load parameter and local variables for the given function by+ * cycling through the <mapsym> tags within the symbollist+ *+ * NOTE: populated <rangelist> tags within a mapsym tag are not currently supported.+ *+ * NOTE: Keep a list of parameters and modify the function only once+ * (ie. 1 call to updateFunction()) after all variables have been parsed.+ *+ * @param parser XmlPullParser+ * @param createdFunction Function+ * @param log XmlMessageLog+ */+ private void findFunctionVariables(XmlPullParser parser, Function createdFunction,+ XmlMessageLog log) {++ ArrayList<ParameterImpl> paramList = new ArrayList<ParameterImpl>();+ try {+ while (parser.peek().isStart()) {+ XmlElement mapsymElement = parser.start("mapsym");+ XmlElement symbolElement = parser.start("symbol");+ boolean isParam = SpecXmlUtils.decodeInt(symbolElement.getAttribute("cat")) == 0;+ String varName = symbolElement.getAttribute(ATTRIB_NAME.name());+ DataType varType = dataTypeManager.parseDataTypeTag(parser, log);+ parser.end(symbolElement);+ XmlElement addrElement = parser.start("addr");++ if (isParam) {+ Address address = AddressXML.restoreXml(addrElement, prog.getCompilerSpec())+ .getFirstAddress();+ ParameterImpl param = new ParameterImpl(varName, varType,+ address, prog);+ paramList.add(param);+ }+ else {+ int offset = (int) AddressXML.restoreXml(addrElement, prog.getCompilerSpec())+ .getOffset();+ LocalVariableImpl lvar =+ new LocalVariableImpl(varName, varType, offset, prog, SourceType.IMPORTED);+ createdFunction.addLocalVariable(lvar, SourceType.IMPORTED);+ }+ parser.end(addrElement);+ while (parser.peek().isStart()) {+ log.appendMsg(parser.getLineNumber(), "Level " + parser.getCurrentLevel() ++ " tag not currently supported: " + parser.peek().getName());+ parser.discardSubTree();+ }+ parser.end(mapsymElement);+ createdFunction.updateFunction(null, null, paramList,+ FunctionUpdateType.CUSTOM_STORAGE,+ true, SourceType.IMPORTED); // calling convention & return variable are updated later++ }+ }+ catch (NumberFormatException | InvalidInputException+ | DuplicateNameException | XmlParseException e) {+ log.appendException(e);+ }+ }++ /**+ * Set the Name and Namespace / custom variable storage on the function symbol after the+ * initial function signature has been created.+ *+ * @param functionName name+ * @param functionAddr address offset+ * @param namespace Namespace parent namespace+ * @param log XmlMessageLog+ *+ * @return generated Function+ */+ private Function setFunctionNamespaceAndStorage(String functionName, Address functionAddr,+ Namespace namespace, XmlMessageLog log) {++ Function createdFunction = createFunction(functionName, functionAddr, namespace, log);+ try {+ createdFunction.setCustomVariableStorage(true);+ Memory memory = prog.getMemory();+ if (!memory.contains(functionAddr)) { // main function block has already been generated+ memory.createInitializedBlock(functionName, functionAddr, 1, (byte) 0, monitor,+ false);+ }+ }+ catch (LockException | IllegalArgumentException+ | MemoryConflictException | AddressOverflowException | CancelledException e) {+ log.appendException(e);+ }+ return createdFunction;+ }++ /**+ * Create Function object for populating later using the program's function manager.+ * The central function is the one processed first.+ *+ * @param functionName String+ * @param functionAddr Address+ * @param namespace Namespace parent namespace+ * @param log XmlMessageLog+ * @return generated function+ */+ private Function createFunction(String functionName, Address functionAddr,+ Namespace namespace, XmlMessageLog log) {++ FunctionManager funcM = prog.getFunctionManager();+ Function generatedFunction = null;+ try {+ generatedFunction = funcM.createFunction(functionName, namespace, functionAddr,+ new AddressSet(functionAddr, functionAddr), SourceType.IMPORTED);+ }+ catch (InvalidInputException | OverlappingFunctionException e) {+ log.appendException(e);+ }++ return generatedFunction;+ }++}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugXmlLoader.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugXmlLoader.javanew file mode 100644index 0000000000..7138537687--- /dev/null+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/DecompileDebugXmlLoader.java@@ -0,0 +1,324 @@+/* ###+ * IP: GHIDRA+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+package ghidra.app.util.opinion;++import java.io.IOException;+import java.lang.reflect.InvocationTargetException;+import java.util.*;++import ghidra.app.plugin.core.analysis.AnalysisWorker;+import ghidra.app.plugin.core.analysis.AutoAnalysisManager;+import ghidra.app.util.Option;+import ghidra.app.util.bin.ByteProvider;+import ghidra.app.util.importer.MessageLog;+import ghidra.framework.model.Project;+import ghidra.program.model.address.Address;+import ghidra.program.model.lang.*;+import ghidra.program.model.listing.Program;+import ghidra.util.Msg;+import ghidra.util.exception.CancelledException;+import ghidra.util.task.TaskMonitor;++/**+ * Loader for handling XML files generated by the Decompiler on the central function that was in the+ * Decompiler pane when the Debug Function Decompilation feature in the Decompiler is used.+ *+ * Reference @DecompileDebug.java for the generation of the XML file.+ */+public class DecompileDebugXmlLoader extends AbstractProgramLoader {++ public static final String DECOMPILER_DEBUG_SRC_NAME = "Decompiler Debug XML";++ @Override+ public String getName() {+ return DECOMPILER_DEBUG_SRC_NAME;+ }++ @Override+ public LoaderTier getTier() {+ return LoaderTier.SPECIALIZED_TARGET_LOADER;+ }++ @Override+ public int getTierPriority() {+ return 50;+ }++ /*+ * This is an override method that identifies the load specs for the program to populate+ * the initial upload dialog.+ *+ * @param provider+ * @return the list of possible load specs (though really only one should work)+ */+ @Override+ public Collection<LoadSpec> findSupportedLoadSpecs(ByteProvider provider) throws IOException {++ List<LoadSpec> loadSpecs = new ArrayList<>();++ // the language service sets up the log, language map, and service+ getLanguageService();++ ParseGhidraDebugResult result = parse(provider);+ DecompileDebugProgramInfo info = result.lastInfo;++ if (info == null) {+ // indicates that a different loader should be used+ return loadSpecs;+ }+ LanguageID languageID = new LanguageID(info.specString());++ LanguageDescription languageDescription =+ getLanguageService().getLanguageDescription(languageID);++ for (CompilerSpecDescription csd : languageDescription+ .getCompatibleCompilerSpecDescriptions()) {+ LanguageCompilerSpecPair pair =+ new LanguageCompilerSpecPair(languageDescription.getLanguageID(),+ csd.getCompilerSpecID());++ if (info.compilerString().equals(csd.getCompilerSpecID().getIdAsString())) {+ loadSpecs.add(new LoadSpec(this, 0, pair, true));+ }+ }++ return loadSpecs;+ }++ /**+ * After initial parsing of the XML file, load the details into a new program for+ * loading/viewing in Ghidra.+ *+ * @param provider ByteProvider+ * @param programName Program name from the XML+ * @param project active project+ * @param programFolderPath folder path to XML+ * @param loadSpec String parsed out of the XML for details regarding language/compiler spec+ * @param options program options - will always be empty+ * @param log MessageLog+ * @param consumer Object+ * @param monitor TaskMonitor+ *+ * @return List of loaded programs - should always be 1+ */+ @Override+ protected List<Loaded<Program>> loadProgram(ByteProvider provider, String programName,+ Project project,+ String programFolderPath, LoadSpec loadSpec, List<Option> options, MessageLog log,+ Object consumer,+ TaskMonitor monitor) throws IOException, CancelledException {++ LanguageCompilerSpecPair pair = loadSpec.getLanguageCompilerSpec();+ Language importerLanguage = getLanguageService().getLanguage(pair.languageID);+ CompilerSpec importerCompilerSpec =+ importerLanguage.getCompilerSpecByID(pair.compilerSpecID);+ ParseGhidraDebugResult parsedResult = parse(provider);+ if (parsedResult.lastInfo == null) {+ return new ArrayList<Loaded<Program>>();+ }++ Address imageBase = null;+ if (parsedResult.lastInfo.offset() != null) {+ imageBase =+ importerLanguage.getAddressFactory().getAddress(parsedResult.lastInfo.offset());+ }++ Program prog = createProgram(provider, programName, imageBase, getName(),+ importerLanguage, importerCompilerSpec, consumer);+ List<Loaded<Program>> loadedList =+ List.of(new Loaded<>(prog, programName, project, programFolderPath, consumer));++ int loadingId = prog.startTransaction("Loading debug XML file");++ try {+ doImport(parsedResult.debugXmlMgr, options, log, prog, monitor, false, programName);+ }+ catch (++ IllegalArgumentException e) {+ throw new LoadException("Failed to load");+ }++ finally {+ prog.endTransaction(loadingId, true);+ }+ return loadedList;+ }++ /**+ * Import the XML; first parse and load details into the generation of a new program based+ * around the "central" function that the Decompile Debug XML file was generated from.+ *+ * @param debugXmlMgr Manages the parsing of the XML objects+ * @param options if there are any settings for importing work - these will always be empty+ * @param log for writing to+ * @param prog main program+ * @param monitor TaskMonitor+ * @param isAddToProgram whether we are importing the program into an existing program - this+ * will always be false.+ * @param programName name of program+ *+ * @return boolean success+ */+ private boolean doImport(DecompileDebugFormatManager debugXmlMgr, List<Option> options,+ MessageLog log, Program prog, TaskMonitor monitor, boolean isAddToProgram,+ String programName)+ throws IOException {++ // if we're adding to another program, an autoAnalysisManager will already exist+ if (!AutoAnalysisManager.hasAutoAnalysisManager(prog)) {+ // helps to manage the threads/task workers+ int txId = prog.startTransaction("Decompiler Debug XML Import");+ try {+ return doImportWork(debugXmlMgr, options, log, prog, monitor, isAddToProgram,+ programName);+ }+ finally {+ prog.endTransaction(txId, true);+ }+ }++ AutoAnalysisManager analysisMgr = AutoAnalysisManager.getAnalysisManager(prog);+ try {+ return analysisMgr.scheduleWorker(new AnalysisWorker() {++ @Override+ public String getWorkerName() {+ return "Decompiler Debug XML Importer";+ }++ @Override+ public boolean analysisWorkerCallback(Program program, Object workerContext,+ TaskMonitor taskMonitor) throws Exception, CancelledException {++ return doImportWork(debugXmlMgr, options, log, program, taskMonitor,+ isAddToProgram, programName);+ }+ }, null, false, monitor);+ }+ catch (CancelledException e) {+ return false;+ }+ catch (InvocationTargetException e) {+ Throwable cause = e.getCause();+ if (cause instanceof IOException) {+ throw (IOException) cause;+ }+ throw new RuntimeException(e);+ }+ catch (InterruptedException e) {+ throw new RuntimeException(e);+ }+ }++ /**+ * Handles calling the parsing function in the DecompileDebugFormat manager.+ *+ * @param debugXmlMgr DecompileDebugFormatManager object which handles the parsing of the XML+ * @param options if there are any settings for importing work - these will always be empty+ * @param log for writing to+ * @param prog main program+ * @param monitor TaskMonitor+ * @param isAddToProgram whether we are importing the program into an existing program - this+ * will always be false.+ * @param programName name of program+ *+ * @return success+ */+ private boolean doImportWork(DecompileDebugFormatManager debugXmlMgr, List<Option> options,+ MessageLog log, Program prog, TaskMonitor monitor, boolean isAddToProgram,+ String programName)+ throws LoadException {++ MessageLog mgrLog = null;+ boolean success = false;++ try {+ mgrLog = debugXmlMgr.read(prog, monitor, programName);+ log.copyFrom(mgrLog);+ success = true;+ }+ catch (Exception e) {+ String message = "";+ if (mgrLog != null && !"".equals(mgrLog.toString())) {+ message = mgrLog.toString();+ }+ if (log != null && !"".equals(log.toString())) {+ message = log.toString();+ }+ Msg.warn(this, "XML import exception, log: " + message, e);+ throw new LoadException(e.getMessage());+ }+ return success;+ }++ /**+ * Class to organize the XML format handler and the program info as extracted from the+ * uploaded decompiler debug XML file.+ */+ private static class ParseGhidraDebugResult {+ final DecompileDebugFormatManager debugXmlMgr;+ final DecompileDebugProgramInfo lastInfo;++ ParseGhidraDebugResult(DecompileDebugFormatManager debugXmlMgr,+ DecompileDebugProgramInfo lastInfo) {+ this.debugXmlMgr = debugXmlMgr;+ this.lastInfo = lastInfo;+ }+ }++ /**+ * Parse the XML file for the needed tags in order to populate a full program to load+ *+ * @param provider ByteProvider from the XML+ *+ * @return result object populated with the program details from the XML file+ */+ private ParseGhidraDebugResult parse(ByteProvider provider) {++ try {+ DecompileDebugFormatManager debugXmlMgr = new DecompileDebugFormatManager(provider);+ DecompileDebugProgramInfo decompileProgInfo = debugXmlMgr.getProgramInfo();++ return new ParseGhidraDebugResult(debugXmlMgr, decompileProgInfo);+ }+ catch (Throwable e) {+ Msg.trace(this, "Unable to parse the Ghidra Decompiler XML for " + provider.getName(),+ e);+ return new ParseGhidraDebugResult(null, null);+ }++ }++ @Override+ protected void loadProgramInto(ByteProvider provider, LoadSpec loadSpec, List<Option> options,+ MessageLog messageLog, Program program, TaskMonitor monitor)+ throws IOException, LoadException, CancelledException {+ // since we will not ever be loading this debug program into an existing program, this+ // should not be used.+ }++ /**+ * Hold program details from the spec string for loading. Object is then passed forward in the+ * .getProgramInfo() function implemented in @DecompileDebugFormatManager.java and populated by @DecompileDebugXmlLoader.java.+ * @param offset String+ * @param compilerString String+ * @param specString String+ */+ static record DecompileDebugProgramInfo(String offset, String compilerString,+ String specString) {}++}diff --git a/Ghidra/Features/Base/src/test/java/ghidra/app/util/opinion/DecompileDebugXmlLoaderTest.java b/Ghidra/Features/Base/src/test/java/ghidra/app/util/opinion/DecompileDebugXmlLoaderTest.javanew file mode 100644index 0000000000..9f8ebb6409--- /dev/null+++ b/Ghidra/Features/Base/src/test/java/ghidra/app/util/opinion/DecompileDebugXmlLoaderTest.java@@ -0,0 +1,239 @@+/* ###+ * IP: GHIDRA+ *+ * Licensed under the Apache License, Version 2.0 (the "License");+ * you may not use this file except in compliance with the License.+ * You may obtain a copy of the License at+ *+ * http://www.apache.org/licenses/LICENSE-2.0+ *+ * Unless required by applicable law or agreed to in writing, software+ * distributed under the License is distributed on an "AS IS" BASIS,+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.+ * See the License for the specific language governing permissions and+ * limitations under the License.+ */+/**+ *+ */+package ghidra.app.util.opinion;++import static org.junit.Assert.*;++import java.io.File;+import java.io.IOException;+import java.math.BigInteger;+import java.nio.file.AccessMode;+import java.util.*;++import org.junit.Before;+import org.junit.Test;+import org.xml.sax.SAXException;++import ghidra.app.util.Option;+import ghidra.app.util.bin.ByteProvider;+import ghidra.app.util.bin.FileByteProvider;+import ghidra.app.util.importer.MessageLog;+import ghidra.app.util.opinion.DecompileDebugXmlLoader.DecompileDebugProgramInfo;+import ghidra.framework.model.DomainObject;+import ghidra.program.database.ProgramDB;+import ghidra.program.database.data.ProgramDataTypeManager;+import ghidra.program.database.function.FunctionManagerDB;+import ghidra.program.model.address.Address;+import ghidra.program.model.data.DataTypeComponent;+import ghidra.program.model.data.Structure;+import ghidra.program.model.listing.Function;+import ghidra.program.model.mem.Memory;+import ghidra.program.model.mem.MemoryBlock;+import ghidra.test.AbstractGhidraHeadedIntegrationTest;+import ghidra.util.exception.CancelledException;+import ghidra.util.exception.VersionException;+import ghidra.util.task.TaskMonitor;+import resources.ResourceManager;++/**+ *+ */+public class DecompileDebugXmlLoaderTest extends AbstractGhidraHeadedIntegrationTest {+ File decompileDebugTestFile;+ private DecompileDebugXmlLoader loader;+ private ProgramDB program;++ @Before+ public void setUp() {+ String DECOMPILE_DEBUG_TEST_FILE = "ghidra/app/util/opinion/decompile_debug_test.xml";+ decompileDebugTestFile = ResourceManager.getResourceFile(DECOMPILE_DEBUG_TEST_FILE);+ loader = new DecompileDebugXmlLoader();+ }++ /**+ * Test method for {@link ghidra.app.util.opinion.DecompileDebugFormatManager#getProgramInfo()}.+ */+ @Test+ public void testDecompileDebugXmlLoad() {+ Collection<LoadSpec> loadSpecs;+ MessageLog log = new MessageLog();+ try {+ ByteProvider byteProvider =+ new FileByteProvider(decompileDebugTestFile, null, AccessMode.READ);+ loadSpecs = loader.findSupportedLoadSpecs(byteProvider);+ assertTrue("Expected single loader opinion", loadSpecs.size() == 1);++ LoadSpec loadSpec = loadSpecs.iterator().next();+ List<Option> options = loader.getDefaultOptions(byteProvider, loadSpec, null, false);++ LoadResults<? extends DomainObject> loadResults =+ loader.load(byteProvider, byteProvider.getName(), null, null, loadSpec, options,+ log, this, TaskMonitor.DUMMY);+ loadResults.getNonPrimary();+ program = (ProgramDB) loadResults.getPrimaryDomainObject(this);+ assertTrue("expected single loaded program", loadResults.size() == 1);+ }+ catch (IOException | CancelledException | VersionException e) {+ log.appendException(e);+ }+ }++ @Test+ public void testVerifyProgramInfo() {+ DecompileDebugFormatManager mngr = new DecompileDebugFormatManager(decompileDebugTestFile);+ DecompileDebugProgramInfo progInfo;+ MessageLog log = new MessageLog();+ try {+ progInfo = mngr.getProgramInfo();+ assertEquals("Spec string should be parsed correctly", "x86:LE:64:default",+ progInfo.specString());+ assertEquals("Compiler string should be extracted separately", "gcc",+ progInfo.compilerString());+ assertEquals("Memory offset should be parsed from the offset tag", "0x140022cb8",+ progInfo.offset());+ }+ catch (SAXException | IOException e) {+ log.appendException(e);+ }+ }++ @Test+ public void testVerifyLoadedProgramBytes() {+ Collection<LoadSpec> loadSpecs;+ MessageLog log = new MessageLog();+ try {+ ByteProvider byteProvider =+ new FileByteProvider(decompileDebugTestFile, null, AccessMode.READ);+ loadSpecs = loader.findSupportedLoadSpecs(byteProvider);++ LoadSpec loadSpec = loadSpecs.iterator().next();+ List<Option> options = loader.getDefaultOptions(byteProvider, loadSpec, null, false);+ LoadResults<? extends DomainObject> loadResults =+ loader.load(byteProvider, byteProvider.getName(), null, null, loadSpec, options,+ new MessageLog(), this, TaskMonitor.DUMMY);+ loadResults.getNonPrimary();+ program = (ProgramDB) loadResults.getPrimaryDomainObject(this);++ assertEquals("gcc", program.getCompilerSpec().getCompilerSpecID().toString());++ Memory memory = program.getMemory();+ MemoryBlock[] blocks = memory.getBlocks();+ assertEquals(26, blocks.length);++ // Verify memory blocks+ verifyBlock(blocks[0], "decompile_debug_test.xml", true,+ getAddr(new BigInteger("140000000", 16)), 128);+ verifyBlock(blocks[1], "__scrt_acquire_startup_lock", true,+ getAddr(new BigInteger("1400227f8", 16)), 1);+ verifyBlock(blocks[2], "FUN_140022834", true,+ getAddr(new BigInteger("140022834", 16)), 1);+ verifyBlock(blocks[3], "FUN_1400228fc", true,+ getAddr(new BigInteger("1400228fc", 16)), 1);+ verifyBlock(blocks[4], "__scrt_release_startup_lock", true,+ getAddr(new BigInteger("140022994", 16)), 1);+ verifyBlock(blocks[5], "__scrt_uninitialize_crt", true,+ getAddr(new BigInteger("1400229b8", 16)), 1);+ verifyBlock(blocks[6], "decompile_debug_test.xml", true,+ getAddr(new BigInteger("140022cb8", 16)), 296);+ verifyBlock(blocks[7], "decompile_debug_test.xml", true,+ getAddr(new BigInteger("140022df9", 16)), 39);++ }+ catch (IOException | CancelledException | VersionException e) {+ log.appendException(e);+ }+ }++ @Test+ public void testVerifyLoadedProgramDataTypes() {+ Collection<LoadSpec> loadSpecs;+ MessageLog log = new MessageLog();+ try {+ ByteProvider byteProvider =+ new FileByteProvider(decompileDebugTestFile, null, AccessMode.READ);+ loadSpecs = loader.findSupportedLoadSpecs(byteProvider);++ LoadSpec loadSpec = loadSpecs.iterator().next();+ List<Option> options = loader.getDefaultOptions(byteProvider, loadSpec, null, false);+ LoadResults<? extends DomainObject> loadResults =+ loader.load(byteProvider, byteProvider.getName(), null, null, loadSpec, options,+ new MessageLog(), this, TaskMonitor.DUMMY);+ loadResults.getNonPrimary();+ program = (ProgramDB) loadResults.getPrimaryDomainObject(this);++ // Verify data type generation+ ProgramDataTypeManager dtm = program.getDataTypeManager();+ assertEquals("Category count didn't match. ", 2, dtm.getCategoryCount());++ Iterator<Structure> structures = dtm.getAllStructures();+ Structure struct = structures.next(); // there is only 1 struct in the example XML dump+ assertEquals("Component count didn't match.", 20, struct.getNumComponents());+ assertEquals("Struct name is incorrect", "IMAGE_DOS_HEADER", struct.getName());+ DataTypeComponent array = struct.getComponentAt(0); // the first component is an array+ assertEquals("Array component name doesn't match", "e_magic", array.getFieldName());+ assertEquals("Array wasn't sized right", 2, array.getLength());+ }+ catch (IOException | CancelledException | VersionException e) {+ log.appendException(e);+ }+ }++ @Test+ public void verifyLoadedProgramFunctions() {+ Collection<LoadSpec> loadSpecs;+ MessageLog log = new MessageLog();+ try {+ ByteProvider byteProvider =+ new FileByteProvider(decompileDebugTestFile, null, AccessMode.READ);+ loadSpecs = loader.findSupportedLoadSpecs(byteProvider);++ LoadSpec loadSpec = loadSpecs.iterator().next();+ List<Option> options = loader.getDefaultOptions(byteProvider, loadSpec, null, false);+ LoadResults<? extends DomainObject> loadResults =+ loader.load(byteProvider, byteProvider.getName(), null, null, loadSpec, options,+ new MessageLog(), this, TaskMonitor.DUMMY);+ loadResults.getNonPrimary();+ program = (ProgramDB) loadResults.getPrimaryDomainObject(this);++ // Verify function collection+ FunctionManagerDB funcMngr = program.getFunctionManager();+ assertEquals("Function count doesn't match", 19, funcMngr.getFunctionCount());++ Iterator<Function> functions = funcMngr.getFunctions(true);+ Function function = functions.next(); // this is the function the dump was made for; the others are references+ assertEquals("Function name needs to match.", "__scrt_acquire_startup_lock",+ function.getName());+ }+ catch (IOException | CancelledException | VersionException e) {+ log.appendException(e);+ }+ }++ private void verifyBlock(MemoryBlock block, String name, boolean initialized, Address min,+ long length) {+ assertEquals("Name should match", name, block.getName());+ assertEquals("Initalization didn't match", initialized, block.isInitialized());+ assertEquals("Start address didn't match", min, block.getStart());+ assertEquals("Block length didn't match", length, block.getSize());+ }++ private Address getAddr(BigInteger offset) {+ return program.getAddressFactory().getDefaultAddressSpace().getAddress(offset.longValue());+ }+}diff --git a/Ghidra/Features/Base/src/test/resources/ghidra/app/util/opinion/decompile_debug_test.xml b/Ghidra/Features/Base/src/test/resources/ghidra/app/util/opinion/decompile_debug_test.xmlnew file mode 100644index 0000000000..ac6ce65036--- /dev/null+++ b/Ghidra/Features/Base/src/test/resources/ghidra/app/util/opinion/decompile_debug_test.xml@@ -0,0 +1,1011 @@+<xml_savefile name="FUN_140022cb8" target="default" adjustvma="0">+<binaryimage arch="x86:LE:64:default:gcc">+<bytechunk space="ram" offset="0x140022cb8" readonly="true">+ 48895c2408574883+ec30b901000000e868fbffff84c00f84+300100004032ff40887c2420e817fbff+ff8ad88b0dcf300c0083f9010f841d01+000085c9754ac705b8300c0001000000+488d15d1720000488d0db2720000e833+09000085c0740ab8ff000000e9d80000+00488d1590720000488d0d09720000e8+0c090000c7057a300c0002000000eb08+40b70140887c24208acbe845fcffffe8+c8070000488bd848833800741e488bc8+e897fbffff84c074124533c0418d5002+33c9488b03ff1595710000e8a4070000+488bd8488338007414488bc8e86bfbff+ff84c07408488b0be8c7080000e87205+00000fb7d8e890080000448bcb4c8bc0+33d2488d0d47d2fdffe8d20800008bd8+e89705000084c074504084ff7505e84f+08000033d2b101e8dcfbffff8bc3eb19++</bytechunk>+<bytechunk space="ram" offset="0x140022df9" readonly="true">+ 488b5c24404883+c4305fc3b907000000e8be03000090b9+07000000e8b30300008bcbe82c080000++</bytechunk>+<bytechunk space="ram" offset="0x140029f10" readonly="true">+5038024001000000+</bytechunk>+</binaryimage>++<coretypes>+ <type name="undefined" size="1" metatype="unknown" id="0xc000000000000000"/>+ <type name="char" size="1" metatype="int" char="true" id="0xc000000000000080"/>+ <type name="code" size="1" metatype="code" id="0xe000000000000001"/>+ <type name="uint16" size="16" metatype="uint" id="0xc0000000000000c2"/>+ <type name="uint3" size="3" metatype="uint" id="0xc0000000000000c3"/>+ <type name="uint5" size="5" metatype="uint" id="0xc0000000000000c4"/>+ <type name="uint6" size="6" metatype="uint" id="0xc0000000000000c5"/>+ <type name="uint7" size="7" metatype="uint" id="0xc0000000000000c6"/>+ <type name="uint" size="4" metatype="uint" id="0xc0000000000000c7"/>+ <type name="double" size="8" metatype="float" id="0xc000000000000087"/>+ <type name="float10" size="10" metatype="float" id="0xc000000000000089"/>+ <type name="ulonglong" size="8" metatype="uint" id="0xc0000000000000ca"/>+ <type name="float16" size="16" metatype="float" id="0xc00000000000008a"/>+ <type name="ushort" size="2" metatype="uint" id="0xc0000000000000cb"/>+ <type name="float2" size="2" metatype="float" id="0xc00000000000008b"/>+ <type name="void" size="0" metatype="void" id="0xc0000000000000cc"/>+ <type name="float" size="4" metatype="float" id="0xc00000000000008f"/>+ <type name="wchar32" size="4" metatype="int" utf="true" id="0xc0000000000000cf"/>+ <type name="wchar_t" size="2" metatype="int" utf="true" id="0xc0000000000000d0"/>+ <type name="int16" size="16" metatype="int" id="0xc000000000000095"/>+ <type name="int3" size="3" metatype="int" id="0xc000000000000096"/>+ <type name="int5" size="5" metatype="int" id="0xc000000000000097"/>+ <type name="int6" size="6" metatype="int" id="0xc000000000000098"/>+ <type name="int7" size="7" metatype="int" id="0xc000000000000099"/>+ <type name="int" size="4" metatype="int" id="0xc00000000000009a"/>+ <type name="longlong" size="8" metatype="int" id="0xc00000000000009f"/>+ <type name="short" size="2" metatype="int" id="0xc0000000000000ab"/>+ <type name="sbyte" size="1" metatype="int" id="0xc0000000000000ac"/>+ <type name="undefined1" size="1" metatype="unknown" id="0xc0000000000000b7"/>+ <type name="undefined2" size="2" metatype="unknown" id="0xc0000000000000b8"/>+ <type name="undefined3" size="3" metatype="unknown" id="0xc0000000000000b9"/>+ <type name="undefined4" size="4" metatype="unknown" id="0xc0000000000000ba"/>+ <type name="undefined5" size="5" metatype="unknown" id="0xc0000000000000bb"/>+ <type name="undefined6" size="6" metatype="unknown" id="0xc0000000000000bc"/>+ <type name="undefined7" size="7" metatype="unknown" id="0xc0000000000000bd"/>+ <type name="undefined8" size="8" metatype="unknown" id="0xc0000000000000be"/>+ <type name="bool" size="1" metatype="bool" id="0xc00000000000007e"/>+ <type name="byte" size="1" metatype="uint" id="0xc00000000000007f"/>+</coretypes><save_state>++<typegrp structalign="4">+ <type name="IMAGE_DOS_HEADER" id="0x100000000000000" metatype="struct" size="128" alignment="1" incomplete="true"/>+ <type name="undefined" id="0xc000000000000000" metatype="unknown" size="1"/>+ <type name="" metatype="ptr" size="8">+ <typeref name="undefined" id="0xc000000000000000"/>+ </type>+ <type name="" metatype="ptr" size="8">+ <typeref name="undefined" id="0xc000000000000000"/>+ </type>+ <type name="" metatype="array" size="2" arraysize="2">+ <type name="char" id="0xc000000000000080" metatype="int" size="1" char="true"/>+ </type>+ <type name="" metatype="array" size="8" arraysize="4">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </type>+ <type name="" metatype="array" size="20" arraysize="10">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </type>+ <type name="" metatype="array" size="64" arraysize="64">+ <type name="byte" id="0xc00000000000007f" metatype="uint" size="1"/>+ </type>+ <def name="WORD" id="0x50000000000000d">+ <type name="ushort" id="0xc0000000000000cb" metatype="uint" size="2"/>+ </def>+ <type name="IMAGE_DOS_HEADER" id="0x100000000000000" metatype="struct" size="128" alignment="1">+ <field name="e_magic" offset="0">+ <type name="" metatype="array" size="2" arraysize="2">+ <type name="char" id="0xc000000000000080" metatype="int" size="1" char="true"/>+ </type>+ </field>+ <field name="e_cblp" offset="2">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_cp" offset="4">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_crlc" offset="6">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_cparhdr" offset="8">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_minalloc" offset="10">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_maxalloc" offset="12">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_ss" offset="14">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_sp" offset="16">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_csum" offset="18">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_ip" offset="20">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_cs" offset="22">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_lfarlc" offset="24">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_ovno" offset="26">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_res[4]" offset="28">+ <type name="" metatype="array" size="8" arraysize="4">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </type>+ </field>+ <field name="e_oemid" offset="36">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_oeminfo" offset="38">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </field>+ <field name="e_res2[10]" offset="40">+ <type name="" metatype="array" size="20" arraysize="10">+ <type name="word" id="0xc0000000000000d1" metatype="uint" size="2"/>+ </type>+ </field>+ <field name="e_lfanew" offset="60">+ <type name="dword" id="0xc000000000000084" metatype="uint" size="4"/>+ </field>+ <field name="e_program" offset="64">+ <type name="" metatype="array" size="64" arraysize="64">+ <type name="byte" id="0xc00000000000007f" metatype="uint" size="1"/>+ </type>+ </field>+ </type>+</typegrp><db scopeidbyname="false">+<scope name="" id="0x0">+<symbollist>++<mapsym>+ <function id="0x46e" name="FUN_140022cb8" size="1">+ <addr space="ram" offset="0x140022cb8"/>+ <localdb lock="false" main="stack">+ <scope name="FUN_140022cb8">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist>+ <mapsym>+ <symbol id="0x1d7b" name="local_18" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined1" id="0xc0000000000000b7"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffe8" size="1"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d7c" name="local_res8" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0x8" size="8"/>+ <rangelist/>+ </mapsym>+ </symbollist>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true" voidlock="true">+ <returnsym typelock="true">+ <addr space="register" offset="0x0" size="8"/>+ <type name="ulonglong" id="0xc0000000000000ca" metatype="uint" size="8"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x140022cb8" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4bb" name="FUN_140022834" size="1">+ <addr space="ram" offset="0x140022834"/>+ <localdb lock="false" main="stack">+ <scope name="FUN_140022834">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist>+ <mapsym>+ <symbol id="0x16b6" name="param_1" typelock="true" namelock="false" merge="false" cat="0" index="0x0">+ <type name="int" id="0xc00000000000009a" metatype="int" size="4"/>+ </symbol>+ <addr space="register" offset="0x8" size="4"/>+ <rangelist>+ <range space="ram" first="0x140022833" last="0x140022833"/>+ </rangelist>+ </mapsym>+ </symbollist>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true">+ <returnsym typelock="true">+ <addr space="register" offset="0x0" size="8"/>+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x140022834" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4ba" name="__scrt_acquire_startup_lock" size="1">+ <addr space="ram" offset="0x1400227f8"/>+ <localdb lock="false" main="stack">+ <scope name="__scrt_acquire_startup_lock">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist/>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true" voidlock="true">+ <returnsym typelock="true">+ <addr space="register" offset="0x0" size="8"/>+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x1400227f8" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <symbol name="DAT_1400e5db8" typelock="true" namelock="true" merge="false" cat="-1">+ <typeref name="undefined4" id="0xc0000000000000ba"/>+ </symbol>+ <addr space="ram" offset="0x1400e5db8" size="4"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x464" name="_initterm_e" size="1">+ <addr space="ram" offset="0x140023646"/>+ <localdb lock="false" main="stack">+ <scope name="_initterm_e">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist/>+ </scope>+ </localdb>+ <prototype extrapop="8" model="unknown">+ <returnsym>+ <addr space="register" offset="0x0" size="1"/>+ <typeref name="undefined" id="0xc000000000000000"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x140023646" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x462" name="_initterm" size="1">+ <addr space="ram" offset="0x140023640"/>+ <localdb lock="false" main="stack">+ <scope name="_initterm">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist/>+ </scope>+ </localdb>+ <prototype extrapop="8" model="unknown">+ <returnsym>+ <addr space="register" offset="0x0" size="1"/>+ <typeref name="undefined" id="0xc000000000000000"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x140023640" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4bd" name="__scrt_release_startup_lock" size="1">+ <addr space="ram" offset="0x140022994"/>+ <localdb lock="false" main="stack">+ <scope name="__scrt_release_startup_lock">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist>+ <mapsym>+ <symbol id="0x169b" name="param_1" typelock="true" namelock="false" merge="false" cat="0" index="0x0">+ <type name="char" id="0xc000000000000080" metatype="int" size="1" char="true"/>+ </symbol>+ <addr space="register" offset="0x8" size="1"/>+ <rangelist>+ <range space="ram" first="0x140022993" last="0x140022993"/>+ </rangelist>+ </mapsym>+ </symbollist>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true">+ <returnsym>+ <addr space="register" offset="0x0" size="1"/>+ <typeref name="undefined" id="0xc000000000000000"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x140022994" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4cb" name="FUN_14002351c" size="1">+ <addr space="ram" offset="0x14002351c"/>+ <localdb lock="false" main="stack">+ <scope name="FUN_14002351c">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist/>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true" voidlock="true">+ <returnsym typelock="true">+ <addr space="register" offset="0x0" size="8"/>+ <type name="" metatype="ptr" size="8">+ <typeref name="undefined" id="0xc000000000000000"/>+ </type>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x14002351c" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4bc" name="FUN_1400228fc" size="1">+ <addr space="ram" offset="0x1400228fc"/>+ <localdb lock="false" main="stack">+ <scope name="FUN_1400228fc">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist>+ <mapsym>+ <symbol id="0x1d7a" name="local_18" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffe8" size="8"/>+ <rangelist/>+ </mapsym>+ </symbollist>+ </scope>+ </localdb>+ <prototype extrapop="8" model="unknown">+ <returnsym>+ <addr space="register" offset="0x0" size="1"/>+ <typeref name="undefined" id="0xc000000000000000"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x1400228fc" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <symbol name="PTR__guard_dispatch_icall_140029f10" typelock="true" namelock="true" readonly="true" merge="false" cat="-1">+ <type name="" metatype="ptr" size="8">+ <typeref name="undefined" id="0xc000000000000000"/>+ </type>+ </symbol>+ <addr space="ram" offset="0x140029f10" size="8"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4cc" name="FUN_140023524" size="1">+ <addr space="ram" offset="0x140023524"/>+ <localdb lock="false" main="stack">+ <scope name="FUN_140023524">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist/>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true" voidlock="true">+ <returnsym typelock="true">+ <addr space="register" offset="0x0" size="8"/>+ <type name="" metatype="ptr" size="8">+ <typeref name="undefined" id="0xc000000000000000"/>+ </type>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x140023524" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x468" name="_register_thread_local_exe_atexit_callback" size="1">+ <addr space="ram" offset="0x140023664"/>+ <localdb lock="false" main="stack">+ <scope name="_register_thread_local_exe_atexit_callback">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist/>+ </scope>+ </localdb>+ <prototype extrapop="8" model="unknown">+ <returnsym>+ <addr space="register" offset="0x0" size="1"/>+ <typeref name="undefined" id="0xc000000000000000"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x140023664" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4c7" name="__scrt_get_show_window_mode" size="1">+ <addr space="ram" offset="0x140023314"/>+ <localdb lock="false" main="stack">+ <scope name="__scrt_get_show_window_mode">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist>+ <mapsym>+ <symbol id="0x1da0" name="local_78" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined1" id="0xc0000000000000b7"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffff88" size="1"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1da1" name="local_3c" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined1" id="0xc0000000000000b7"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffc4" size="1"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1da2" name="local_38" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined2" id="0xc0000000000000b8"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffc8" size="2"/>+ <rangelist/>+ </mapsym>+ </symbollist>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true" voidlock="true">+ <returnsym typelock="true">+ <addr space="register" offset="0x0" size="2"/>+ <typeref name="WORD" id="0x50000000000000d"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x140023314" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x460" name="_get_narrow_winmain_command_line" size="1">+ <addr space="ram" offset="0x14002363a"/>+ <localdb lock="false" main="stack">+ <scope name="_get_narrow_winmain_command_line">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist/>+ </scope>+ </localdb>+ <prototype extrapop="8" model="unknown">+ <returnsym>+ <addr space="register" offset="0x0" size="1"/>+ <typeref name="undefined" id="0xc000000000000000"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x14002363a" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4cd" name="FUN_140023690" size="1">+ <addr space="ram" offset="0x140023690"/>+ <localdb lock="false" main="stack">+ <scope name="FUN_140023690">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist>+ <mapsym>+ <symbol id="0x1db0" name="local_20" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffe0" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1db1" name="local_res8" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0x8" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1db2" name="local_res10" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0x10" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1db3" name="local_res18" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0x18" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1da8" name="local_68" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffff98" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1da9" name="local_60" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined4" id="0xc0000000000000ba"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffa0" size="4"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1daa" name="local_58" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffa8" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1dab" name="local_50" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffb0" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1dac" name="local_48" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined4" id="0xc0000000000000ba"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffb8" size="4"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1dad" name="local_40" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffc0" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1dae" name="local_38" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffc8" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1daf" name="local_28" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xffffffffffffffd8" size="8"/>+ <rangelist/>+ </mapsym>+ </symbollist>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true" voidlock="true">+ <returnsym typelock="true">+ <addr space="register" offset="0x0" size="8"/>+ <type name="ulonglong" id="0xc0000000000000ca" metatype="uint" size="8"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x140023690" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4c8" name="FUN_14002335c" size="1">+ <addr space="ram" offset="0x14002335c"/>+ <localdb lock="false" main="stack">+ <scope name="FUN_14002335c">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist/>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true" voidlock="true">+ <returnsym typelock="true">+ <addr space="register" offset="0x0" size="8"/>+ <type name="ulonglong" id="0xc0000000000000ca" metatype="uint" size="8"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x14002335c" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x45e" name="_cexit" size="1">+ <addr space="ram" offset="0x140023622"/>+ <localdb lock="false" main="stack">+ <scope name="_cexit">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist/>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__cdecl" modellock="true" voidlock="true">+ <returnsym typelock="true">+ <addr/>+ <void/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x140023622" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4be" name="__scrt_uninitialize_crt" size="1">+ <addr space="ram" offset="0x1400229b8"/>+ <localdb lock="false" main="stack">+ <scope name="__scrt_uninitialize_crt">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist>+ <mapsym>+ <symbol id="0x16b4" name="param_1" typelock="true" namelock="false" merge="false" cat="0" index="0x0">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="register" offset="0x8" size="8"/>+ <rangelist>+ <range space="ram" first="0x1400229b7" last="0x1400229b7"/>+ </rangelist>+ </mapsym>+ <mapsym>+ <symbol id="0x16b5" name="param_2" typelock="true" namelock="false" merge="false" cat="0" index="0x1">+ <type name="char" id="0xc000000000000080" metatype="int" size="1" char="true"/>+ </symbol>+ <addr space="register" offset="0x10" size="1"/>+ <rangelist>+ <range space="ram" first="0x1400229b7" last="0x1400229b7"/>+ </rangelist>+ </mapsym>+ </symbollist>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true">+ <returnsym>+ <addr space="register" offset="0x0" size="1"/>+ <typeref name="undefined" id="0xc000000000000000"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x1400229b8" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x465" name="exit" size="1" noreturn="true">+ <addr space="ram" offset="0x14002364c"/>+ <localdb lock="false" main="stack">+ <scope name="exit">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist>+ <mapsym>+ <symbol id="0xfb1" name="_Code" typelock="true" namelock="true" merge="false" cat="0" index="0x0">+ <type name="int" id="0xc00000000000009a" metatype="int" size="4"/>+ </symbol>+ <addr space="register" offset="0x8" size="4"/>+ <rangelist>+ <range space="ram" first="0x14002364b" last="0x14002364b"/>+ </rangelist>+ </mapsym>+ </symbollist>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__cdecl" modellock="true" noreturn="true">+ <returnsym typelock="true">+ <addr/>+ <void/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x14002364c" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x4c6" name="FUN_1400231cc" size="1">+ <addr space="ram" offset="0x1400231cc"/>+ <localdb lock="false" main="stack">+ <scope name="FUN_1400231cc">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist>+ <mapsym>+ <symbol id="0x1d8e" name="local_5a0" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffa60" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d8f" name="local_598" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffa68" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d90" name="local_590" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffa70" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d91" name="local_588" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffa78" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x16b1" name="param_1" typelock="true" namelock="false" merge="false" cat="0" index="0x0">+ <typeref name="undefined4" id="0xc0000000000000ba"/>+ </symbol>+ <addr space="register" offset="0x8" size="4"/>+ <rangelist>+ <range space="ram" first="0x1400231cb" last="0x1400231cb"/>+ </rangelist>+ </mapsym>+ <mapsym>+ <symbol id="0x1d92" name="local_580" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffa80" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d93" name="local_578" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffa88" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d94" name="local_570" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined4" id="0xc0000000000000ba"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffa90" size="4"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d95" name="local_56c" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined4" id="0xc0000000000000ba"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffa94" size="4"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d96" name="local_560" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffaa0" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d97" name="local_4d8" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined1" id="0xc0000000000000b7"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffb28" size="1"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d98" name="local_4c8" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined1" id="0xc0000000000000b7"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffb38" size="1"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d99" name="local_440" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffbc0" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d9a" name="local_3e0" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0xfffffffffffffc20" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d9b" name="local_res0" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0x0" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d9c" name="local_res8" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0x8" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d9d" name="local_res10" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined8" id="0xc0000000000000be"/>+ </symbol>+ <addr space="stack" offset="0x10" size="8"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d9e" name="local_res18" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined1" id="0xc0000000000000b7"/>+ </symbol>+ <addr space="stack" offset="0x18" size="1"/>+ <rangelist/>+ </mapsym>+ <mapsym>+ <symbol id="0x1d9f" name="local_res20" typelock="false" namelock="true" cat="-1">+ <typeref name="undefined1" id="0xc0000000000000b7"/>+ </symbol>+ <addr space="stack" offset="0x20" size="1"/>+ <rangelist/>+ </mapsym>+ </symbollist>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true">+ <returnsym>+ <addr space="register" offset="0x0" size="1"/>+ <typeref name="undefined" id="0xc000000000000000"/>+ </returnsym>+ </prototype>+ </function>+ <addr space="ram" offset="0x1400231cc" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <function id="0x11" name="_guard_dispatch_icall" size="1">+ <addr space="ram" offset="0x140023850"/>+ <localdb lock="false" main="stack">+ <scope name="_guard_dispatch_icall">+ <parent id="0x0"/>+ <rangelist/>+ <symbollist/>+ </scope>+ </localdb>+ <prototype extrapop="8" model="__fastcall" modellock="true" voidlock="true">+ <returnsym>+ <addr space="register" offset="0x0" size="1"/>+ <typeref name="undefined" id="0xc000000000000000"/>+ </returnsym>+ <inject>guard_dispatch_icall</inject>+ </prototype>+ </function>+ <addr space="ram" offset="0x140023850" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <symbol name="IMAGE_DOS_HEADER_140000000" typelock="true" namelock="true" readonly="true" merge="false" cat="-1">+ <typeref name="IMAGE_DOS_HEADER" id="0x100000000000000"/>+ </symbol>+ <addr space="ram" offset="0x140000000" size="128"/>+ <rangelist/>+</mapsym>+<mapsym>+ <symbol name="DAT_140029f38" typelock="true" namelock="true" readonly="true" merge="false" cat="-1">+ <typeref name="undefined" id="0xc000000000000000"/>+ </symbol>+ <addr space="ram" offset="0x140029f38" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <symbol name="DAT_140029fc0" typelock="true" namelock="true" readonly="true" merge="false" cat="-1">+ <typeref name="undefined" id="0xc000000000000000"/>+ </symbol>+ <addr space="ram" offset="0x140029fc0" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <symbol name="DAT_140029fd8" typelock="true" namelock="true" readonly="true" merge="false" cat="-1">+ <typeref name="undefined" id="0xc000000000000000"/>+ </symbol>+ <addr space="ram" offset="0x140029fd8" size="1"/>+ <rangelist/>+</mapsym>+<mapsym>+ <labelsym name="LAB_140022e19" id="0x4000000040022e19"/>+ <addr space="ram" offset="0x140022e19"/>+ <rangelist/>+</mapsym></symbollist>+</scope>+</db>+<context_points>++<context_pointset space="ram" offset="0x140022cb8">+ <set name="longMode" val="1"/>+ <set name="reserved" val="0"/>+ <set name="addrsize" val="2"/>+ <set name="bit64" val="1"/>+ <set name="opsize" val="1"/>+ <set name="segover" val="0"/>+ <set name="highseg" val="0"/>+ <set name="protectedMode" val="0"/>+ <set name="mandover" val="0"/>+ <set name="repneprefx" val="0"/>+ <set name="xacquireprefx" val="0"/>+ <set name="prefix_f2" val="0"/>+ <set name="repprefx" val="0"/>+ <set name="xreleaseprefx" val="0"/>+ <set name="prefix_f3" val="0"/>+ <set name="prefix_66" val="0"/>+ <set name="rexWRXBprefix" val="0"/>+ <set name="rexWprefix" val="0"/>+ <set name="rexRprefix" val="0"/>+ <set name="rexXprefix" val="0"/>+ <set name="rexBprefix" val="0"/>+ <set name="rexprefix" val="0"/>+ <set name="vexMode" val="0"/>+ <set name="evexL" val="0"/>+ <set name="evexLp" val="0"/>+ <set name="suffix3D" val="0"/>+ <set name="vexL" val="0"/>+ <set name="evexV5" val="0"/>+ <set name="evexVp" val="0"/>+ <set name="vexVVVV" val="0"/>+ <set name="vexHighV" val="0"/>+ <set name="instrPhase" val="0"/>+ <set name="lockprefx" val="0"/>+ <set name="vexMMMMM" val="0"/>+ <set name="evexRp" val="0"/>+ <set name="evexB" val="0"/>+ <set name="evexZ" val="0"/>+ <set name="evexAAA" val="0"/>+ <set name="evexD8Type" val="0"/>+ <set name="evexTType" val="0"/>+ <set name="evexDisp8" val="0"/>+ <set name="reservedHigh" val="0"/>+ <set name="evexBType" val="0"/>+</context_pointset>+<tracked_pointset space="ram" offset="0x140022cb8">+ <set space="register" offset="0x118" size="8" val="0xff00000000"/>+ <set space="register" offset="0x20a" size="1" val="0x0"/>+</tracked_pointset>+<tracked_pointset space="ram" offset="0x140022cb8">+ <set space="register" offset="0x118" size="8" val="0xff00000000"/>+ <set space="register" offset="0x20a" size="1" val="0x0"/>+</tracked_pointset></context_points>++<commentdb/>+<optionslist>+ <readonly>on</readonly>+ <setlanguage>c-language</setlanguage>+ <protoeval>__fastcall</protoeval>+</optionslist><flowoverridelist>++<flow type="callreturn">+ <addr space="ram" offset="0x140022cb8"/>+ <addr space="ram" offset="0x140022e1b"/>+</flow>+<flow type="callreturn">+ <addr space="ram" offset="0x140022cb8"/>+ <addr space="ram" offset="0x140022e1b"/>+</flow></flowoverridelist>+<injectdebug>++<inject name="guard_dispatch_icall" type="1">+ <addr space="ram" offset="0x140022d75"/>+ <payload>+<inst offset="6">+ <addr space="ram" offset="0x140022d75"/>+ <op code="8" size="1">+ <void/>+ <addr space="register" offset="0x0" size="8"/>+ </op>+</inst></payload>+</inject></injectdebug>+</save_state>+</xml_savefile>diff --git a/Ghidra/Framework/Utility/src/main/java/ghidra/xml/XmlElement.java b/Ghidra/Framework/Utility/src/main/java/ghidra/xml/XmlElement.javaindex 93d0de4292..1f6d68b017 100644--- a/Ghidra/Framework/Utility/src/main/java/ghidra/xml/XmlElement.java+++ b/Ghidra/Framework/Utility/src/main/java/ghidra/xml/XmlElement.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -44,4 +44,6 @@ public interface XmlElement {public int getLineNumber();public void setAttribute(String key, String value);++ public boolean isStart(String string);}diff --git a/Ghidra/Framework/Utility/src/main/java/ghidra/xml/XmlElementImpl.java b/Ghidra/Framework/Utility/src/main/java/ghidra/xml/XmlElementImpl.javaindex f8b7ac89f4..3b921a4c9f 100644--- a/Ghidra/Framework/Utility/src/main/java/ghidra/xml/XmlElementImpl.java+++ b/Ghidra/Framework/Utility/src/main/java/ghidra/xml/XmlElementImpl.java@@ -4,9 +4,9 @@* Licensed under the Apache License, Version 2.0 (the "License");* you may not use this file except in compliance with the License.* You may obtain a copy of the License at- *+ ** http://www.apache.org/licenses/LICENSE-2.0- *+ ** Unless required by applicable law or agreed to in writing, software* distributed under the License is distributed on an "AS IS" BASIS,* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.@@ -189,4 +189,16 @@ public class XmlElementImpl implements XmlElement {}return result;}++ @Override+ /**+ * Checks that the element is a starting element and also that its name matches the passed+ * string.+ *+ * @param string element name to check for a match.+ * @return boolean+ */+ public boolean isStart(String string) {+ return this.isStart && this.name.equals(string);+ }}