Java Code Examples for ghidra.program.model.mem.Memory#createInitializedBlock()

@Before
public void setUp() throws Exception {
	TestEnv env = new TestEnv();
	LanguageService ls = DefaultLanguageService.getLanguageService();
	Language i8051 = ls.getDefaultLanguage(TestProcessorConstants.PROCESSOR_8051);
	program = new ProgramDB("Test", i8051, i8051.getDefaultCompilerSpec(), this);
	env.dispose();
	space = program.getAddressFactory().getDefaultAddressSpace();
	Memory memory = program.getMemory();
	transactionID = program.startTransaction("Test");
	memory.createInitializedBlock("test", addr(0), 5000, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);
	symbolTable = program.getSymbolTable();
	refMgr = program.getReferenceManager();
	listing = program.getListing();
}
 

public void addMemory(String name, String address, int size) {
	startTransactions();
	try {
		for (Program p : programs) {
			Address startAddress = addr(p, address);
			Memory memory = p.getMemory();

			try {
				memory.createInitializedBlock(name, startAddress, size, (byte) 0,
					TaskMonitorAdapter.DUMMY_MONITOR, false);
			}
			catch (Exception e) {
				throw new RuntimeException("Exception building memory", e);
			}
		}
	}
	finally {
		endTransations();
	}
}
 

@Test
   public void testDeleteBlockRange() throws Exception {
	Memory memory = program.getMemory();
	MemoryBlock block = memory.createInitializedBlock(".test", getAddr(5), 0x20, (byte) 0xa,
		TaskMonitorAdapter.DUMMY_MONITOR, false);

	AddressSet set = new AddressSet();
	set.addRange(getAddr(0), getAddr(0x10));
	set.addRange(getAddr(0x20), getAddr(0x25));
	set.addRange(getAddr(0x26), getAddr(0x30));
	IntRangeMap map = program.createIntRangeMap("MyMap");
	int value = 0x11223344;
	map.setValue(set, value);
	// remove the block
	memory.removeBlock(block, TaskMonitorAdapter.DUMMY_MONITOR);

	// [0,4], [25,30] should still exist
	// [5,24] should have been removed
	AddressSet s = new AddressSet();
	s.addRange(getAddr(0), getAddr(0x4));
	s.addRange(getAddr(0x25), getAddr(0x30));
	AddressSet mapSet = map.getAddressSet();
	assertEquals(s, mapSet);
}
 

private void open8051Program() throws Exception {

		program = createDefaultProgram("Test", ProgramBuilder._8051, this);
		Memory memory = program.getMemory();

		AddressFactory af = program.getAddressFactory();
		AddressSpace codeSpace = af.getAddressSpace("CODE");
		AddressSpace extmemSpace = af.getAddressSpace("EXTMEM");

		int transactionID = program.startTransaction("Test");
		try {
			memory.createInitializedBlock("EEPROM", extmemSpace.getAddress(0), 0x100, (byte) 0,
				TaskMonitorAdapter.DUMMY_MONITOR, false);
			memory.createInitializedBlock("CODE", codeSpace.getAddress(0), 0x100, (byte) 0,
				TaskMonitorAdapter.DUMMY_MONITOR, false);
		}
		finally {
			program.endTransaction(transactionID, true);
		}

		env.showTool(program);
		waitForSwing();
	}
 

@Test
   public void testDeleteBlockRange() throws Exception {
	Memory memory = program.getMemory();
	MemoryBlock block = memory.createInitializedBlock(".test", getAddr(5), 0x20, (byte) 0xa,
		TaskMonitorAdapter.DUMMY_MONITOR, false);

	AddressSet set = new AddressSet();
	set.addRange(getAddr(0), getAddr(0x10));
	set.addRange(getAddr(0x20), getAddr(0x25));
	set.addRange(getAddr(0x26), getAddr(0x30));
	AddressSetPropertyMap pm = program.createAddressSetPropertyMap("MyMap");
	pm.add(set);
	// remove the block
	memory.removeBlock(block, TaskMonitorAdapter.DUMMY_MONITOR);

	// [0,4], [25,30] should still exist
	// [5,24] should have been removed
	AddressSet s = new AddressSet();
	s.addRange(getAddr(0), getAddr(0x4));
	s.addRange(getAddr(0x25), getAddr(0x30));
	AddressSet pmSet = pm.getAddressSet();
	assertEquals(s, pmSet);
}
 

