mirror of
https://github.com/NationalSecurityAgency/ghidra.git
synced 2025-10-05 10:49:34 +02:00
Merge branch 'ghidra1_ByteMappedBlocks'
This commit is contained in:
ghidra1
commit
2885f74867
76 changed files with 2351 additions and 1618 deletions
|
|
@ -1,194 +0,0 @@
|
|||
/* ###
|
||||
* IP: GHIDRA
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package ghidra.program.database.mem;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
import java.util.Iterator;
|
||||
import java.util.Set;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import generic.test.AbstractGenericTest;
|
||||
import ghidra.program.model.address.*;
|
||||
import ghidra.program.model.mem.MemoryBlock;
|
||||
import ghidra.program.model.mem.MemoryBlockStub;
|
||||
|
||||
public class ByteSourceRangeListTest extends AbstractGenericTest {
|
||||
private AddressSpace space = new GenericAddressSpace("test", 64, AddressSpace.TYPE_RAM, 0);
|
||||
private MemoryBlock block = new MemoryBlockStub();
|
||||
|
||||
@Test
|
||||
public void testConstructor() {
|
||||
ByteSourceRange range1 = new ByteSourceRange(block, addr(0), 0x10, 1, 0x50);
|
||||
|
||||
ByteSourceRangeList list1 = new ByteSourceRangeList(range1);
|
||||
ByteSourceRangeList list2 = new ByteSourceRangeList();
|
||||
list2.add(range1);
|
||||
|
||||
assertTrue(list1.equals(list2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAdd() {
|
||||
ByteSourceRange range1 = new ByteSourceRange(block, addr(0), 0x10, 1, 0x50);
|
||||
ByteSourceRange range2 = new ByteSourceRange(block, addr(0x100), 0x10, 2, 0x50);
|
||||
ByteSourceRangeList list1 = new ByteSourceRangeList(range1);
|
||||
ByteSourceRangeList list2 = new ByteSourceRangeList(range2);
|
||||
list1.add(list2);
|
||||
assertEquals(2, list1.getRangeCount());
|
||||
assertEquals(range1, list1.get(0));
|
||||
assertEquals(range2, list1.get(1));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIsEmpty() {
|
||||
ByteSourceRange range1 = new ByteSourceRange(block, addr(0), 0x10, 1, 0x50);
|
||||
ByteSourceRangeList list1 = new ByteSourceRangeList();
|
||||
|
||||
assertTrue(list1.isEmpty());
|
||||
list1.add(range1);
|
||||
assertFalse(list1.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testAddNullRange() {
|
||||
ByteSourceRange range = null;
|
||||
ByteSourceRangeList list1 = new ByteSourceRangeList();
|
||||
list1.add(range);
|
||||
assertTrue(list1.isEmpty());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIterator() {
|
||||
ByteSourceRange range1 = new ByteSourceRange(block, addr(0), 0x10, 1, 0x50);
|
||||
ByteSourceRange range2 = new ByteSourceRange(block, addr(0x100), 0x10, 2, 0x50);
|
||||
ByteSourceRangeList list1 = new ByteSourceRangeList(range1);
|
||||
list1.add(range2);
|
||||
|
||||
Iterator<ByteSourceRange> it = list1.iterator();
|
||||
|
||||
assertTrue(it.hasNext());
|
||||
assertEquals(range1, it.next());
|
||||
assertTrue(it.hasNext());
|
||||
assertEquals(range2, it.next());
|
||||
assertFalse(it.hasNext());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIntersectSimple() {
|
||||
ByteSourceRangeList list1 = new ByteSourceRangeList();
|
||||
list1.add(new ByteSourceRange(block, addr(0), 0x100, 1, 0));
|
||||
|
||||
ByteSourceRangeList list2 = new ByteSourceRangeList();
|
||||
list2.add(new ByteSourceRange(block, addr(0x100), 0x100, 1, 0x10));
|
||||
|
||||
// note that list1.intersect(list2) is not equal to list2.intersect(list1).
|
||||
// The byte sources are the same but the corresponding real addresses are calling
|
||||
// objects byte sources.
|
||||
|
||||
ByteSourceRangeList result = list1.intersect(list2);
|
||||
assertEquals(1, result.getRangeCount());
|
||||
ByteSourceRange range = result.get(0);
|
||||
|
||||
assertEquals(0xf0, range.getSize());
|
||||
assertEquals(0x10, range.getOffset());
|
||||
assertEquals(block, range.getMemoryBlock());
|
||||
assertEquals(1, range.getSourceId());
|
||||
assertEquals(addr(0x10), range.getStart());
|
||||
assertEquals(addr(0xff), range.getEnd());
|
||||
|
||||
// now intersect from list2 perspective
|
||||
result = list2.intersect(list1);
|
||||
assertEquals(1, result.getRangeCount());
|
||||
range = result.get(0);
|
||||
|
||||
assertEquals(0xf0, range.getSize());
|
||||
assertEquals(0x10, range.getOffset());
|
||||
assertEquals(block, range.getMemoryBlock());
|
||||
assertEquals(1, range.getSourceId());
|
||||
|
||||
assertEquals(addr(0x100), range.getStart());
|
||||
assertEquals(addr(0x1ef), range.getEnd());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetOverlappingBlocks() {
|
||||
ByteSourceRange range = new ByteSourceRange(block, addr(0), 0x100, 1, 0x00);
|
||||
MemoryBlock block1 = new MemoryBlockStub();
|
||||
ByteSourceRange range1 = new ByteSourceRange(block1, addr(0x100), 0x100, 2, 0x00);
|
||||
|
||||
// create a byte source overlap with the first block
|
||||
MemoryBlock block2 = new MemoryBlockStub();
|
||||
ByteSourceRange range2 = new ByteSourceRange(block2, addr(0x200), 0x100, 1, 0x50);
|
||||
|
||||
ByteSourceRangeList list = new ByteSourceRangeList();
|
||||
list.add(range);
|
||||
list.add(range1);
|
||||
list.add(range2);
|
||||
|
||||
Set<MemoryBlock> overlappingBlocks = list.getOverlappingBlocks();
|
||||
assertEquals(2, overlappingBlocks.size());
|
||||
assertTrue(overlappingBlocks.contains(block));
|
||||
assertTrue(overlappingBlocks.contains(block2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetOverlappingBlocksBlocksWhereBlocksAreAdjacentButDontOverlap() {
|
||||
ByteSourceRange range = new ByteSourceRange(block, addr(0), 0x100, 1, 0x00);
|
||||
MemoryBlock block1 = new MemoryBlockStub();
|
||||
ByteSourceRange range1 = new ByteSourceRange(block1, addr(0x100), 0x100, 2, 0x00);
|
||||
|
||||
// create a byte source overlap with the first block
|
||||
MemoryBlock block2 = new MemoryBlockStub();
|
||||
ByteSourceRange range2 = new ByteSourceRange(block2, addr(0x200), 0x100, 1, 0x100);
|
||||
|
||||
ByteSourceRangeList list = new ByteSourceRangeList();
|
||||
list.add(range);
|
||||
list.add(range1);
|
||||
list.add(range2);
|
||||
|
||||
Set<MemoryBlock> overlappingBlocks = list.getOverlappingBlocks();
|
||||
assertEquals(0, overlappingBlocks.size());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetOverlappingBlocksBlocksWhereBlocksOverlapByExactlyOneByte() {
|
||||
ByteSourceRange range = new ByteSourceRange(block, addr(0), 0x100, 1, 0x00);
|
||||
MemoryBlock block1 = new MemoryBlockStub();
|
||||
ByteSourceRange range1 = new ByteSourceRange(block1, addr(0x100), 0x100, 2, 0x00);
|
||||
|
||||
// create a byte source overlap with the first block
|
||||
MemoryBlock block2 = new MemoryBlockStub();
|
||||
ByteSourceRange range2 = new ByteSourceRange(block2, addr(0x200), 0x100, 1, 0xff);
|
||||
|
||||
ByteSourceRangeList list = new ByteSourceRangeList();
|
||||
list.add(range);
|
||||
list.add(range1);
|
||||
list.add(range2);
|
||||
|
||||
Set<MemoryBlock> overlappingBlocks = list.getOverlappingBlocks();
|
||||
assertEquals(2, overlappingBlocks.size());
|
||||
assertTrue(overlappingBlocks.contains(block));
|
||||
assertTrue(overlappingBlocks.contains(block2));
|
||||
}
|
||||
|
||||
private Address addr(long value) {
|
||||
return space.getAddress(value);
|
||||
}
|
||||
|
||||
}
|
||||
|
|
@ -1,119 +0,0 @@
|
|||
/* ###
|
||||
* IP: GHIDRA
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
package ghidra.program.database.mem;
|
||||
|
||||
import static org.junit.Assert.*;
|
||||
|
||||
import org.junit.Test;
|
||||
|
||||
import generic.test.AbstractGenericTest;
|
||||
import ghidra.program.model.address.*;
|
||||
import ghidra.program.model.mem.MemoryBlock;
|
||||
import ghidra.program.model.mem.MemoryBlockStub;
|
||||
|
||||
public class ByteSourceRangeTest extends AbstractGenericTest {
|
||||
private AddressSpace space = new GenericAddressSpace("test", 64, AddressSpace.TYPE_RAM, 0);
|
||||
private MemoryBlock block = new MemoryBlockStub();
|
||||
@Test
|
||||
public void testIntersectNotSameSource() {
|
||||
ByteSourceRange range1 = new ByteSourceRange(block, addr(0), 0x10, 1, 0x50);
|
||||
ByteSourceRange range2 = new ByteSourceRange(block, addr(0x100), 0x10, 2, 0x50);
|
||||
assertNull(range1.intersect(range2));
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIntersectOneRangeSimpleOverlap() {
|
||||
ByteSourceRange range1 = new ByteSourceRange(block, addr(0), 0x20, 1, 0x50);
|
||||
ByteSourceRange range2 = new ByteSourceRange(block, addr(0x100), 0x20, 1, 0x60);
|
||||
|
||||
ByteSourceRange intersect = range1.intersect(range2);
|
||||
assertNotNull(intersect);
|
||||
assertEquals(addr(0x10), intersect.getStart());
|
||||
assertEquals(addr(0x1f), intersect.getEnd());
|
||||
assertEquals(0x10, intersect.getSize());
|
||||
assertEquals(1, intersect.getSourceId());
|
||||
assertEquals(0x60, intersect.getOffset());
|
||||
|
||||
intersect = range2.intersect(range1);
|
||||
assertNotNull(intersect);
|
||||
assertEquals(addr(0x100), intersect.getStart());
|
||||
assertEquals(addr(0x10f), intersect.getEnd());
|
||||
assertEquals(0x10, intersect.getSize());
|
||||
assertEquals(1, intersect.getSourceId());
|
||||
assertEquals(0x60, intersect.getOffset());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testIntersectOneRangeButsAgainsAnother() {
|
||||
ByteSourceRange range1 = new ByteSourceRange(block, addr(0), 0x20, 1, 0x50);
|
||||
ByteSourceRange range2 = new ByteSourceRange(block, addr(0x100), 0x20, 2, 0x70);
|
||||
|
||||
assertNull(range1.intersect(range2));
|
||||
assertNull(range2.intersect(range1));
|
||||
}
|
||||
|
||||
|
||||
@Test
|
||||
public void testIntersectOneRangeCompletelyInAnother() {
|
||||
ByteSourceRange range1 = new ByteSourceRange(block, addr(0), 0x10, 1, 0x50);
|
||||
ByteSourceRange range2 = new ByteSourceRange(block, addr(0x100), 0x30, 1, 0x40);
|
||||
|
||||
ByteSourceRange intersect = range1.intersect(range2);
|
||||
assertNotNull(intersect);
|
||||
assertEquals(addr(0), intersect.getStart());
|
||||
assertEquals(addr(0xf), intersect.getEnd());
|
||||
assertEquals(0x10, intersect.getSize());
|
||||
assertEquals(1, intersect.getSourceId());
|
||||
assertEquals(0x50, intersect.getOffset());
|
||||
|
||||
intersect = range2.intersect(range1);
|
||||
assertNotNull(intersect);
|
||||
assertEquals(addr(0x110), intersect.getStart());
|
||||
assertEquals(addr(0x11f), intersect.getEnd());
|
||||
assertEquals(0x10, intersect.getSize());
|
||||
assertEquals(1, intersect.getSourceId());
|
||||
assertEquals(0x50, intersect.getOffset());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testBitMappedIntersect() {
|
||||
ByteSourceRange range1 = new ByteSourceRange(block, addr(0), 0x10, 1, 0x50);
|
||||
ByteSourceRange range2 = new BitMappedByteSourceRange(block, addr(0x100), 1, 0x55, 2);
|
||||
|
||||
ByteSourceRange intersect = range1.intersect(range2);
|
||||
assertNotNull(intersect);
|
||||
assertEquals(addr(5), intersect.getStart());
|
||||
assertEquals(addr(6), intersect.getEnd());
|
||||
assertEquals(2, intersect.getSize());
|
||||
assertEquals(1, intersect.getSourceId());
|
||||
assertEquals(0x55, intersect.getOffset());
|
||||
|
||||
intersect = range2.intersect(range1);
|
||||
assertNotNull(intersect);
|
||||
assertEquals(addr(0x100), intersect.getStart());
|
||||
assertEquals(addr(0x10f), intersect.getEnd());
|
||||
assertEquals(2, intersect.getSize());
|
||||
assertEquals(1, intersect.getSourceId());
|
||||
assertEquals(0x55, intersect.getOffset());
|
||||
|
||||
}
|
||||
|
||||
private Address addr(long value) {
|
||||
return space.getAddress(value);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -142,7 +142,8 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
assertEquals(0, block.getStart().getOffset());
|
||||
assertEquals(9, block.getEnd().getOffset());
|
||||
assertTrue(block.getStart().getAddressSpace().isOverlaySpace());
|
||||
assertEquals(MemoryBlockType.OVERLAY, block.getType());
|
||||
assertEquals(MemoryBlockType.DEFAULT, block.getType());
|
||||
assertTrue(block.isOverlay());
|
||||
List<MemoryBlockSourceInfo> sourceInfos = block.getSourceInfos();
|
||||
assertEquals(1, sourceInfos.size());
|
||||
MemoryBlockSourceInfo info = sourceInfos.get(0);
|
||||
|
|
@ -167,7 +168,8 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
assertEquals(0, block.getStart().getOffset());
|
||||
assertEquals(9, block.getEnd().getOffset());
|
||||
assertTrue(block.getStart().getAddressSpace().isOverlaySpace());
|
||||
assertEquals(MemoryBlockType.OVERLAY, block.getType());
|
||||
assertEquals(MemoryBlockType.DEFAULT, block.getType());
|
||||
assertTrue(block.isOverlay());
|
||||
List<MemoryBlockSourceInfo> sourceInfos = block.getSourceInfos();
|
||||
assertEquals(1, sourceInfos.size());
|
||||
MemoryBlockSourceInfo info = sourceInfos.get(0);
|
||||
|
|
@ -181,7 +183,7 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testCreateByteMappedBlock() throws Exception {
|
||||
mem.createInitializedBlock("test1", addr(0), 50, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
mem.createUninitializedBlock("test2", addr(50), 50, false);
|
||||
MemoryBlock block = mem.createByteMappedBlock("mapped", addr(1000), addr(40), 20);
|
||||
MemoryBlock block = mem.createByteMappedBlock("mapped", addr(1000), addr(40), 20, false);
|
||||
|
||||
assertEquals(20, block.getSize());
|
||||
assertEquals("mapped", block.getName());
|
||||
|
|
@ -217,7 +219,7 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testCreateBitMappedBlock() throws Exception {
|
||||
mem.createInitializedBlock("test1", addr(0), 50, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
mem.createUninitializedBlock("test2", addr(50), 50, false);
|
||||
MemoryBlock block = mem.createBitMappedBlock("mapped", addr(1000), addr(49), 16);
|
||||
MemoryBlock block = mem.createBitMappedBlock("mapped", addr(1000), addr(49), 16, false);
|
||||
|
||||
assertEquals(16, block.getSize());
|
||||
assertEquals("mapped", block.getName());
|
||||
|
|
@ -570,7 +572,8 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testByteMappedGetPutByte() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
MemoryBlock block1 = createFileBytesBlock(fileBytes, addr(0), 0, 10);
|
||||
MemoryBlock mappedBlock = mem.createByteMappedBlock("mapped", addr(100), addr(0), 20);
|
||||
MemoryBlock mappedBlock =
|
||||
mem.createByteMappedBlock("mapped", addr(100), addr(0), 20, false);
|
||||
assertEquals(5, mappedBlock.getByte(addr(105)));
|
||||
assertEquals(5, block1.getByte(addr(5)));
|
||||
mappedBlock.putByte(addr(105), (byte) 87);
|
||||
|
|
@ -581,7 +584,8 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testByteMappedGetPutBytes() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
MemoryBlock block1 = createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
MemoryBlock mappedBlock = mem.createByteMappedBlock("mapped", addr(100), addr(0), 20);
|
||||
MemoryBlock mappedBlock =
|
||||
mem.createByteMappedBlock("mapped", addr(100), addr(0), 20, false);
|
||||
byte[] bytes = new byte[10];
|
||||
mappedBlock.getBytes(addr(100), bytes);
|
||||
checkBytes(bytes, 0);
|
||||
|
|
@ -595,8 +599,10 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testByteMappedJoin() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
MemoryBlock mappedBlock1 = mem.createByteMappedBlock("mapped1", addr(100), addr(0), 10);
|
||||
MemoryBlock mappedBlock2 = mem.createByteMappedBlock("mapped2", addr(110), addr(10), 10);
|
||||
MemoryBlock mappedBlock1 =
|
||||
mem.createByteMappedBlock("mapped1", addr(100), addr(0), 10, false);
|
||||
MemoryBlock mappedBlock2 =
|
||||
mem.createByteMappedBlock("mapped2", addr(110), addr(10), 10, false);
|
||||
try {
|
||||
mem.join(mappedBlock1, mappedBlock2);
|
||||
fail("Expected exception when joining byte mapped blocks");
|
||||
|
|
@ -610,7 +616,8 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testByteMappedSplit() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
MemoryBlock mappedBlock1 = mem.createByteMappedBlock("mapped1", addr(100), addr(0), 20);
|
||||
MemoryBlock mappedBlock1 =
|
||||
mem.createByteMappedBlock("mapped1", addr(100), addr(0), 20, false);
|
||||
mem.split(mappedBlock1, addr(110));
|
||||
MemoryBlock[] blocks = mem.getBlocks();
|
||||
assertEquals(3, blocks.length);
|
||||
|
|
@ -621,7 +628,8 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testBitMappedGetPutByte() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
MemoryBlock block = createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
MemoryBlock mappedBlock = mem.createBitMappedBlock("mapped1", addr(100), addr(0), 20);
|
||||
MemoryBlock mappedBlock =
|
||||
mem.createBitMappedBlock("mapped1", addr(100), addr(0), 20, false);
|
||||
|
||||
assertEquals(0, mappedBlock.getByte(addr(100)));
|
||||
assertEquals(0, mappedBlock.getByte(addr(101)));
|
||||
|
|
@ -637,7 +645,8 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testBitMappedGetPutBytes() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
MemoryBlock block = createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
MemoryBlock mappedBlock = mem.createBitMappedBlock("mapped1", addr(100), addr(0), 50);
|
||||
MemoryBlock mappedBlock =
|
||||
mem.createBitMappedBlock("mapped1", addr(100), addr(0), 50, false);
|
||||
|
||||
byte[] bytes = new byte[8];
|
||||
|
||||
|
|
@ -668,8 +677,10 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testBitMappedJoin() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
MemoryBlock mappedBlock1 = mem.createBitMappedBlock("mapped1", addr(100), addr(0), 16);
|
||||
MemoryBlock mappedBlock2 = mem.createBitMappedBlock("mapped2", addr(116), addr(2), 16);
|
||||
MemoryBlock mappedBlock1 =
|
||||
mem.createBitMappedBlock("mapped1", addr(100), addr(0), 16, false);
|
||||
MemoryBlock mappedBlock2 =
|
||||
mem.createBitMappedBlock("mapped2", addr(116), addr(2), 16, false);
|
||||
try {
|
||||
mem.join(mappedBlock1, mappedBlock2);
|
||||
fail("Expected exception when joining bit mapped blocks");
|
||||
|
|
@ -683,7 +694,8 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testBitMappedSplit() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
MemoryBlock mappedBlock1 = mem.createBitMappedBlock("mapped1", addr(100), addr(0), 16);
|
||||
MemoryBlock mappedBlock1 =
|
||||
mem.createBitMappedBlock("mapped1", addr(100), addr(0), 16, false);
|
||||
try {
|
||||
mem.split(mappedBlock1, addr(108));
|
||||
fail("Expected exception when joining bit mapped blocks");
|
||||
|
|
@ -693,200 +705,229 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
}
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetByteSourceSetForFileBytesBlock() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
MemoryBlockDB block = (MemoryBlockDB) createFileBytesBlock(fileBytes, addr(0), 10, 50);
|
||||
// @Test
|
||||
// public void testGetByteSourceSetForFileBytesBlock() throws Exception {
|
||||
// FileBytes fileBytes = createFileBytes();
|
||||
// MemoryBlockDB block = (MemoryBlockDB) createFileBytesBlock(fileBytes, addr(0), 10, 50);
|
||||
//
|
||||
// ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(5), 10);
|
||||
//
|
||||
// // we expect to get a single range ByteSourceSet pointing into the filebytes at offset
|
||||
// // 15 (10 because block was created at filebytes:10 and 5 because we start at the 5th byte
|
||||
// // in the block)
|
||||
//
|
||||
// assertEquals(1, ranges.getRangeCount());
|
||||
// assertEquals(10, ranges.get(0).getSize());
|
||||
// assertEquals(5, ranges.get(0).getStart().getOffset());
|
||||
// assertEquals(14, ranges.get(0).getEnd().getOffset());
|
||||
// assertEquals(fileBytes.getId(), ranges.get(0).getSourceId());
|
||||
// assertEquals(15, ranges.get(0).getOffset());
|
||||
// }
|
||||
|
||||
ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(5), 10);
|
||||
|
||||
// we expect to get a single range ByteSourceSet pointing into the filebytes at offset
|
||||
// 15 (10 because block was created at filebytes:10 and 5 because we start at the 5th byte
|
||||
// in the block)
|
||||
|
||||
assertEquals(1, ranges.getRangeCount());
|
||||
assertEquals(10, ranges.get(0).getSize());
|
||||
assertEquals(5, ranges.get(0).getStart().getOffset());
|
||||
assertEquals(14, ranges.get(0).getEnd().getOffset());
|
||||
assertEquals(fileBytes.getId(), ranges.get(0).getSourceId());
|
||||
assertEquals(15, ranges.get(0).getOffset());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetByteSourceSetForBufferBlock() throws Exception {
|
||||
MemoryBlockDB block = (MemoryBlockDB) mem.createInitializedBlock("test", addr(0), 30,
|
||||
(byte) 1, TaskMonitor.DUMMY, false);
|
||||
|
||||
ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(10), 10);
|
||||
|
||||
// We expect to get to ranges because we made the buffer size small (16) so when we
|
||||
// created a 30 size block, it had to make two separate sub blocks each with its own
|
||||
// DBBuffer. The first range should contain the first 6 bytes of the requested range
|
||||
// and the second buffer should contain the last 4 bytes of request range.
|
||||
|
||||
assertEquals(2, ranges.getRangeCount()); // we have two sublocks so two distinct ranges
|
||||
assertEquals(10, ranges.get(0).getSize() + ranges.get(1).getSize());
|
||||
|
||||
ByteSourceRange range = ranges.get(0);
|
||||
assertEquals(10, range.getStart().getOffset());
|
||||
assertEquals(15, range.getEnd().getOffset());
|
||||
assertEquals(6, range.getSize());
|
||||
assertEquals(10, range.getOffset());
|
||||
|
||||
range = ranges.get(1);
|
||||
assertEquals(16, range.getStart().getOffset());
|
||||
assertEquals(19, range.getEnd().getOffset());
|
||||
assertEquals(4, range.getSize());
|
||||
assertEquals(0, range.getOffset());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetByteSourceForUndefinedBlock() throws Exception {
|
||||
MemoryBlockDB block =
|
||||
(MemoryBlockDB) mem.createUninitializedBlock("test", addr(0), 30, false);
|
||||
ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(10), 10);
|
||||
// undefined blocks have no source bytes
|
||||
assertTrue(ranges.isEmpty());
|
||||
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetByteSourceForByteMappedBlock() throws Exception {
|
||||
mem.createInitializedBlock("test1", addr(0), 15, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
mem.createUninitializedBlock("test2", addr(15), 20, false);
|
||||
mem.createInitializedBlock("test3", addr(35), 15, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
MemoryBlockDB block =
|
||||
(MemoryBlockDB) mem.createByteMappedBlock("mapped", addr(1000), addr(5), 40);
|
||||
|
||||
ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(1005), 30);
|
||||
|
||||
// Uninitialized blocks don't contribute, so we should have 10 address (5 from first and last blocks each).
|
||||
assertEquals(2, ranges.getRangeCount());
|
||||
assertEquals(10, ranges.get(0).getSize() + ranges.get(1).getSize());
|
||||
|
||||
ByteSourceRange range = ranges.get(0);
|
||||
assertEquals(addr(1005), range.getStart());
|
||||
assertEquals(addr(1009), range.getEnd());
|
||||
assertEquals(5, range.getSize());
|
||||
assertEquals(10, range.getOffset());
|
||||
|
||||
range = ranges.get(1);
|
||||
assertEquals(addr(1030), range.getStart());
|
||||
assertEquals(addr(1034), range.getEnd());
|
||||
assertEquals(5, range.getSize());
|
||||
assertEquals(0, range.getOffset());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetByteSourceForBitMappedBlock() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
|
||||
MemoryBlockDB block =
|
||||
(MemoryBlockDB) mem.createBitMappedBlock("mapped", addr(0x1000), addr(5), 0x14);
|
||||
|
||||
ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(0x1000), 0x14);
|
||||
|
||||
assertEquals(1, ranges.getRangeCount());
|
||||
assertEquals(3, ranges.get(0).getSize());
|
||||
|
||||
ByteSourceRange range = ranges.get(0);
|
||||
assertEquals(addr(0x1000), range.getStart());
|
||||
assertEquals(addr(0x1017), range.getEnd());
|
||||
assertEquals(3, range.getSize());
|
||||
assertEquals(5, range.getOffset());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetByteSourceForBitMappedBlockOffcutStart() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
|
||||
MemoryBlockDB block =
|
||||
(MemoryBlockDB) mem.createBitMappedBlock("mapped", addr(0x1000), addr(5), 0x14);
|
||||
|
||||
ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(0x1005), 8);
|
||||
|
||||
assertEquals(1, ranges.getRangeCount());
|
||||
assertEquals(2, ranges.get(0).getSize());
|
||||
|
||||
ByteSourceRange range = ranges.get(0);
|
||||
assertEquals(addr(0x1000), range.getStart());
|
||||
assertEquals(addr(0x100f), range.getEnd());
|
||||
assertEquals(2, range.getSize());
|
||||
assertEquals(5, range.getOffset());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetByteSourceForBitMappedBlockOffcutStartNotAtStart() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
|
||||
MemoryBlockDB block =
|
||||
(MemoryBlockDB) mem.createBitMappedBlock("mapped", addr(0x1000), addr(5), 0x44);
|
||||
|
||||
ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(0x1015), 8);
|
||||
|
||||
assertEquals(1, ranges.getRangeCount());
|
||||
assertEquals(2, ranges.get(0).getSize());
|
||||
|
||||
ByteSourceRange range = ranges.get(0);
|
||||
assertEquals(addr(0x1010), range.getStart());
|
||||
assertEquals(addr(0x101f), range.getEnd());
|
||||
assertEquals(2, range.getSize());
|
||||
assertEquals(7, range.getOffset());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetByteSourceForBitMappedBlock2() throws Exception {
|
||||
mem.createInitializedBlock("test1", addr(0), 4, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
mem.createUninitializedBlock("test2", addr(0x4), 4, false);
|
||||
mem.createInitializedBlock("test3", addr(0x8), 4, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
MemoryBlockDB block =
|
||||
(MemoryBlockDB) mem.createBitMappedBlock("mapped", addr(0x1000), addr(2), 0x40);
|
||||
|
||||
ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(0x1008), 0x30);
|
||||
|
||||
assertEquals(2, ranges.getRangeCount());
|
||||
|
||||
ByteSourceRange range = ranges.get(0);
|
||||
assertEquals(addr(0x1008), range.getStart());
|
||||
assertEquals(addr(0x100f), range.getEnd());
|
||||
assertEquals(1, range.getSize());
|
||||
assertEquals(3, range.getOffset());
|
||||
|
||||
range = ranges.get(1);
|
||||
assertEquals(addr(0x1030), range.getStart());
|
||||
assertEquals(addr(0x1037), range.getEnd());
|
||||
assertEquals(1, range.getSize());
|
||||
assertEquals(0, range.getOffset());
|
||||
}
|
||||
|
||||
@Test
|
||||
public void testGetByteSourceForBitMappedBlock2Offcut() throws Exception {
|
||||
mem.createInitializedBlock("test1", addr(0), 4, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
mem.createUninitializedBlock("test2", addr(0x4), 4, false);
|
||||
mem.createInitializedBlock("test3", addr(0x8), 4, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
MemoryBlockDB block =
|
||||
(MemoryBlockDB) mem.createBitMappedBlock("mapped", addr(0x1000), addr(2), 0x40);
|
||||
|
||||
ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(0x1006), 0x34);
|
||||
|
||||
assertEquals(2, ranges.getRangeCount());
|
||||
|
||||
ByteSourceRange range = ranges.get(0);
|
||||
assertEquals(addr(0x1000), range.getStart());
|
||||
assertEquals(addr(0x100f), range.getEnd());
|
||||
assertEquals(2, range.getSize());
|
||||
assertEquals(2, range.getOffset());
|
||||
|
||||
range = ranges.get(1);
|
||||
assertEquals(addr(0x1030), range.getStart());
|
||||
assertEquals(addr(0x103f), range.getEnd());
|
||||
assertEquals(2, range.getSize());
|
||||
assertEquals(0, range.getOffset());
|
||||
}
|
||||
// @Test
|
||||
// public void testGetByteSourceSetForBufferBlock() throws Exception {
|
||||
// MemoryBlockDB block = (MemoryBlockDB) mem.createInitializedBlock("test", addr(0), 30,
|
||||
// (byte) 1, TaskMonitor.DUMMY, false);
|
||||
//
|
||||
// ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(10), 10);
|
||||
//
|
||||
// // We expect to get to ranges because we made the buffer size small (16) so when we
|
||||
// // created a 30 size block, it had to make two separate sub blocks each with its own
|
||||
// // DBBuffer. The first range should contain the first 6 bytes of the requested range
|
||||
// // and the second buffer should contain the last 4 bytes of request range.
|
||||
//
|
||||
// assertEquals(2, ranges.getRangeCount()); // we have two sublocks so two distinct ranges
|
||||
// assertEquals(10, ranges.get(0).getSize() + ranges.get(1).getSize());
|
||||
//
|
||||
// ByteSourceRange range = ranges.get(0);
|
||||
// assertEquals(10, range.getStart().getOffset());
|
||||
// assertEquals(15, range.getEnd().getOffset());
|
||||
// assertEquals(6, range.getSize());
|
||||
// assertEquals(10, range.getOffset());
|
||||
//
|
||||
// range = ranges.get(1);
|
||||
// assertEquals(16, range.getStart().getOffset());
|
||||
// assertEquals(19, range.getEnd().getOffset());
|
||||
// assertEquals(4, range.getSize());
|
||||
// assertEquals(0, range.getOffset());
|
||||
//
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testGetByteSourceForUndefinedBlock() throws Exception {
|
||||
// MemoryBlockDB block =
|
||||
// (MemoryBlockDB) mem.createUninitializedBlock("test", addr(0), 30, false);
|
||||
// ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(10), 10);
|
||||
// // undefined blocks have no source bytes
|
||||
// assertTrue(ranges.isEmpty());
|
||||
//
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testGetByteSourceForByteMappedBlock() throws Exception {
|
||||
// mem.createInitializedBlock("test1", addr(0), 15, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
// mem.createUninitializedBlock("test2", addr(15), 20, false);
|
||||
// mem.createInitializedBlock("test3", addr(35), 15, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
// MemoryBlockDB block =
|
||||
// (MemoryBlockDB) mem.createByteMappedBlock("mapped", addr(1000), addr(5), 40, false);
|
||||
//
|
||||
// ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(1005), 30); // 5, 20, 5
|
||||
//
|
||||
// // Uninitialized blocks don't contribute, so we should have 10 address (5 from first and last blocks each).
|
||||
// assertEquals(2, ranges.getRangeCount());
|
||||
// assertEquals(10, ranges.get(0).getSize() + ranges.get(1).getSize());
|
||||
//
|
||||
// ByteSourceRange range = ranges.get(0);
|
||||
// assertEquals(addr(1005), range.getStart());
|
||||
// assertEquals(addr(1009), range.getEnd());
|
||||
// assertEquals(5, range.getSize());
|
||||
// assertEquals(10, range.getOffset());
|
||||
//
|
||||
// range = ranges.get(1);
|
||||
// assertEquals(addr(1030), range.getStart());
|
||||
// assertEquals(addr(1034), range.getEnd());
|
||||
// assertEquals(5, range.getSize());
|
||||
// assertEquals(0, range.getOffset());
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testGetByteSourceForByteMappedBlockWithScheme() throws Exception {
|
||||
// mem.createInitializedBlock("test1", addr(0), 15, (byte) 1, TaskMonitor.DUMMY, false); // mapped bytes: 5, 6, .. 9, 10, .. 13, (14
|
||||
// mem.createUninitializedBlock("test2", addr(15), 20, false); // mapped bytes: 17, 18, 21, 22, 25, 26, 29, 30, 33, 34
|
||||
// mem.createInitializedBlock("test3", addr(35), 15, (byte) 1, TaskMonitor.DUMMY, false); // mapped bytes: .. 37, 38, .. 41, 42), .. 45, 46, .. 49, 50 ...
|
||||
// MemoryBlockDB block = (MemoryBlockDB) mem.createByteMappedBlock("mapped", addr(1000),
|
||||
// addr(5), 40, new ByteMappingScheme(2, 4), false);
|
||||
//
|
||||
// // NOTE: source range includes skipped bytes within mapped range
|
||||
//
|
||||
// ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(1005), 15);
|
||||
//// FIXME XXX Expected something different than previous test !!
|
||||
// // Uninitialized blocks don't contribute, so we should have 16 address (1 from first and 4 from last block each, plus 4 skipped bytes in last block).
|
||||
//// assertEquals(2, ranges.getRangeCount());
|
||||
//// assertEquals(8, ranges.get(0).getSize() + ranges.get(1).getSize());
|
||||
//
|
||||
// ByteSourceRange range = ranges.get(0);
|
||||
// assertEquals(addr(1005), range.getStart());
|
||||
// assertEquals(addr(1005), range.getEnd());
|
||||
// assertEquals(1, range.getSize());
|
||||
// assertEquals(14, range.getOffset());
|
||||
//
|
||||
// range = ranges.get(1);
|
||||
// assertEquals(addr(1016), range.getStart());
|
||||
// assertEquals(addr(1019), range.getEnd());
|
||||
// assertEquals(5, range.getSize());
|
||||
// assertEquals(0, range.getOffset());
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testGetByteSourceForBitMappedBlock() throws Exception {
|
||||
// FileBytes fileBytes = createFileBytes();
|
||||
// createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
//
|
||||
// MemoryBlockDB block =
|
||||
// (MemoryBlockDB) mem.createBitMappedBlock("mapped", addr(0x1000), addr(5), 0x14, false);
|
||||
//
|
||||
// ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(0x1000), 0x14);
|
||||
//
|
||||
// assertEquals(1, ranges.getRangeCount());
|
||||
// assertEquals(3, ranges.get(0).getSize());
|
||||
//
|
||||
// ByteSourceRange range = ranges.get(0);
|
||||
// assertEquals(addr(0x1000), range.getStart());
|
||||
// assertEquals(addr(0x1017), range.getEnd());
|
||||
// assertEquals(3, range.getSize());
|
||||
// assertEquals(5, range.getOffset());
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testGetByteSourceForBitMappedBlockOffcutStart() throws Exception {
|
||||
// FileBytes fileBytes = createFileBytes();
|
||||
// createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
//
|
||||
// MemoryBlockDB block =
|
||||
// (MemoryBlockDB) mem.createBitMappedBlock("mapped", addr(0x1000), addr(5), 0x14, false);
|
||||
//
|
||||
// ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(0x1005), 8);
|
||||
//
|
||||
// assertEquals(1, ranges.getRangeCount());
|
||||
// assertEquals(2, ranges.get(0).getSize());
|
||||
//
|
||||
// ByteSourceRange range = ranges.get(0);
|
||||
// assertEquals(addr(0x1000), range.getStart());
|
||||
// assertEquals(addr(0x100f), range.getEnd());
|
||||
// assertEquals(2, range.getSize());
|
||||
// assertEquals(5, range.getOffset());
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testGetByteSourceForBitMappedBlockOffcutStartNotAtStart() throws Exception {
|
||||
// FileBytes fileBytes = createFileBytes();
|
||||
// createFileBytesBlock(fileBytes, addr(0), 0, 50);
|
||||
//
|
||||
// MemoryBlockDB block =
|
||||
// (MemoryBlockDB) mem.createBitMappedBlock("mapped", addr(0x1000), addr(5), 0x44, false);
|
||||
//
|
||||
// ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(0x1015), 8);
|
||||
//
|
||||
// assertEquals(1, ranges.getRangeCount());
|
||||
// assertEquals(2, ranges.get(0).getSize());
|
||||
//
|
||||
// ByteSourceRange range = ranges.get(0);
|
||||
// assertEquals(addr(0x1010), range.getStart());
|
||||
// assertEquals(addr(0x101f), range.getEnd());
|
||||
// assertEquals(2, range.getSize());
|
||||
// assertEquals(7, range.getOffset());
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testGetByteSourceForBitMappedBlock2() throws Exception {
|
||||
// mem.createInitializedBlock("test1", addr(0), 4, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
// mem.createUninitializedBlock("test2", addr(0x4), 4, false);
|
||||
// mem.createInitializedBlock("test3", addr(0x8), 4, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
// MemoryBlockDB block =
|
||||
// (MemoryBlockDB) mem.createBitMappedBlock("mapped", addr(0x1000), addr(2), 0x40, false);
|
||||
//
|
||||
// ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(0x1008), 0x30);
|
||||
//
|
||||
// assertEquals(2, ranges.getRangeCount());
|
||||
//
|
||||
// ByteSourceRange range = ranges.get(0);
|
||||
// assertEquals(addr(0x1008), range.getStart());
|
||||
// assertEquals(addr(0x100f), range.getEnd());
|
||||
// assertEquals(1, range.getSize());
|
||||
// assertEquals(3, range.getOffset());
|
||||
//
|
||||
// range = ranges.get(1);
|
||||
// assertEquals(addr(0x1030), range.getStart());
|
||||
// assertEquals(addr(0x1037), range.getEnd());
|
||||
// assertEquals(1, range.getSize());
|
||||
// assertEquals(0, range.getOffset());
|
||||
// }
|
||||
//
|
||||
// @Test
|
||||
// public void testGetByteSourceForBitMappedBlock2Offcut() throws Exception {
|
||||
// mem.createInitializedBlock("test1", addr(0), 4, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
// mem.createUninitializedBlock("test2", addr(0x4), 4, false);
|
||||
// mem.createInitializedBlock("test3", addr(0x8), 4, (byte) 1, TaskMonitor.DUMMY, false);
|
||||
// MemoryBlockDB block =
|
||||
// (MemoryBlockDB) mem.createBitMappedBlock("mapped", addr(0x1000), addr(2), 0x40, false);
|
||||
//
|
||||
// ByteSourceRangeList ranges = block.getByteSourceRangeList(addr(0x1006), 0x34);
|
||||
//
|
||||
// assertEquals(2, ranges.getRangeCount());
|
||||
//
|
||||
// ByteSourceRange range = ranges.get(0);
|
||||
// assertEquals(addr(0x1000), range.getStart());
|
||||
// assertEquals(addr(0x100f), range.getEnd());
|
||||
// assertEquals(2, range.getSize());
|
||||
// assertEquals(2, range.getOffset());
|
||||
//
|
||||
// range = ranges.get(1);
|
||||
// assertEquals(addr(0x1030), range.getStart());
|
||||
// assertEquals(addr(0x103f), range.getEnd());
|
||||
// assertEquals(2, range.getSize());
|
||||
// assertEquals(0, range.getOffset());
|
||||
// }
|
||||
|
||||
@Test
|
||||
public void testAddressSourceInfoForFileBytesBlock() throws Exception {
|
||||
|
|
@ -934,7 +975,7 @@ public class MemBlockDBTest extends AbstractGenericTest {
|
|||
public void testAddressSourceInfoForMappedBlock() throws Exception {
|
||||
FileBytes fileBytes = createFileBytes();
|
||||
mem.createInitializedBlock("block", addr(0), fileBytes, 10, 50, false);
|
||||
mem.createByteMappedBlock("mapped", addr(1000), addr(0), 20);
|
||||
mem.createByteMappedBlock("mapped", addr(1000), addr(0), 20, false);
|
||||
|
||||
AddressSourceInfo info = mem.getAddressSourceInfo(addr(1000));
|
||||
assertEquals(addr(1000), info.getAddress());
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue