diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/cmd/formats/ElfBinaryAnalysisCommand.java b/Ghidra/Features/Base/src/main/java/ghidra/app/cmd/formats/ElfBinaryAnalysisCommand.java index 7bb0256610..e6fe53afcf 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/cmd/formats/ElfBinaryAnalysisCommand.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/cmd/formats/ElfBinaryAnalysisCommand.java @@ -17,6 +17,8 @@ package ghidra.app.cmd.formats; import java.util.Arrays; +import org.apache.commons.lang3.StringUtils; + import ghidra.app.plugin.core.analysis.AnalysisWorker; import ghidra.app.plugin.core.analysis.AutoAnalysisManager; import ghidra.app.util.bin.*; @@ -379,12 +381,14 @@ public class ElfBinaryAnalysisCommand extends FlatProgramAPI } String name = symbols[j].getNameAsString(); - long value = Integer.toUnsignedLong((int) symbols[j].getValue()); + if (StringUtils.isBlank(name)) { + continue; + } try { Address currAddr = symbolTableAddr.add(j * symbolTable2.getEntrySize()); listing.setComment(currAddr, CodeUnit.EOL_COMMENT, - name + " at 0x" + Long.toHexString(value)); + name + " at 0x" + Long.toHexString(symbols[j].getValue())); } catch (Exception e) { messages.appendMsg("Could not markup symbol table: " + e); diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfHeader.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfHeader.java index d6f1129c87..e89bd5cf00 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfHeader.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfHeader.java @@ -876,6 +876,7 @@ public class ElfHeader implements StructConverter, Writeable { for (ElfSectionHeader symbolTableSectionHeader : sectionHeaders) { if (symbolTableSectionHeader.getType() == ElfSectionHeaderConstants.SHT_SYMTAB || symbolTableSectionHeader.getType() == ElfSectionHeaderConstants.SHT_DYNSYM) { + // || symbolTableSectionHeader.getType() == ElfSectionHeaderConstants.SHT_SUNW_LDYNSYM) { if (symbolTableSectionHeader.isInvalidOffset()) { continue; } diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfSymbol.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfSymbol.java index 2cc6b015e2..c241656708 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfSymbol.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfSymbol.java @@ -17,6 +17,8 @@ package ghidra.app.util.bin.format.elf; import java.io.IOException; +import org.apache.commons.lang3.StringUtils; + import ghidra.app.util.bin.BinaryReader; import ghidra.app.util.bin.ByteArrayConverter; import ghidra.util.DataConverter; @@ -48,6 +50,8 @@ import ghidra.util.exception.NotFoundException; */ public class ElfSymbol implements ByteArrayConverter { + public static final String FORMATTED_NO_NAME = ""; + /**Local symbols are not visible outside the object file containing their definition.*/ public static final byte STB_LOCAL = 0; /**Global symbols are visible to all object files being combined.*/ @@ -227,7 +231,7 @@ public class ElfSymbol implements ByteArrayConverter { * @param stringTable stringTable to initialize symbol name */ public void initSymbolName(BinaryReader reader, ElfStringTable stringTable) { - if (nameAsString == null) { + if (nameAsString == null && stringTable != null) { nameAsString = stringTable.readString(reader, st_name); } } @@ -460,12 +464,23 @@ public class ElfSymbol implements ByteArrayConverter { * Returns the actual string name for this symbol. The symbol only * stores an byte index into the string table where * the name string is located. - * @return the actual string name for this symbol + * @return the actual string name for this symbol (may be null or empty string) */ public String getNameAsString() { return nameAsString; } + /** + * Returns the formatted string name for this symbol. If the name is blank or + * can not be resolved due to a missing string table the literal string + * <no name> will be returned. + * the name string is located. + * @return the actual string name for this symbol or the literal string <no name> + */ + public String getFormattedName() { + return StringUtils.isBlank(nameAsString) ? FORMATTED_NO_NAME : nameAsString; + } + /** * This member currently holds 0 and has no defined meaning. * @return no defined meaning diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfSymbolTable.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfSymbolTable.java index 5f7e6e4b12..38c591cba4 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfSymbolTable.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/ElfSymbolTable.java @@ -203,13 +203,26 @@ public class ElfSymbolTable implements ElfFileSection, ByteArrayConverter { } /** - * Get the ELF symbol name which corresponds to the specified index. + * Get the ELF symbol name which corresponds to the specified index. * @param symbolIndex symbol index - * @return symbol name which corresponds to symbol index or < if out of range + * @return symbol name which corresponds to symbol index or null if out of range */ public final String getSymbolName(int symbolIndex) { ElfSymbol sym = getSymbol(symbolIndex); - return sym != null ? sym.getNameAsString() : ""; + return sym != null ? sym.getNameAsString() : null; + } + + /** + * Get the formatted ELF symbol name which corresponds to the specified index. + * If the name is blank or can not be resolved due to a missing string table the + * literal string <no name> will be returned. + * @param symbolIndex symbol index + * @return formatted symbol name which corresponds to symbol index or the + * literal string <no name> + */ + public final String getFormattedSymbolName(int symbolIndex) { + ElfSymbol sym = getSymbol(symbolIndex); + return sym != null ? sym.getFormattedName() : ElfSymbol.FORMATTED_NO_NAME; } /** diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfRelocationContext.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfRelocationContext.java index a8631fc622..98049bd8bf 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfRelocationContext.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfRelocationContext.java @@ -17,6 +17,8 @@ package ghidra.app.util.bin.format.elf.relocation; import java.util.Map; +import org.apache.commons.lang3.StringUtils; + import ghidra.app.util.bin.format.elf.*; import ghidra.app.util.bin.format.elf.extend.ElfLoadAdapter; import ghidra.app.util.importer.MessageLog; @@ -114,11 +116,15 @@ public class ElfRelocationContext { String symName = getSymbolName(relocation.getSymbolIndex()); + String nameMsg = ""; + if (!StringUtils.isBlank(symName)) { + nameMsg = " to: " + symName; + } program.getBookmarkManager().setBookmark(relocationAddress, BookmarkType.ERROR, - "Relocation", "No handler to process ELF Relocation to : " + symName); + "Relocation", "No handler to process ELF Relocation" + nameMsg); loadHelper.log("WARNING: At " + relocationAddress + - " no handler to process ELF Relocations to " + symName); + " no handler to process ELF Relocation" + nameMsg); } /** @@ -209,10 +215,10 @@ public class ElfRelocationContext { /** * Get the ELF symbol name which corresponds to the specified index. * @param symbolIndex symbol index - * @return symbol name which corresponds to symbol index or < if out of range + * @return symbol name which corresponds to symbol index or null if out of range */ public final String getSymbolName(int symbolIndex) { - return symbolTable != null ? symbolTable.getSymbolName(symbolIndex) : ""; + return symbolTable != null ? symbolTable.getSymbolName(symbolIndex) : null; } /** diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfRelocationHandler.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfRelocationHandler.java index 986e2d9547..770ce5b036 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfRelocationHandler.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/bin/format/elf/relocation/ElfRelocationHandler.java @@ -126,7 +126,7 @@ abstract public class ElfRelocationHandler implements ExtensionPoint { } String adjStr = sign + "0x" + Long.toHexString(adjustment); - symbolName = StringUtils.isEmpty(symbolName) ? "" : symbolName; + symbolName = StringUtils.isEmpty(symbolName) ? ElfSymbol.FORMATTED_NO_NAME : symbolName; Msg.warn(ElfRelocationHandler.class, "EXTERNAL Data Elf Relocation with offset: at " + relocationAddress + " (External Location = " + symbolName + adjStr + ")"); @@ -149,7 +149,7 @@ abstract public class ElfRelocationHandler implements ExtensionPoint { public static void markAsUnhandled(Program program, Address relocationAddress, long type, long symbolIndex, String symbolName, MessageLog log) { - symbolName = StringUtils.isEmpty(symbolName) ? "" : symbolName; + symbolName = StringUtils.isEmpty(symbolName) ? ElfSymbol.FORMATTED_NO_NAME : symbolName; log.appendMsg("Unhandled Elf Relocation: Type = " + type + " (0x" + Long.toHexString(type) + ") at " + relocationAddress + " (Symbol = " + symbolName + ")"); BookmarkManager bookmarkManager = program.getBookmarkManager(); @@ -184,7 +184,7 @@ abstract public class ElfRelocationHandler implements ExtensionPoint { public static void markAsUninitializedMemory(Program program, Address relocationAddress, long type, long symbolIndex, String symbolName, MessageLog log) { - symbolName = StringUtils.isEmpty(symbolName) ? "" : symbolName; + symbolName = StringUtils.isEmpty(symbolName) ? ElfSymbol.FORMATTED_NO_NAME : symbolName; log.appendMsg("Unable to perform relocation: Type = " + type + " (0x" + Long.toHexString(type) + ") at " + relocationAddress + " (Symbol = " + symbolName + ") - uninitialized memory"); @@ -225,7 +225,7 @@ abstract public class ElfRelocationHandler implements ExtensionPoint { public static void markAsError(Program program, Address relocationAddress, String type, String symbolName, String msg, MessageLog log) { - symbolName = StringUtils.isEmpty(symbolName) ? "" : symbolName; + symbolName = StringUtils.isEmpty(symbolName) ? ElfSymbol.FORMATTED_NO_NAME : symbolName; log.appendMsg("Elf Relocation Error: Type = " + type + " at " + relocationAddress + ", Symbol = " + symbolName + ": " + msg); BookmarkManager bookmarkManager = program.getBookmarkManager(); @@ -262,7 +262,7 @@ abstract public class ElfRelocationHandler implements ExtensionPoint { public static void markAsWarning(Program program, Address relocationAddress, String type, String symbolName, long symbolIndex, String msg, MessageLog log) { - symbolName = StringUtils.isEmpty(symbolName) ? "" : symbolName; + symbolName = StringUtils.isEmpty(symbolName) ? ElfSymbol.FORMATTED_NO_NAME : symbolName; log.appendMsg("Elf Relocation Warning: Type = " + type + " at " + relocationAddress + ", Symbol = " + symbolName + ": " + msg); BookmarkManager bookmarkManager = program.getBookmarkManager(); diff --git a/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/ElfProgramBuilder.java b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/ElfProgramBuilder.java index d4f1f3c903..f2f5237f70 100644 --- a/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/ElfProgramBuilder.java +++ b/Ghidra/Features/Base/src/main/java/ghidra/app/util/opinion/ElfProgramBuilder.java @@ -536,7 +536,7 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { String comment = null; comment = symbols[index].getNameAsString(); - if (comment == null) { + if (StringUtils.isBlank(comment)) { comment = Long.toHexString(symbols[index].getValue()); } @@ -1546,8 +1546,8 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { boolean usingFakeExternal = false; if (address == Address.NO_ADDRESS) { - if (symName == null) { - continue; // unexpected + if (StringUtils.isBlank(symName)) { + continue; } // check for @ or @@ @@ -1574,7 +1574,7 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { evaluateElfSymbol(elfSymbol, address, usingFakeExternal); } catch (Exception e) { - log("Error creating symbol: " + elfSymbol.getNameAsString() + " - " + + log("Error creating symbol: " + elfSymbol.getFormattedName() + " - " + getMessage(e)); } } @@ -1598,7 +1598,7 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { if (elfSymbol.isTLS()) { // TODO: Investigate support for TLS symbols - log("Unsupported Thread-Local Symbol not loaded: " + elfSymbol.getNameAsString()); + log("Unsupported Thread-Local Symbol not loaded: " + elfSymbol.getFormattedName()); return null; } @@ -1646,7 +1646,7 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { uSectionIndex = elfSymbol.getExtendedSectionHeaderIndex(); if (uSectionIndex == 0) { log("Failed to read extended symbol section index: " + - elfSymbol.getNameAsString() + " - value=0x" + + elfSymbol.getFormattedName() + " - value=0x" + Long.toHexString(elfSymbol.getValue())); return null; } @@ -1658,7 +1658,7 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { symSectionBase = findLoadAddress(symSection, 0); if (symSectionBase == null) { log("Unable to place symbol due to non-loaded section: " + - elfSymbol.getNameAsString() + " - value=0x" + + elfSymbol.getFormattedName() + " - value=0x" + Long.toHexString(elfSymbol.getValue()) + ", section=" + symSection.getNameAsString()); return null; @@ -1678,7 +1678,7 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { // Unable to place symbol within relocatable if section missing/stripped else if (elf.isRelocatable()) { - log("No Memory for symbol: " + elfSymbol.getNameAsString() + + log("No Memory for symbol: " + elfSymbol.getFormattedName() + " - 0x" + Long.toHexString(elfSymbol.getValue())); return null; } @@ -1717,7 +1717,7 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { // SHN_HIPROC 0xff1f // SHN_HIRESERVE 0xffff - log("Unable to place symbol: " + elfSymbol.getNameAsString() + + log("Unable to place symbol: " + elfSymbol.getFormattedName() + " - value=0x" + Long.toHexString(elfSymbol.getValue()) + ", section-index=0x" + Integer.toHexString(Short.toUnsignedInt(sectionIndex))); return null; @@ -1756,6 +1756,9 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { */ private Address findMemoryRegister(ElfSymbol elfSymbol) { String name = elfSymbol.getNameAsString(); + if (StringUtils.isBlank(name)) { + return null; + } Address regAddr = getMemoryRegister(name, elfSymbol.getValue()); if (regAddr == null) { name = StringUtils.stripStart(name, "_"); @@ -1812,6 +1815,9 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { return false; } String symName = elfSymbol.getNameAsString(); + if (StringUtils.isBlank(symName)) { + return false; + } Symbol s = findExternalBlockSymbol(symName, externalBlockLimits.getMinAddress(), lastExternalBlockEntryAddress); if (s != null) { @@ -1833,6 +1839,9 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { private boolean processVersionedExternal(ElfSymbol elfSymbol) { String symName = elfSymbol.getNameAsString(); + if (StringUtils.isBlank(symName)) { + return false; + } int index = symName.indexOf("@"); if (index < 0) { return false; @@ -1929,26 +1938,26 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { // Remember where in memory Elf symbols have been mapped setElfSymbolAddress(elfSymbol, address); - if (address.isConstantAddress()) { - // Do not add constant symbols to program symbol table - // define as equate instead - try { - program.getEquateTable() - .createEquate(elfSymbol.getNameAsString(), address.getOffset()); - } - catch (DuplicateNameException | InvalidInputException e) { - // ignore - } - return; - } - if (elfSymbol.isSection()) { // Do not add section symbols to program symbol table return; } String name = elfSymbol.getNameAsString(); - if (name == null) { + if (StringUtils.isBlank(name)) { + return; + } + + if (address.isConstantAddress()) { + // Do not add constant symbols to program symbol table + // define as equate instead + try { + program.getEquateTable() + .createEquate(name, address.getOffset()); + } + catch (DuplicateNameException | InvalidInputException e) { + // ignore + } return; } @@ -2029,30 +2038,25 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { @Override public Function createOneByteFunction(String name, Address address, boolean isEntry) { + Function function = null; try { + if (isEntry) { + program.getSymbolTable().addExternalEntryPoint(address); + } FunctionManager functionMgr = program.getFunctionManager(); function = functionMgr.getFunctionAt(address); if (function == null) { function = functionMgr.createFunction(null, address, new AddressSet(address), SourceType.IMPORTED); } + else if (!StringUtils.isEmpty(name)) { + createSymbol(address, name, true, false, null); + } } catch (Exception e) { log("Error while creating function at " + address + ": " + getMessage(e)); } - - try { - if (name != null) { - createSymbol(address, name, true, false, null); - } - if (isEntry) { - program.getSymbolTable().addExternalEntryPoint(address); - } - } - catch (Exception e) { - log("Error while creating symbol " + name + " at " + address + ": " + getMessage(e)); - } return function; } @@ -2431,13 +2435,13 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { ElfSymbol[] symbols = symbolTable.getSymbols(); for (int i = 0; i < symbols.length; ++i) { - int stringOffset = symbols[i].getName(); - if (stringOffset == 0) { + String name = symbols[i].getNameAsString(); + if (StringUtils.isBlank(name)) { continue; } Data structData = array.getComponent(i); if (structData != null) { - structData.setComment(CodeUnit.EOL_COMMENT, symbols[i].getNameAsString()); + structData.setComment(CodeUnit.EOL_COMMENT, name); } } } @@ -2533,7 +2537,7 @@ class ElfProgramBuilder extends MemorySectionResolver implements ElfLoadHelper { program.getReferenceManager() .addMemoryReference(valueData.getAddress(), refAddr, RefType.DATA, SourceType.ANALYSIS, 0); - if (label != null) { + if (!StringUtils.isBlank(label)) { // add label if no label exists of there is just a default label Symbol symbol = program.getSymbolTable().getPrimarySymbol(refAddr); if (symbol == null || symbol.getSource() == SourceType.DEFAULT) { diff --git a/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/function/FunctionManagerTest.java b/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/function/FunctionManagerTest.java index 5180c01bd8..604b9773d1 100644 --- a/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/function/FunctionManagerTest.java +++ b/Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/function/FunctionManagerTest.java @@ -26,6 +26,7 @@ import ghidra.app.cmd.function.AddStackVarCmd; import ghidra.app.cmd.refs.AddStackRefCmd; import ghidra.program.database.ProgramBuilder; import ghidra.program.database.ProgramDB; +import ghidra.program.database.symbol.SymbolManager; import ghidra.program.model.address.*; import ghidra.program.model.data.PointerDataType; import ghidra.program.model.lang.PrototypeModel; @@ -75,6 +76,7 @@ public class FunctionManagerTest extends AbstractGhidraHeadedIntegrationTest { functionManager.createFunction(name, entryPt, body, SourceType.USER_DEFINED); Function f = functionManager.getFunctionAt(entryPt); + assertEquals(name, f.getName()); assertEquals(entryPt, f.getEntryPoint()); assertEquals(body, f.getBody()); return f; @@ -83,8 +85,19 @@ public class FunctionManagerTest extends AbstractGhidraHeadedIntegrationTest { @Test public void testCreateFunction() throws Exception { + SymbolManager symbolTable = program.getSymbolTable(); + symbolTable.createLabel(addr(100), "foo", SourceType.USER_DEFINED); + createFunction("foo", addr(100), new AddressSet(addr(100), addr(200))); + Symbol[] symbols = symbolTable.getSymbols(addr(100)); + assertEquals(1, symbols.length); // label should be converted to function + + Symbol s = symbolTable.createLabel(addr(100), "foo", SourceType.USER_DEFINED); + assertEquals(SymbolType.FUNCTION, s.getSymbolType()); + symbols = symbolTable.getSymbols(addr(100)); + assertEquals(1, symbols.length); // should still be just a function + // Overlapping functions - not allowed try { functionManager.createFunction("foo1", addr(50), new AddressSet(addr(50), addr(100)), diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionManagerDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionManagerDB.java index 314ae35498..24053a6151 100644 --- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionManagerDB.java +++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionManagerDB.java @@ -19,6 +19,8 @@ import java.io.IOException; import java.util.*; import java.util.function.Predicate; +import org.apache.commons.lang3.StringUtils; + import db.*; import generic.FilteredIterator; import ghidra.program.database.DBObjectCache; @@ -356,7 +358,7 @@ public class FunctionManagerDB implements FunctionManager { throw new OverlappingFunctionException(entryPoint); } - if (name == null || name.length() == 0 || + if (StringUtils.isBlank(name) || SymbolUtilities.isReservedDynamicLabelName(name, program.getAddressFactory())) { source = SourceType.DEFAULT; name = ""; diff --git a/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/extend/AARCH64_ElfExtension.java b/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/extend/AARCH64_ElfExtension.java index 741a3460ea..43b23afdc9 100644 --- a/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/extend/AARCH64_ElfExtension.java +++ b/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/extend/AARCH64_ElfExtension.java @@ -15,6 +15,8 @@ */ package ghidra.app.util.bin.format.elf.extend; +import org.apache.commons.lang3.StringUtils; + import ghidra.app.util.bin.format.elf.*; import ghidra.program.model.address.Address; import ghidra.program.model.lang.Language; @@ -59,6 +61,9 @@ public class AARCH64_ElfExtension extends ElfExtension { } String symName = elfSymbol.getNameAsString(); + if (StringUtils.isBlank(symName)) { + return address; + } if ("$x".equals(symName) || symName.startsWith("$x.")) { elfLoadHelper.markAsCode(address); diff --git a/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationHandler.java b/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationHandler.java index 719ce32fe7..aff6978ab7 100644 --- a/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationHandler.java +++ b/Ghidra/Processors/AARCH64/src/main/java/ghidra/app/util/bin/format/elf/relocation/AARCH64_ElfRelocationHandler.java @@ -15,6 +15,8 @@ */ package ghidra.app.util.bin.format.elf.relocation; +import org.apache.commons.lang3.StringUtils; + import ghidra.app.util.bin.format.elf.*; import ghidra.program.model.address.Address; import ghidra.program.model.listing.Function; @@ -255,7 +257,7 @@ public class AARCH64_ElfRelocationHandler extends ElfRelocationHandler { if (!isPltSym) { setValue(memory, relocationAddress, symAddress.getOffset(), is64bit); } - if (isPltSym || isExternalSym) { + if ((isPltSym || isExternalSym) && !StringUtils.isBlank(symbolName)) { Function extFunction = elfRelocationContext.getLoadHelper().createExternalFunctionLinkage( symbolName, symAddress, null); diff --git a/Ghidra/Processors/ARM/src/main/java/ghidra/app/util/bin/format/elf/extend/ARM_ElfExtension.java b/Ghidra/Processors/ARM/src/main/java/ghidra/app/util/bin/format/elf/extend/ARM_ElfExtension.java index 6d2d388594..40c77e68e1 100644 --- a/Ghidra/Processors/ARM/src/main/java/ghidra/app/util/bin/format/elf/extend/ARM_ElfExtension.java +++ b/Ghidra/Processors/ARM/src/main/java/ghidra/app/util/bin/format/elf/extend/ARM_ElfExtension.java @@ -19,6 +19,8 @@ import java.io.IOException; import java.math.BigInteger; import java.util.List; +import org.apache.commons.lang3.StringUtils; + import ghidra.app.util.Option; import ghidra.app.util.bin.format.elf.*; import ghidra.app.util.opinion.Loader; @@ -148,6 +150,9 @@ public class ARM_ElfExtension extends ElfExtension { Program program = elfLoadHelper.getProgram(); String symName = elfSymbol.getNameAsString(); + if (StringUtils.isBlank(symName)) { + return address; + } try { Register tmodeRegister = program.getRegister("TMode"); diff --git a/Ghidra/Processors/MIPS/src/main/java/ghidra/app/util/bin/format/elf/extend/MIPS_ElfExtension.java b/Ghidra/Processors/MIPS/src/main/java/ghidra/app/util/bin/format/elf/extend/MIPS_ElfExtension.java index 11bf62ce73..755852570e 100644 --- a/Ghidra/Processors/MIPS/src/main/java/ghidra/app/util/bin/format/elf/extend/MIPS_ElfExtension.java +++ b/Ghidra/Processors/MIPS/src/main/java/ghidra/app/util/bin/format/elf/extend/MIPS_ElfExtension.java @@ -17,6 +17,8 @@ package ghidra.app.util.bin.format.elf.extend; import java.math.BigInteger; +import org.apache.commons.lang3.StringUtils; + import ghidra.app.util.bin.format.elf.*; import ghidra.app.util.bin.format.elf.ElfDynamicType.ElfDynamicValueType; import ghidra.app.util.bin.format.elf.relocation.MIPS_Elf64Relocation; @@ -361,6 +363,11 @@ public class MIPS_ElfExtension extends ElfExtension { return address; } + String symName = elfSymbol.getNameAsString(); + if (StringUtils.isBlank(symName)) { + return address; + } + if (elfSymbol.getType() == ElfSymbol.STT_FUNC) { Program program = elfLoadHelper.getProgram(); @@ -371,8 +378,7 @@ public class MIPS_ElfExtension extends ElfExtension { } if (!isExternal && (elfSymbol.getOther() & STO_MIPS_PLT) != 0) { - elfLoadHelper.createExternalFunctionLinkage(elfSymbol.getNameAsString(), address, - null); + elfLoadHelper.createExternalFunctionLinkage(symName, address, null); } } return address; @@ -784,9 +790,11 @@ public class MIPS_ElfExtension extends ElfExtension { ElfDefaultGotPltMarkup.setConstant(pointerData); if (elfSymbols[i].isFunction() && elfSymbols[i].getSectionHeaderIndex() == 0) { // ensure that external function/thunk are created in absence of sections - Address refAddr = (Address) pointerData.getValue(); - elfLoadHelper.createExternalFunctionLinkage(elfSymbols[i].getNameAsString(), - refAddr, gotEntryAddr); + String symName = elfSymbols[i].getNameAsString(); + if (!StringUtils.isBlank(symName)) { + Address refAddr = (Address) pointerData.getValue(); + elfLoadHelper.createExternalFunctionLinkage(symName, refAddr, gotEntryAddr); + } } } } diff --git a/Ghidra/Processors/MIPS/src/main/java/ghidra/app/util/bin/format/elf/relocation/MIPS_ElfRelocationHandler.java b/Ghidra/Processors/MIPS/src/main/java/ghidra/app/util/bin/format/elf/relocation/MIPS_ElfRelocationHandler.java index 7f53b6fec3..b77b0ad4f9 100644 --- a/Ghidra/Processors/MIPS/src/main/java/ghidra/app/util/bin/format/elf/relocation/MIPS_ElfRelocationHandler.java +++ b/Ghidra/Processors/MIPS/src/main/java/ghidra/app/util/bin/format/elf/relocation/MIPS_ElfRelocationHandler.java @@ -987,8 +987,7 @@ public class MIPS_ElfRelocationHandler extends ElfRelocationHandler { // failed to allocate section GOT entry for symbol markAsError(mipsRelocationContext.getProgram(), got16reloc.relocAddr, Integer.toString(got16reloc.relocType), symbolName, - "Relocation Failed, unable to allocate GOT entry for relocation symbol: " + - symbolName, + "Relocation Failed, unable to allocate GOT entry for relocation symbol", mipsRelocationContext.getLog()); return; } diff --git a/Ghidra/Processors/PowerPC/src/main/java/ghidra/app/util/bin/format/elf/extend/PowerPC64_ElfExtension.java b/Ghidra/Processors/PowerPC/src/main/java/ghidra/app/util/bin/format/elf/extend/PowerPC64_ElfExtension.java index e0f7f9cb5a..ee68c5c04c 100644 --- a/Ghidra/Processors/PowerPC/src/main/java/ghidra/app/util/bin/format/elf/extend/PowerPC64_ElfExtension.java +++ b/Ghidra/Processors/PowerPC/src/main/java/ghidra/app/util/bin/format/elf/extend/PowerPC64_ElfExtension.java @@ -18,11 +18,14 @@ package ghidra.app.util.bin.format.elf.extend; import java.math.BigInteger; import java.util.List; +import org.apache.commons.lang3.StringUtils; + import ghidra.app.util.bin.format.elf.*; import ghidra.app.util.bin.format.elf.ElfDynamicType.ElfDynamicValueType; import ghidra.app.util.bin.format.elf.relocation.PowerPC64_ElfRelocationConstants; import ghidra.app.util.opinion.ElfLoader; -import ghidra.program.model.address.*; +import ghidra.program.model.address.Address; +import ghidra.program.model.address.AddressOverflowException; import ghidra.program.model.data.PointerDataType; import ghidra.program.model.data.QWordDataType; import ghidra.program.model.lang.*; @@ -486,34 +489,35 @@ public class PowerPC64_ElfExtension extends ElfExtension { // Handle V2 ABI - st_other signals local entry vs. global entry behavior and offset. // 4-byte instructions are assumed.l + String name = elfSymbol.getNameAsString(); Function localFunction = null; + int localOffset = PPC64_ABIV2_GLOBAL_ENTRY_OFFSET[(elfSymbol.getOther() & 0xe0) >>> 5] * 4; if (localOffset != 0) { - - // generate local symbol TODO: this should really be done after demangling - String name = elfSymbol.getNameAsString(); - String localName = "." + name; + // generate local function + String localName = ""; + if (!StringUtils.isBlank(name)) { + // NOTE: this naming could cause issues with mangled name use + localName = "." + name; + } try { Address localFunctionAddr = address.add(localOffset); - localFunction = elfLoadHelper.createOneByteFunction(null, localFunctionAddr, false); - if (localFunction != null && - localFunction.getSymbol().getSource() == SourceType.DEFAULT) { - elfLoadHelper.createSymbol(localFunctionAddr, localName, true, false, null); - } + localFunction = + elfLoadHelper.createOneByteFunction(localName, localFunctionAddr, false); + // TODO: global function should be a thunk to the local function - need analyzer to do this String cmt = "local function entry for global function " + name + " at {@address " + address + "}"; elfLoadHelper.getProgram().getListing().setComment(localFunctionAddr, CodeUnit.PRE_COMMENT, cmt); } - catch (AddressOutOfBoundsException | InvalidInputException e) { + catch (Exception e) { elfLoadHelper.log("Failed to generate local function symbol " + localName + " at " + address + "+" + localOffset); } } - Function f = - elfLoadHelper.createOneByteFunction(elfSymbol.getNameAsString(), address, false); + Function f = elfLoadHelper.createOneByteFunction(name, address, false); if (f != null && localFunction != null) { f.setThunkedFunction(localFunction); return null; // symbol creation handled