@Test
public void testGetDefaultFunctionInOverlaySymbolByName() throws Exception {
	Memory memory = program.getMemory();
	MemoryBlock block = memory.createInitializedBlock("ov_12", addr(0), 5000, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, true);
	Address ovAddress = block.getStart();
	assertEquals("ov_12::00000000", ovAddress.toString());

	Listing listing = program.getListing();

	AddressSet set = new AddressSet(ovAddress, ovAddress);
	Function f = listing.createFunction("fredFunc", ovAddress, set, SourceType.DEFAULT);
	assertNotNull(f);

	String defaultName = "FUN_ov_12__00000000";
	Symbol s1 = st.getPrimarySymbol(ovAddress);
	assertNotNull(s1);
	assertEquals(defaultName, s1.getName());
	assertTrue(s1.isPrimary());

	Symbol s = getUniqueSymbol(program, defaultName);
	assertNotNull(s);
	assertEquals(ovAddress, s.getAddress());
}
 

@Before
public void setUp() throws Exception {
	program = createDefaultProgram(testName.getMethodName(), ProgramBuilder._TOY, this);
	globalScope = program.getGlobalNamespace();
	space = program.getAddressFactory().getDefaultAddressSpace();
	Memory memory = program.getMemory();
	transactionID = program.startTransaction("Test");
	memory.createInitializedBlock("test", addr(0), 5000, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);
	st = program.getSymbolTable();
	refMgr = program.getReferenceManager();
}
 

@Test
   public void testMoveRange() throws Exception {
	Memory memory = program.getMemory();
	MemoryBlock block = memory.createInitializedBlock(".test", getAddr(0), 0x23, (byte) 0xa,
		TaskMonitorAdapter.DUMMY_MONITOR, false);

	AddressSet set = new AddressSet();
	set.addRange(getAddr(0), getAddr(0x10));
	set.addRange(getAddr(0x20), getAddr(0x25));
	set.addRange(getAddr(0x26), getAddr(0x30));
	IntRangeMap map = program.createIntRangeMap("MyMap");

	int value = 0x11223344;
	map.setValue(set, value);
	assertEquals(set, map.getAddressSet());

	// move .test block to 0x1000
	memory.moveBlock(block, getAddr(0x1000), TaskMonitorAdapter.DUMMY_MONITOR);

	// [0,10], [20, 22] should be moved
	// [23,30] should not be moved

	AddressSet s = new AddressSet();
	s.addRange(getAddr(0), getAddr(0x10));
	s.addRange(getAddr(0x20), getAddr(0x22));
	AddressSet mapSet = map.getAddressSet();
	assertTrue(!mapSet.contains(s));
	assertTrue(mapSet.contains(getAddr(0x23), getAddr(0x30)));

	s.clear();
	s.addRange(getAddr(0x1000), getAddr(0x1010));
	s.addRange(getAddr(0x1020), getAddr(0x1022));
	s.addRange(getAddr(0x23), getAddr(0x30));
	assertEquals(s, mapSet);
}
 

