path: root/dsf/org.eclipse.cdt.dsf/src/org/eclipse/cdt/dsf/debug/model/DsfMemoryBlock.java

/*******************************************************************************
 * Copyright (c) 2007, 2016 Wind River Systems 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:
 *     Wind River Systems - initial API and implementation
 *     Ericsson Communication - upgrade IF to IMemoryBlockExtension
 *     Ericsson Communication - added support for 64 bit processors
 *     Ericsson Communication - added support for changed bytes
 *     Ericsson Communication - better management of exceptions
 *     Alvaro Sanchez-Leon (Ericsson AB) - [Memory] Support 16 bit addressable size (Bug 426730)
 *******************************************************************************/
package org.eclipse.cdt.dsf.debug.model;

import java.math.BigInteger;
import java.util.ArrayList;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.RejectedExecutionException;

import org.eclipse.cdt.core.IAddress;
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
import org.eclipse.cdt.dsf.concurrent.Query;
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
import org.eclipse.cdt.dsf.debug.internal.provisional.model.IMemoryBlockUpdatePolicyProvider;
import org.eclipse.cdt.dsf.debug.service.IMemory;
import org.eclipse.cdt.dsf.debug.service.IMemory.IMemoryChangedEvent;
import org.eclipse.cdt.dsf.debug.service.IMemory.IMemoryDMContext;
import org.eclipse.cdt.dsf.debug.service.IRunControl;
import org.eclipse.cdt.dsf.debug.service.IRunControl.StateChangeReason;
import org.eclipse.cdt.dsf.internal.DsfPlugin;
import org.eclipse.cdt.dsf.service.DsfServiceEventHandler;
import org.eclipse.cdt.utils.Addr64;
import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.PlatformObject;
import org.eclipse.core.runtime.Status;
import org.eclipse.debug.core.DebugEvent;
import org.eclipse.debug.core.DebugException;
import org.eclipse.debug.core.DebugPlugin;
import org.eclipse.debug.core.ILaunch;
import org.eclipse.debug.core.model.IDebugTarget;
import org.eclipse.debug.core.model.IMemoryBlockExtension;
import org.eclipse.debug.core.model.IMemoryBlockRetrieval;
import org.eclipse.debug.core.model.MemoryByte;

/**
 * This class manages the memory block retrieved from the target as a result
 * of a getBytesFromAddress() call from the platform.
 * 
 * It performs its read/write functions using the MemoryService.
 * 
 * @since 1.0
 */
public class DsfMemoryBlock extends PlatformObject implements IMemoryBlockExtension, IMemoryBlockUpdatePolicyProvider
{
	private final static String UPDATE_POLICY_AUTOMATIC = "Automatic"; //$NON-NLS-1$
	private final static String UPDATE_POLICY_MANUAL = "Manual"; //$NON-NLS-1$
	private final static String UPDATE_POLICY_BREAKPOINT = "On Breakpoint"; //$NON-NLS-1$
	
	private final IMemoryDMContext fContext;
    private final ILaunch fLaunch;
    private final IDebugTarget fDebugTarget;
    private final DsfMemoryBlockRetrieval fRetrieval;
    private final String fModelId;
    private final String fExpression;
    private final BigInteger fBaseAddress;

    private BigInteger fBlockAddress;
    private int fLength;
    private int fWordSize;
    private MemoryByte[] fBlock;
    
    private String fUpdatePolicy = UPDATE_POLICY_AUTOMATIC;
    
    private ArrayList<Object> fConnections = new ArrayList<Object>();

    @SuppressWarnings("unused")
	private boolean isEnabled;

    /**
     * Constructor.
     * 
     * @param retrieval    - the MemoryBlockRetrieval (session context)
     * @param modelId      - 
     * @param expression   - the displayed expression in the UI
     * @param address      - the actual memory block start address
     * @param word_size    - the number of bytes per address
     * @param length       - the requested block length (could be 0)
     * @since 2.1
     */
    protected DsfMemoryBlock(DsfMemoryBlockRetrieval retrieval, IMemoryDMContext context, String modelId, String expression, BigInteger address, int word_size, long length) {
    	fLaunch      = retrieval.getLaunch();
    	fDebugTarget = retrieval.getDebugTarget();
        fRetrieval   = retrieval;
        fContext     = context;
        fModelId     = modelId;
        fExpression  = expression;
        fBaseAddress = address;

        // Current block information
        fBlockAddress = address;
        fWordSize     = word_size;
        fLength       = (int) length;
        fBlock        = null;

        try {
            fRetrieval.getExecutor().execute(new Runnable() {
                @Override
                public void run() {
                    fRetrieval.getSession().addServiceEventListener(DsfMemoryBlock.this, null);
                }
            });
        } catch (RejectedExecutionException e) {
            // Session is shut down.
        }
    }

