yetangitu/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2025-10-05 02:39:44 +02:00
Code Issues Releases Wiki Activity

GP-94 - Gnu Demangler - review fixes

Browse source 
Closes #2214
This commit is contained in:
dragonmacher 2021-02-12 16:05:26 -05:00
parent 443e398bb4
commit 8f1dc3f476
14 changed files with 386 additions and 319 deletions
Download patch file Download diff file Expand all files Collapse all files

14
Ghidra/Features/Base/src/main/help/help/topics/AutoAnalysisPlugin/AutoAnalysis.htm
View file

@ -386,10 +386,7 @@
<U><B>Use Deprecated Demangler</B></U> -
By default, GCC symbols will be demangled using the most up-to-date demangler
that Ghidra contains (<B>version 2.33.1</B> as of this writing). Turning this
option on will also invoke the now deprecated previous version of the demangler
(<B>version 2.24</B>) if the preferred demangler cannot demangle a given symbol.
This option only has an effect when the demangler format is available in both
the deprecated and modern demanglers.
option on will invoke the now deprecated version of the demangler (<B>version 2.24</B>).
</P>
<P>
Support for older demangling styles was removed in <CODE>c++filt (v2.32)</CODE>.
@ -402,10 +399,15 @@
<P>
The available programs are:
<UL>
<LI><CODE>demangler_gnu_v2_33_1</CODE></LI>
<LI><CODE>demangler_gnu_v2_24</CODE></LI>
<LI><CODE CLASS="path">
&lt;GHIDRA_INSTALL_DIR&gt;/GPL/DemanglerGnu/os/&lt;OS&gt;/
</CODE><CODE>demangler_gnu_v2_33_1</CODE></LI>
<LI><CODE CLASS="path">
&lt;GHIDRA_INSTALL_DIR&gt;/GPL/DemanglerGnu/os/&lt;OS&gt;/
</CODE><CODE>demangler_gnu_v2_24</CODE></LI>
</UL>
</P>
<P style="background-color: #FFF0E0;">
<IMG SRC="../../shared/warning.png" />When using an external GNU demangler,
please understand the risks associated with using that version of the

49
Ghidra/Features/Base/src/main/java/ghidra/app/util/demangler/DemanglerOptions.java
View file