@Test
   public void testMoveRange() throws Exception {
	Memory memory = program.getMemory();
	MemoryBlock block = memory.createInitializedBlock(".test", getAddr(0), 0x23, (byte) 0xa,
		TaskMonitorAdapter.DUMMY_MONITOR, false);

	AddressSet set = new AddressSet();
	set.addRange(getAddr(0), getAddr(0x10));
	set.addRange(getAddr(0x20), getAddr(0x25));
	set.addRange(getAddr(0x26), getAddr(0x30));
	AddressSetPropertyMap pm = program.createAddressSetPropertyMap("MyMap");
	pm.add(set);

	assertEquals(set, pm.getAddressSet());

	// move .test block to 0x1000
	memory.moveBlock(block, getAddr(0x1000), TaskMonitorAdapter.DUMMY_MONITOR);

	// [0,10], [20, 22] should be moved
	// [23,30] should not be moved

	AddressSet s = new AddressSet();
	s.addRange(getAddr(0), getAddr(0x10));
	s.addRange(getAddr(0x20), getAddr(0x22));
	AddressSet pmSet = pm.getAddressSet();
	assertTrue(!pmSet.contains(s));
	assertTrue(pmSet.contains(getAddr(0x23), getAddr(0x30)));

	s.clear();
	s.addRange(getAddr(0x1000), getAddr(0x1010));
	s.addRange(getAddr(0x1020), getAddr(0x1022));
	s.addRange(getAddr(0x23), getAddr(0x30));
	assertEquals(s, pmSet);
}
 

@Before
public void setUp() throws Exception {
	program = createDefaultProgram("Test", ProgramBuilder._TOY, this);
	space = program.getAddressFactory().getDefaultAddressSpace();
	Memory memory = program.getMemory();
	transactionID = program.startTransaction("Test");
	memory.createInitializedBlock("test", addr(0), 5000, (byte) 0, TaskMonitor.DUMMY, false);

	equateTable = program.getEquateTable();

}
 

@Test
public void testGetDefaultFunctionInOverlaySymbolByNameWith2WordSize() throws Exception {
	Program p = createDefaultProgram("whatever", ProgramBuilder._TOY_WORDSIZE2_BE, this);
	Address address = p.getAddressFactory().getDefaultAddressSpace().getAddress(0);
	int txID = p.startTransaction("test");
	Memory memory = p.getMemory();
	MemoryBlock block = memory.createInitializedBlock("ov12", address, 5000, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, true);
	Address ovAddress = block.getStart();
	assertEquals("ov12::00000000", ovAddress.toString());
	ovAddress = ovAddress.add(2);
	Listing listing = p.getListing();
	st = p.getSymbolTable();

	AddressSet set = new AddressSet(ovAddress, ovAddress);

	Function f = listing.createFunction("fredFunc", ovAddress, set, SourceType.DEFAULT);

	p.endTransaction(txID, true);
	assertNotNull(f);

	String defaultName = "FUN_ov12__00000001";
	Symbol s1 = st.getPrimarySymbol(ovAddress);
	assertNotNull(s1);
	assertEquals(defaultName, s1.getName());
	assertTrue(s1.isPrimary());
}
 

@Before
public void setUp() throws Exception {
	program = createDefaultProgram(testName.getMethodName(), ProgramBuilder._TOY, this);
	globalScope = program.getGlobalNamespace();
	space = program.getAddressFactory().getDefaultAddressSpace();
	Memory memory = program.getMemory();
	transactionID = program.startTransaction("Test");
	memory.createInitializedBlock("test", addr(0), 5000, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);
	st = program.getSymbolTable();
	refMgr = program.getReferenceManager();
	scopeMgr = program.getNamespaceManager();
}
 

private void addBlocks() throws Exception {
	Memory mem = program.getMemory();

	Address start = addr("0000:0000");
	mem.createInitializedBlock("stdproc.c", start, 0x5EDA, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);

	start = addr("05ee:0000");
	mem.createInitializedBlock("scada.c", start, 0x5FAA, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);

	start = addr("0be9:0000");
	mem.createInitializedBlock("cseg03", start, 0x2A6, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);

	start = addr("0c14:0000");
	mem.createInitializedBlock("cseg04", start, 0xF04, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);

	start = addr("0d05:0000");
	mem.createInitializedBlock("cseg05", start, 0x3E0, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);

	start = addr("0d43:0000");
	mem.createInitializedBlock("cseg06", start, 0x10E8, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);

}
 

/**
 * Method addBlock.
 * @param name block name
 * @param offset offset for the starting address
 * @param length number of bytes in the block
 */
private MemoryBlock addBlock(String name, long offset, int length) throws Exception {
	Memory memory = program.getMemory();
	Address start = getAddr(offset);
	return memory.createInitializedBlock(name, start, length, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);
}
 