    // ////////////////////////////////////////////////////////////////////////
    // IAdaptable
    // ////////////////////////////////////////////////////////////////////////

    /* (non-Javadoc)
     * @see org.eclipse.core.runtime.PlatformObject#getAdapter(java.lang.Class)
     */
	@SuppressWarnings({ "rawtypes", "unchecked" })
	@Override
    public Object getAdapter(Class adapter) {
        if (adapter.isAssignableFrom(DsfMemoryBlockRetrieval.class)) {
            return fRetrieval;
        }
        if (adapter.isAssignableFrom(IMemoryDMContext.class)) {
          return getContext();
        }
        return super.getAdapter(adapter);
    }

    // ////////////////////////////////////////////////////////////////////////
    // IDebugElement
    // ////////////////////////////////////////////////////////////////////////

    /* (non-Javadoc)
     * @see org.eclipse.debug.core.model.IDebugElement#getDebugTarget()
     */
    @Override
    public IDebugTarget getDebugTarget() {
        return fDebugTarget;
    }

    /* (non-Javadoc)
     * @see org.eclipse.debug.core.model.IDebugElement#getModelIdentifier()
     */
    @Override
    public String getModelIdentifier() {
        return fModelId;
    }
    
    /* (non-Javadoc)
     * @see org.eclipse.debug.core.model.IDebugElement#getLaunch()
     */
    @Override
    public ILaunch getLaunch() {
        return fLaunch;
    }

    // ////////////////////////////////////////////////////////////////////////
    // IMemoryBock interface - obsoleted by IMemoryBlockExtension
    // ////////////////////////////////////////////////////////////////////////

    /* (non-Javadoc)
     * @see org.eclipse.debug.core.model.IMemoryBlock#getStartAddress()
     */
    @Override
    public long getStartAddress() {
    	// Not implemented (obsolete)
    	return 0;
    }

    /* (non-Javadoc)
     * @see org.eclipse.debug.core.model.IMemoryBlock#getLength()
     */
    @Override
    public long getLength() {
    	// Not implemented (obsolete)
        return 0;
    }

    /* (non-Javadoc)
     * @see org.eclipse.debug.core.model.IMemoryBlock#getBytes()
     */
    @Override
    public byte[] getBytes() throws DebugException {
    	// Not implemented (obsolete)
    	return new byte[0];
    }

    /* (non-Javadoc)
     * @see org.eclipse.debug.core.model.IMemoryBlock#supportsValueModification()
     */
    @Override
    public boolean supportsValueModification() {
    	return fRetrieval.supportsValueModification();
    }

    /* (non-Javadoc)
     * @see org.eclipse.debug.core.model.IMemoryBlock#setValue(long, byte[])
     */
    @Override
    public void setValue(long offset, byte[] bytes) throws DebugException {
    	// Not implemented (obsolete)
    }

