development/ghidra
development/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra synced 2024-10-02 16:33:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch

Browse source 
'origin/GP-3656_Dan_fixEmuDsPic30F--SQUASHED' into patch (Closes #5556)
This commit is contained in:
Ryan Kurtz 2023-07-21 06:12:07 -04:00
parent 8eb31518cd cfac9a1b3a
commit 36695e8cbb
2 changed files with 123 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

68
Ghidra/Debug/ProposedUtils/src/main/java/ghidra/util/TwoWayBreakdownAddressRangeIterator.java
View file

@ -76,6 +76,7 @@ public class TwoWayBreakdownAddressRangeIterator
private final PeekableIterator<AddressRange> rit;
private final boolean forward;
private AddressSpace curSpace = null;
private Address cur = null; // max/min address of next range expected
private final MyEntry entry = new MyEntry();
@ -86,17 +87,33 @@ public class TwoWayBreakdownAddressRangeIterator
this.rit = PeekableIterators.castOrWrap(rit);
this.forward = forward;
if (this.lit.hasNext()) {
cur = getStart(this.lit.peek());
}
if (this.rit.hasNext()) {
Address a = getStart(this.rit.peek());
cur = cur == null ? a : first(cur, a);
}
initCur();
}
private Address getBefore(AddressRange r) {
return forward ? r.getMinAddress().previous() : r.getMaxAddress().next();
private void initCur() {
if (lit.hasNext()) {
cur = getStart(this.lit.peek());
}
if (rit.hasNext()) {
Address a = getStart(rit.peek());
cur = cur == null ? a : first(cur, a);
}
curSpace = cur == null ? null : cur.getAddressSpace();
}
private Address getBefore(AddressRange r, AddressSpace beforeSpace) {
if (forward) {
Address prev = r.getMinAddress().previous();
if (prev != null) {
return prev;
}
return beforeSpace.getMaxAddress();
}
Address next = r.getMaxAddress().next();
if (next != null) {
return next;
}
return beforeSpace.getMinAddress();
}
private Address getStart(AddressRange r) {
@ -142,6 +159,25 @@ public class TwoWayBreakdownAddressRangeIterator
}
}
private void advanceSpace(PeekableIterator<AddressRange> it) {
while (it.hasNext() && it.peek().getAddressSpace() == curSpace) {
it.next();
}
}
private void advanceSpace() {
advanceSpace(lit);
advanceSpace(rit);
}
private void advance() {
cur = getAfter(entry.key);
if (cur == null) { // ended at an extreme
advanceSpace();
initCur();
}
}
@Override
protected Entry<AddressRange, Which> seekNext() {
if (cur == null) {
@ -158,13 +194,13 @@ public class TwoWayBreakdownAddressRangeIterator
if (ln && !rn) {
entry.key = truncateRange(lit.next());
entry.val = Which.LEFT;
cur = getAfter(entry.key);
advance();
return entry;
}
if (!ln && rn) {
entry.key = truncateRange(rit.next());
entry.val = Which.RIGHT;
cur = getAfter(entry.key);
advance();
return entry;
}
@ -179,23 +215,23 @@ public class TwoWayBreakdownAddressRangeIterator
Address end = first(getEnd(lit.peek()), getEnd(rit.peek()));
entry.key = truncateRange(beg, end);
entry.val = Which.BOTH;
cur = getAfter(entry.key);
advance();
return entry;
}
if (lc && !rc) {
Address beg = getStart(lit.peek());
Address end = first(getEnd(lit.peek()), getBefore(rit.peek()));
Address end = first(getEnd(lit.peek()), getBefore(rit.peek(), beg.getAddressSpace()));
entry.key = truncateRange(beg, end);
entry.val = Which.LEFT;
cur = getAfter(entry.key);
advance();
return entry;
}
if (!lc && rc) {
Address beg = getStart(rit.peek());
Address end = first(getEnd(rit.peek()), getBefore(lit.peek()));
Address end = first(getEnd(rit.peek()), getBefore(lit.peek(), beg.getAddressSpace()));
entry.key = truncateRange(beg, end);
entry.val = Which.RIGHT;
cur = getAfter(entry.key);
advance();
return entry;
}
throw new AssertionError();

75
Ghidra/Debug/ProposedUtils/src/test/java/ghidra/util/TwoWayBreakdownAddressRangeIteratorTest.java
View file

@ -44,10 +44,18 @@ public class TwoWayBreakdownAddressRangeIteratorTest extends AbstractGhidraHeadl
return toy.getAddressFactory().getDefaultAddressSpace().getAddress(offset);
}
protected Address dAddr(long offset) {
return toy.getAddressFactory().getAddressSpace("data").getAddress(offset);
}
protected AddressRange rng(long min, long max) {
return new AddressRangeImpl(addr(min), addr(max));
}
protected AddressRange dRng(long min, long max) {
return new AddressRangeImpl(dAddr(min), dAddr(max));
}
protected AddressSet set(AddressRange... ranges) {
AddressSet set = new AddressSet();
for (AddressRange rng : ranges) {
@ -57,7 +65,11 @@ public class TwoWayBreakdownAddressRangeIteratorTest extends AbstractGhidraHeadl
}
protected Pair<AddressRange, Which> pair(long min, long max, Which which) {
return new ImmutablePair<>(rng(min, max), which);
return Pair.of(rng(min, max), which);
}
protected Pair<AddressRange, Which> dPair(long min, long max, Which which) {
return Pair.of(dRng(min, max), which);
}
/**
@ -77,8 +89,8 @@ public class TwoWayBreakdownAddressRangeIteratorTest extends AbstractGhidraHeadl
@Before
public void setUpIteratorTest() throws LanguageNotFoundException {
toy = DefaultLanguageService.getLanguageService().getLanguage(
new LanguageID("Toy:BE:64:default"));
toy = DefaultLanguageService.getLanguageService()
.getLanguage(new LanguageID("Toy:BE:64:harvard"));
}
@Test
@ -281,6 +293,56 @@ public class TwoWayBreakdownAddressRangeIteratorTest extends AbstractGhidraHeadl
assertEquals(expected, actual);
}
@Test
public void testAcrossSpaces() {
AddressSet a = set(rng(0x1000, 0x2000));
AddressSet b = set(dRng(0x1000, 0x2000));
List<Entry<AddressRange, Which>> expected;
List<Entry<AddressRange, Which>> actual;
expected = List.of(pair(0x1000, 0x2000, Which.LEFT), dPair(0x1000, 0x2000, Which.RIGHT));
actual = toList(makeIterator(a, b, true));
assertEquals(expected, actual);
expected = List.of(pair(0x1000, 0x2000, Which.RIGHT), dPair(0x1000, 0x2000, Which.LEFT));
actual = toList(makeIterator(b, a, true));
assertEquals(expected, actual);
expected = List.of(dPair(0x1000, 0x2000, Which.RIGHT), pair(0x1000, 0x2000, Which.LEFT));
actual = toList(makeIterator(a, b, false));
assertEquals(expected, actual);
expected = List.of(dPair(0x1000, 0x2000, Which.LEFT), pair(0x1000, 0x2000, Which.RIGHT));
actual = toList(makeIterator(b, a, false));
assertEquals(expected, actual);
}
@Test
public void testAcrossSpacesExtremes() {
AddressSet a = set(rng(0x1000, -1L));
AddressSet b = set(dRng(0x0, 0xfff));
List<Entry<AddressRange, Which>> expected;
List<Entry<AddressRange, Which>> actual;
expected = List.of(pair(0x1000, -1L, Which.LEFT), dPair(0x0, 0xfff, Which.RIGHT));
actual = toList(makeIterator(a, b, true));
assertEquals(expected, actual);
expected = List.of(pair(0x1000, -1L, Which.RIGHT), dPair(0x0, 0xfff, Which.LEFT));
actual = toList(makeIterator(b, a, true));
assertEquals(expected, actual);
expected = List.of(dPair(0x0, 0xfff, Which.RIGHT), pair(0x1000, -1L, Which.LEFT));
actual = toList(makeIterator(a, b, false));
assertEquals(expected, actual);
expected = List.of(dPair(0x0, 0xfff, Which.LEFT), pair(0x1000, -1L, Which.RIGHT));
actual = toList(makeIterator(b, a, false));
assertEquals(expected, actual);
}
@Test
public void testRandom() {
AddressSet a = randomSet();
@ -298,7 +360,12 @@ public class TwoWayBreakdownAddressRangeIteratorTest extends AbstractGhidraHeadl
for (int i = 0; i < 20; i++) {
int len = r.nextInt(0x7ff) + 1;
int off = r.nextInt(0x10000 - len);
result.add(rng(off, off + len - 1));
if (r.nextBoolean()) {
result.add(rng(off, off + len - 1));
}
else {
result.add(dRng(off, off + len - 1));
}
}
return result;
}