protected void addOverlayBlock(String name, String startAddress, long length)
		throws LockException, DuplicateNameException, MemoryConflictException,
		AddressOverflowException, CancelledException {
	int transactionID = program.startTransaction("Add Overlay Block to test");
	Address address = program.getAddressFactory().getAddress(startAddress);
	Memory memory = program.getMemory();
	memory.createInitializedBlock(name, address, length, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, true);
	program.endTransaction(transactionID, true);
}
 

private void openX86ProgramInTool() throws Exception {

		program = createDefaultProgram("Test", ProgramBuilder._X86, this);
		Memory memory = program.getMemory();
		int transactionID = program.startTransaction("Test");
		try {
			memory.createInitializedBlock("test1", addr(0x1006000), 0x1000, (byte) 0,
				TaskMonitorAdapter.DUMMY_MONITOR, false);
			memory.createInitializedBlock("test2", addr(0x1008000), 0x1000, (byte) 0,
				TaskMonitorAdapter.DUMMY_MONITOR, false);
			memory.createInitializedBlock("test3", addr(0x100b000), 0x1000, (byte) 0,
				TaskMonitorAdapter.DUMMY_MONITOR, false);
			memory.createInitializedBlock("test4", addr(0xf0000000), 0x2000, (byte) 0,
				TaskMonitorAdapter.DUMMY_MONITOR, false);

			SymbolTable st = program.getSymbolTable();
			Namespace ns = st.createNameSpace(null, "Deadpool", SourceType.USER_DEFINED);
			st.createLabel(addr(0x01006100), "Bob", ns, SourceType.USER_DEFINED);

		}
		finally {
			program.endTransaction(transactionID, true);
		}
		// write the file to the project to test external navigation for comment annotation
		env.getProject().getProjectData().getRootFolder().createFile("Test", program,
			TaskMonitor.DUMMY);
		env.showTool(program);
	}
 

@Test
   public void testShowHideDiffApplySettings() throws Exception {
	ClassicSampleX86ProgramBuilder builder = new ClassicSampleX86ProgramBuilder();
	builder.createMemory(".data", "0x2001000", 1000);

	Program p1 = builder.getProgram();
	assertTrue(p1.getAddressFactory() instanceof ProgramAddressFactory);
	assertEquals(2, p1.getAddressFactory().getNumAddressSpaces()); // ram, OTHER

	int id1 = p1.startTransaction("");
	Memory memory1 = p1.getMemory();
	MemoryBlock dataBlock1 = memory1.getBlock(".data");
	MemoryBlock overlayBlock1 =
		memory1.createInitializedBlock("OVL1", dataBlock1.getStart(), 0x20L, (byte) 0,
			TaskMonitorAdapter.DUMMY_MONITOR, true);
	assertEquals(3, p1.getAddressFactory().getNumAddressSpaces()); // ram, OTHER, OVL1

	AddressSet addressSet1 = new AddressSet(overlayBlock1.getStart(), overlayBlock1.getEnd());
	byte[] bytes1 =
		{ 'a', 'p', 'p', 'l', 'e', (byte) 0, 'o', 'r', 'a', 'n', 'g', 'e', (byte) 0 };
	memory1.setBytes(overlayBlock1.getStart(), bytes1);

	Listing listing1 = p1.getListing();
	Address overlayAddress1 = overlayBlock1.getStart();
	listing1.createData(overlayAddress1, new TerminatedStringDataType());
	overlayAddress1 = overlayAddress1.add(6);
	listing1.createData(overlayAddress1, new TerminatedStringDataType());

	p1.endTransaction(id1, true);

	ClassicSampleX86ProgramBuilder builder2 = new ClassicSampleX86ProgramBuilder();
	builder2.createMemory(".data", "0x2001000", 1000);
	Program p2 = builder2.getProgram();
	assertTrue(p2.getAddressFactory() instanceof ProgramAddressFactory);
	assertEquals(2, p2.getAddressFactory().getNumAddressSpaces());

	int id2 = p2.startTransaction("");
	Memory memory2 = p2.getMemory();
	MemoryBlock dataBlock2 = memory2.getBlock(".data");
	MemoryBlock overlayBlock2 =
		memory2.createInitializedBlock("OVL1", dataBlock2.getStart(), 0x20L, (byte) 0,
			TaskMonitorAdapter.DUMMY_MONITOR, true);
	assertEquals(3, p2.getAddressFactory().getNumAddressSpaces());

	AddressSet addressSet2 = DiffUtility.getCompatibleAddressSet(addressSet1, p2);
	byte[] bytes2 =
		{ 'd', 'o', 'b', 'e', 'r', 'm', 'a', 'n', (byte) 0, 'p', 'o', 'o', 'd', 'l', 'e',
			(byte) 0 };
	memory2.setBytes(overlayBlock2.getStart(), bytes2);

	Listing listing2 = p2.getListing();
	Address overlayAddress2 = overlayBlock2.getStart();
	listing2.createData(overlayAddress2, new TerminatedStringDataType());
	overlayAddress2 = overlayAddress2.add(9);
	listing2.createData(overlayAddress2, new TerminatedStringDataType());

	p2.endTransaction(id2, true);

	openProgram(p1);

	openDiff(p2);
	setDiffSelection(addressSet2);
	apply();

	Listing listing = p1.getListing();
	MemoryBlock overlayBlock = p1.getMemory().getBlock("OVL1");
	Address overlayAddress = overlayBlock.getStart();
	Data dataAt = listing.getDataAt(overlayAddress);
	assertNotNull(dataAt);
	assertEquals("doberman", dataAt.getValue());

	overlayAddress = overlayBlock.getStart().add(9);
	dataAt = listing.getDataAt(overlayAddress);
	assertNotNull(dataAt);
	assertEquals("poodle", dataAt.getValue());
}
 