    // ////////////////////////////////////////////////////////////////////////
    // IMemoryBlockExtension interface
    // ////////////////////////////////////////////////////////////////////////

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getExpression()
	 */
    @Override
	public String getExpression() {
		return fExpression;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getBigBaseAddress()
	 */
    @Override
	public BigInteger getBigBaseAddress() throws DebugException {
        return fBaseAddress;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getMemoryBlockStartAddress()
	 */
    @Override
	public BigInteger getMemoryBlockStartAddress() throws DebugException {
		// Null indicates that memory can be retrieved at addresses lower than the block base address
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getMemoryBlockEndAddress()
	 */
    @Override
	public BigInteger getMemoryBlockEndAddress() throws DebugException {
		// Null indicates that memory can be retrieved at addresses higher the block base address
		return null;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getBigLength()
	 */
    @Override
	public BigInteger getBigLength() throws DebugException {
		// -1 indicates that memory block is unbounded
		return BigInteger.valueOf(-1);
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getAddressSize()
	 */
    @Override
	public int getAddressSize() throws DebugException {
		return fRetrieval.getAddressSize();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#supportBaseAddressModification()
	 */
    @Override
	public boolean supportBaseAddressModification() throws DebugException {
		return fRetrieval.supportBaseAddressModification();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#supportsChangeManagement()
	 */
    @Override
	public boolean supportsChangeManagement() {
		return true;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#setBaseAddress(java.math.BigInteger)
	 */
    @Override
	public void setBaseAddress(BigInteger address) throws DebugException {
		fBlockAddress = address;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getBytesFromOffset(java.math.BigInteger, long)
	 */
    @Override
	public MemoryByte[] getBytesFromOffset(BigInteger offset, long units) throws DebugException {
		return getBytesFromAddress(fBlockAddress.add(offset), units);
	}
	
	private boolean fUseCachedData = false;
	
    @Override
	public void clearCache() {
		fUseCachedData = false;
	}
	
	@DsfServiceEventHandler 
    public void handleCacheSuspendEvent(IRunControl.ISuspendedDMEvent e) {
		if (e.getReason() == StateChangeReason.BREAKPOINT)
			fUseCachedData = false;
	}
	
	private boolean isUseCacheData()
	{
		if (fUpdatePolicy.equals(DsfMemoryBlock.UPDATE_POLICY_BREAKPOINT))
			return fUseCachedData;

		if (fUpdatePolicy.equals(DsfMemoryBlock.UPDATE_POLICY_MANUAL))
			return fUseCachedData;

		return false;
	}
	
    /* (non-Javadoc)
     * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getBytesFromAddress(java.math.BigInteger, long)
     */
    @SuppressWarnings("null")
    @Override
    public MemoryByte[] getBytesFromAddress(BigInteger address, long units) throws DebugException {

		int addressableSize = 1;
		try {
			addressableSize = getAddressableSize();
		} catch (DebugException e) {}
		
        if (isUseCacheData() && fBlockAddress.compareTo(address) == 0 && units * addressableSize <= fBlock.length)
            return fBlock;
        
        MemoryByte[] newBlock = fetchMemoryBlock(address, units);
        int newLength = (newBlock != null) ? newBlock.length : 0;

        // If the retrieved block overlaps with the cached block, flag the changed bytes
        // so they can be properly highlighted in the platform Memory view. 
        // Note: In the standard Memory view, the values are displayed in cells of 4 bytes
        // (on 4-bytes address boundaries) and all 4 bytes have to be flagged so the
        // cell is highlighted (and the delta sigh is shown).
        if (fBlock != null && newLength > 0) {
            switch (fBlockAddress.compareTo(address))    {
                // case : Cached block begins before the retrieved block location
                //          
                //          <--- fLength -------------------------------------------------->
                //          +--------------------------------------------------------------+
                //          | Cached data from previous retrieve                           |
                //          |                                                              |
                //          |     <------------------ length ----------------------->      |
                //          |     +-------------------------------------------------+      |
                //          |     |<----------------- newLength ------------------->|      |
                //          |     |          Newly retrieved data                   |      |
                //          |<-+->+-------------------------------------------------+      |
                //          |  |   address                                                 |
                //          |  |                                                           |
                //          |  +--- bigDistance/distance                                   |
                //          |                                                              |
                //          |     <------------------ length ----------------------------->|
                //          |     +--------------------------------------------------------+
                //          |     |<----------------- newLength -------------------------->|
                //          |     |          Newly retrieved data                          |
                //          |<-+->+--------------------------------------------------------+
                //          |  |   address                                                 |
                //          |  |                                                           |
                //          |  +--- bigDistance/distance                                   |
                //          |                                                              |
                //          |     <------------------ length ----------------------------->|
                //          |     +---------------------------------------------------------------+
                //          |     |<----------------- newLength --------------------------------->|
                //          |     |          Newly retrieved data                                 |
                //          |<-+->+---------------------------------------------------------------+
                //          |  |   address                                                 |
                //          |  |                                                           |
                //          |  +--- bigDistance/distance                                   |
                //          |                                                              |
                //          +--------------------------------------------------------------+
                //          fBlockAddress
                case -1:
                {
                    // Determine the distance between the cached and the requested block addresses
                	// If the distance does not exceed the length of the cached block,  then there 
                	// is some overlap between the blocks and we have to mark the changed bytes.
                    BigInteger bigDistance = address.subtract(fBlockAddress).multiply(BigInteger.valueOf(addressableSize));
                    if (bigDistance.compareTo(BigInteger.valueOf(fLength)) == -1) {
                    	// Calculate the length of the data we are going to examine/update
                        int distance = bigDistance.intValue(); 
                        int length   = fLength - distance;
                        if ( length > newLength ) {
                            length = newLength;
                        }

                        // Process each cell, updating the status and history/change
                        for (int i = 0; i < length; i++) {
                        	if ( i < newLength ) {
                        		newBlock[i].setFlags(fBlock[distance + i].getFlags());
                    			newBlock[i].setHistoryKnown(true);
                        		if (newBlock[i].getValue() != fBlock[distance + i].getValue()) {
                        			newBlock[i].setChanged(true);
                        		}
                        	}
                        }
                    }
                    break;
                }

                // The cached block starts at the same address as the retrieved data
                // or it starts after the retrieved block and the retrieved block runs
                // in to it.
                //
                // Case 0:
                //          <--- fLength -------------------------------------------------->
                //          +--------------------------------------------------------------+
                //          | Cached data from previous retrieve                           |
                //          |                                                              |
                //          |<-- length ---------------->                                  |
                //          +---------------------------+                                  |
                //          |<-- newLength ------------>|                                  |
                //          | Newly retrieve data       |                                  |
                //          +---------------------------+                                  |
                //          |address                                                       |
                //          |                                                              |
                //          |<--------------------- length ------------------------------->|
                //          +--------------------------------------------------------------+
                //          |<--------------------- newLength ---------------------------->|
                //          | Newly retrieve data                                          |
                //          +--------------------------------------------------------------+
                //          |address                                                       |
                //          |                                                              |
                //          +--------------------------------------------------------------+
                //          fBlockAddress
                //          bigDistance/distance = 0
                //
                // Case 1:
                //          <--- fLength -------------------------------------------------->
                //          +--------------------------------------------------------------+
                //          | Cached data from previous retrieve                           |
                //          |                                                              |
                //          |<-- length ----->                                             |
                //   +-----------------------+                                             |
                //   |<----- newLength ----->|                                             |
                //   | Newly retrieved data  |                                             |
                //   +-----------------------+                                             |
                //   address|                                                              |
                //          |                                                              |
                //          |<----------------------- length ----------------------------->|
                //   +---------------------------------------------------------------------+
                //   |<------------------------------ newLength -------------------------->|
                //   | Newly retrieved data                                                |
                //   +---------------------------------------------------------------------+
                //   address|                                                              |
                //          |                                                              |
                //          |<----------------------- length ----------------------------->|
                //   +---------------------------------------------------------------------------+
                //   |<------------------------------ newLength -------------------------------->|
                //   | Newly retrieved data                                                      |
                //   +---------------------------------------------------------------------------+
                //   address|                                                              |
                //   <--+-->|                                                              |
                //      |   +--------------------------------------------------------------+
                //      |   fBlockAddress
                //      +---bigDistance/distance
                case 0:
                case 1:
                {
                    // Determine the distance between the requested block  and the cache block
                	// If the distance does not exceed the length of the new block, then there
                	// is some overlap between the blocks and we have to update the blanks and
                	// possibly note they are changed.
                    BigInteger bigDistance = fBlockAddress.subtract(address).multiply(BigInteger.valueOf(addressableSize));
                    if (bigDistance.compareTo(BigInteger.valueOf(newLength)) == -1) {
                        // Calculate the length of the data we are going to examine/update
                        int distance = bigDistance.intValue(); 
                        int length   = newLength - distance;
                        if ( length > fBlock.length ) {
                            length = fBlock.length;
                        }

                        // Process each cell, updating the status and history/change
                        for (int i = 0; i < length; i++) {
                        	if ( (distance + i) < newLength ) {
                        		newBlock[distance + i].setFlags(fBlock[i].getFlags());
                    			newBlock[distance + i].setHistoryKnown(true);
                        		if (newBlock[distance + i].getValue() != fBlock[i].getValue()) {
                        			newBlock[distance + i].setChanged(true);
                        		}
                        	}
                        }
                    }
                    break;
                }
            }
        }

        // Update the internal state
        fBlock        = newBlock;
        fBlockAddress = address;
        fLength       = newLength;
        
        if (fUpdatePolicy.equals(DsfMemoryBlock.UPDATE_POLICY_BREAKPOINT)) {
            fUseCachedData = true;
        } 
        else if (fUpdatePolicy.equals(DsfMemoryBlock.UPDATE_POLICY_MANUAL)) {
            fUseCachedData = true;
        }

        return fBlock;
    }

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#setValue(java.math.BigInteger, byte[])
	 */
    @Override
	public void setValue(BigInteger offset, byte[] bytes) throws DebugException {
		writeMemoryBlock(offset.longValue(), bytes);
	}
	
	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#connect(java.lang.Object)
	 */
    @Override
	public void connect(Object client) {
		if (!fConnections.contains(client))
			fConnections.add(client);
		if (fConnections.size() == 1)
			enable();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#disconnect(java.lang.Object)
	 */
    @Override
	public void disconnect(Object client) {
		if (fConnections.contains(client))
			fConnections.remove(client);
		if (fConnections.size() == 0)
			disable();
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getConnections()
	 */
    @Override
	public Object[] getConnections() {
		return fConnections.toArray();
	}

	private void enable() {
		isEnabled = true;
	}

	private void disable() {
		isEnabled = false;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#dispose()
	 */
    @Override
	public void dispose() throws DebugException {
		try {
    		fRetrieval.getExecutor().execute(new Runnable() {
    		    @Override
    		    public void run() {
    		        fRetrieval.getSession().removeServiceEventListener(DsfMemoryBlock.this);
    		    }
    		});
		} catch (RejectedExecutionException e) {
		    // Session is down.
		}
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getMemoryBlockRetrieval()
	 */
    @Override
	public IMemoryBlockRetrieval getMemoryBlockRetrieval() {
		return fRetrieval;
	}

	/* (non-Javadoc)
	 * @see org.eclipse.debug.core.model.IMemoryBlockExtension#getAddressableSize()
	 */
    @Override
	public int getAddressableSize() throws DebugException {
		return fWordSize;
	}

    ///////////////////////////////////////////////////////////////////////////
    // Helper functions
    ///////////////////////////////////////////////////////////////////////////

    /**
	 * The real thing. Since the original call is synchronous (from a platform
	 * Job), we use a Query that will patiently wait for the underlying
	 * asynchronous calls to complete before returning.
	 * 
	 * @param bigAddress 
	 * @param count - Number of addressable units for this memory block
	 * @return MemoryByte[] 
	 * @throws DebugException
	 * @since 2.1
	 */
    protected MemoryByte[] fetchMemoryBlock(BigInteger bigAddress, final long count) throws DebugException {
		//resolve the addressable size
    	int aSize;
		try {
			aSize = getAddressableSize();
		} catch (DebugException e) {
			aSize = 1;
		}
		final int addressableSize = aSize;
		
    	// For the IAddress interface
    	final Addr64 address = new Addr64(bigAddress);
    	
        // Use a Query to synchronize the downstream calls  
        Query<MemoryByte[]> query = new Query<MemoryByte[]>() {
			@Override
			protected void execute(final DataRequestMonitor<MemoryByte[]> drm) {
			    IMemory memoryService = fRetrieval.getServiceTracker().getService();
			    if (memoryService != null) {
			        // Go for it
			        memoryService.getMemory( 
			            fContext, address, 0, addressableSize, (int) count,
			            new DataRequestMonitor<MemoryByte[]>(fRetrieval.getExecutor(), drm) {
			                @Override
			                protected void handleSuccess() {
			                    drm.setData(getData());
			                    drm.done();
			                }
			            });
			    }
				else {
			    	drm.done();
			    }
			}
        };
        fRetrieval.getExecutor().execute(query);

		try {
            return query.get();
        } catch (InterruptedException e) {
    		throw new DebugException(new Status(IStatus.ERROR, DsfPlugin.PLUGIN_ID, DebugException.INTERNAL_ERROR, "Error reading memory block (InterruptedException)", e)); //$NON-NLS-1$
        } catch (ExecutionException e) {
    		throw new DebugException(new Status(IStatus.ERROR, DsfPlugin.PLUGIN_ID, DebugException.INTERNAL_ERROR, "Error reading memory block (ExecutionException)", e)); //$NON-NLS-1$
        }
    }

	/**
	 *  Writes an array of bytes to memory.
     * 
     * @param offset
     * @param bytes
     * @throws DebugException
	 * @since 2.1
	 */
    protected void writeMemoryBlock(final long offset, final byte[] bytes) throws DebugException {
		//resolve the addressable size
    	int aSize;
		try {
			aSize = getAddressableSize();
		} catch (DebugException e) {
			aSize = 1;
		}
		final int addressableSize = aSize;
		
		final int addressableUnits = bytes.length/addressableSize;
		
    	// For the IAddress interface
    	final Addr64 address = new Addr64(fBaseAddress);

        // Use a Query to synchronize the downstream calls  
        Query<MemoryByte[]> query = new Query<MemoryByte[]>() {
			@Override
			protected void execute(final DataRequestMonitor<MemoryByte[]> drm) {
			    IMemory memoryService = fRetrieval.getServiceTracker().getService();
			    if (memoryService != null) {
			        // Go for it
	    	        memoryService.setMemory(
		    	  	      fContext, address, offset, addressableSize, addressableUnits, bytes,
		    	  	      new RequestMonitor(fRetrieval.getExecutor(), drm));
			    }
			    else {
			    	drm.done();
			    }
			}
        };
        fRetrieval.getExecutor().execute(query);

		try {
            query.get();
        } catch (InterruptedException e) {
    		throw new DebugException(new Status(IStatus.ERROR,
    				DsfPlugin.PLUGIN_ID, DebugException.INTERNAL_ERROR,
    				"Error writing memory block (InterruptedException)", e)); //$NON-NLS-1$
        } catch (ExecutionException e) {
    		throw new DebugException(new Status(IStatus.ERROR,
    				DsfPlugin.PLUGIN_ID, DebugException.INTERNAL_ERROR,
    				"Error writing memory block (ExecutionException)", e)); //$NON-NLS-1$
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    // Event Handlers
    ///////////////////////////////////////////////////////////////////////////

    @DsfServiceEventHandler 
    public void eventDispatched(IRunControl.ISuspendedDMEvent e) {

    	// Clear the "Changed" flags after each run/resume/step
		for (int i = 0; i < fLength; i++)
			fBlock[i].setChanged(false);
    	
    	// Generate the MemoryChangedEvents
        handleMemoryChange(BigInteger.ZERO);
    }
    
    @DsfServiceEventHandler
    public void eventDispatched(IMemoryChangedEvent e) {

        // Check if we are in the same address space 
        if (e.getDMContext().equals(fContext)) {
        	IAddress[] addresses = e.getAddresses();
        	for (int i = 0; i < addresses.length; i++)
        		handleMemoryChange(addresses[i].getValue());
        }
    }
    
    /**
	 * @param address
	 * @param length
	 */
	public void handleMemoryChange(BigInteger address) {
    	int addressableSize;
		try {
			addressableSize = getAddressableSize();
		} catch (DebugException e) {
			addressableSize = 1;
		}
		
		int addressesLength = fLength/addressableSize;
		// Check if the change affects this particular block (0 is universal)
		BigInteger fEndAddress = fBlockAddress.add(BigInteger.valueOf(addressesLength));
		if (address.equals(BigInteger.ZERO) ||
		   ((fBlockAddress.compareTo(address) != 1) && (fEndAddress.compareTo(address) == 1)))
		{
			// Notify the event listeners
			DebugEvent debugEvent = new DebugEvent(this, DebugEvent.CHANGE, DebugEvent.CONTENT);
			DebugPlugin.getDefault().fireDebugEventSet(new DebugEvent[] { debugEvent });
		}
	}

    @Override
	public String[] getUpdatePolicies() {
		return new String[] {UPDATE_POLICY_AUTOMATIC, UPDATE_POLICY_MANUAL, UPDATE_POLICY_BREAKPOINT};
	}
    
    @Override
    public String getUpdatePolicy()
    {
    	return fUpdatePolicy;
    }
    
    @Override
    public void setUpdatePolicy(String policy)
    {
    	fUpdatePolicy = policy;
    }
    
    @Override
    public String getUpdatePolicyDescription(String id) {
		return id;
	}
    
    /**
     * Get the context specified at construction.
     * 
	 * @since 2.7
	 */
    public IMemoryDMContext getContext() {
    	return fContext;
    }
}