Skip to content

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.java
index 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.java
index 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.java
index 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.java
index 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.java
index 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 {
@Override
public 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.java
index 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 String
private 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.java
index 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.java
index 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.java
index 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 AbstractGhidraHeadedIntegrationTes
Msg.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");
+ }
+
@Test
public 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.java
index 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.java
index 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);