private void addBlock() throws Exception {

		Memory memory = program.getMemory();
		memory.createInitializedBlock("test", addr(0), 100, (byte) 0,
			TaskMonitorAdapter.DUMMY_MONITOR, false);
	}
 

private void addBlock() throws Exception {
	Memory mem = program.getMemory();
	mem.createInitializedBlock("test", addr(0), 0x1000L, (byte) 0,
		TaskMonitorAdapter.DUMMY_MONITOR, false);
}
 

@Before
public void setUp() throws Exception {
	ProgramBuilder builder = new ProgramBuilder("Test", ProgramBuilder._8051, this);
	program = builder.getProgram();

	int txId = program.startTransaction("Add Stuff");

	Memory memory = program.getMemory();
	memory.createInitializedBlock("A", addr("OTHER:0"), 0x300, (byte) 0, DUMMY, true);
	memory.createInitializedBlock("B", addr("CODE:0"), 0x300, (byte) 0, DUMMY, true);
	memory.createInitializedBlock("C", addr("OTHER:0"), 0x300, (byte) 0, DUMMY, true);

	memory.createUninitializedBlock("BLOCK1", addr("CODE:100"), 100, false);
	memory.createUninitializedBlock("BLOCK2", addr("CODE:200"), 100, false);

	AddressFactory addressFactory = program.getAddressFactory();
	AddressSpace stackSpace = addressFactory.getStackSpace();
	AddressSpace constSpace = addressFactory.getConstantSpace();

	program.getFunctionManager().createFunction("testFunc", addr("CODE:0"),
		new AddressSet(addr("CODE:0"), addr("CODE:20")), ANALYSIS);

	ReferenceManager rm = program.getReferenceManager();

	Reference offsetRef1 =
		rm.addOffsetMemReference(addr("CODE:0"), addr("CODE:110"), 0x10, DATA, ANALYSIS, 0);
	Reference offsetRef2 =
		rm.addOffsetMemReference(addr("CODE:1"), addr("CODE:f0"), -0x10, DATA, ANALYSIS, 0);
	Reference offsetRef3 =
		rm.addOffsetMemReference(addr("CODE:2"), addr("CODE:120"), 0x20, DATA, ANALYSIS, 0);

	Reference stackRef1 = rm.addStackReference(addr("CODE:3"), 0, 0x10, DATA, ANALYSIS);
	Reference stackRef2 = rm.addStackReference(addr("CODE:4"), 0, -0x10, DATA, ANALYSIS);
	Reference stackRef3 = rm.addStackReference(addr("CODE:5"), 0, 0x20, DATA, ANALYSIS);

	Reference regRef1 =
		rm.addRegisterReference(addr("CODE:6"), 0, program.getRegister("R4"), DATA, ANALYSIS);
	Reference regRef2 =
		rm.addRegisterReference(addr("CODE:7"), 0, program.getRegister("DPTR"), DATA, ANALYSIS);
	Reference regRef3 =
		rm.addRegisterReference(addr("CODE:8"), 0, program.getRegister("ACC"), DATA, ANALYSIS);

	Reference shiftRef1 =
		rm.addShiftedMemReference(addr("CODE:9"), addr("CODE:200"), 2, DATA, ANALYSIS, 0);
	Reference shiftRef2 =
		rm.addShiftedMemReference(addr("CODE:10"), addr("CODE:200"), 4, DATA, ANALYSIS, 0);
	Reference shiftRef3 =
		rm.addShiftedMemReference(addr("CODE:11"), addr("CODE:200"), 3, DATA, ANALYSIS, 0);

	Reference extRef1 =
		rm.addExternalReference(addr("CODE:12"), "LIBA.DLL", "LAB1", null, ANALYSIS, 0, DATA);
	Reference extRef2 = rm.addExternalReference(addr("CODE:13"), "LIBA.DLL", "LAB2",
		addr("INTMEM:10"), ANALYSIS, 0, DATA);
	Reference extRef3 = rm.addExternalReference(addr("CODE:14"), "LIBA.DLL", "LAB3",
		addr("EXTMEM:1000"), ANALYSIS, 0, DATA);

	program.endTransaction(txId, true);

	locations = new AddressBasedLocation[] {
		new AddressBasedLocation(program, stackSpace.getAddress(-2)),
		new AddressBasedLocation(program, addr("CODE:200")),
		new AddressBasedLocation(program, AddressSpace.HASH_SPACE.getAddress(0x12345678)),
		new AddressBasedLocation(program, shiftRef1, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, addr("CODE:120")),
		new AddressBasedLocation(program, extRef2, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, regRef1, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, addr("CODE:210")),
		new AddressBasedLocation(program, constSpace.getAddress(-6)),
		new AddressBasedLocation(program, offsetRef1, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, addr("A:210")),
		new AddressBasedLocation(program, addr("B:210")),
		new AddressBasedLocation(program, addr("C:210")),
		new AddressBasedLocation(program, Address.NO_ADDRESS),
		new AddressBasedLocation(program, extRef1, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, addr("CODE:90")),
		new AddressBasedLocation(program, stackRef1, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, addr("CODE:110")),
		new AddressBasedLocation(program, shiftRef2, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, null),
		new AddressBasedLocation(program, regRef2, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, addr("CODE:100")),
		new AddressBasedLocation(program, addr("C:100")),
		new AddressBasedLocation(program, addr("B:100")),
		new AddressBasedLocation(program, addr("A:100")),
		new AddressBasedLocation(program, offsetRef2, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, AddressSpace.HASH_SPACE.getAddress(0x87654321L)),
		new AddressBasedLocation(program, extRef3, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, addr("CODE:80")),
		new AddressBasedLocation(program, stackRef2, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, addr("A:80")),
		new AddressBasedLocation(program, addr("C:80")),
		new AddressBasedLocation(program, addr("B:80")),
		new AddressBasedLocation(program, addr("CODE:125")),
		new AddressBasedLocation(program, shiftRef3, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, regRef3, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, addr("CODE:115")),
		new AddressBasedLocation(program, offsetRef3, ShowBlockName.ALWAYS),
		new AddressBasedLocation(),
		new AddressBasedLocation(program, stackRef3, ShowBlockName.ALWAYS),
		new AddressBasedLocation(program, constSpace.getAddress(3)), };
}