@ -16,7 +16,7 @@
package ghidra.app.util.demangler;
/**
* A simple class to contain the various settings for demangling.
* A simple class to contain the various settings for demangling
*/
public class DemanglerOptions {
@ -35,47 +35,47 @@ public class DemanglerOptions {
}
/**
* Checks if the apply signature option is currently set.
*
* @return true if set to apply function signatures that are demangled.
* Checks if the apply signature option is currently set
*
* @return true if set to apply function signatures that are demangled
*/
public boolean applySignature() {
return applySignature;
}
/**
* Set the option to apply function signatures that are demangled.
*
* @param applySignature true to apply function signatures that are demangled.
* Set the option to apply function signatures that are demangled
*
* @param applySignature true to apply function signatures that are demangled
*/
public void setApplySignature(boolean applySignature) {
this.applySignature = applySignature;
}
/**
* Checks if the option to perform disassembly for known data structures (like functions) when
* demangling is set.
*
* @return true if the option is set.
* Checks if the option to perform disassembly for known data structures (like functions) when
* demangling is set
*
* @return true if the option is set
*/
public boolean doDisassembly() {
return doDisassembly;
}
/**
* Sets the option to perform disassembly for known data structures (like functions) when
* demangling.
*
* @param doDisassembly true to perform disassembly when demangling.
* Sets the option to perform disassembly for known data structures (like functions) when
* demangling
*
* @param doDisassembly true to perform disassembly when demangling
*/
public void setDoDisassembly(boolean doDisassembly) {
this.doDisassembly = doDisassembly;
}
/**
* Checks if the option to only demangle known mangled patterns is set.
*
* @return true if only known mangled patterns will be demangled.
* Checks if the option to only demangle known mangled patterns is set
*
* @return true if only known mangled patterns will be demangled
*/
public boolean demangleOnlyKnownPatterns() {
return demangleOnlyKnownPatterns;
@ -83,10 +83,15 @@ public class DemanglerOptions {
/**
* Sets the option to only demangle known mangled patterns. Setting this to false causes
* all symbols to be demangled, which may result in some symbols getting demangled that were not
* actually mangled symbols.
*
* @param demangleOnlyKnownPatterns true to only demangle known mangled patterns.
* most symbols to be demangled, which may result in some symbols getting demangled that were
* not actually mangled symbols.
*
* <P>Generally, a demangler will report an error if a symbol fails to demangle. Hence,
* clients can use this flag to prevent such errors, signalling to the demangler to only
* attempt those symbols that have a known start pattern. If the known start pattern list
* becomes comprehensive, then this flag can go away.
*
* @param demangleOnlyKnownPatterns true to only demangle known mangled patterns
*/
public void setDemangleOnlyKnownPatterns(boolean demangleOnlyKnownPatterns) {
this.demangleOnlyKnownPatterns = demangleOnlyKnownPatterns;

13
Ghidra/Features/GnuDemangler/ghidra_scripts/DemangleElfWithOptionScript.java
View file

@ -21,8 +21,7 @@
//@category Examples.Demangler
import ghidra.app.script.GhidraScript;
import ghidra.app.util.demangler.DemangledObject;
import ghidra.app.util.demangler.gnu.GnuDemangler;
import ghidra.app.util.demangler.gnu.GnuDemanglerOptions;
import ghidra.app.util.demangler.gnu.*;
import ghidra.program.model.symbol.Symbol;
public class DemangleElfWithOptionScript extends GhidraScript {
@ -33,8 +32,8 @@ public class DemangleElfWithOptionScript extends GhidraScript {
GnuDemangler demangler = new GnuDemangler();
if (!demangler.canDemangle(currentProgram)) {
String executableFormat = currentProgram.getExecutableFormat();
println("Cannot use the elf demangling options for executable format: " +
executableFormat);
println(
"Cannot use the elf demangling options for executable format: " + executableFormat);
return;
}
@ -49,14 +48,12 @@ public class DemangleElfWithOptionScript extends GhidraScript {
String mangled = symbol.getName();
GnuDemanglerOptions options = new GnuDemanglerOptions();
GnuDemanglerOptions options = new GnuDemanglerOptions(GnuDemanglerFormat.AUTO, false);
options.setDoDisassembly(false);
options.setDemanglerApplicationArguments("-s auto");
/*
// for older formats use the deprecated demangler
options.setDemanglerName(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
options.setDemanglerApplicationArguments("-s arm");
options = options.withDemanglerFormat(GnuDemanglerFormat.ARM, true);
*/
DemangledObject demangledObject = demangler.demangle(mangled, options);

38
Ghidra/Features/GnuDemangler/src/main/java/ghidra/app/plugin/core/analysis/GnuDemanglerAnalyzer.java
View file

@ -19,6 +19,7 @@ import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.util.Arrays;
import docking.options.editor.BooleanEditor;
import ghidra.app.util.demangler.*;
import ghidra.app.util.demangler.gnu.*;
import ghidra.app.util.importer.MessageLog;
@ -26,10 +27,8 @@ import ghidra.framework.options.*;
import ghidra.program.model.listing.Program;
import ghidra.util.HelpLocation;
import docking.options.editor.BooleanEditor;
/**
* A version of the demangler analyzer to handle GNU GCC symbols
* A version of the demangler analyzer to handle GNU GCC symbols
*/
public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
@ -87,12 +86,12 @@ public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
options.registerOption(OPTION_NAME_DEMANGLE_USE_KNOWN_PATTERNS, demangleOnlyKnownPatterns,
help, OPTION_DESCRIPTION_USE_KNOWN_PATTERNS);
options.registerOption(OPTION_NAME_USE_DEPRECATED_DEMANGLER, OptionType.BOOLEAN_TYPE,
useDeprecatedDemangler, help, OPTION_DESCRIPTION_DEPRECATED_DEMANGLER, editor);
options.registerOption(OPTION_NAME_DEMANGLER_FORMAT, OptionType.ENUM_TYPE,
demanglerFormat, help, OPTION_DESCRIPTION_DEMANGLER_FORMAT, formatEditor);
options.registerOption(OPTION_NAME_DEMANGLER_FORMAT, OptionType.ENUM_TYPE, demanglerFormat,
help, OPTION_DESCRIPTION_DEMANGLER_FORMAT, formatEditor);
}
@Override
@ -102,7 +101,7 @@ public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
options.getBoolean(OPTION_NAME_DEMANGLE_USE_KNOWN_PATTERNS, demangleOnlyKnownPatterns);
demanglerFormat = options.getEnum(OPTION_NAME_DEMANGLER_FORMAT, GnuDemanglerFormat.AUTO);
useDeprecatedDemangler =
options.getBoolean(OPTION_NAME_USE_DEPRECATED_DEMANGLER, useDeprecatedDemangler);
options.getBoolean(OPTION_NAME_USE_DEPRECATED_DEMANGLER, useDeprecatedDemangler);
}
@Override
@ -118,7 +117,7 @@ public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
@Override
protected DemangledObject doDemangle(String mangled, DemanglerOptions demanglerOtions,
MessageLog log) throws DemangledException {
return demangler.demangle(mangled, (GnuDemanglerOptions) demanglerOtions);
return demangler.demangle(mangled, demanglerOtions);
}
private static class FormatEditor extends EnumEditor implements PropertyChangeListener {
@ -145,16 +144,16 @@ public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
@Override
public GnuDemanglerFormat[] getEnums() {
return Arrays.stream(GnuDemanglerFormat.values())
.filter(this::filter)
.toArray(GnuDemanglerFormat[]::new);
.filter(this::filter)
.toArray(GnuDemanglerFormat[]::new);
}
@Override
public String[] getTags() {
return Arrays.stream(GnuDemanglerFormat.values())
.filter(this::filter)
.map(GnuDemanglerFormat::name)
.toArray(String[]::new);
.filter(this::filter)
.map(GnuDemanglerFormat::name)
.toArray(String[]::new);
}
@Override
@ -164,7 +163,8 @@ public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
if (format.isAvailable(isDeprecatedDemangler())) {
setValue(format);
selector.setFormat(format);
} else {
}
else {
setValue(GnuDemanglerFormat.AUTO);
}
}
@ -178,18 +178,16 @@ public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
}
}
@SuppressWarnings("serial")
private static class FormatSelector extends PropertySelector {
public FormatSelector(FormatEditor fe) {
super(fe);
}
@SuppressWarnings("unchecked")
void reset(String[] tags) {
removeAllItems();
for (int i = 0; i < tags.length; i++) {
addItem(tags[i]);
for (String tag : tags) {
addItem(tag);
}
}
@ -200,6 +198,6 @@ public class GnuDemanglerAnalyzer extends AbstractDemanglerAnalyzer {
void setFormat(GnuDemanglerFormat format) {
setSelectedItem(format.name());
}
}
}

60
Ghidra/Features/GnuDemangler/src/main/java/ghidra/app/util/demangler/gnu/GnuDemangler.java
View file

@ -106,16 +106,14 @@ public class GnuDemangler implements Demangler {
}
boolean onlyKnownPatterns = options.demangleOnlyKnownPatterns();
DemangledObject demangledObject =
parse(mangled, process, demangled, onlyKnownPatterns);
DemangledObject demangledObject = parse(mangled, process, demangled, onlyKnownPatterns);
if (demangledObject == null) {
return demangledObject;
}
if (globalPrefix != null) {
DemangledFunction dfunc =
new DemangledFunction(originalMangled, demangled,
globalPrefix + demangledObject.getName());
DemangledFunction dfunc = new DemangledFunction(originalMangled, demangled,
globalPrefix + demangledObject.getName());
dfunc.setNamespace(demangledObject.getNamespace());
demangledObject = dfunc;
}
@ -163,6 +161,19 @@ public class GnuDemangler implements Demangler {
applicationOptions);
}
/**
* Determines if the given mangled string should not be demangled. There are a couple
* patterns that will always be skipped.
* If {@link GnuDemanglerOptions#demangleOnlyKnownPatterns()} is true, then only mangled
* symbols matching a list of known start patters will not be skipped.
*
* <P>This demangler class will default to demangling most patterns, since we do not yet
* have a comprehensive list of known start patterns.
*
* @param mangled the mangled string
* @param options the options
* @return true if the string should not be demangled
*/
private boolean skip(String mangled, GnuDemanglerOptions options) {
// Ignore versioned symbols which are generally duplicated at the same address
@ -179,36 +190,29 @@ public class GnuDemangler implements Demangler {
return false; // let it go through
}
// TODO provide some checks specific to the other formats
GnuDemanglerFormat format = options.getDemanglerFormat();
if (format == GnuDemanglerFormat.AUTO) {
// This is the current list of known demangler start patterns. Add to this list if we
// find any other known GNU start patterns.
if (mangled.startsWith("_Z")) {
return false;
}
if (format == GnuDemanglerFormat.GNUV3) {
// add to this list if we find any other known GNU start patterns
if (mangled.startsWith("_Z")) {
return false;
}
if (mangled.startsWith("__Z")) {
return false;
}
if (mangled.startsWith("h__")) {
return false; // not sure about this one
}
if (mangled.startsWith("?")) {
return false; // not sure about this one
}
if (isGnu2Or3Pattern(mangled)) {
return false;
}
if (mangled.startsWith("__Z")) {
return false;
}
if (mangled.startsWith("h__")) {
return false; // not sure about this one
}
if (mangled.startsWith("?")) {
return false; // not sure about this one
}
if (isGnu2Or3Pattern(mangled)) {
return false;
}
return true;
}
private DemangledObject parse(String mangled, GnuDemanglerNativeProcess process,
String demangled,
boolean demangleOnlyKnownPatterns) {
String demangled, boolean demangleOnlyKnownPatterns) {
if (demangleOnlyKnownPatterns && !isKnownMangledString(mangled, demangled)) {
return null;
@ -224,7 +228,7 @@ public class GnuDemangler implements Demangler {
// We get requests to demangle strings that are not mangled. For newer mangled strings
// we know how to avoid that. However, older mangled strings can be of many forms. To
// detect whether a string is mangled, we have to resort to examining the output of
// the demangler.
// the demangler.
//
// check for the case where good strings have '__' in them (which is valid GNU2 mangling)

127
Ghidra/Features/GnuDemangler/src/main/java/ghidra/app/util/demangler/gnu/GnuDemanglerFormat.java
View file

@ -19,71 +19,74 @@ package ghidra.app.util.demangler.gnu;
* Enum representation of the available GnuDemangler formats
*/
public enum GnuDemanglerFormat {
// OLD: none,auto,gnu,lucid,arm,hp,edg,gnu-v3,java,gnat
// NEW: none,auto,gnu-v3,java,gnat,dlang,rust
/** Automatic mangling format detection */
AUTO("", 0),
/** GNUv2 mangling format */
GNU("gnu", -1),
/** lucid mangling format */
LUCID("lucid", -1),
/** arm mangling format */
ARM("arm", -1),
/** hp mangling format */
HP("hp", -1),
/** mangling format used by the Edison Design Group (EDG) compiler */
EDG("edg", -1),
/** GNUv3 mangling format */
GNUV3("gnu-v3", 0),
/** Java mangling format */
JAVA("java", 0),
/** GNAT Ada compiler mangling format */
GNAT("gnat", 0),
/** D mangling format */
DLANG("dlang", 1),
/** Rust mangling format */
RUST("rust", 1);
// OLD: none,auto,gnu,lucid,arm,hp,edg,gnu-v3,java,gnat
// NEW: none,auto,gnu-v3,java,gnat,dlang,rust
/** Automatic mangling format detection */
AUTO("", Version.ALL),
/** GNUv2 mangling format */
GNU("gnu", Version.DEPRECATED),
/** lucid mangling format */
LUCID("lucid", Version.DEPRECATED),
/** arm mangling format */
ARM("arm", Version.DEPRECATED),
/** hp mangling format */
HP("hp", Version.DEPRECATED),
/** mangling format used by the Edison Design Group (EDG) compiler */
EDG("edg", Version.DEPRECATED),
/** GNUv3 mangling format */
GNUV3("gnu-v3", Version.ALL),
/** Java mangling format */
JAVA("java", Version.ALL),
/** GNAT Ada compiler mangling format */
GNAT("gnat", Version.ALL),
/** D mangling format */
DLANG("dlang", Version.MODERN),
/** Rust mangling format */
RUST("rust", Version.MODERN);
/** the format option string */
private final String format;
/** private sentinal. deprecated = -1, both = 0, new = 1 */
private final byte version;
/** the format option string used by the native demangler */
private final String format;
private final Version version;
private GnuDemanglerFormat(String format, int version) {
this.format = format;
this.version = (byte) version;
}
private GnuDemanglerFormat(String format, Version version) {
this.format = format;
this.version = version;
}
/**
* Checks if this format is available in the deprecated gnu demangler
* @return true if this format is available in the deprecated gnu demangler
*/
public boolean isDeprecatedFormat() {
return version <= 0;
}
/**
* Checks if this format is available in the deprecated gnu demangler
* @return true if this format is available in the deprecated gnu demangler
*/
public boolean isDeprecatedFormat() {
return version == Version.DEPRECATED || version == Version.ALL;
}
/**
* Checks if this format is available in a modern version of the gnu demangler
* @return true if this format is available in a modern version of the gnu demangler.
*/
public boolean isModernFormat() {
return version >= 0;
}
/**
* Checks if this format is available for the specified demangler
* @param isDeprecated true for the deprecated demangler, false for the modern demangler.
* @return true if the format is available
*/
public boolean isAvailable(boolean isDeprecated) {
return isDeprecated ? isDeprecatedFormat() : isModernFormat();
}
/**
* Checks if this format is available in a modern version of the gnu demangler
* @return true if this format is available in a modern version of the gnu demangler
*/
public boolean isModernFormat() {
return version == Version.MODERN || version == Version.ALL;
}
/**
* Gets the format option to be passed to the demangler via the <code>-s</code> option
* @return the format option to be passed to the demangler
*/
public String getFormat() {
return format;
}
/**
* Checks if this format is available for the specified demangler
* @param isDeprecated true for the deprecated demangler, false for the modern demangler
* @return true if the format is available
*/
public boolean isAvailable(boolean isDeprecated) {
return isDeprecated ? isDeprecatedFormat() : isModernFormat();
}
/**
* Gets the format option to be passed to the demangler via the <code>-s</code> option
* @return the format option to be passed to the demangler
*/
public String getFormat() {
return format;
}
private enum Version {
DEPRECATED, MODERN, ALL
}
}

55
Ghidra/Features/GnuDemangler/src/main/java/ghidra/app/util/demangler/gnu/GnuDemanglerOptions.java
View file

@ -46,26 +46,45 @@ public class GnuDemanglerOptions extends DemanglerOptions {
private final GnuDemanglerFormat format;
private final boolean isDeprecated;
/**
* Default constructor to use the modern demangler with auto-detect for the format. This
* constructor will limit demangling to only known symbols.
*/
public GnuDemanglerOptions() {
// use default values
this(GnuDemanglerFormat.AUTO);
}
/**
* Constructor to specify a particular format
*
* @param format signals to use the given format
*/
public GnuDemanglerOptions(GnuDemanglerFormat format) {
this.format = format;
// default to the "new" demangler if the format is available in both
this.isDeprecated = !format.isModernFormat();
this(format, !format.isModernFormat());
}
/**
* Constructor to specify the format to use and whether to prefer the deprecated format when
* both deprecated and modern are available
*
* @param format the format
* @param isDeprecated true if the format is not available in the modern demangler
* @throws IllegalArgumentException if the given format is not available in the deprecated
* demangler
*/
public GnuDemanglerOptions(GnuDemanglerFormat format, boolean isDeprecated) {
this.format = format;
this.isDeprecated = isDeprecated;
if (!format.isAvailable(isDeprecated)) {
throw new IllegalArgumentException(
format.name() + " is not available in the "+getDemanglerName());
format.name() + " is not available in the " + getDemanglerName());
}
}
/**
* Copy constructor to create a version of this class from a more generic set of options
* @param copy the options to copy
*/
public GnuDemanglerOptions(DemanglerOptions copy) {
super(copy);
@ -73,7 +92,8 @@ public class GnuDemanglerOptions extends DemanglerOptions {
GnuDemanglerOptions gCopy = (GnuDemanglerOptions) copy;
format = gCopy.format;
isDeprecated = gCopy.isDeprecated;
} else {
}
else {
format = GnuDemanglerFormat.AUTO;
isDeprecated = false;
}
@ -87,7 +107,7 @@ public class GnuDemanglerOptions extends DemanglerOptions {
}
/**
* Returns the external demangler executable name to be used for demangling. The
* Returns the external demangler executable name to be used for demangling. The
* default value is {@link #GNU_DEMANGLER_DEFAULT}.
* @return the name
*/
@ -96,24 +116,25 @@ public class GnuDemanglerOptions extends DemanglerOptions {
}
/**
* A convenience method to copy the state of this options object, changing the
* demangler executable name and demangler format to the specified values.
* @param format the demangling format to use
* @param isDeprecated true to use the deprecated gnu demangler, else false
* A convenience method to copy the state of this options object, changing the
* demangler executable name and demangler format to the specified values
*
* @param demanglerFormat the demangling format to use
* @param useDeprecated true to use the deprecated gnu demangler, else false
* @return the new options
* @throws IllegalArgumentException if the current format is not available in the
* selected demangler.
*/
public GnuDemanglerOptions withDemanglerFormat(GnuDemanglerFormat format, boolean isDeprecated)
throws IllegalArgumentException {
if (this.format == format && this.isDeprecated == isDeprecated) {
public GnuDemanglerOptions withDemanglerFormat(GnuDemanglerFormat demanglerFormat,
boolean useDeprecated) throws IllegalArgumentException {
if (this.format == demanglerFormat && this.isDeprecated == useDeprecated) {
return this;
}
if (format.isAvailable(isDeprecated)) {
return new GnuDemanglerOptions(this, format, isDeprecated);
if (demanglerFormat.isAvailable(useDeprecated)) {
return new GnuDemanglerOptions(this, demanglerFormat, useDeprecated);
}
throw new IllegalArgumentException(
format.name() + " is not available in the "+getDemanglerName());
demanglerFormat.name() + " is not available in the " + getDemanglerName());
}
/**

20
Ghidra/Features/GnuDemangler/src/main/java/ghidra/app/util/demangler/gnu/GnuDemanglerParser.java
View file

@ -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.
@ -896,9 +896,9 @@ public class GnuDemanglerParser {
/*
Note: really, this should just be checking a list of known disallowed characters,
which is something like:
<,>,(,),&,*,[,]
It seems like the current code below is unnecessarily restrictive
*/
@ -1187,9 +1187,9 @@ public class GnuDemanglerParser {
/*
Examples:
NS1::Function<>()::StructureName::StructureConstructor()
*/
String nameString = removeBadSpaces(demangled).trim();
@ -1353,7 +1353,7 @@ public class GnuDemanglerParser {
DemangledObject doBuild(Demangled namespace) {
DemangledString demangledString = new DemangledString(mangledSource, demangledSource,
"typeinfo-name", type, -1/*unknown length*/, false);
demangledString.setSpecialPrefix("typeinfo name for ");
demangledString.setSpecialPrefix(TYPEINFO_NAME_FOR);
String namespaceString = removeBadSpaces(type);
setNamespace(demangledString, namespaceString);
return demangledString;
@ -1372,13 +1372,13 @@ public class GnuDemanglerParser {
Samples:
prefix: construction vtable for
name: construction-vtable
prefix: vtable for
name: vtable
prefix: typeinfo name for
name: typeinfo-name
prefix: covariant return thunk
name: covariant-return
*/

85
Ghidra/Features/GnuDemangler/src/test/java/ghidra/app/plugin/core/analysis/GnuDemanglerAnalyzerTest.java
View file

@ -17,12 +17,16 @@ package ghidra.app.plugin.core.analysis;
import static org.junit.Assert.*;
import java.util.Arrays;
import org.junit.Before;
import org.junit.Test;
import docking.options.editor.BooleanEditor;
import ghidra.app.cmd.label.AddLabelCmd;
import ghidra.app.util.demangler.gnu.GnuDemanglerFormat;
import ghidra.app.util.importer.MessageLog;
import ghidra.framework.options.EnumEditor;
import ghidra.framework.options.Options;
import ghidra.program.database.ProgramBuilder;
import ghidra.program.database.ProgramDB;
@ -104,6 +108,24 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationT
assertDemangled(addr, "__dt");
}
@Test
public void testMangledString_WithArguments_Valid() {
//
// The below demangles to std::io::Read::read_to_end
//
String mangled = "_ZN3std2io4Read11read_to_end17hb85a0f6802e14499E";
Address addr = addr("0x110");
createSymbol(addr, mangled);
setFormat(GnuDemanglerFormat.RUST);
analyze();
assertDemangled(addr, "read_to_end");
}
@Test
public void testMangledString_WithArguments_ValidButWrongFormat() {
@ -123,26 +145,13 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationT
}
@Test
public void testUseDeprecatedOptionRemoval_WithDeprecatedFormat() {
setFormat(GnuDemanglerFormat.GNU);
Options options = program.getOptions("Analyzers");
assertFalse(options.contains(GnuDemanglerAnalyzer.OPTION_NAME_USE_DEPRECATED_DEMANGLER));
}
public void testUseDeprecatedOptionUpdatesAvailableFormats() {
@Test
public void testUseDeprecatedOptionRemoval_WithRecentFormat() {
setFormat(GnuDemanglerFormat.RUST);
Options options = program.getOptions("Analyzers");
assertFalse(options.contains(GnuDemanglerAnalyzer.OPTION_NAME_USE_DEPRECATED_DEMANGLER));
}
setOption_UseDeprecatedDemangler(false);
assertFormatAvailable(GnuDemanglerFormat.RUST, true);
@Test
public void testUseDeprecatedOptionAddition() {
// remove it first
testUseDeprecatedOptionRemoval_WithDeprecatedFormat();
setFormat(GnuDemanglerFormat.AUTO);
Options options = program.getOptions("Analyzers");
assertTrue(options.contains(GnuDemanglerAnalyzer.OPTION_NAME_USE_DEPRECATED_DEMANGLER));
setOption_UseDeprecatedDemangler(true);
assertFormatAvailable(GnuDemanglerFormat.RUST, false);
}
// things missed:
@ -151,7 +160,7 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationT
//==================================================================================================
// Private Methods
//==================================================================================================
//==================================================================================================
private void analyze() {
tx(program, () -> analyzer.added(program, program.getMemory(), TaskMonitor.DUMMY, log));
@ -181,6 +190,32 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationT
fail("Unable to find demangled symbol '" + name + "'");
}
private void assertFormatAvailable(GnuDemanglerFormat format, boolean isAvailable) {
Options options = program.getOptions("Analyzers");
Options analyzerOptions = options.getOptions(analyzer.getName());
EnumEditor enumEditor =
(EnumEditor) runSwing(() -> analyzerOptions.getPropertyEditor("Demangler Format"));
assertNotNull(enumEditor);
Enum<?>[] values = enumEditor.getEnums();
for (Enum<?> enum1 : values) {
if (format.equals(enum1)) {
if (isAvailable) {
return;
}
fail("Found bad enum in list of choices: " + format + ".\nFound: " +
Arrays.toString(values));
}
}
if (isAvailable) {
fail("Did not find enum in list of choices: " + format + ".\nInstead found: " +
Arrays.toString(values));
}
}
private void setOption(String optionName, boolean doUse) {
String fullOptionName = analyzer.getName() + Options.DELIMITER_STRING + optionName;
@ -199,6 +234,18 @@ public class GnuDemanglerAnalyzerTest extends AbstractGhidraHeadlessIntegrationT
fail("Could not find option '" + optionName + "'");
}
private void setOption_UseDeprecatedDemangler(boolean use) {
Options options = program.getOptions("Analyzers");
Options analyzerOptions = options.getOptions(analyzer.getName());
BooleanEditor enumEditor = (BooleanEditor) runSwing(
() -> analyzerOptions.getPropertyEditor("Use Deprecated Demangler"));
assertNotNull(enumEditor);
runSwing(() -> enumEditor.setValue(use));
}
private void setFormat(GnuDemanglerFormat format) {
String optionName = GnuDemanglerAnalyzer.OPTION_NAME_DEMANGLER_FORMAT;

138
Ghidra/Features/GnuDemangler/src/test/java/ghidra/app/util/demangler/GnuDemanglerParserTest.java
View file

@ -32,8 +32,8 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
@Before
public void setUp() throws Exception {
process = GnuDemanglerNativeProcess.getDemanglerNativeProcess(
GnuDemanglerOptions.GNU_DEMANGLER_V2_33_1);
process = GnuDemanglerNativeProcess
.getDemanglerNativeProcess(GnuDemanglerOptions.GNU_DEMANGLER_V2_33_1);
parser = new GnuDemanglerParser();
}
@ -111,8 +111,8 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testFunctionPointers() throws Exception {
String mangled = "__t6XpsMap2ZlZP14CORBA_TypeCodePFRCl_UlUlUlf";
process = GnuDemanglerNativeProcess.getDemanglerNativeProcess(
GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
process = GnuDemanglerNativeProcess
.getDemanglerNativeProcess(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
String demangled = process.demangle(mangled);
@ -564,8 +564,8 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
String mangled = "CalcPortExposedRect__13LScrollerViewCFR4Rectb";
// use an older demangler; the current demangler cannot handle this string
process = GnuDemanglerNativeProcess.getDemanglerNativeProcess(
GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
process = GnuDemanglerNativeProcess
.getDemanglerNativeProcess(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
String demangled = process.demangle(mangled);
@ -589,8 +589,8 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
String mangled = "__dt__Q26MsoDAL9VertFrameFv";
// use an older demangler; the current demangler cannot handle this string
process = GnuDemanglerNativeProcess.getDemanglerNativeProcess(
GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
process = GnuDemanglerNativeProcess
.getDemanglerNativeProcess(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
String demangled = process.demangle(mangled);
@ -630,8 +630,8 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
String mangled = "GetColWidths__13CDataRendererCFRA7_s";
// use an older demangler; the current demangler cannot handle this string
process = GnuDemanglerNativeProcess.getDemanglerNativeProcess(
GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
process = GnuDemanglerNativeProcess
.getDemanglerNativeProcess(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
String demangled = process.demangle(mangled);
@ -655,8 +655,8 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
String mangled = "GetColWidths__13CDataRendererCFPA7_s";
// use an older demangler; the current demangler cannot handle this string
process = GnuDemanglerNativeProcess.getDemanglerNativeProcess(
GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
process = GnuDemanglerNativeProcess
.getDemanglerNativeProcess(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
String demangled = process.demangle(mangled);
@ -709,13 +709,13 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
// This is testing a bug where we were 'off by one' when the array pointer syntax was
// followed by another parameter.
//
// The below demangles to _gmStage2(SECTION_INFO *, int *, int (*)[12], int, short const *)
// The below demangles to _gmStage2(SECTION_INFO *, int *, int (*)[12], int, short const *)
//
String mangled = "_gmStage2__FP12SECTION_INFOPiPA12_iiPCs";
// use an older demangler; the current demangler cannot handle this string
process = GnuDemanglerNativeProcess.getDemanglerNativeProcess(
GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
process = GnuDemanglerNativeProcess
.getDemanglerNativeProcess(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
String demangled = process.demangle(mangled);
@ -749,8 +749,8 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
String mangled = "__ct__Q24CStr6BufferFR4CStrUl";
// use an older demangler; the current demangler cannot handle this string
process = GnuDemanglerNativeProcess.getDemanglerNativeProcess(
GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
process = GnuDemanglerNativeProcess
.getDemanglerNativeProcess(GnuDemanglerOptions.GNU_DEMANGLER_V2_24);
String demangled = process.demangle(mangled);
@ -887,16 +887,14 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
@Test
public void testOverloadedShiftOperatorTemplated_LeftShift() {
String raw =
"std::basic_ostream<char, std::char_traits<char> >& " +
"std::operator<< <std::char_traits<char> >" +
"(std::basic_ostream<char, std::char_traits<char> >&, char const*)";
String raw = "std::basic_ostream<char, std::char_traits<char> >& " +
"std::operator<< <std::char_traits<char> >" +
"(std::basic_ostream<char, std::char_traits<char> >&, char const*)";
String formatted = "std::basic_ostream<char,std::char_traits<char>> & " +
"std::operator<<<std::char_traits<char>>" +
"(std::basic_ostream<char,std::char_traits<char>> &,char const *)";
DemangledObject object = parser.parse(
"_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc",
raw);
DemangledObject object =
parser.parse("_ZStlsISt11char_traitsIcEERSt13basic_ostreamIcT_ES5_PKc", raw);
String name = object.getName();
assertEquals("operator<<", name);
assertEquals(formatted, object.getSignature());
@ -928,15 +926,15 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
String demangled = process.demangle(mangled);
/*
typeinfo for
typeinfo for
std::__ndk1::__function::__func<
dummy::it::other::Namespace::function(float)::$_2::operator()(dummy::it::other::Namespace*) const::{lambda(dummy::it::other::Namespace*)#1},
std::__ndk1::allocator<{lambda(dummy::it::other::Namespace*)#1}>,
int (dummy::it::other::Namespace*)
>
'__func' has 3 template parameters, the operator and the allocator
*/
String dummyNs = "dummy::it::other::Namespace";
@ -985,7 +983,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testOperatorCastTo() throws Exception {
//
// Mangled: _ZNKSt17integral_constantIbLb0EEcvbEv
//
//
// Demangled: std::integral_constant<bool, false>::operator bool() const
String mangled = "_ZNKSt17integral_constantIbLb0EEcvbEv";
@ -1005,11 +1003,11 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// Converts the object upon which it is overridden to the given value.
//
//
// Format: operator std::string() const { return "bob"; }
//
//
//
//
//
// Mangled: _ZNK6Magick5ColorcvSsEv
//
@ -1031,7 +1029,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
@Test
public void testConversionOperatorWithConst() throws Exception {
//
//
//
// Mangled: _ZN12_GLOBAL__N_120decode_charset_iconvEPKc
//
@ -1040,7 +1038,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// Converts the object upon which it is overridden to the given value.
//
//
// Format: operator std::string() const { return "bob"; }
//
//
@ -1064,7 +1062,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// Converts the object upon which it is overridden to the given value.
//
//
// Format: operator delete(void*)
//
@ -1084,7 +1082,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// Converts the object upon which it is overridden to the given value.
//
//
// Format: operator delete[](void*)
//
@ -1100,7 +1098,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// Converts the object upon which it is overridden to the given value.
//
//
// Format: operator new(unsigned long)
//
@ -1217,7 +1215,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
// Mangled: _ZN2Dr15ClipboardHelper17FTransferGvmlDataERN3Art11TransactionERKN3Ofc13TReferringPtrINS_10DrawingE2oEEEbNS4_7TCntPtrI11IDataObjectEERNS_18IClientDataCreatorERNS4_7TVectorINS4_8TWeakPtrINS_14DrawingElementEEELj0ELj4294967295EEERNS1_6Rect64E
//
// Demangled: Dr::ClipboardHelper::FTransferGvmlData(Art::Transaction&, Ofc::TReferringPtr<Dr::DrawingE2o> const&, bool, Ofc::TCntPtr<IDataObject>, Dr::IClientDataCreator&, Ofc::TVector<Ofc::TWeakPtr<Dr::DrawingElement>, 0u, 4294967295u>&, Art::Rect64&)
//
//
String mangled =
"_ZN2Dr15ClipboardHelper17FTransferGvmlDataERN3Art11TransactionERKN3Ofc13TReferringPtrINS_10DrawingE2oEEEbNS4_7TCntPtrI11IDataObjectEERNS_18IClientDataCreatorERNS4_7TVectorINS4_8TWeakPtrINS_14DrawingElementEEELj0ELj4294967295EEERNS1_6Rect64E";
@ -1235,11 +1233,11 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
@Test
public void testTemplatedParametersWithCast_OldStyleDemangle() throws Exception {
//
// This demangled string has appeared at some point in the past. It no longer looks like
// This demangled string has appeared at some point in the past. It no longer looks like
// this (note the odd syntax of '<(int)2085>&)')
//
// Ofc::TSimpleTypeHelper<Art::Percentage>::ToString(Art::Percentage const&, Ofc::TFixedVarStr<(int)2085>&)
//
//
String demangled =
"Ofc::TSimpleTypeHelper<Art::Percentage>::ToString(Art::Percentage const&, Ofc::TFixedVarStr<(int)2085>&)";
DemangledObject object = parser.parse("nomangled", demangled);
@ -1257,7 +1255,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
// Mangled: _ZN4Core9AsyncFile7performEON3WTF1FIFNS2_IFvRNS_10FileClientEEEERNS_4FileEEEE
//
// Demangled: Core::AsyncFile::perform(WTF::F<WTF::F<void (Core::FileClient&)> (Core::File&)>&&)
//
//
String mangled =
"_ZN4Core9AsyncFile7performEON3WTF1FIFNS2_IFvRNS_10FileClientEEEERNS_4FileEEEE";
@ -1287,7 +1285,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testFunctionInsideOfTemplates_NoArguments_NoPointerParens() throws Exception {
//
// Mangled: _ZN15LogLevelMonitor27registerKeysChangedCallbackERKN5boost8functionIFvvEEE
//
//
// Demangled: LogLevelMonitor::registerKeysChangedCallback(boost::function<void ()> const&)
String mangled =
@ -1320,7 +1318,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testFunctionInsideOfTemplates_WithArguments_NoPointerParens() throws Exception {
//
// Mangled: _ZN9DnsThread32set_mutate_ares_options_callbackERKN5boost8functionIFvP12ares_optionsPiEEE
//
//
// Demangled: DnsThread::set_mutate_ares_options_callback(boost::function<void (ares_options*, int*)> const&)
String mangled =
@ -1354,7 +1352,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testTemplatesThatContainFunctionSignatures() throws Exception {
//
// Mangled: _ZNSt6vectorIN5boost8functionIFvvEEESaIS3_EE13_M_insert_auxEN9__gnu_cxx17__normal_iteratorIPS3_S5_EERKS3_
//
//
// Demangled: std::vector<boost::function<void ()>, std::allocator<boost::function<void ()> > >::_M_insert_aux(__gnu_cxx::__normal_iterator<boost::function<void ()>*, std::vector<boost::function<void ()>, std::allocator<boost::function<void ()> > > >, boost::function<void ()> const&)
String mangled =
@ -1405,7 +1403,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testVtableParsingError_NoSpaceBeforeTrailingDigits() throws Exception {
//
// Mangled: _ZTCN6Crypto10HmacSha256E0_NS_3MacE
//
//
// Demangled: construction vtable for Crypto::Mac-in-Crypto::HmacSha256
//
@ -1425,7 +1423,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testVarArgs() throws Exception {
//
// Mangled: _Z11testVarArgsiz
//
//
// Demangled: testVarArgs(int, ...)
//
@ -1449,7 +1447,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testMultidimensionalArrayFunctionParameter() throws Exception {
//
// Mangled: _ZN12uavcan_stm329CanDriverC1ILj64EEERA2_AT__NS_9CanRxItemE
//
//
// Demangled: uavcan_stm32::CanDriver::CanDriver<64u>(uavcan_stm32::CanRxItem (&) [2][64u])
//
@ -1473,15 +1471,11 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
// This is a function name that the native demangler tries to demangle, but should not:
// Input: uv__dup
// Incorrect Native Output: uv(double, *__restrict)
//
//
String mangled = "uv__dup";
GnuDemangler demangler = new GnuDemangler();
try {
demangler.demangle(mangled);
} catch (DemangledException e) {
assertTrue(e.isInvalidMangledName());
}
DemangledObject demangled = demangler.demangle(mangled);
assertNull(demangled);
}
@Test
@ -1489,7 +1483,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// Mangled: _ZZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_EN11_Save_errnoC2Ev
//
//
// Demangled: __gnu_cxx
// ::
// __stoa<long, int, char, int>(long (*)(char const*, char**, int), char const*, char const*, unsigned long*, int)
@ -1500,7 +1494,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// This is _Save_errno struct's constructor inside of the stoa templated function, in the
// __gnu_cxx namespace.
//
//
String mangled =
"_ZZN9__gnu_cxx6__stoaIlicJiEEET0_PFT_PKT1_PPS3_DpT2_EPKcS5_PmS9_EN11_Save_errnoC2Ev";
@ -1521,7 +1515,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// Mangled: _ZNK2cc14ScrollSnapTypeneERKS0_
//
//
// Demangled: cc::ScrollSnapType::operator!=(cc::ScrollSnapType const&) const
//
@ -1551,8 +1545,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
String name =
"for_each_args<WebCore::JSConverter<WebCore::IDLUnion<WebCore::IDLNull,WebCore::IDLDOMString,WebCore::IDLUnrestrictedDouble>>::convert(JSC::ExecState&,WebCore::JSDOMGlobalObject&,WTF::Variant<decltype(nullptr),WTF::String,double>const&)::{lambda(auto:1&&)#1},brigand::type_<std::__1::integral_constant<long,0l>>,WebCore::JSConverter<WebCore::IDLUnion<WebCore::IDLNull,WebCore::IDLDOMString,WebCore::IDLUnrestrictedDouble>>::convert(JSC::ExecState&,WebCore::JSDOMGlobalObject&,WTF::Variant<decltype(nullptr),WTF::String,double>const&)::{lambda(auto:1&&)#1}<std::__1<long,1l>>,WebCore::JSConverter<WebCore::IDLUnion<WebCore::IDLNull,WebCore::IDLDOMString,WebCore::IDLUnrestrictedDouble>>::convert(JSC::ExecState&,WebCore::JSDOMGlobalObject&,WTF::Variant<decltype(nullptr),WTF::String,double>const&)::{lambda(auto:1&&)#1}<std::__1<long,2l>>>";
assertName(object, name,
"brigand");
assertName(object, name, "brigand");
String signature = object.getSignature(false);
assertEquals(
@ -1571,8 +1564,8 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// WebCore::FontSelectionAlgorithm::filterCapability
// (
// bool*,
// WebCore::FontSelectionAlgorithm::DistanceResult (WebCore::FontSelectionAlgorithm::*)(WebCore::FontSelectionCapabilities) const,
// bool*,
// WebCore::FontSelectionAlgorithm::DistanceResult (WebCore::FontSelectionAlgorithm::*)(WebCore::FontSelectionCapabilities) const,
// WebCore::FontSelectionRange WebCore::FontSelectionCapabilities::*
// )
//
@ -1604,10 +1597,10 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// Mangled: __ZN7WebCore12TextCodecICU14registerCodecsEPFvPKcON3WTF8FunctionIFNSt3__110unique_ptrINS_9TextCodecENS5_14default_deleteIS7_EEEEvEEEE
//
// Demangled: undefined WebCore::TextCodecICU::registerCodecs(void ()(char const *,WTF::Function<std::__1::unique_ptr<WebCore::TextCodec,std::__1::default_delete<WebCore::TextCodec>> ()> &&))
// Demangled: undefined WebCore::TextCodecICU::registerCodecs(void ()(char const *,WTF::Function<std::__1::unique_ptr<WebCore::TextCodec,std::__1::default_delete<WebCore::TextCodec>> ()> &&))
//
// The regression tested here revolves around this parameter:
//
//
// void ()(char const *,WTF::Function<std::__1::unique_ptr<WebCore::TextCodec,std::__1::default_delete<WebCore::TextCodec>> ()> &&
//
// (note the trailing '()' chars)
@ -1641,7 +1634,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// where the above is a parameter to function, where the params look like:
// (
// WTF::Visitor<WTF::TextBreakIterator::following(unsigned int) const::{lambda(auto:1 const&)#1}>&,
// WTF::Visitor<WTF::TextBreakIterator::following(unsigned int) const::{lambda(auto:1 const&)#1}>&,
// (WTF::__multi_visitor_return_type&&)...
// )
//
@ -1673,8 +1666,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
assertNotNull(object);
assertType(object, DemangledFunction.class);
String name =
"operator=";
String name = "operator=";
assertName(object, name, "WTF", "Function<void()>");
String signature = object.getSignature(false);
@ -1709,18 +1701,18 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testFunctionWithLambdaParameter() throws Exception {
//
// Mangled: _ZN3JSC9Structure3addILNS0_9ShouldPinE1EZNS_8JSObject35prepareToPutDirectWithoutTransitionERNS_2VMENS_12PropertyNameEjjPS0_EUlRKNS_24GCSafeConcurrentJSLockerEiiE_EEiS5_S6_jRKT0_
// Mangled: _ZN3JSC9Structure3addILNS0_9ShouldPinE1EZNS_8JSObject35prepareToPutDirectWithoutTransitionERNS_2VMENS_12PropertyNameEjjPS0_EUlRKNS_24GCSafeConcurrentJSLockerEiiE_EEiS5_S6_jRKT0_
//
// Demangled: int
// Demangled: int
// JSC::Structure::add<
// (JSC::Structure::ShouldPin)1,
// (JSC::Structure::ShouldPin)1,
// JSC::JSObject::prepareToPutDirectWithoutTransition(JSC::VM&, JSC::PropertyName, unsigned int, unsigned int, JSC::Structure*)::{lambda(JSC::GCSafeConcurrentJSLocker const&, int, int)#1}
// >(
// JSC::VM&, JSC::PropertyName,
// unsigned int,
// JSC::VM&, JSC::PropertyName,
// unsigned int,
// JSC::JSObject::prepareToPutDirectWithoutTransition(JSC::VM&, JSC::PropertyName, unsigned int, unsigned int, JSC::Structure*)::{lambda(JSC::GCSafeConcurrentJSLocker const&, int, int)#1} const&
// )
//
//
//
DemangledObject object = parser.parse(
@ -1743,7 +1735,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testFunctionInLambdaNamespace() throws Exception {
//
// Mangled: _ZZN12GrGLFunctionIFPKhjEEC1IZN13skia_bindings28CreateGLES2InterfaceBindingsEPN3gpu5gles214GLES2InterfaceEPNS6_14ContextSupportEE3$_0EET_ENUlPKvjE_8__invokeESF_j
// Mangled: _ZZN12GrGLFunctionIFPKhjEEC1IZN13skia_bindings28CreateGLES2InterfaceBindingsEPN3gpu5gles214GLES2InterfaceEPNS6_14ContextSupportEE3$_0EET_ENUlPKvjE_8__invokeESF_j
//
// Demangled: GrGLFunction<unsigned char const* (unsigned int)>
// ::
@ -1774,7 +1766,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
public void testFunctionWithLamba_WithUnnamedType() throws Exception {
//
// Mangled: _ZN13SoloGimbalEKFUt_C2Ev
// Mangled: _ZN13SoloGimbalEKFUt_C2Ev
//
// Demangled: SoloGimbalEKF::{unnamed type#1}::SoloGimbalEKF()
//
@ -1794,7 +1786,7 @@ public class GnuDemanglerParserTest extends AbstractGenericTest {
//
// Mangled: _Z11wrap_360_cdIiEDTcl8wrap_360fp_Lf42c80000EEET_
//
//
// Demangled: decltype (wrap_360({parm#1}, (float)[42c80000])) wrap_360_cd<int>(int)
//
// 'wrap_360_cd<int>(int)' is a function that takes an int and then passes that int along

28
Ghidra/Features/GnuDemangler/src/test/java/ghidra/app/util/demangler/gnu/GnuDemanglerTest.java
View file

@ -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.
@ -57,7 +57,8 @@ public class GnuDemanglerTest extends AbstractGenericTest {
// this throws an exception with the bug in place
try {
demangler.demangle(mangled);
} catch (DemangledException e) {
}
catch (DemangledException e) {
assertTrue(e.isInvalidMangledName());
}
}
@ -167,10 +168,10 @@ public class GnuDemanglerTest extends AbstractGenericTest {
/*
Note:
This test is less of a requirement and more of an observation. This symbol was
This test is less of a requirement and more of an observation. This symbol was
seen in the wild and is claimed to be of the Edison Design Group (EDG) format.
It fails our parsing due to its resemblance to non-mangled text (see
the test testNonMangledSymbol()). If we update the code that checks for this
the test testNonMangledSymbol()). If we update the code that checks for this
noise, then this test and it's parter should be consolidated.
*/
@ -184,6 +185,22 @@ public class GnuDemanglerTest extends AbstractGenericTest {
assertNull(result);
}
@Test
public void testDemangler_Format_EDG_DemangleOnlyKnownPatterns_False()
throws DemangledException {
String mangled = "_$_10MyFunction";
GnuDemangler demangler = new GnuDemangler();
demangler.canDemangle(program);// this perform initialization
GnuDemanglerOptions options = new GnuDemanglerOptions(GnuDemanglerFormat.AUTO, true);
options.setDemangleOnlyKnownPatterns(false);
DemangledObject result = demangler.demangle(mangled, options);
assertNotNull(result);
assertEquals("undefined MyFunction::~MyFunction(void)", result.getSignature(false));
}
@Test
public void testDemangler_Format_CodeWarrior_MacOS8or9() throws DemangledException {
// NOTE: mangled CodeWarrior format symbols with templates will fail
@ -196,6 +213,7 @@ public class GnuDemanglerTest extends AbstractGenericTest {
demangler.canDemangle(program);// this perform initialization
GnuDemanglerOptions options = new GnuDemanglerOptions(GnuDemanglerFormat.AUTO, true);
options.setDemangleOnlyKnownPatterns(false);
DemangledObject result = demangler.demangle(mangled, options);
assertNotNull(result);
assertEquals("undefined TTextPanel::scroll(unsigned char,short,int)",

31
Ghidra/Framework/Generic/src/main/java/ghidra/framework/options/EnumEditor.java
View file

@ -1,6 +1,5 @@
/* ###
* IP: GHIDRA
* REVIEWED: YES
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -16,38 +15,26 @@
*/
package ghidra.framework.options;
import ghidra.util.Msg;
import java.beans.PropertyEditorSupport;
import java.lang.reflect.Method;
import java.util.HashSet;
import ghidra.util.Msg;
public class EnumEditor extends PropertyEditorSupport {
private Enum<?> value;
/**
*
* @see java.beans.PropertyEditor#setValue(java.lang.Object)
*/
@Override
public void setValue(Object o) {
value = (Enum<?>) o;
}
/**
*
* @see java.beans.PropertyEditor#getValue()
*/
@Override
public Object getValue() {
return value;
}
/**
*
* @see java.beans.PropertyEditor#getTags()
*/
@Override
public String[] getTags() {
@ -85,28 +72,20 @@ public class EnumEditor extends PropertyEditorSupport {
return new Enum<?>[] { value };
}
/**
*
* @see java.beans.PropertyEditor#getAsText()
*/
@Override
public String getAsText() {
return value.toString();
}
/**
*
* @see java.beans.PropertyEditor#setAsText(java.lang.String)
*/
@Override
public void setAsText(String s) {
try {
Method m = value.getClass().getMethod("values");
Enum<?>[] enums = (Enum<?>[]) m.invoke(null);
for (int i = 0; i < enums.length; i++) {
if (s.equals(enums[i].toString())) {
value = enums[i];
for (Enum<?> enum1 : enums) {
if (s.equals(enum1.toString())) {
value = enum1;
break;
}
}

41
Ghidra/Framework/Generic/src/main/java/ghidra/framework/options/PropertySelector.java
View file

@ -1,6 +1,5 @@
/* ###
* IP: GHIDRA
* REVIEWED: YES
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -17,19 +16,19 @@
package ghidra.framework.options;
// Support for PropertyEditors that use tags.
import java.awt.event.*;
import java.awt.event.ItemEvent;
import java.awt.event.ItemListener;
import java.beans.*;
import javax.swing.*;
import javax.swing.JComboBox;
/**
* An implementation of a PropertyComponent that is represented as a
* combo box.
*/
public class PropertySelector extends JComboBox implements ItemListener {
public class PropertySelector extends JComboBox<String> implements ItemListener {
private PropertyEditor editor;
private PropertyEditor propertyEditor;
private boolean notifyEditorOfChanges = true;
/**
@ -38,22 +37,23 @@ public class PropertySelector extends JComboBox implements ItemListener {
* changes in the combo box
*/
public PropertySelector(PropertyEditor pe) {
editor = pe;
String tags[] = editor.getTags();
for (int i = 0; i < tags.length; i++) {
addItem(tags[i]);
propertyEditor = pe;
String tags[] = propertyEditor.getTags();
for (String tag : tags) {
addItem(tag);
}
setSelectedIndex(0);
// This is a no-op if the getAsText is not a tag that we set from getTags() above
setSelectedItem(editor.getAsText());
setSelectedItem(propertyEditor.getAsText());
addItemListener(this);
invalidate();
editor.addPropertyChangeListener(new PropertyChangeListener() {
propertyEditor.addPropertyChangeListener(new PropertyChangeListener() {
@Override
public void propertyChange(PropertyChangeEvent evt) {
String value = editor.getAsText();
String value = propertyEditor.getAsText();
if (!value.equals(getSelectedItem())) {
notifyEditorOfChanges = false;
try {
@ -67,14 +67,15 @@ public class PropertySelector extends JComboBox implements ItemListener {
});
}
/*
* (non-Javadoc)
* @see java.awt.event.ItemListener#itemStateChanged(java.awt.event.ItemEvent)
*/
@Override
public void itemStateChanged(ItemEvent evt) {
if (notifyEditorOfChanges) {
String s = (String) getSelectedItem();
editor.setAsText(s);
if (!notifyEditorOfChanges) {
return;
}
String s = (String) getSelectedItem();
if (s != null) {
propertyEditor.setAsText(s);
}
}
}

6
Ghidra/Test/IntegrationTest/src/test.slow/java/ghidra/app/util/demangler/gnu/GnuDemanglerIntegrationTest.java
View file

@ -61,7 +61,7 @@ public class GnuDemanglerIntegrationTest extends AbstractGhidraHeadlessIntegrati
GnuDemanglerOptions options = new GnuDemanglerOptions();
options.setDemangleOnlyKnownPatterns(false);
options = options.withDeprecatedDemangler();
options = options.withDemanglerFormat(GnuDemanglerFormat.AUTO, true);
DemangledObject result = demangler.demangle(mangled, options);
assertNotNull(result);
assertEquals("undefined MyNamespace::MyFunction($ParamNamespace::paramName *)",
@ -86,7 +86,7 @@ public class GnuDemanglerIntegrationTest extends AbstractGhidraHeadlessIntegrati
GnuDemanglerOptions options = new GnuDemanglerOptions();
options.setDemangleOnlyKnownPatterns(false);
options = options.withDeprecatedDemangler();
options = options.withDemanglerFormat(GnuDemanglerFormat.AUTO, true);
DemangledObject result = demangler.demangle(mangled, options);
assertNotNull(result);
assertEquals("undefined SoloGimbalEKF::{unnamed_type#1}::SoloGimbalEKF(void)",
@ -116,7 +116,7 @@ public class GnuDemanglerIntegrationTest extends AbstractGhidraHeadlessIntegrati
GnuDemanglerOptions options = new GnuDemanglerOptions();
options.setDemangleOnlyKnownPatterns(false);
options = options.withDeprecatedDemangler();
options = options.withDemanglerFormat(GnuDemanglerFormat.AUTO, true);
DemangledObject result = demangler.demangle(mangled, options);
assertNotNull(result);
assertEquals(