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

Merge branch 'GP-1525_ghidra1_ExternalFunctionPrimary' into Ghidra_10.1

Browse source
This commit is contained in:
ghidra1 2021-11-23 21:44:26 -05:00
commit 5c82f87905
18 changed files with 553 additions and 433 deletions
Download patch file Download diff file Expand all files Collapse all files

9
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/AbstractDBTraceProgramViewReferenceManager.java
View file

@ -160,6 +160,15 @@ public abstract class AbstractDBTraceProgramViewReferenceManager implements Refe
new AddressRangeImpl(fromAddr, fromAddr));
}
@Override
public void removeAllReferencesTo(Address toAddr) {
if (refs(false) == null) {
return;
}
refs.clearReferencesTo(Range.closed(program.snap, program.snap),
new AddressRangeImpl(toAddr, toAddr));
}
@Override
public Reference[] getReferencesTo(Variable var) {
return TODO();

5
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceReferenceManager.java
View file

@ -266,6 +266,11 @@ public class DBTraceReferenceManager extends
Collections.emptyList());
}
@Override
public void clearReferencesTo(Range<Long> span, AddressRange range) {
delegateDeleteV(range.getAddressSpace(), s -> s.clearReferencesTo(span, range));
}
@Override
public AddressSetView getReferenceSources(Range<Long> span) {
return new UnionAddressSetView(

49
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceReferenceSpace.java
View file

@ -578,28 +578,26 @@ public class DBTraceReferenceSpace implements DBTraceSpaceBased, TraceReferenceS
@Override
public void clearReferencesFrom(Range<Long> span, AddressRange range) {
long startSnap = DBTraceUtils.lowerEndpoint(span);
for (DBTraceReferenceEntry ref : referenceMapSpace.reduce(
TraceAddressSnapRangeQuery.intersecting(range, span)).values()) {
if (DBTraceUtils.lowerEndpoint(ref.getLifespan()) < startSnap) {
Range<Long> oldSpan = ref.getLifespan();
ref.setEndSnap(startSnap - 1);
trace.setChanged(new TraceChangeRecord<>(TraceReferenceChangeType.LIFESPAN_CHANGED,
this, ref.ref, oldSpan, ref.getLifespan()));
}
else {
ref.ref.delete();
try (LockHold hold = manager.getTrace().lockWrite()) {
long startSnap = DBTraceUtils.lowerEndpoint(span);
for (DBTraceReferenceEntry ref : referenceMapSpace.reduce(
TraceAddressSnapRangeQuery.intersecting(range, span)).values()) {
truncateOrDeleteEntry(ref, startSnap);
}
// TODO: Coalesce events?
}
}
protected DBTraceReference getRefForXRefEntry(DBTraceXRefEntry e) {
protected DBTraceReferenceEntry getRefEntryForXRefEntry(DBTraceXRefEntry e) {
AddressSpace fromAddressSpace =
baseLanguage.getAddressFactory().getAddressSpace(e.refSpaceId);
DBTraceReferenceSpace fromSpace = manager.getForSpace(fromAddressSpace, false);
assert fromSpace != null;
return fromSpace.referenceMapSpace.getDataByKey(e.refKey).ref;
return fromSpace.referenceMapSpace.getDataByKey(e.refKey);
}
protected DBTraceReference getRefForXRefEntry(DBTraceXRefEntry e) {
return getRefEntryForXRefEntry(e).ref;
}
@Override
@ -617,6 +615,31 @@ public class DBTraceReferenceSpace implements DBTraceSpaceBased, TraceReferenceS
this::getRefForXRefEntry);
}
protected void truncateOrDeleteEntry(DBTraceReferenceEntry ref, long otherStartSnap) {
if (DBTraceUtils.lowerEndpoint(ref.getLifespan()) < otherStartSnap) {
Range<Long> oldSpan = ref.getLifespan();
ref.setEndSnap(otherStartSnap - 1);
trace.setChanged(new TraceChangeRecord<>(TraceReferenceChangeType.LIFESPAN_CHANGED,
this, ref.ref, oldSpan, ref.getLifespan()));
}
else {
ref.ref.delete();
}
}
@Override
public void clearReferencesTo(Range<Long> span, AddressRange range) {
try (LockHold hold = manager.getTrace().lockWrite()) {
long startSnap = DBTraceUtils.lowerEndpoint(span);
for (DBTraceXRefEntry xref : xrefMapSpace.reduce(
TraceAddressSnapRangeQuery.intersecting(range, span)).values()) {
DBTraceReferenceEntry ref = getRefEntryForXRefEntry(xref);
truncateOrDeleteEntry(ref, startSnap);
}
// TODO: Coalesce events?
}
}
@Override
public AddressSetView getReferenceSources(Range<Long> span) {
return new DBTraceAddressSnapRangePropertyMapAddressSetView<>(space, lock,

2
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/symbol/TraceReferenceOperations.java
View file

@ -72,6 +72,8 @@ public interface TraceReferenceOperations {
Collection<? extends TraceReference> getReferencesTo(long snap, Address toAddress);
void clearReferencesTo(Range<Long> span, AddressRange range);
/**
* TODO: Document me
*

33
Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/symbol/DBTraceReferenceManagerTest.java
View file

@ -461,6 +461,39 @@ public class DBTraceReferenceManagerTest extends AbstractGhidraHeadlessIntegrati
new HashSet<>(manager.getReferencesTo(0, b.addr(0x5000))));
}
@Test
public void testClearReferencesTo() {
DBTraceReference keptRef;
try (UndoableTransaction tid = b.startTransaction()) {
b.addMemoryReference(0, b.addr(0x4000), b.addr(0x5000), 3);
b.addOffsetReference(0, b.addr(0x4001), b.addr(0x5000), 20);
b.addShiftedReference(0, b.addr(0x4002), b.addr(0x5000), 1);
keptRef = b.addMemoryReference(0, b.addr(0x8000), b.addr(0x5001));
}
assertEquals(3, manager.getReferencesTo(0, b.addr(0x5000)).size());
assertEquals(1, manager.getReferencesTo(0, b.addr(0x5001)).size());
try (UndoableTransaction tid = b.startTransaction()) {
manager.clearReferencesTo(Range.atLeast(10L), b.range(0x4000, 0x5000));
}
assertEquals(3, manager.getReferencesTo(0, b.addr(0x5000)).size());
assertEquals(0, manager.getReferencesTo(10, b.addr(0x5000)).size());
assertEquals(Range.closed(0L, 9L),
manager.getReferencesTo(0, b.addr(0x5000)).iterator().next().getLifespan());
try (UndoableTransaction tid = b.startTransaction()) {
manager.clearReferencesTo(Range.atLeast(0L), b.range(0x4000, 0x5000));
}
assertEquals(0, manager.getReferencesTo(0, b.addr(0x5000)).size());
assertEquals(0, manager.getReferencesTo(-1, b.addr(0x5000)).size());
assertEquals(1, manager.getReferencesTo(0, b.addr(0x5001)).size());
assertEquals(keptRef, manager.getReferencesTo(0, b.addr(0x5001)).iterator().next());
assertEquals(Range.atLeast(0L), keptRef.getLifespan());
}
@Test
public void testGetReferenceSourcesAndDestinations() {
try (UndoableTransaction tid = b.startTransaction()) {

9
Ghidra/Features/Base/src/test.slow/java/ghidra/app/merge/listing/SymbolMergeManagerNamespace1Test.java
View file

@ -1397,15 +1397,6 @@ public class SymbolMergeManagerNamespace1Test extends AbstractListingMergeManage
"The following namespaces were not removed", 4000);
waitForMergeCompletion();
SymbolTable symtab = resultProgram.getSymbolTable();
Namespace globalNS = resultProgram.getGlobalNamespace();
SymbolIterator iter = symtab.getSymbols(globalNS);
while (iter.hasNext()) {
Symbol s = iter.next();
if (s.getSymbolType().equals(SymbolType.NAMESPACE)) {
System.out.println("Namespace = " + s.getName(true));
}
}
Symbol firstNsSymbol =
getUniqueSymbol(resultProgram, "FirstNamespace", resultProgram.getGlobalNamespace());
assertNotNull(firstNsSymbol);

465
Ghidra/Features/Base/src/test.slow/java/ghidra/program/database/symbol/SymbolManagerTest.java
View file

@ -26,6 +26,7 @@ import ghidra.app.cmd.disassemble.DisassembleCommand;
import ghidra.app.cmd.function.CreateFunctionCmd;
import ghidra.program.database.ProgramBuilder;
import ghidra.program.database.ProgramDB;
import ghidra.program.database.function.OverlappingFunctionException;
import ghidra.program.model.address.*;
import ghidra.program.model.data.*;
import ghidra.program.model.listing.*;
@ -83,24 +84,24 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testCreateSymbol() throws Exception {
Symbol s = createSymbol(addr(100), "bob");
Symbol s = createLabel(addr(100), "bob");
assertNotNull(s);
}
@Test
public void testCreateLocal() throws Exception {
Namespace scope = st.createNameSpace(null, "MyNamespace", SourceType.USER_DEFINED);
Symbol s = createSymbol(addr(0x200), "printf", scope);
Symbol s = createLabel(addr(0x200), "printf", scope);
assertNotNull(s);
}
@Test
public void testGetLocal() throws Exception {
createSymbol(addr(100), "primary");
createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
createLabel(addr(100), "primary");
createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
Namespace scope = st.createNameSpace(null, "MyNamespace", SourceType.USER_DEFINED);
createSymbol(addr(200), "fred", scope);
createLabel(addr(200), "fred", scope);
Symbol s = st.getSymbol("fred", addr(200), scope);
assertNotNull(s);
assertTrue(!s.isGlobal());
@ -109,17 +110,17 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testGetLocalSymbols() throws Exception {
createSymbol(addr(100), "primary");
createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
createLabel(addr(100), "primary");
createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
Namespace scope = st.createNameSpace(null, "MyNamespace", SourceType.USER_DEFINED);
createSymbol(addr(100), "exit", scope);
createLabel(addr(100), "exit", scope);
Namespace scope2 = st.createNameSpace(null, "MyNamespace2", SourceType.USER_DEFINED);
createSymbol(addr(200), "exit", scope2);
createSymbol(addr(200), "printf");
createLabel(addr(200), "exit", scope2);
createLabel(addr(200), "printf");
createSymbol(addr(256), "exit");
createLabel(addr(256), "exit");
SymbolIterator it = st.getSymbols("exit");
int cnt = 0;
@ -133,23 +134,23 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testGetNumSymbols() throws Exception {
createSymbol(addr(100), "primary");
createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
createLabel(addr(100), "primary");
createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
Namespace scope = st.createNameSpace(null, "MyNamespace", SourceType.USER_DEFINED);
Namespace scope2 = st.createNameSpace(null, "MyNamespace2", SourceType.USER_DEFINED);
createSymbol(addr(100), "exit", scope);
createSymbol(addr(200), "exit", scope2);
createSymbol(addr(200), "printf");
createSymbol(addr(256), "exit");
createLabel(addr(100), "exit", scope);
createLabel(addr(200), "exit", scope2);
createLabel(addr(200), "printf");
createLabel(addr(256), "exit");
assertEquals(9, st.getNumSymbols());
}
@Test
public void testGetPrimarySymbol() throws Exception {
createSymbol(addr(100), "primary");
createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
createLabel(addr(100), "primary");
createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
Symbol s = st.getPrimarySymbol(addr(100));
assertNotNull(s);
assertEquals("primary", s.getName());
@ -157,20 +158,20 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testGetAllSymbols() throws Exception {
createSymbol(addr(100), "primary");
createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
createLabel(addr(100), "primary");
createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
Symbol[] syms = st.getSymbols(addr(100));
assertEquals(3, syms.length);
}
@Test
public void testGetByName() throws Exception {
createSymbol(addr(100), "primary");
createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
createLabel(addr(100), "primary");
createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
Namespace scope = st.createNameSpace(null, "MyNamespace", SourceType.USER_DEFINED);
createSymbol(addr(200), "fred", scope);
createLabel(addr(200), "fred", scope);
Symbol s = getUniqueSymbol(program, "fred");
assertNotNull(s);
assertEquals("fred", s.getName());
@ -187,11 +188,11 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testGetSymbolByAddress() throws Exception {
createSymbol(addr(100), "A");
createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
createLabel(addr(100), "A");
createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
Namespace scope = st.createNameSpace(null, "MyNamespace", SourceType.USER_DEFINED);
createSymbol(addr(200), "fred", scope);
createLabel(addr(200), "fred", scope);
Symbol s = st.getSymbol("fred", addr(200), scope);
assertNotNull(s);
@ -203,11 +204,11 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testGetSymbolIteratorByAddress() throws Exception {
createSymbol(addr(100), "A");
createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
createLabel(addr(100), "A");
createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
Namespace scope = st.createNameSpace(null, "MyNamespace", SourceType.USER_DEFINED);
createSymbol(addr(200), "fred", scope);
createLabel(addr(200), "fred", scope);
SymbolIterator it = st.getSymbolsAsIterator(addr(100));
@ -225,7 +226,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testGetSymbolByReference() throws Exception {
createSymbol(addr(256), "A");
createLabel(addr(256), "A");
refMgr.addMemoryReference(addr(512), addr(256), RefType.FLOW, SourceType.USER_DEFINED, -1);
Reference ref = refMgr.getReference(addr(512), addr(256), -1);
Symbol s = st.getSymbol(ref);
@ -366,7 +367,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
set.addRange(addr(100), addr(150));
set.addRange(addr(300), addr(310));
set.addRange(addr(320), addr(330));
Function f = listing.createFunction("fredFunc", addr(102), set, SourceType.DEFAULT);
Function f = listing.createFunction("fredFunc", addr(102), set, SourceType.DEFAULT); // name ignored
assertNotNull(f);
String defaultName = "FUN_00000066";
@ -465,11 +466,11 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testRemoveSymbol() throws Exception {
createSymbol(addr(100), "primary");
createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
createSymbol(addr(100), "bob");
createSymbol(addr(0x200), "A");
createLabel(addr(100), "primary");
createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
createLabel(addr(100), "bob");
createLabel(addr(0x200), "A");
Symbol s = st.getPrimarySymbol(addr(100));
assertTrue(st.removeSymbolSpecial(s));
@ -486,7 +487,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
assertTrue(sym.isPrimary());
assertTrue(sym.getSource() == SourceType.DEFAULT);
Symbol s2 = createSymbol(addr(256), "TEST");
Symbol s2 = createLabel(addr(256), "TEST");
sym = st.getPrimarySymbol(addr(256));
assertTrue(sym.isPrimary());
assertTrue(sym.getSource() != SourceType.DEFAULT);
@ -499,7 +500,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testRemoveSymbol3() throws Exception {
// remove non-dynamic, primary symbol without refs
Symbol sym = createSymbol(addr(256), "TEST");
Symbol sym = createLabel(addr(256), "TEST");
assertTrue(sym.isPrimary());
assertTrue(sym.getSource() != SourceType.DEFAULT);
assertTrue(st.removeSymbolSpecial(sym));
@ -507,9 +508,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testRemoveSymbol5() throws Exception {
createSymbol(addr(256), "TEST1");
Symbol sym2 = createSymbol(addr(256), "TEST2");
createSymbol(addr(256), "TEST3");
createLabel(addr(256), "TEST1");
Symbol sym2 = createLabel(addr(256), "TEST2");
createLabel(addr(256), "TEST3");
assertTrue(st.removeSymbolSpecial(sym2));
Symbol[] symbols = st.getSymbols(addr(256));
assertEquals(2, symbols.length);
@ -521,9 +522,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testRemoveSymbol7() throws Exception {
Symbol sym1 = createSymbol(addr(256), "TEST1");
Symbol sym1 = createLabel(addr(256), "TEST1");
Symbol sym2 = createSymbol(addr(256), "TEST2");
Symbol sym2 = createLabel(addr(256), "TEST2");
Reference ref = refMgr.addMemoryReference(addr(512), addr(256), RefType.FLOW,
SourceType.USER_DEFINED, -1);
refMgr.setAssociation(sym2, ref);
@ -844,9 +845,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testPrimarySymbolBecomesNonPrimaryAfterFunctionCreated() throws Exception {
Address addr = addr(256);
Symbol sym1 = createSymbol(addr, "TEST1");
Symbol sym2 = createSymbol(addr, "TEST2");
Symbol sym3 = createSymbol(addr, "TEST3");
Symbol sym1 = createLabel(addr, "TEST1");
Symbol sym2 = createLabel(addr, "TEST2");
Symbol sym3 = createLabel(addr, "TEST3");
assertEquals(sym1, st.getPrimarySymbol(addr));
@ -873,9 +874,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testPrimarySymbolGetsPromotedToFunction() throws Exception {
Address addr = addr(256);
Symbol sym1 = createSymbol(addr, "TEST1");
Symbol sym2 = createSymbol(addr, "TEST2");
Symbol sym3 = createSymbol(addr, "TEST3");
Symbol sym1 = createLabel(addr, "TEST1");
Symbol sym2 = createLabel(addr, "TEST2");
Symbol sym3 = createLabel(addr, "TEST3");
assertEquals(sym1, st.getPrimarySymbol(addr));
@ -937,9 +938,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testRenameSymbol() throws Exception {
Symbol s = createSymbol(addr(100), "primary");
createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
Symbol s = createLabel(addr(100), "primary");
createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
s.setName("printf", SourceType.USER_DEFINED);
assertEquals("printf", s.getName());
@ -957,7 +958,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testRenameSymbol2() throws Exception {
// long names (>60) was a problem
Symbol s = createSymbol(addr(100),
Symbol s = createLabel(addr(100),
"aabcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzABCDEFGH");
s.setName("abcdefghijklmnopqrstuvwxyzabcdefghijklmnopqrstuvwxyzABCDEFGH1",
@ -967,9 +968,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testSetPrimary() throws Exception {
Symbol s1 = createSymbol(addr(100), "primary");
Symbol s2 = createSymbol(addr(100), "fred");
createSymbol(addr(100), "joe");
Symbol s1 = createLabel(addr(100), "primary");
Symbol s2 = createLabel(addr(100), "fred");
createLabel(addr(100), "joe");
assertTrue(s1.isPrimary());
s2.setPrimary();
@ -980,9 +981,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testSetScope() throws Exception {
Symbol s1 = createSymbol(addr(100), "primary");
Symbol s2 = createSymbol(addr(100), "fred");
Symbol s3 = createSymbol(addr(100), "joe");
Symbol s1 = createLabel(addr(100), "primary");
Symbol s2 = createLabel(addr(100), "fred");
Symbol s3 = createLabel(addr(100), "joe");
Namespace scope = st.createNameSpace(null, "MyNamespace", SourceType.USER_DEFINED);
s2.setNamespace(scope);
@ -994,7 +995,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testExternalEntry() throws Exception {
createSymbol(addr(100), "A");
createLabel(addr(100), "A");
st.addExternalEntryPoint(addr(100));
Symbol s = st.getPrimarySymbol(addr(100));
assertTrue(s.isExternalEntryPoint());
@ -1025,14 +1026,14 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testIsExternalEntry() throws Exception {
createSymbol(addr(100), "A");
createLabel(addr(100), "A");
st.addExternalEntryPoint(addr(100));
assertTrue(st.isExternalEntryPoint(addr(100)));
}
@Test
public void testAssociation() throws Exception {
Symbol sym2 = createSymbol(addr(256), "TEST2");
Symbol sym2 = createLabel(addr(256), "TEST2");
refMgr.addMemoryReference(addr(784), addr(256), RefType.FLOW, SourceType.USER_DEFINED, 2);
Reference ref = refMgr.getReference(addr(784), addr(256), 2);
@ -1049,7 +1050,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testRemoveAssociation() throws Exception {
Symbol sym2 = createSymbol(addr(256), "TEST2");
Symbol sym2 = createLabel(addr(256), "TEST2");
refMgr.addMemoryReference(addr(784), addr(256), RefType.FLOW, SourceType.USER_DEFINED, 2);
Reference ref = refMgr.getReference(addr(784), addr(256), 2);
refMgr.setAssociation(sym2, ref);
@ -1063,13 +1064,13 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testGetSymbolReferences() throws Exception {
Symbol sym1 = createSymbol(addr(256), "TEST1");
Symbol sym1 = createLabel(addr(256), "TEST1");
refMgr.addMemoryReference(addr(512), addr(256), RefType.FLOW, SourceType.USER_DEFINED, 2);
refMgr.addMemoryReference(addr(1024), addr(256), RefType.FLOW, SourceType.USER_DEFINED, 0);
refMgr.addMemoryReference(addr(1024), addr(256), RefType.FLOW, SourceType.USER_DEFINED, 1);
refMgr.addMemoryReference(addr(784), addr(256), RefType.FLOW, SourceType.USER_DEFINED, -1);
Symbol sym2 = createSymbol(addr(256), "TEST2");
Symbol sym2 = createLabel(addr(256), "TEST2");
refMgr.addMemoryReference(addr(784), addr(256), RefType.FLOW, SourceType.USER_DEFINED, 2);
Reference ref = refMgr.getReference(addr(784), addr(256), 2);
refMgr.setAssociation(sym2, ref);
@ -1114,21 +1115,21 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testSymbolSearcherIterator() throws Exception {
createSymbol(addr(100), "Four");
createSymbol(addr(100), "Five");
createSymbol(addr(100), "Six");
createSymbol(addr(100), "Seven");
createSymbol(addr(100), "Eight");
createSymbol(addr(100), "Nine");
createSymbol(addr(100), "Thirteen");
createSymbol(addr(200), "Fourteen");
createSymbol(addr(200), "Fifteen");
createSymbol(addr(200), "Sixteen");
createSymbol(addr(200), "Seventeen");
createSymbol(addr(300), "Eighteen");
createSymbol(addr(300), "Nineteen");
createSymbol(addr(300), "Sixty");
createSymbol(addr(300), "Sixty-five");
createLabel(addr(100), "Four");
createLabel(addr(100), "Five");
createLabel(addr(100), "Six");
createLabel(addr(100), "Seven");
createLabel(addr(100), "Eight");
createLabel(addr(100), "Nine");
createLabel(addr(100), "Thirteen");
createLabel(addr(200), "Fourteen");
createLabel(addr(200), "Fifteen");
createLabel(addr(200), "Sixteen");
createLabel(addr(200), "Seventeen");
createLabel(addr(300), "Eighteen");
createLabel(addr(300), "Nineteen");
createLabel(addr(300), "Sixty");
createLabel(addr(300), "Sixty-five");
List<String> list = search("Six*", true);
assertContains(list, "Six", "Sixteen", "Sixty", "Sixty-five");
@ -1146,18 +1147,18 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testSymbolSearcherIterator_WithSymbolNamesContainingWildcards() throws Exception {
createSymbols(addr(100), "Alpha", "alpha", "Albha", "Alzza", "Alibaba", "Alibabas");
createSymbol(addr(100), "Bravo");
createSymbol(addr(100), "Charlie");
createSymbol(addr(200), "Delta");
createSymbols(addr(200), "echo", "echo!bang", "ECHO!bang", "!bangecho", "!bangECHO");
createSymbols(addr(300), "^FOXTROT-hyphen", "^foxtrot-hyphen");
createSymbol(addr(400), "golf,comma");
createSymbol(addr(500), "hotel_underscore");
createSymbol(addr(600), "india.dot.dollar$");
createSymbols(addr(700), "*juliet*", "*JULIET*");
createSymbols(addr(700), "kilo*star", "KILO*star");
createSymbols(addr(800), "lima?questionmark", "LIMA?questionmark");
createLabels(addr(100), "Alpha", "alpha", "Albha", "Alzza", "Alibaba", "Alibabas");
createLabel(addr(100), "Bravo");
createLabel(addr(100), "Charlie");
createLabel(addr(200), "Delta");
createLabels(addr(200), "echo", "echo!bang", "ECHO!bang", "!bangecho", "!bangECHO");
createLabels(addr(300), "^FOXTROT-hyphen", "^foxtrot-hyphen");
createLabel(addr(400), "golf,comma");
createLabel(addr(500), "hotel_underscore");
createLabel(addr(600), "india.dot.dollar$");
createLabels(addr(700), "*juliet*", "*JULIET*");
createLabels(addr(700), "kilo*star", "KILO*star");
createLabels(addr(800), "lima?questionmark", "LIMA?questionmark");
boolean caseSensitive = true;
@ -1247,51 +1248,75 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testPrimarySymbolIteratorSet() throws Exception {
createSymbol(addr(100), "1");
createSymbol(addr(200), "2");
createSymbol(addr(200), "2a");
createSymbol(addr(200), "2b");
createSymbol(addr(200), "2c");
createSymbol(addr(300), "3");
createSymbol(addr(300), "3a");
createSymbol(addr(300), "3b");
createSymbol(addr(300), "3c");
createSymbol(addr(400), "4");
createSymbol(addr(500), "5");
createSymbol(addr(500), "5a");
createLabel(addr(100), "1");
createLabel(addr(200), "2");
createLabel(addr(200), "2a");
createLabel(addr(200), "2b");
createLabel(addr(200), "2c");
createLabel(addr(300), "3");
createLabel(addr(300), "3a");
createLabel(addr(300), "3b");
createLabel(addr(300), "3c");
createLabel(addr(400), "4");
createLabel(addr(500), "5");
createLabel(addr(500), "5a");
createFunction(addr(2000), "6");
createLabel(addr(2000), "6a");
createExternalFunction("7");
createExternalLabel("8");
AddressSet set = new AddressSet(addr(0), addr(50));
set.addRange(addr(300), addr(350));
set.addRange(addr(500), addr(1000));
set.addRange(AddressSpace.EXTERNAL_SPACE.getMinAddress(),
AddressSpace.EXTERNAL_SPACE.getMaxAddress());
SymbolIterator it = st.getPrimarySymbolIterator(set, true);
// External space before memory space
Symbol s = it.next();
assertNotNull(s);
assertEquals("7", s.getName());
assertEquals(extAddr(1), s.getAddress());
s = it.next();
assertNotNull(s);
assertEquals("8", s.getName());
assertEquals(extAddr(2), s.getAddress());
s = it.next();
assertNotNull(s);
assertEquals(addr(300), s.getAddress());
s = it.next();
assertNotNull(s);
assertEquals(addr(500), s.getAddress());
assertTrue(!it.hasNext());
assertNull(it.next());
}
@Test
public void testPrimarySymbolIteratorSetBackwards() throws Exception {
createSymbol(addr(100), "1");
createSymbol(addr(200), "2");
createSymbol(addr(200), "2a");
createSymbol(addr(200), "2b");
createSymbol(addr(200), "2c");
createSymbol(addr(300), "3");
createSymbol(addr(300), "3a");
createSymbol(addr(300), "3b");
createSymbol(addr(300), "3c");
createSymbol(addr(400), "4");
createSymbol(addr(500), "5");
createSymbol(addr(500), "5a");
createLabel(addr(100), "1");
createLabel(addr(200), "2");
createLabel(addr(200), "2a");
createLabel(addr(200), "2b");
createLabel(addr(200), "2c");
createLabel(addr(300), "3");
createLabel(addr(300), "3a");
createLabel(addr(300), "3b");
createLabel(addr(300), "3c");
createLabel(addr(400), "4");
createLabel(addr(500), "5");
createLabel(addr(500), "5a");
createFunction(addr(2000), "6");
createLabel(addr(2000), "6a");
createExternalFunction("7");
createExternalLabel("8");
AddressSet set = new AddressSet(addr(0), addr(50));
set.addRange(addr(300), addr(350));
set.addRange(addr(500), addr(1000));
set.addRange(AddressSpace.EXTERNAL_SPACE.getMinAddress(),
AddressSpace.EXTERNAL_SPACE.getMaxAddress());
SymbolIterator it = st.getPrimarySymbolIterator(set, false);
Symbol s = it.next();
@ -1302,23 +1327,34 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
assertNotNull(s);
assertEquals(addr(300), s.getAddress());
assertEquals("3", s.getName());
// External space after memory space
s = it.next();
assertNotNull(s);
assertEquals("8", s.getName());
assertEquals(extAddr(2), s.getAddress());
s = it.next();
assertNotNull(s);
assertEquals("7", s.getName());
assertEquals(extAddr(1), s.getAddress());
assertTrue(!it.hasNext());
assertNull(it.next());
}
@Test
public void testSymbolIteratorBackwards() throws Exception {
createSymbol(addr(100), "1");
createSymbol(addr(200), "2");
createSymbol(addr(200), "2b");
createSymbol(addr(200), "2c");
createSymbol(addr(300), "3");
createSymbol(addr(300), "3a");
createSymbol(addr(300), "3b");
createSymbol(addr(300), "3c");
createSymbol(addr(400), "4");
createSymbol(addr(500), "5");
createSymbol(addr(600), "6");
createLabel(addr(100), "1");
createLabel(addr(200), "2");
createLabel(addr(200), "2b");
createLabel(addr(200), "2c");
createLabel(addr(300), "3");
createLabel(addr(300), "3a");
createLabel(addr(300), "3b");
createLabel(addr(300), "3c");
createLabel(addr(400), "4");
createLabel(addr(500), "5");
createLabel(addr(600), "6");
SymbolIterator it = st.getSymbolIterator(false);
assertTrue(it.hasNext());
@ -1336,18 +1372,18 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testPrimarySymbolIterator() throws Exception {
createSymbol(addr(100), "1");
createSymbol(addr(200), "2");
createSymbol(addr(200), "2a");
createSymbol(addr(200), "2b");
createSymbol(addr(200), "2c");
createSymbol(addr(300), "3");
createSymbol(addr(300), "3a");
createSymbol(addr(300), "3b");
createSymbol(addr(300), "3c");
createSymbol(addr(400), "4");
createSymbol(addr(500), "5");
createSymbol(addr(500), "5a");
createLabel(addr(100), "1");
createLabel(addr(200), "2");
createLabel(addr(200), "2a");
createLabel(addr(200), "2b");
createLabel(addr(200), "2c");
createLabel(addr(300), "3");
createLabel(addr(300), "3a");
createLabel(addr(300), "3b");
createLabel(addr(300), "3c");
createLabel(addr(400), "4");
createLabel(addr(500), "5");
createLabel(addr(500), "5a");
SymbolIterator it = st.getPrimarySymbolIterator(true);
int count = 1;
@ -1361,18 +1397,18 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testPrimarySymbolIteratorBackwards() throws Exception {
createSymbol(addr(100), "1");
createSymbol(addr(200), "2");
createSymbol(addr(200), "2a");
createSymbol(addr(200), "2b");
createSymbol(addr(200), "2c");
createSymbol(addr(300), "3");
createSymbol(addr(300), "3a");
createSymbol(addr(300), "3b");
createSymbol(addr(300), "3c");
createSymbol(addr(400), "4");
createSymbol(addr(500), "5");
createSymbol(addr(500), "5a");
createLabel(addr(100), "1");
createLabel(addr(200), "2");
createLabel(addr(200), "2a");
createLabel(addr(200), "2b");
createLabel(addr(200), "2c");
createLabel(addr(300), "3");
createLabel(addr(300), "3a");
createLabel(addr(300), "3b");
createLabel(addr(300), "3c");
createLabel(addr(400), "4");
createLabel(addr(500), "5");
createLabel(addr(500), "5a");
SymbolIterator it = st.getPrimarySymbolIterator(false);
assertTrue(it.hasNext());
@ -1394,9 +1430,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testSymbolIteratorByType() throws Exception {
createSymbol(addr(100), "1");
createSymbol(addr(200), "2");
createSymbol(addr(300), "3");
createLabel(addr(100), "1");
createLabel(addr(200), "2");
createLabel(addr(300), "3");
Function f1 = createFunction("A", addr(150));
Function f2 = createFunction("B", addr(250));
@ -1415,9 +1451,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testSymbolIteratorByTypeBackward() throws Exception {
createSymbol(addr(100), "1");
createSymbol(addr(200), "2");
createSymbol(addr(300), "3");
createLabel(addr(100), "1");
createLabel(addr(200), "2");
createLabel(addr(300), "3");
Function f1 = createFunction("A", addr(150));
Function f2 = createFunction("B", addr(250));
@ -1446,7 +1482,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
refMgr.addMemoryReference(addr(200), addr(356), RefType.CONDITIONAL_JUMP,
SourceType.USER_DEFINED, 2);
Reference ref = refMgr.getReference(addr(200), addr(356), 2);
createSymbol(addr(356), "printf");
createLabel(addr(356), "printf");
s = st.getSymbol(ref);
assertNotNull(s);
assertEquals("printf", s.getName());
@ -1469,7 +1505,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
ref = refMgr.addMemoryReference(addr(200), addr(356), RefType.CONDITIONAL_JUMP,
SourceType.USER_DEFINED, 2);
createSymbol(addr(356), "printf");
createLabel(addr(356), "printf");
s = st.getSymbol(ref);
assertNotNull(s);
assertEquals("printf", s.getName());
@ -1485,7 +1521,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testCreateFunction() throws Exception {
Symbol s = createSymbol(addr(100), "fred");
Symbol s = createLabel(addr(100), "fred");
assertTrue(s.isPrimary());
AddressSet set = new AddressSet();
@ -1512,9 +1548,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testPromoteLabelToFunctionWithMultipleLabels() throws Exception {
Symbol s = createSymbol(addr(100), "fred");
Symbol s = createLabel(addr(100), "fred");
assertTrue(s.isPrimary());
Symbol s2 = createSymbol(addr(100), "joe");
Symbol s2 = createLabel(addr(100), "joe");
assertTrue(!s2.isPrimary());
s2.setPrimary();
@ -1547,7 +1583,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testRemoveFunction() throws Exception {
Symbol s = createSymbol(addr(100), "fred");
Symbol s = createLabel(addr(100), "fred");
assertFalse(s.isDeleted());
AddressSet set = new AddressSet();
@ -1596,7 +1632,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testAddExtEntryPoint() throws Exception {
Symbol s = createSymbol(addr(100), "extEntryPoint");
Symbol s = createLabel(addr(100), "extEntryPoint");
st.addExternalEntryPoint(addr(100));
assertEquals("extEntryPoint", s.getName());
assertTrue(s.isExternalEntryPoint());
@ -1605,7 +1641,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testRemoveExtEntryPoint() throws Exception {
Symbol s = createSymbol(addr(100), "extEntryPoint");
Symbol s = createLabel(addr(100), "extEntryPoint");
st.addExternalEntryPoint(addr(100));
assertEquals("extEntryPoint", s.getName());
assertTrue(s.isExternalEntryPoint());
@ -1617,9 +1653,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testGetAllSymbolsIncludingDynamic() throws Exception {
createSymbol(addr(0x100), "aaaa");
createSymbol(addr(0x200), "bbbb");
createSymbol(addr(0x300), "cccc");
createLabel(addr(0x100), "aaaa");
createLabel(addr(0x200), "bbbb");
createLabel(addr(0x300), "cccc");
refMgr.addMemoryReference(addr(0x40), addr(0x050), RefType.FLOW, SourceType.USER_DEFINED,
-1);
refMgr.addMemoryReference(addr(0x30), addr(0x150), RefType.FLOW, SourceType.USER_DEFINED,
@ -1648,9 +1684,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
String[] names = { "primary", "fred", "joe" };
Address address = addr(100);
createSymbol(address, "primary");
createSymbol(address, "fred");
createSymbol(address, "joe");
createLabel(address, "primary");
createLabel(address, "fred");
createLabel(address, "joe");
LabelHistory[] h = st.getLabelHistory(address);
assertEquals(3, h.length);
@ -1672,9 +1708,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
Address address = addr(100);
Symbol s1 = createSymbol(address, "primary");
Symbol s2 = createSymbol(address, "fred");
createSymbol(address, "joe");
Symbol s1 = createLabel(address, "primary");
Symbol s2 = createLabel(address, "fred");
createLabel(address, "joe");
// rename s1 to
s1.setName("MyPrimary", SourceType.USER_DEFINED);
@ -1683,7 +1719,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
st.removeSymbolSpecial(s2);
// create new symbol
createSymbol(addr(100), "bob");
createLabel(addr(100), "bob");
LabelHistory[] h = st.getLabelHistory(address);
assertEquals(6, h.length);
@ -1711,9 +1747,9 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
Address[] addrs =
{ address, address, address, address, address, address, addr(200), addr(200) };
Symbol s1 = createSymbol(address, "primary");
Symbol s2 = createSymbol(address, "fred");
createSymbol(address, "joe");
Symbol s1 = createLabel(address, "primary");
Symbol s2 = createLabel(address, "fred");
createLabel(address, "joe");
// rename s1 to
s1.setName("MyPrimary", SourceType.USER_DEFINED);
@ -1722,10 +1758,10 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
st.removeSymbolSpecial(s2);
// create new symbol
createSymbol(addr(100), "bob");
createLabel(addr(100), "bob");
createSymbol(addr(200), "printf");
createSymbol(addr(200), "fprintf");
createLabel(addr(200), "printf");
createLabel(addr(200), "fprintf");
ArrayList<LabelHistory> list = new ArrayList<LabelHistory>();
Iterator<LabelHistory> iter = st.getLabelHistory();
@ -1832,13 +1868,13 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testSetSymbolName() throws Exception {
Symbol s = createSymbol(addr(0x100), "mysymbol");
Symbol s = createLabel(addr(0x100), "mysymbol");
Namespace s1 = st.createNameSpace(null, "MySpace1", SourceType.USER_DEFINED);
st.createNameSpace(s1, "subspace1", SourceType.USER_DEFINED);
st.createNameSpace(s1, "fred", SourceType.USER_DEFINED);
s.setName("fred", SourceType.USER_DEFINED);
createSymbol(addr(0x100), "fred", s1);
createLabel(addr(0x100), "fred", s1);
Symbol[] symbols = st.getSymbols(addr(0x100));
assertEquals(2, symbols.length);
assertEquals("fred", symbols[0].getName());
@ -2192,7 +2228,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testIsValidParentForCodeSymbol() throws Exception {
Namespace namespace = st.createNameSpace(null, "TestNameSpace", SourceType.USER_DEFINED);
Symbol s = createSymbol(addr(0x125), "printf", namespace);
Symbol s = createLabel(addr(0x125), "printf", namespace);
Namespace subspace1 = st.createNameSpace(namespace, "MySpace1", SourceType.USER_DEFINED);
assertTrue(s.isValidParent(subspace1));
@ -2212,7 +2248,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testIsValidParentForFunction() throws Exception {
Namespace namespace = st.createNameSpace(null, "TestNameSpace", SourceType.USER_DEFINED);
createSymbol(addr(0x125), "printf", namespace);
createLabel(addr(0x125), "printf", namespace);
Namespace subspace1 = st.createNameSpace(namespace, "MySpace1", SourceType.USER_DEFINED);
AddressSet set = new AddressSet(addr(0x100), addr(0x150));
@ -2277,7 +2313,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
public void testClassParentScope() throws Exception {
Namespace scope = st.createClass(null, "TestClass", SourceType.USER_DEFINED);
createSymbol(addr(0x200), "printf", scope);
createLabel(addr(0x200), "printf", scope);
}
@ -2293,7 +2329,7 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
Function extFunc = (Function) extSym.getObject();
try {
createSymbol(addr(0x200), "printf", extFunc);
createLabel(addr(0x200), "printf", extFunc);
Assert.fail("should have gotten invalid input exception!");
}
catch (InvalidInputException e) {
@ -2314,15 +2350,15 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
@Test
public void testGetUniqueSymbol_OneSymbol() throws InvalidInputException {
Symbol newBob = createSymbol(addr(1), "bob");
Symbol newBob = createLabel(addr(1), "bob");
Symbol s = getUniqueSymbol(program, "bob");
assertEquals(newBob, s);
}
@Test
public void testGetUniqueSymbol_MultipleSymbols() throws InvalidInputException {
createSymbol(addr(1), "bob");
createSymbol(addr(2), "bob");
createLabel(addr(1), "bob");
createLabel(addr(2), "bob");
Symbol s = getUniqueSymbol(program, "bob");
assertNull(s);
}
@ -2353,20 +2389,45 @@ public class SymbolManagerTest extends AbstractGhidraHeadedIntegrationTest {
return space.getAddress(l);
}
private Symbol createSymbol(Address addr, String name) throws InvalidInputException {
private Address extAddr(long l) {
return AddressSpace.EXTERNAL_SPACE.getAddress(l);
}
private Symbol createLabel(Address addr, String name) throws InvalidInputException {
return st.createLabel(addr, name, SourceType.USER_DEFINED);
}
private void createSymbols(Address addr, String... names) throws InvalidInputException {
private void createLabels(Address addr, String... names) throws InvalidInputException {
for (String name : names) {
st.createLabel(addr, name, SourceType.USER_DEFINED);
}
}
private Symbol createSymbol(Address addr, String name, Namespace namespace)
private Symbol createLabel(Address addr, String name, Namespace namespace)
throws InvalidInputException {
return st.createLabel(addr, name, namespace, SourceType.USER_DEFINED);
}
private Symbol createFunction(Address addr, String name)
throws InvalidInputException, OverlappingFunctionException {
return program.getFunctionManager()
.createFunction(name, addr, new AddressSet(addr, addr), SourceType.USER_DEFINED)
.getSymbol();
}
private Symbol createExternalLabel(String name)
throws InvalidInputException, DuplicateNameException {
ExternalManager externalManager = program.getExternalManager();
return externalManager.addExtLocation("Test", name, null, SourceType.USER_DEFINED)
.getSymbol();
}
private Symbol createExternalFunction(String name)
throws InvalidInputException, DuplicateNameException {
ExternalManager externalManager = program.getExternalManager();
return externalManager.addExtFunction("Test", name, null, SourceType.USER_DEFINED)
.getSymbol();
}
}

73
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/external/ExternalManagerDB.java vendored
View file

@ -87,9 +87,6 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
}
}
/**
* @see ghidra.program.database.ManagerDB#setProgram(ghidra.program.database.ProgramDB)
*/
@Override
public void setProgram(ProgramDB program) {
this.program = program;
@ -98,9 +95,6 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
scopeMgr = program.getNamespaceManager();
}
/**
* @see ghidra.program.database.ManagerDB#programReady(int, int, ghidra.util.task.TaskMonitor)
*/
@Override
public void programReady(int openMode, int currentRevision, TaskMonitor monitor)
throws IOException, CancelledException {
@ -185,26 +179,17 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
return true;
}
/**
* @see ghidra.program.database.ManagerDB#invalidateCache(boolean)
*/
@Override
public void invalidateCache(boolean all) throws IOException {
// nothing to do here
}
/**
* @see ghidra.program.database.ManagerDB#deleteAddressRange(ghidra.program.model.address.Address, ghidra.program.model.address.Address, ghidra.util.task.TaskMonitor)
*/
@Override
public void deleteAddressRange(Address startAddr, Address endAddr, TaskMonitor monitor)
throws CancelledException {
// Has no affect on externals
}
/**
* @see ghidra.program.database.ManagerDB#moveAddressRange(ghidra.program.model.address.Address, ghidra.program.model.address.Address, long, ghidra.util.task.TaskMonitor)
*/
@Override
public void moveAddressRange(Address fromAddr, Address toAddr, long length, TaskMonitor monitor)
throws CancelledException {
@ -230,8 +215,7 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
@Override
public ExternalLocation addExtLocation(Namespace extParentNamespace, String extLabel,
Address extAddr, SourceType sourceType)
throws InvalidInputException, DuplicateNameException {
Address extAddr, SourceType sourceType) throws InvalidInputException {
lock.acquire();
try {
return addExtLocation(extParentNamespace, extLabel, extAddr, false, sourceType, true);
@ -243,8 +227,7 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
@Override
public ExternalLocation addExtLocation(Namespace extParentNamespace, String extLabel,
Address extAddr, SourceType sourceType, boolean reuseExisting)
throws InvalidInputException, DuplicateNameException {
Address extAddr, SourceType sourceType, boolean reuseExisting) throws InvalidInputException {
lock.acquire();
try {
return addExtLocation(extParentNamespace, extLabel, extAddr, false, sourceType,
@ -275,8 +258,7 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
@Override
public ExternalLocation addExtFunction(Namespace extParentNamespace, String extLabel,
Address extAddr, SourceType sourceType)
throws InvalidInputException, DuplicateNameException {
Address extAddr, SourceType sourceType) throws InvalidInputException {
lock.acquire();
try {
return addExtLocation(extParentNamespace, extLabel, extAddr, true, sourceType, true);
@ -288,9 +270,7 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
@Override
public ExternalLocation addExtFunction(Namespace extNamespace, String extLabel, Address extAddr,
SourceType sourceType, boolean reuseExisting)
throws InvalidInputException, DuplicateNameException {
SourceType sourceType, boolean reuseExisting) throws InvalidInputException {
lock.acquire();
try {
return addExtLocation(extNamespace, extLabel, extAddr, true, sourceType, reuseExisting);
@ -314,11 +294,18 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
private ExternalLocation addExtLocation(Namespace extNamespace, String extLabel,
Address extAddr, boolean isFunction, SourceType sourceType, boolean reuseExisting)
throws InvalidInputException, DuplicateNameException {
throws InvalidInputException {
if (extNamespace == null) {
extNamespace = getLibraryScope(Library.UNKNOWN);
if (extNamespace == null) {
extNamespace = addExternalLibraryName(Library.UNKNOWN, SourceType.ANALYSIS);
try {
extNamespace = addExternalLibraryName(Library.UNKNOWN, SourceType.ANALYSIS);
}
catch (DuplicateNameException e) {
// TODO: really need to reserve the unknown namespace name
throw new InvalidInputException(
"Failed to establish " + Library.UNKNOWN + " library");
}
}
}
else if (!extNamespace.isExternal()) {
@ -637,9 +624,6 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
return symbolMgr;
}
/**
* @see ghidra.program.model.symbol.ExternalManager#removeExternalLibrary(java.lang.String)
*/
@Override
public boolean removeExternalLibrary(String name) {
lock.acquire();
@ -694,8 +678,7 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
private Library addExternalName(String name, String pathname, SourceType source)
throws DuplicateNameException, InvalidInputException {
SymbolDB s = symbolMgr.createSpecialSymbol(Address.NO_ADDRESS, name,
scopeMgr.getGlobalNamespace(), SymbolType.LIBRARY, null, null, pathname, source);
SymbolDB s = symbolMgr.createLibrarySymbol(name, pathname, source);
return (Library) s.getObject();
}
@ -704,17 +687,11 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
return s == null ? null : (Namespace) s.getObject();
}
/**
* @see ghidra.program.model.symbol.ExternalManager#contains(java.lang.String)
*/
@Override
public boolean contains(String libraryName) {
return symbolMgr.getLibrarySymbol(libraryName) != null;
}
/**
* @see ghidra.program.model.symbol.ExternalManager#getExternalLibraryNames()
*/
@Override
public String[] getExternalLibraryNames() {
ArrayList<String> list = new ArrayList<>();
@ -735,9 +712,6 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
return s != null ? (Library) s.getObject() : null;
}
/**
* @see ghidra.program.model.symbol.ExternalManager#getExternalLibraryPath(java.lang.String)
*/
@Override
public String getExternalLibraryPath(String externalName) {
SymbolDB s = (SymbolDB) symbolMgr.getLibrarySymbol(externalName);
@ -799,7 +773,7 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
try {
SymbolDB symbol = (SymbolDB) extLoc.getSymbol();
if (!(symbol instanceof CodeSymbol)) {
return null;
throw new IllegalStateException("Expected external code symbol");
}
//long dtId = symbol.getSymbolData1();
String extData = symbol.getSymbolStringData();
@ -813,18 +787,13 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
return functionMgr.createExternalFunction(extAddr, name, namespace, extData, source);
}
catch (Exception e) {
e.printStackTrace();
throw new RuntimeException("Unexpected exception", e);
}
finally {
lock.release();
}
}
/**
* @return
*/
AddressMap getAddressMap() {
return addrMap;
}
@ -834,9 +803,6 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
return new ExternalLocationDBIterator(symbolMgr.getExternalSymbols(), memoryAddress);
}
/**
* @see ghidra.program.model.symbol.ExternalManager#getExternalLocations(java.lang.String)
*/
@Override
public ExternalLocationIterator getExternalLocations(String externalName) {
Namespace scope = getLibraryScope(externalName);
@ -864,9 +830,6 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
this.symIter = symIter;
}
/**
* @see java.util.Iterator#remove()
*/
@Override
public void remove() {
throw new UnsupportedOperationException();
@ -888,9 +851,6 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
return null;
}
/**
* @see ghidra.program.model.symbol.ExternalLocationIterator#hasNext()
*/
@Override
public boolean hasNext() {
if (symIter != null) {
@ -902,9 +862,6 @@ public class ExternalManagerDB implements ManagerDB, ExternalManager {
return nextExtLoc != null;
}
/**
* @see ghidra.program.model.symbol.ExternalLocationIterator#next()
*/
@Override
public ExternalLocation next() {
if (hasNext()) {

12
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/function/FunctionManagerDB.java
View file

@ -272,23 +272,23 @@ public class FunctionManagerDB implements FunctionManager {
/**
* Transform an existing external symbol into an external function.
* This method should only be invoked by an ExternalSymbol
* @param extSpaceAddr the external space address to use when creating this external.
* @param extSpaceAddr the external space address to use when creating this external. Any
* other symbol using this address must first be deleted. Results are unpredictable if this is
* not done.
* @param name the external function name
* @param nameSpace the external function namespace
* @param extData the external data string to store additional info (see {@link ExternalLocationDB})
* @param source the source of this external.
* @return external function
* @throws InvalidInputException if the name is invalid
* @throws DuplicateNameException if the name is an invalid duplicate
*/
public Function createExternalFunction(Address extSpaceAddr, String name, Namespace nameSpace,
String extData, SourceType source)
throws DuplicateNameException, InvalidInputException {
throws InvalidInputException {
lock.acquire();
try {
Symbol symbol = symbolMgr.createSpecialSymbol(extSpaceAddr, name, nameSpace,
SymbolType.FUNCTION, null, null, extData, source);
Symbol symbol =
symbolMgr.createFunctionSymbol(extSpaceAddr, name, nameSpace, source, extData);
long returnDataTypeId = program.getDataTypeManager().getResolvedID(DataType.DEFAULT);

11
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/references/ReferenceDBManager.java
View file

@ -1115,6 +1115,17 @@ public class ReferenceDBManager implements ReferenceManager, ManagerDB, ErrorHan
}
@Override
public void removeAllReferencesTo(Address toAddr) {
try {
removeAllTo(toAddr);
}
catch (IOException e) {
program.dbError(e);
}
}
void removeReference(Address fromAddr, Address toAddr, int opIndex) {
lock.acquire();
try {

16
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/CodeSymbol.java
View file

@ -85,18 +85,22 @@ public class CodeSymbol extends SymbolDB {
@Override
public boolean delete() {
if (isExternal()) {
return delete(false);
}
return super.delete();
boolean keepReferences = !isExternal();
return delete(keepReferences);
}
/**
* Delete code/label symbol
* @param keepReferences if false all references to this symbols address will be removed,
* otherwise associated references will simply be disassociated following symbol removal
* (see {@link SymbolManager#doRemoveSymbol(SymbolDB)}.
* @return true if symbol successfully removed
*/
public boolean delete(boolean keepReferences) {
lock.acquire();
try {
if (!keepReferences) {
// remove external references
removeAllReferencesTo();
symbolMgr.getReferenceManager().removeAllReferencesTo(getAddress());
}
return super.delete();
}

50
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/FunctionSymbol.java
View file

@ -20,7 +20,6 @@ import java.util.List;
import db.DBRecord;
import ghidra.program.database.DBObjectCache;
import ghidra.program.database.ProgramDB;
import ghidra.program.database.external.ExternalManagerDB;
import ghidra.program.database.function.FunctionManagerDB;
import ghidra.program.model.address.Address;
@ -91,9 +90,6 @@ public class FunctionSymbol extends SymbolDB {
}
}
/**
* @see ghidra.program.model.symbol.Symbol#delete()
*/
@Override
public boolean delete() {
lock.acquire();
@ -120,7 +116,8 @@ public class FunctionSymbol extends SymbolDB {
boolean restored = createLabelForDeletedFunctionName(address, symName, extData,
namespace, source, pinned);
if (!restored && isExternal()) {
removeAllReferencesTo();
// remove all associated external references if label not restored
symbolMgr.getReferenceManager().removeAllReferencesTo(getAddress());
}
}
return true;
@ -138,34 +135,19 @@ public class FunctionSymbol extends SymbolDB {
*/
private boolean createLabelForDeletedFunctionName(Address entryPoint, String symName,
String stringData, Namespace namespace, SourceType source, boolean pinned) {
if (isExternal()) {
SymbolDB parent = (SymbolDB) namespace.getSymbol();
if (parent.isDeleting()) {
return false; // don't recreate external
}
Symbol parentSymbol = namespace.getSymbol();
if ((parentSymbol instanceof SymbolDB) && ((SymbolDB) parentSymbol).isDeleting()) {
// do not replace function with label if parent namespace is getting removed
return false;
}
try {
SymbolDB newSym;
try {
newSym = symbolMgr.createSpecialSymbol(entryPoint, symName, namespace,
SymbolType.LABEL, null, null, stringData, source);
if (pinned) {
newSym.setPinned(true);
}
}
catch (InvalidInputException e) {
ProgramDB program = symbolMgr.getProgram();
newSym = (SymbolDB) symbolMgr.createLabel(entryPoint, symName,
program.getGlobalNamespace(), source);
}
newSym.setSymbolStringData(stringData);
Symbol newSym =
symbolMgr.createCodeSymbol(entryPoint, symName, namespace, source, stringData);
newSym.setPrimary();
return true;
}
catch (DuplicateNameException e) {
// This should't happen.
Msg.error(this, "Unexpected Exception: " + e.getMessage(), e);
}
catch (InvalidInputException e) {
// This shouldn't happen.
Msg.error(this, "Unexpected Exception: " + e.getMessage(), e);
@ -173,17 +155,11 @@ public class FunctionSymbol extends SymbolDB {
return false;
}
/**
* @see ghidra.program.model.symbol.Symbol#getObject()
*/
@Override
public Object getObject() {
return functionMgr.getFunction(key);
}
/**
* @see ghidra.program.model.symbol.Symbol#isPrimary()
*/
@Override
public boolean isPrimary() {
return true;
@ -204,9 +180,6 @@ public class FunctionSymbol extends SymbolDB {
}
}
/**
* @see ghidra.program.model.symbol.Symbol#getProgramLocation()
*/
@Override
public ProgramLocation getProgramLocation() {
lock.acquire();
@ -224,9 +197,6 @@ public class FunctionSymbol extends SymbolDB {
}
}
/**
* @see ghidra.program.model.symbol.Symbol#isValidParent(ghidra.program.model.symbol.Namespace)
*/
@Override
public boolean isValidParent(Namespace parent) {
return SymbolType.FUNCTION.isValidParent(symbolMgr.getProgram(), parent, address,

9
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolDB.java
View file

@ -855,15 +855,6 @@ public abstract class SymbolDB extends DatabaseObject implements Symbol {
}
}
protected void removeAllReferencesTo() {
ReferenceManager refMgr = symbolMgr.getReferenceManager();
ReferenceIterator it = refMgr.getReferencesTo(address);
while (it.hasNext()) {
Reference ref = it.next();
refMgr.delete(ref);
}
}
public long getDataTypeId() {
lock.acquire();
try {

167
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/symbol/SymbolManager.java
View file

@ -2498,8 +2498,8 @@ public class SymbolManager implements SymbolTable, ManagerDB {
try {
source = adjustSourceTypeIfNecessary(name, type, source, storage);
Address varAddr = variableStorageMgr.getVariableStorageAddress(storage, true);
return (VariableSymbolDB) createSpecialSymbol(varAddr, name, namespace, type,
null, Integer.valueOf(firstUseOffsetOrOrdinal), null, source);
return (VariableSymbolDB) doCreateSpecialSymbol(varAddr, name, namespace, type, null,
Integer.valueOf(firstUseOffsetOrOrdinal), null, source, true);
}
catch (IOException e) {
dbError(e);
@ -2525,29 +2525,21 @@ public class SymbolManager implements SymbolTable, ManagerDB {
@Override
public GhidraClass createClass(Namespace parent, String name, SourceType source)
throws DuplicateNameException, InvalidInputException {
SymbolDB s =
createSpecialSymbol(Address.NO_ADDRESS, name, parent, SymbolType.CLASS, null, null,
null, source);
SymbolDB s = createClassSymbol(name, parent, source, true);
return new GhidraClassDB(s, namespaceMgr);
}
@Override
public Library createExternalLibrary(String name, SourceType source)
throws DuplicateNameException, InvalidInputException {
SymbolDB s =
createSpecialSymbol(Address.NO_ADDRESS, name, null, SymbolType.LIBRARY, null, null,
null, source);
SymbolDB s = createLibrarySymbol(name, null, source);
return new LibraryDB(s, namespaceMgr);
}
@Override
public Namespace createNameSpace(Namespace parent, String name, SourceType source)
throws DuplicateNameException, InvalidInputException {
SymbolDB s =
createSpecialSymbol(Address.NO_ADDRESS, name, parent, SymbolType.NAMESPACE, null,
null, null, source);
SymbolDB s = createNamespaceSymbol(name, parent, source, true);
return new NamespaceDB(s, namespaceMgr);
}
@ -2569,10 +2561,8 @@ public class SymbolManager implements SymbolTable, ManagerDB {
// no duplicate check, since this class name will be set to that of the existing namespace
String tempName = "_temp_" + System.nanoTime();
SymbolDB classSymbol =
doCreateSpecialSymbol(Address.NO_ADDRESS, tempName, namespace.getParentNamespace(),
SymbolType.CLASS, null, null, null, originalSource,
false /*check for duplicate */);
SymbolDB classSymbol = createClassSymbol(tempName, namespace.getParentNamespace(),
originalSource, false /*check for duplicate */);
GhidraClassDB classNamespace = new GhidraClassDB(classSymbol, namespaceMgr);
// move everything from old namespace into new class namespace
@ -2646,11 +2636,9 @@ public class SymbolManager implements SymbolTable, ManagerDB {
// Note: We know there are no namespaces with the name; do we still have to check for
// duplicates? Assuming yes, as another symbol type may exist with this name.
SymbolDB s =
doCreateSpecialSymbol(Address.NO_ADDRESS, name, parent, SymbolType.NAMESPACE, null,
null, null, source, true /*check for duplicates*/);
return new NamespaceDB(s, namespaceMgr);
SymbolDB s = createNamespaceSymbol(name, parent, source, true /*check for duplicates*/);
return new NamespaceDB(s, namespaceMgr);
}
finally {
lock.release();
@ -2658,36 +2646,55 @@ public class SymbolManager implements SymbolTable, ManagerDB {
}
/**
* Creates a symbol, specifying all information for the record. This method is not on the
* public interface and is only intended for program API internal use. The user of this
* method must carefully provided exactly the information needed depending on the type of symbol
* being created.
* @param addr the address for the symbol
* @param name the name of the symbol
* @param parent the namespace for the symbol
* @param symbolType the type of the symbol
* @param dataTypeId the id for an associated datatype or null
* @param variableOffset this is the ordinal for params and firstUseOffset for locals
* @param stringData value whose meaning depends on the symbol type.
* @param source the SourceType for the new symbol
* @return the newly created symbol
* @throws DuplicateNameException if the symbol type must be unique and another already has that name
* in the given namespace.
* @throws InvalidInputException if the name contains any illegal characters (i.e. space)
* Create a Library symbol with the specified name and optional pathname
* @param name library name
* @param pathname project file path (may be null)
* @param source symbol source
* @return library symbol
* @throws DuplicateNameException if library name conflicts with another symbol
* @throws InvalidInputException
*/
public SymbolDB createSpecialSymbol(Address addr, String name, Namespace parent,
SymbolType symbolType, Long dataTypeId, Integer variableOffset, String stringData,
SourceType source)
public SymbolDB createLibrarySymbol(String name, String pathname, SourceType source)
throws DuplicateNameException, InvalidInputException {
return doCreateSpecialSymbol(Address.NO_ADDRESS, name, null, SymbolType.LIBRARY, null, null,
pathname, source, true);
}
return doCreateSpecialSymbol(addr, name, parent, symbolType, stringData, dataTypeId,
variableOffset, source, true);
/**
* Create a Class symbol with the specified name and parent
* @param name class name
* @param parent parent namespace (may be null for global namespace)
* @param source symbol source
* @param checkForDuplicates true if check for duplicate name conflict should be performed
* @return class symbol
* @throws DuplicateNameException if class name conflicts with another symbol
* @throws InvalidInputException
*/
SymbolDB createClassSymbol(String name, Namespace parent, SourceType source,
boolean checkForDuplicates) throws DuplicateNameException, InvalidInputException {
return doCreateSpecialSymbol(Address.NO_ADDRESS, name, parent, SymbolType.CLASS, null, null,
null, source, true);
}
/**
* Create a simple Namespace symbol with the specified name and parent
* @param name class name
* @param parent parent namespace (may be null for global namespace)
* @param source symbol source
* @param checkForDuplicates true if check for duplicate name conflict should be performed
* @return namespace symbol
* @throws DuplicateNameException if namespace name conflicts with another symbol
* @throws InvalidInputException
*/
SymbolDB createNamespaceSymbol(String name, Namespace parent, SourceType source,
boolean checkForDuplicates) throws DuplicateNameException, InvalidInputException {
return doCreateSpecialSymbol(Address.NO_ADDRESS, name, parent, SymbolType.NAMESPACE, null,
null, null, source, true);
}
private SymbolDB doCreateSpecialSymbol(Address addr, String name, Namespace parent,
SymbolType symbolType, String stringData, Long dataTypeId, Integer variableOffset,
SourceType source,
boolean checkForDuplicates)
SymbolType symbolType, Long dataTypeId, Integer variableOffset, String stringData,
SourceType source, boolean checkForDuplicates)
throws DuplicateNameException, InvalidInputException {
lock.acquire();
@ -2722,8 +2729,9 @@ public class SymbolManager implements SymbolTable, ManagerDB {
}
/**
* Internal method for creating label symbols.
* @param addr the address for the new symbol
* Internal method for creating label symbols. If identical memory symbol already exists
* it will be returned.
* @param addr the address for the new symbol (memory or external)
* @param name the name of the new symbol
* @param namespace the namespace for the new symbol
* @param source the SourceType of the new symbol
@ -2739,24 +2747,38 @@ public class SymbolManager implements SymbolTable, ManagerDB {
source = validateSource(source, name, addr, SymbolType.LABEL);
name = validateName(name, source);
Symbol symbol = getSymbol(name, addr, namespace);
if (symbol != null) {
return symbol;
}
boolean makePrimary = true;
if (addr.isMemoryAddress()) {
// If there is a default named function, rename it to the new symbol name
Symbol functionSymbol = tryUpdatingDefaultFunction(addr, name, namespace, source);
if (functionSymbol != null) {
return functionSymbol;
}
Symbol symbol = getSymbol(name, addr, namespace);
if (symbol != null) {
return symbol;
}
// if there is a dynamic symbol, delete it and make the new symbol primary.
Symbol primary = getPrimarySymbol(addr);
if (primary != null && primary.isDynamic()) {
deleteDynamicSymbol(primary);
primary = null;
// If there is a default named function, rename it to the new symbol name
Symbol functionSymbol = tryUpdatingDefaultFunction(addr, name, namespace, source);
if (functionSymbol != null) {
return functionSymbol;
}
// if there is a dynamic symbol, delete it and make the new symbol primary.
Symbol primary = getPrimarySymbol(addr);
if (primary != null && primary.isDynamic()) {
deleteDynamicSymbol(primary);
primary = null;
}
makePrimary = (primary == null);
}
else if (addr.isExternalAddress()) {
// only one symbol per external address is allowed
Symbol primary = getPrimarySymbol(addr);
if (primary != null) {
throw new IllegalArgumentException("external address already used");
}
}
else {
throw new IllegalArgumentException("bad label address");
}
boolean makePrimary = primary == null;
return doCreateSymbol(name, addr, namespace, SymbolType.LABEL, stringData, null, null,
source, makePrimary);
@ -2784,6 +2806,27 @@ public class SymbolManager implements SymbolTable, ManagerDB {
source = validateSource(source, name, addr, SymbolType.FUNCTION);
name = validateName(name, source);
if (addr.isMemoryAddress()) {
return doCreateMemoryFunctionSymbol(addr, name, namespace, source, stringData);
}
else if (addr.isExternalAddress()) {
// only one symbol per external address is allowed
Symbol primary = getPrimarySymbol(addr);
if (primary != null) {
throw new IllegalArgumentException("external address already used");
}
}
else {
throw new IllegalArgumentException("bad function address");
}
return doCreateSymbol(name, addr, namespace, SymbolType.FUNCTION, stringData, null, null,
source, true);
}
private Symbol doCreateMemoryFunctionSymbol(Address addr, String name, Namespace namespace,
SourceType source, String stringData) throws InvalidInputException {
// if there is already a FUNCTION symbol with that name and namespace here, just return it.
Symbol matching = getSymbol(name, addr, namespace);
if (matching != null && matching.getSymbolType() == SymbolType.FUNCTION) {

61
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/symbol/ExternalManager.java
View file

@ -30,29 +30,31 @@ import ghidra.util.exception.InvalidInputException;
public interface ExternalManager {
/**
* Returns a list of all external names for which locations have been defined.
* Returns an array of all external names for which locations have been defined.
* @return array of external names
*/
public String[] getExternalLibraryNames();
/**
* Get the Library which corresponds to the specified name
* @param name name of library
* @param libraryName name of library
* @return library or null if not found
*/
public Library getExternalLibrary(String name);
public Library getExternalLibrary(String libraryName);
/**
* Removes external name if no associated ExternalLocation's exist
* @param name external name
* @param libraryName external library name
* @return true if removed, false if unable to due to associated locations/references
*/
public boolean removeExternalLibrary(String name);
public boolean removeExternalLibrary(String libraryName);
/**
* Returns the file pathname associated with an external name.
* Null is returned if either the external name does not exist or
* a pathname has not been set.
* @param libraryName external name
* @return project file pathname or null
*/
public String getExternalLibraryPath(String libraryName);
@ -61,6 +63,7 @@ public interface ExternalManager {
* @param libraryName the name of the library to associate with a file.
* @param pathname the path to the program to be associated with the library name.
* @param userDefined true if the external path is being specified by the user
* @throws InvalidInputException
*/
public void setExternalPath(String libraryName, String pathname, boolean userDefined)
throws InvalidInputException;
@ -70,6 +73,8 @@ public interface ExternalManager {
* @param oldName the old name of the external library name.
* @param newName the new name of the external library name.
* @param source the source of this external library
* @throws DuplicateNameException if another namespace has the same name
* @throws InvalidInputException
*/
public void updateExternalLibraryName(String oldName, String newName, SourceType source)
throws DuplicateNameException, InvalidInputException;
@ -85,7 +90,7 @@ public interface ExternalManager {
/**
* Get an iterator over all external locations which have been associated to
* the specified memory address
* @param memoryAddress
* @param memoryAddress memory address
* @return external location iterator
*/
public ExternalLocationIterator getExternalLocations(Address memoryAddress);
@ -94,7 +99,9 @@ public interface ExternalManager {
* Get an external location.
* @param libraryName the name of the library for which to get an external location
* @param label the name of the external location.
* @deprecated Use {@link #getExternalLocations(String, String)} instead
* @return first matching external location
* @deprecated Use {@link #getExternalLocations(String, String)} or
* {@link #getUniqueExternalLocation(String, String)} since duplicate names may exist
*/
@Deprecated
public ExternalLocation getExternalLocation(String libraryName, String label);
@ -103,7 +110,9 @@ public interface ExternalManager {
* Get an external location.
* @param namespace the namespace containing the external label.
* @param label the name of the external location.
* @deprecated Use {@link #getExternalLocations(Namespace, String)}
* @return first matching external location
* @deprecated Use {@link #getExternalLocations(Namespace, String)} or
* {@link #getUniqueExternalLocation(Namespace, String)} since duplicate names may exist
*/
@Deprecated
public ExternalLocation getExternalLocation(Namespace namespace, String label);
@ -156,25 +165,27 @@ public interface ExternalManager {
/**
* Adds a new external library name
* @param name the new library name to add.
* @param libraryName the new external library name to add.
* @param source the source of this external library
* @return library
* @throws InvalidInputException
* @throws DuplicateNameException if another non-Library namespace has the same name
*/
public Library addExternalLibraryName(String name, SourceType source)
throws DuplicateNameException, InvalidInputException;
public Library addExternalLibraryName(String libraryName, SourceType source)
throws InvalidInputException, DuplicateNameException;
/**
* Get or create an external location associated with an library/file named extName
* and the label within that file specified by extLabel
* @param extName the external name
* @param libraryName the external library name
* @param extLabel the external label
* @param extAddr the external address
* @param sourceType the source type of this external library's symbol
* @return external location
* @throws InvalidInputException
* @throws DuplicateNameException
* @throws DuplicateNameException if another non-Library namespace has the same name
*/
public ExternalLocation addExtLocation(String extName, String extLabel, Address extAddr,
public ExternalLocation addExtLocation(String libraryName, String extLabel, Address extAddr,
SourceType sourceType) throws InvalidInputException, DuplicateNameException;
/**
@ -185,10 +196,9 @@ public interface ExternalManager {
* @param sourceType the source type of this external library's symbol
* @return external location
* @throws InvalidInputException
* @throws DuplicateNameException
*/
public ExternalLocation addExtLocation(Namespace extNamespace, String extLabel, Address extAddr,
SourceType sourceType) throws InvalidInputException, DuplicateNameException;
SourceType sourceType) throws InvalidInputException;
/**
* Get or create an external location in the indicated parent namespace with the specified name.
@ -200,25 +210,24 @@ public interface ExternalManager {
* location instead of creating a new one.
* @return external location
* @throws InvalidInputException
* @throws DuplicateNameException
*/
public ExternalLocation addExtLocation(Namespace extNamespace, String extLabel, Address extAddr,
SourceType sourceType, boolean reuseExisting)
throws InvalidInputException, DuplicateNameException;
throws InvalidInputException;
/**
* Get or create an external location associated with an library/file named extName
* and the label within that file specified by extLabel
* @param extName the external name
* @param libraryName the external library name
* @param extLabel the external label
* @param extAddr the external address
* @param sourceType the source type of this external library's symbol
* @return external location
* @throws InvalidInputException
* @throws DuplicateNameException
* @throws DuplicateNameException if another non-Library namespace has the same name
*/
public ExternalLocation addExtFunction(String extName, String extLabel, Address extAddr,
SourceType sourceType) throws DuplicateNameException, InvalidInputException;
public ExternalLocation addExtFunction(String libraryName, String extLabel, Address extAddr,
SourceType sourceType) throws InvalidInputException, DuplicateNameException;
/**
* Get or create an external function location associated with an library/file named extName
@ -229,10 +238,9 @@ public interface ExternalManager {
* @param sourceType the source type of this external library's symbol
* @return external location
* @throws InvalidInputException
* @throws DuplicateNameException if another non-Library namespace has the same name
*/
public ExternalLocation addExtFunction(Namespace extNamespace, String extLabel, Address extAddr,
SourceType sourceType) throws InvalidInputException, DuplicateNameException;
SourceType sourceType) throws InvalidInputException;
/**
* Get or create an external function location associated with an library/file named extName
@ -245,10 +253,9 @@ public interface ExternalManager {
* address is not null and not used in an existing location.
* @return external location
* @throws InvalidInputException
* @throws DuplicateNameException if another non-Library namespace has the same name
*/
public ExternalLocation addExtFunction(Namespace extNamespace, String extLabel, Address extAddr,
SourceType sourceType, boolean reuseExisting)
throws InvalidInputException, DuplicateNameException;
throws InvalidInputException;
}

7
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/symbol/ReferenceManager.java
View file

@ -173,6 +173,13 @@ public interface ReferenceManager {
*/
public void removeAllReferencesFrom(Address fromAddr);
/**
* Remove all stack, external, and memory references for the given
* to address.
* @param toAddr the address for which all references to should be removed.
*/
public void removeAllReferencesTo(Address toAddr);
/**
* Returns all references to the given variable. Only data references to storage
* are considered.

3
Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/symbol/Symbol.java
View file

@ -183,7 +183,8 @@ public interface Symbol {
throws DuplicateNameException, InvalidInputException, CircularDependencyException;
/**
* Delete the symbol and its associated resources.
* Delete the symbol and its associated resources. Any references symbol associations
* will be discarded.
* @return true if successful
*/
public boolean delete();

5
Ghidra/Framework/SoftwareModeling/src/test/java/ghidra/program/model/ReferenceManagerTestDouble.java
View file

@ -89,6 +89,11 @@ public class ReferenceManagerTestDouble implements ReferenceManager {
throw new UnsupportedOperationException();
}
@Override
public void removeAllReferencesTo(Address toAddr) {
throw new UnsupportedOperationException();
}
@Override
public Reference[] getReferencesTo(Variable var) {
throw new UnsupportedOperationException();