/*******************************************************************************
* Copyright (c) 2013 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.debug.examples.internal.memory.engine;
import java.math.BigInteger;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Random;
import org.eclipse.core.runtime.CoreException;
import org.eclipse.debug.core.model.MemoryByte;
import org.eclipse.debug.examples.internal.memory.core.SampleDebugTarget;
import org.eclipse.debug.examples.internal.memory.core.SampleMemoryBlock;
import org.eclipse.debug.examples.internal.memory.core.SampleStackFrame;
import org.eclipse.debug.examples.internal.memory.core.SampleThread;
/**
* Sample engine for sample deug adapter This engine randomly generates content
* for a memory block. To get to this engine, call
* {@link SampleDebugTarget#getEngine()};
*/
public class SampleEngine {
Random fRandom = new Random();
byte[] fMemory;
Hashtable<BigInteger, SampleMemoryUnit> memoryBlockTable;
Hashtable<String, BigInteger> expressionAddressTable = new Hashtable<String, BigInteger>();
Hashtable<SampleDebugTarget, Object> threadTable = new Hashtable<SampleDebugTarget, Object>();
Hashtable<SampleThread, Object> stackframeTable = new Hashtable<SampleThread, Object>();
Random random = new Random();
/**
* Allow debug adapters to get memory from an address
*
* @param address
* @param length
* @return memory byte from an address
* @throws RuntimeException
*/
synchronized public MemoryByte[] getBytesFromAddress(BigInteger address, long length) throws RuntimeException {
if (memoryBlockTable == null) {
// create new memoryBlock table
memoryBlockTable = new Hashtable<BigInteger, SampleMemoryUnit>();
byte[] bytes = new byte[(int) length * getAddressableSize()];
BigInteger addressKey = address;
random.nextBytes(bytes);
for (int i = 0; i < bytes.length; i = i + getAddressableSize()) {
addressKey = addressKey.add(BigInteger.valueOf(1));
MemoryByte[] byteUnit = new MemoryByte[getAddressableSize()];
for (int j = 0; j < getAddressableSize(); j++) {
MemoryByte oneByte = new MemoryByte(bytes[i + j]);
oneByte.setBigEndian(isBigEndian(addressKey));
oneByte.setWritable(isWritable(addressKey));
oneByte.setReadable(isReadable(addressKey));
byteUnit[j] = oneByte;
}
SampleMemoryUnit unit = new SampleMemoryUnit(byteUnit);
memoryBlockTable.put(addressKey, unit);
}
}
MemoryByte[] returnBytes = new MemoryByte[(int) length * getAddressableSize()];
BigInteger addressKey;
for (int i = 0; i < returnBytes.length; i = i + getAddressableSize()) {
addressKey = address.add(BigInteger.valueOf(i / getAddressableSize()));
SampleMemoryUnit temp = (memoryBlockTable.get(addressKey));
// if memoryBlock does not already exist in the table, generate a
// value
if (temp == null) {
byte[] x = new byte[getAddressableSize()];
random.nextBytes(x);
byte flag = 0;
flag |= MemoryByte.READABLE;
flag |= MemoryByte.ENDIANESS_KNOWN;
flag |= MemoryByte.WRITABLE;
MemoryByte[] byteUnit = new MemoryByte[getAddressableSize()];
for (int j = 0; j < getAddressableSize(); j++) {
MemoryByte oneByte = new MemoryByte(x[j], flag);
byteUnit[j] = oneByte;
byteUnit[j].setBigEndian(isBigEndian(addressKey));
byteUnit[j].setWritable(isWritable(addressKey));
byteUnit[j].setReadable(isReadable(addressKey));
returnBytes[i + j] = oneByte;
}
SampleMemoryUnit unit = new SampleMemoryUnit(byteUnit);
memoryBlockTable.put(addressKey, unit);
} else {
MemoryByte[] bytes = temp.getBytes();
for (int j = 0; j < bytes.length; j++) {
MemoryByte oneByte = new MemoryByte(bytes[j].getValue(), bytes[j].getFlags());
returnBytes[i + j] = oneByte;
returnBytes[i + j].setBigEndian(isBigEndian(addressKey));
returnBytes[i + j].setWritable(isWritable(addressKey));
}
}
}
return returnBytes;
}
/**
* Run the debuggee
*/
public void resume() {
changeValue();
}
/**
* Convenience function to cause changes in a memoryBlock block. Changes
* could result from running the program, changing a variable, etc.
*/
synchronized public void changeValue() {
if (memoryBlockTable == null) {
return;
}
Enumeration<BigInteger> enumeration = memoryBlockTable.keys();
long randomChange = random.nextInt(37);
while (randomChange <= 5) {
randomChange = random.nextInt(37);
}
while (enumeration.hasMoreElements()) {
BigInteger key = enumeration.nextElement();
if (key.remainder(BigInteger.valueOf(randomChange)).equals(BigInteger.valueOf(0))) {
byte[] x = new byte[getAddressableSize()];
random.nextBytes(x);
MemoryByte unitBytes[] = new MemoryByte[getAddressableSize()];
for (int i = 0; i < x.length; i++) {
MemoryByte oneByte = new MemoryByte();
oneByte.setValue(x[i]);
oneByte.setReadable(true);
oneByte.setChanged(true);
oneByte.setHistoryKnown(true);
oneByte.setBigEndian(isBigEndian(key));
oneByte.setWritable(isWritable(key));
oneByte.setReadable(isReadable(key));
unitBytes[i] = oneByte;
}
SampleMemoryUnit unit = new SampleMemoryUnit(unitBytes);
memoryBlockTable.put(key, unit);
} else {
SampleMemoryUnit unit = memoryBlockTable.get(key);
MemoryByte[] bytes = unit.getBytes();
for (int i = 0; i < bytes.length; i++) {
bytes[i].setChanged(false);
bytes[i].setHistoryKnown(true);
}
unit.setBytes(bytes);
memoryBlockTable.put(key, unit);
}
}
}
/**
* Simulates evaluation of an expression. Given an expression, return ad
* address
*
* @param expression
* @param evalContext
* @return the address the expression is evaluated to
*/
public BigInteger evaluateExpression(String expression, Object evalContext) {
BigInteger expAddress = expressionAddressTable.get(expression);
if (expAddress == null) {
int address = random.nextInt();
// make sure number is positive
if (address < 0) {
address = address * -1;
}
expAddress = BigInteger.valueOf(address);
expressionAddressTable.put(expression, expAddress);
}
return expAddress;
}
/**
* Simulates checking if storage retrieval is supported
*
* @return if the engine supports storage retrieval
*/
public boolean supportsStorageRetrieval() {
return true;
}
/**
* Simulates modifying memory using BigInteger as the address
*
* @param address
* @param bytes
* @throws RuntimeException
*/
public void setValue(BigInteger address, byte[] bytes) throws RuntimeException {
BigInteger convertedAddress = address;
for (int i = 0; i < bytes.length; i = i + getAddressableSize()) {
SampleMemoryUnit unit = memoryBlockTable.get(convertedAddress);
MemoryByte[] unitBytes = unit.getBytes();
for (int j = 0; j < unitBytes.length; j++) {
unitBytes[j].setValue(bytes[i + j]);
unitBytes[j].setChanged(true);
unitBytes[j].setHistoryKnown(true);
}
convertedAddress = convertedAddress.add(BigInteger.valueOf(1));
}
}
/**
* @return addrssablesize of the debuggee
*/
public int getAddressableSize() {
return 1;
}
/**
* @param address
* @return true if the debuggee is big endian, false otherwise
*/
public boolean isBigEndian(BigInteger address) {
// simulate mixed endianess in a memory block
// memory before the boundary address is little endian
// memory after the boundaress is big endian
BigInteger boundary = new BigInteger("12345678", 16); //$NON-NLS-1$
if (address.compareTo(boundary) > 0) {
return true;
}
return false;
}
/**
* @param address
* @return true if the address is writable, false otherwise Read only
* segment: 0xab123456 to 0xab123556
*/
public boolean isWritable(BigInteger address) {
BigInteger boundary = new BigInteger("ab123456", 16); //$NON-NLS-1$
BigInteger boundaryEnd = new BigInteger("ab123556", 16); //$NON-NLS-1$
if (address.compareTo(boundary) > 0 && address.compareTo(boundaryEnd) < 0) {
return false;
}
boundary = new BigInteger("cd123456", 16); //$NON-NLS-1$
boundaryEnd = new BigInteger("cd123576", 16); //$NON-NLS-1$
if (address.compareTo(boundary) > 0 && address.compareTo(boundaryEnd) < 0) {
return false;
}
return true;
}
/**
* @param address
* @return
*/
public boolean isReadable(BigInteger address) {
BigInteger boundary = new BigInteger("cd123456", 16); //$NON-NLS-1$
BigInteger boundaryEnd = new BigInteger("cd123576", 16); //$NON-NLS-1$
if (address.compareTo(boundary) > 0 && address.compareTo(boundaryEnd) < 0) {
return false;
}
return true;
}
/**
* @param target
* @return
*/
public SampleThread[] getThreads(SampleDebugTarget target) {
Object thread = threadTable.get(target);
if (thread == null) {
thread = new SampleThread(target);
threadTable.put(target, thread);
}
return new SampleThread[] { (SampleThread) thread };
}
/**
* @param thread
* @return
*/
public SampleStackFrame[] getStackframes(SampleThread thread) {
Object stackframes = stackframeTable.get(thread);
if (stackframes == null) {
stackframes = createStackframes(thread);
stackframeTable.put(thread, stackframes);
}
return (SampleStackFrame[]) stackframes;
}
/**
*
*/
private SampleStackFrame[] createStackframes(SampleThread thread) {
SampleStackFrame[] stackframes = new SampleStackFrame[2];
stackframes[0] = new SampleStackFrame(thread, "Frame1"); //$NON-NLS-1$
stackframes[1] = new SampleStackFrame(thread, "Frame2"); //$NON-NLS-1$
return stackframes;
}
/**
* @param mb
* @return true if memory block is to support base address modification,
* false otherwise
*/
public boolean suppostsBaseAddressModification(SampleMemoryBlock mb) {
return false;
}
/**
* Sets the base address of this memory block
*
* @param mb the memory block to change base address
* @param address the new base address of the memory block
* @throws CoreException
*/
public void setBaseAddress(SampleMemoryBlock mb, BigInteger address) throws CoreException {
}
/**
* @param mb
* @return true if this memory block supports value modification, false
* otherwise
* @throws CoreException
*/
public boolean supportsValueModification(SampleMemoryBlock mb) {
return true;
}
/**
* @return address size of the debuggee
* @throws CoreException
*/
public int getAddressSize() throws CoreException {
return 4;
}
}
