Ghidra is a software reverse engineering (SRE) framework
GP-3040 - Demangler - Demangle all mangled symbols at an address
dragonmacher5237c3697503
diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/cmd/disassemble/DisassembleCommand.java b/Ghidra/Features/Base/src/main/java/ghidra/app/cmd/disassemble/DisassembleCommand.javaindex fd84140998..6ed5f5a83e 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/cmd/disassemble/DisassembleCommand.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/cmd/disassemble/DisassembleCommand.java@@ -343,7 +343,7 @@ public class DisassembleCommand extends BackgroundCommand<Program> {/*** Determine if intermediate analysis is required to reduce the risk of disassembling data* regions when performing static disassembly over a contiguous range if addresses. This method- * attemps to identify this situation by checking the first range of disassembledSet against the+ * attempts to identify this situation by checking the first range of disassembledSet against the* startSet. Analysis will be triggered if startSet contains both the max address of the first* range of disassembledSet (M where M=disassembledSet.firstRange().getMaxAddress()) and the* next address (M.next()) which will be the next seed point.diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/analysis/AbstractDemanglerAnalyzer.java b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/analysis/AbstractDemanglerAnalyzer.javaindex 59c76223d1..19826222fd 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/analysis/AbstractDemanglerAnalyzer.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/plugin/core/analysis/AbstractDemanglerAnalyzer.java@@ -87,9 +87,9 @@ public abstract class AbstractDemanglerAnalyzer extends AbstractAnalyzer {// Demangle external symbols after memory symbols.// This is done to compensate for cases where the mangled name on externals may be lost// after demangling when an alternate Ordinal symbol exists. The external mangled- // name is helpful in preserving thunk relationships when a mangled symbols have been- // placed on a thunk. It is assumed that analyzer is presented with entire- // EXTERNAL space in set (all or none).+ // name is helpful in preserving thunk relationships when mangled symbols have been+ // placed on a thunk. It is assumed that this analyzer is presented with the entire+ // EXTERNAL space in the given set (all or none).boolean demangleExternals = set.contains(EXTERNAL_SET.getMinAddress());if (demangleExternals) {set = set.subtract(EXTERNAL_SET);@@ -126,50 +126,54 @@ public abstract class AbstractDemanglerAnalyzer extends AbstractAnalyzer {throws CancelledException {int count = initialCount;- SymbolTable symbolTable = program.getSymbolTable();- // TODO: iterator will continually need to reinitialize due to symbol changes++ // Note: iterator will continually need to reinitialize due to symbol changes// consider copying primary symbols to alt storage for iteration+ SymbolTable symbolTable = program.getSymbolTable();SymbolIterator it = symbolTable.getPrimarySymbolIterator(set, true);while (it.hasNext()) {monitor.checkCancelled();if (++count % 100 == 0) {- monitor.setMessage(getName() + " - " + count + " symbols");+ monitor.setMessage("%s - %s symbols".formatted(getName(), count));}- Symbol symbol = it.next();- if (skipSymbol(symbol)) {- continue;- }+ Symbol primarySymbol = it.next();+ if (!skipSymbol(primarySymbol)) {- Address address = symbol.getAddress();- MangledContext mangledContext = createMangledContext(program, options, symbol);- DemangledObject demangled = demangle(mangledContext, log);- if (demangled != null) {- apply(mangledContext, demangled, log, monitor);- continue;+ MangledContext mangledContext =+ createMangledContext(program, options, primarySymbol);+ DemangledObject demangled = demangle(mangledContext, log);+ if (demangled != null) {+ apply(mangledContext, demangled, true, log, monitor);+ }}- // Only attempt to demangle a non-primary symbol if primary is imported and will- // not demangle.- if (symbol.getSource() != SourceType.IMPORTED) {+ Address address = primarySymbol.getAddress();+ demangleNonPrimarySymbols(program, address, options, log, monitor);+ }++ return count;+ }++ private void demangleNonPrimarySymbols(Program program, Address address,+ DemanglerOptions options, MessageLog log, TaskMonitor monitor)+ throws CancelledException {++ SymbolTable symbolTable = program.getSymbolTable();+ for (Symbol symbol : symbolTable.getSymbols(address)) {+ monitor.checkCancelled();++ if (symbol.isPrimary() || skipSymbol(symbol)) {continue;}- for (Symbol altSym : symbolTable.getSymbols(address)) {- if (altSym.isPrimary() || skipSymbol(altSym)) {- continue;- }- mangledContext = createMangledContext(program, options, altSym);- demangled = demangle(mangledContext, log);- if (demangled != null) {- apply(mangledContext, demangled, log, monitor);- break;- }+ MangledContext context = createMangledContext(program, options, symbol);+ DemangledObject demangled = demangle(context, log);+ if (demangled != null) {+ apply(context, demangled, false, log, monitor);}-}- return count;}/**@@ -266,15 +270,17 @@ public abstract class AbstractDemanglerAnalyzer extends AbstractAnalyzer {}catch (Throwable e) {- if (e instanceof DemangledException) {- if (((DemangledException) e).isInvalidMangledName()) {- //ignore invalid names, consider as not an error- return null;+ if (e instanceof DemangledException de) {+ if (de.isInvalidMangledName()) {+ return null; // ignore invalid names, consider as not an error}}- log.appendMsg(getName(), "Unable to demangle symbol: " + mangledContext.getMangled() +- " at " + mangledContext.getAddress() + ". Message: " + e.getMessage());+ String mangled = mangledContext.getMangled();+ Address addr = mangledContext.getAddress();+ String msg = e.getMessage();+ log.appendMsg(+ "Unable to demangle symbol: %s at %s. Message: %s".formatted(mangled, addr, msg));return null;}@@ -286,21 +292,28 @@ public abstract class AbstractDemanglerAnalyzer extends AbstractAnalyzer {** @param mangledContext the mangled context* @param demangled the demangled object- * @param log the error log+ * @param isPrimary true if the symbol being demangle is the primary symbol+ * @param log the error log* @param monitor the task monitor*/- protected void apply(MangledContext mangledContext, DemangledObject demangled, MessageLog log,- TaskMonitor monitor) {+ protected void apply(MangledContext mangledContext, DemangledObject demangled,+ boolean isPrimary, MessageLog log, TaskMonitor monitor) {++ demangled.setPrimary(isPrimary);++ Program program = mangledContext.getProgram();+ Address addr = mangledContext.getAddress();+ DemanglerOptions options = mangledContext.getOptions();try {- if (demangled.applyTo(mangledContext.getProgram(), mangledContext.getAddress(),- mangledContext.getOptions(), monitor)) {+ if (demangled.applyTo(program, addr, options, monitor)) {return;}+String errorString = demangled.getErrorMessage();- logApplyErrorMessage(log, demangled, mangledContext.getAddress(), null, errorString);+ logApplyErrorMessage(log, demangled, addr, null, errorString);}catch (Exception e) {- logApplyErrorMessage(log, demangled, mangledContext.getAddress(), e, null);+ logApplyErrorMessage(log, demangled, addr, e, null);}}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledAddressTable.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledAddressTable.javaindex 5b6fb87137..7871978529 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledAddressTable.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledAddressTable.java@@ -83,7 +83,7 @@ public class DemangledAddressTable extends DemangledObject {return false;}- Symbol s = applyDemangledName(address, true, false, program);+ Symbol s = applyDemangledName(address, isPrimary, false, program);if (s == null) {return false;}@@ -121,7 +121,7 @@ public class DemangledAddressTable extends DemangledObject {if (isUndefinedInRange(program, address, address.add(length - 1))) {long count = length / program.getDefaultPointerSize();- createPointers(program, address, (int) count);+ createPointers(program, address, (int) count, monitor);}return true;@@ -166,8 +166,9 @@ public class DemangledAddressTable extends DemangledObject {/*** Creates pointers from start address.* If a pointer already exists, then skip it and continue.+ * @param monitor the task monitor*/- private void createPointers(Program program, Address start, int count) {+ private void createPointers(Program program, Address start, int count, TaskMonitor monitor) {DataType pointerDt = new PointerDataType(program.getDataTypeManager());@@ -177,6 +178,10 @@ public class DemangledAddressTable extends DemangledObject {for (int i = 0; i < count; ++i) {+ if (monitor.isCancelled()) {+ return;+ }+Address addr = start.add(pointerDt.getLength() * i);buf.setPosition(addr);diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledFunction.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledFunction.javaindex 74827196a1..fbfd35b3fb 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledFunction.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledFunction.java@@ -463,7 +463,10 @@ public class DemangledFunction extends DemangledObject {}// If existing function signature is user defined - add demangled label only- boolean makePrimary = (function.getSignatureSource() != SourceType.USER_DEFINED);+ boolean makePrimary = isPrimary;+ if (function.getSignatureSource() == SourceType.USER_DEFINED) {+ makePrimary = false;+ }Symbol demangledSymbol =applyDemangledName(function.getEntryPoint(), makePrimary, false, program);@@ -514,7 +517,7 @@ public class DemangledFunction extends DemangledObject {ApplyFunctionSignatureCmd cmd = new ApplyFunctionSignatureCmd(function.getEntryPoint(),signature, signatureSourceType, true, false, DataTypeConflictHandler.DEFAULT_HANDLER,FunctionRenameOption.RENAME_IF_DEFAULT);- cmd.applyTo(program);+ cmd.applyTo(program, monitor);return true;}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledLabel.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledLabel.javaindex 5ccd76c06c..c3190ecf5c 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledLabel.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledLabel.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.@@ -40,7 +40,7 @@ public class DemangledLabel extends DemangledObject {@Overridepublic boolean applyTo(Program program, Address address, DemanglerOptions options,TaskMonitor monitor) throws Exception {- Symbol symbol = applyDemangledName(address, true, false, program);+ Symbol symbol = applyDemangledName(address, isPrimary, false, program);return symbol != null;}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledObject.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledObject.javaindex 58e055aa79..538ec9abc6 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledObject.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledObject.java@@ -116,6 +116,7 @@ public abstract class DemangledObject implements Demangled {// Status of mangled String converted successfully to demangled Stringprivate boolean demangledNameSucceeded = false;private String errorMessage = null;+ protected boolean isPrimary = true; // default to true for backward compatibility/*** Constructor. This is the older constructor that does not take a mangled context@@ -249,6 +250,15 @@ public abstract class DemangledObject implements Demangled {demangledNameSucceeded = !mangled.equals(name);}+ /**+ * Sets whether the symbol from which this demangle object was created is the primary symbol at+ * the given address. If true, then the demangled symbol will be made the primary symbol.+ * @param isPrimary true if primary+ */+ public void setPrimary(boolean isPrimary) {+ this.isPrimary = isPrimary;+ }+/*** Returns the success state of converting a mangled String into a demangled String* @return true succeeded creating demangled String@@ -438,11 +448,14 @@ public abstract class DemangledObject implements Demangled {* @param address address which corresponds to this demangled object* @param options options which control how demangled data is applied* @param monitor task monitor- * @return true if successfully applied, else false+ * @return false if there is an issue applying* @throws Exception if an error occurs during the apply operation*/public boolean applyTo(Program program, Address address, DemanglerOptions options,TaskMonitor monitor) throws Exception {+ if (!isPrimary) {+ return true;+ }return applyPlateCommentOnly(program, address);}diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledString.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledString.javaindex 83d1f2bd06..abd71b696d 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledString.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledString.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.@@ -94,9 +94,8 @@ public class DemangledString extends DemangledObject {CreateStringCmd cmd = new CreateStringCmd(address, -1, isUnicode());cmd.applyTo(program);- Symbol demangledSymbol =- applyDemangledName(label, address, true, false, program);- return (demangledSymbol != null);+ Symbol demangledSymbol = applyDemangledName(label, address, isPrimary, false, program);+ return demangledSymbol != null;}private String buildStringLabel() {diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledThunk.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledThunk.javaindex 94c1917b5d..e2608f37e4 100644--- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledThunk.java+++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemangledThunk.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.@@ -97,11 +97,7 @@ public class DemangledThunk extends DemangledObject {Function function =createPreThunkFunction(program, thunkAddress, options.doDisassembly(), monitor);if (function == null) {- // no function whose signature we need to update- // NOTE: This does not much sense- // renameExistingSymbol(program, thunkAddress, symbolTable);- // DemangledFunction.maybeCreateUndefined(program, thunkAddress);- return false;+ return false; // no function whose signature we need to update}// For pre-existing default thunks - apply demangling to thunked function who owns mangled name@@ -114,7 +110,8 @@ public class DemangledThunk extends DemangledObject {function.setThunkedFunction(thunkedFunction);}- Symbol s = applyDemangledName(thunkAddress, function.isThunk(), false, program);+ boolean makePrimary = isPrimary && function.isThunk();+ Symbol s = applyDemangledName(thunkAddress, makePrimary, false, program);return s != null;}diff --git a/Ghidra/Features/GnuDemangler/src/test/java/ghidra/app/plugin/core/analysis/GnuDemanglerAnalyzerTest.java b/Ghidra/Features/GnuDemangler/src/test/java/ghidra/app/plugin/core/analysis/GnuDemanglerAnalyzerTest.javaindex 04bbf5826a..12b12d0245 100644--- a/Ghidra/Features/GnuDemangler/src/test/java/ghidra/app/plugin/core/analysis/GnuDemanglerAnalyzerTest.java+++ b/Ghidra/Features/GnuDemangler/src/test/java/ghidra/app/plugin/core/analysis/GnuDemanglerAnalyzerTest.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.@@ -65,6 +65,21 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadedIntegrationTesMsg.error(this, "Test failed - analysis log:\n" + log);}+ @Test+ public void testDemangleMultipleSymbolsAtAnAddress() {++ Address addr = addr("0x110");+ createSymbol(addr, "_ZGV17globalVariableFoo");+ createSymbol(addr, "_ZZ18__gthread_active_pvE20__gthread_active_ptr");+ createSymbol(addr, "_ZGVZN10KDirLister11emitChangesEvE3dot");++ analyze();++ assertDemangled(addr, "globalVariableFoo");+ assertDemangled(addr, "__gthread_active_ptr");+ assertDemangled(addr, "dot");+ }+@Testpublic void testDeprectedMangledString_WithoutDeprecatedDemangler() throws Exception {diff --git a/Ghidra/Features/Rust/src/main/java/ghidra/app/plugin/core/analysis/rust/RustDemanglerAnalyzer.java b/Ghidra/Features/Rust/src/main/java/ghidra/app/plugin/core/analysis/rust/RustDemanglerAnalyzer.javaindex e3c09c787d..3de66efbe8 100644--- a/Ghidra/Features/Rust/src/main/java/ghidra/app/plugin/core/analysis/rust/RustDemanglerAnalyzer.java+++ b/Ghidra/Features/Rust/src/main/java/ghidra/app/plugin/core/analysis/rust/RustDemanglerAnalyzer.java@@ -25,6 +25,7 @@ import ghidra.app.services.AnalysisPriority;import ghidra.app.util.demangler.*;import ghidra.app.util.importer.MessageLog;import ghidra.framework.options.*;+import ghidra.program.model.address.Address;import ghidra.program.model.listing.Program;import ghidra.util.HelpLocation;import ghidra.util.SystemUtilities;@@ -125,12 +126,15 @@ public class RustDemanglerAnalyzer extends AbstractDemanglerAnalyzer {}@Override- protected void apply(MangledContext mangledContext, DemangledObject demangled, MessageLog log,- TaskMonitor monitor) {+ protected void apply(MangledContext mangledContext, DemangledObject demangled,+ boolean isPrimary, MessageLog log, TaskMonitor monitor) {+try {if (demangled instanceof DemangledFunction defunc) {- defunc.applyTo(mangledContext.getProgram(), mangledContext.getAddress(),- mangledContext.getOptions(), monitor);+ Program program = mangledContext.getProgram();+ Address address = mangledContext.getAddress();+ DemanglerOptions options = mangledContext.getOptions();+ defunc.applyTo(program, address, options, monitor);return;}}@@ -148,7 +152,7 @@ public class RustDemanglerAnalyzer extends AbstractDemanglerAnalyzer {DemangledVariable demangledVariable = new DemangledVariable(mangled, original, name);demangledVariable.setNamespace(namespace);- super.apply(mangledContext, demangledVariable, log, monitor);+ super.apply(mangledContext, demangledVariable, isPrimary, log, monitor);}//==================================================================================================diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/symbol/SymbolUtilities.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/symbol/SymbolUtilities.javaindex edc9d5c6fb..80835e5448 100644--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/symbol/SymbolUtilities.java+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/symbol/SymbolUtilities.java@@ -146,7 +146,6 @@ public class SymbolUtilities {return false;}-/*** Generates a default function name for a given address.* @param addr the entry point of the function.@@ -158,8 +157,8 @@ public class SymbolUtilities {/*** Returns true if the specified name is reserved as a default external name.- * @param name- * @param addrFactory+ * @param name the name+ * @param addrFactory the address factory* @return true if the specified name is reserved as a default external name.*/public static boolean isReservedExternalDefaultName(String name, AddressFactory addrFactory) {@@ -197,6 +196,9 @@ public class SymbolUtilities {* at some address.* WARNING! Does not handle dynamic labels which use data-type prefixes -* see {@link #isDynamicSymbolPattern(String, boolean)} for more liberal check+ * @param name the name+ * @param addrFactory the address factory+ * @return true if a reserved dynamic name*/public static boolean isReservedDynamicLabelName(String name, AddressFactory addrFactory) {String prefix = findDynamicPrefix(name);