| /******************************************************************************* |
| * Copyright (c) 2007 - 2010 QNX Software 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: |
| * Ericsson - initial API and implementation this class is based on |
| * QNX Software Systems - Initial implementation for Jtag debugging |
| * Sage Electronic Engineering, LLC - bug 305943 |
| * - API generalization to become transport-independent (allow |
| * connections via serial ports and pipes). |
| *******************************************************************************/ |
| package org.eclipse.cdt.debug.gdbjtag.core; |
| |
| /** |
| * @author Andy Jin |
| * |
| */ |
| |
| import java.net.URI; |
| import java.net.URISyntaxException; |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Properties; |
| |
| import org.eclipse.cdt.debug.core.CDebugUtils; |
| import org.eclipse.cdt.debug.gdbjtag.core.jtagdevice.GDBJtagDeviceContribution; |
| import org.eclipse.cdt.debug.gdbjtag.core.jtagdevice.GDBJtagDeviceContributionFactory; |
| import org.eclipse.cdt.debug.gdbjtag.core.jtagdevice.IGDBJtagDevice; |
| import org.eclipse.cdt.debug.internal.core.sourcelookup.CSourceLookupDirector; |
| import org.eclipse.cdt.dsf.concurrent.CountingRequestMonitor; |
| import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor; |
| import org.eclipse.cdt.dsf.concurrent.DsfExecutor; |
| import org.eclipse.cdt.dsf.concurrent.RequestMonitor; |
| import org.eclipse.cdt.dsf.concurrent.Sequence; |
| import org.eclipse.cdt.dsf.datamodel.DataModelInitializedEvent; |
| import org.eclipse.cdt.dsf.debug.service.IBreakpoints.IBreakpointsTargetDMContext; |
| import org.eclipse.cdt.dsf.debug.service.ISourceLookup.ISourceLookupDMContext; |
| import org.eclipse.cdt.dsf.gdb.IGDBLaunchConfigurationConstants; |
| import org.eclipse.cdt.dsf.gdb.launching.GdbLaunch; |
| import org.eclipse.cdt.dsf.gdb.launching.LaunchMessages; |
| import org.eclipse.cdt.dsf.gdb.service.IGDBBackend; |
| import org.eclipse.cdt.dsf.gdb.service.SessionType; |
| import org.eclipse.cdt.dsf.gdb.service.command.IGDBControl; |
| import org.eclipse.cdt.dsf.mi.service.CSourceLookup; |
| import org.eclipse.cdt.dsf.mi.service.IMIProcesses; |
| import org.eclipse.cdt.dsf.mi.service.MIBreakpointsManager; |
| import org.eclipse.cdt.dsf.mi.service.command.CommandFactory; |
| import org.eclipse.cdt.dsf.mi.service.command.commands.CLICommand; |
| import org.eclipse.cdt.dsf.mi.service.command.output.MIInfo; |
| import org.eclipse.cdt.dsf.service.DsfServicesTracker; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IPath; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.core.variables.VariablesPlugin; |
| import org.eclipse.debug.core.ILaunchConfiguration; |
| |
| /** |
| * The final launch sequence for the Jtag hardware debugging using the |
| * DSF/GDB debugger framework. |
| * <p> |
| * This class is based on the implementation of the standard DSF/GDB debugging |
| * <code>org.eclipse.cdt.dsf.gdb.launching.FinalLaunchSequence</code> |
| * <p> |
| * It adds Jtag hardware debugging specific steps to initialize remote target |
| * and start the remote Jtag debugging. |
| * <p> |
| * @since 7.0 |
| */ |
| public class GDBJtagDSFFinalLaunchSequence extends Sequence { |
| |
| /** utility method; cuts down on clutter */ |
| private void queueCommands(List<String> commands, RequestMonitor rm) { |
| if (!commands.isEmpty()) { |
| fCommandControl.queueCommand( |
| new CLICommand<MIInfo>(fCommandControl.getContext(), composeCommand(commands)), |
| new DataRequestMonitor<MIInfo>(getExecutor(), rm)); |
| } |
| else { |
| rm.done(); |
| } |
| } |
| |
| private Step[] fSteps = new Step[] { |
| /* |
| * Create the service tracker for later use |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor requestMonitor) { |
| fTracker = new DsfServicesTracker(Activator.getBundleContext(), fLaunch.getSession().getId()); |
| requestMonitor.done(); |
| } |
| @Override |
| public void rollBack(RequestMonitor requestMonitor) { |
| if (fTracker != null) fTracker.dispose(); |
| fTracker = null; |
| requestMonitor.done(); |
| }}, |
| /* |
| * Fetch the GDBBackend service for later use |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor requestMonitor) { |
| fGDBBackend = fTracker.getService(IGDBBackend.class); |
| if (fGDBBackend == null) { |
| requestMonitor.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot obtain GDBBackend service", null)); //$NON-NLS-1$ |
| } |
| |
| requestMonitor.done(); |
| }}, |
| /* |
| * Fetch the control service for later use |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor requestMonitor) { |
| fCommandControl = fTracker.getService(IGDBControl.class); |
| if (fCommandControl == null) { |
| requestMonitor.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot obtain control service", null)); //$NON-NLS-1$ |
| } |
| |
| fCommandFactory = fCommandControl.getCommandFactory(); |
| |
| requestMonitor.done(); |
| }}, |
| /* |
| * Fetch the process service for later use |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor requestMonitor) { |
| fProcService = fTracker.getService(IMIProcesses.class); |
| if (fProcService == null) { |
| requestMonitor.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot obtain process service", null)); //$NON-NLS-1$ |
| } |
| |
| requestMonitor.done(); |
| }}, |
| /* |
| * Specify GDB's working directory |
| */ |
| new Step() { |
| @Override |
| public void execute(final RequestMonitor requestMonitor) { |
| IPath dir = null; |
| try { |
| dir = fGDBBackend.getGDBWorkingDirectory(); |
| } catch (CoreException e) { |
| requestMonitor.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot get working directory", e)); //$NON-NLS-1$ |
| requestMonitor.done(); |
| return; |
| } |
| |
| if (dir != null) { |
| fCommandControl.queueCommand( |
| fCommandFactory.createMIEnvironmentCD(fCommandControl.getContext(), dir.toPortableString()), |
| new DataRequestMonitor<MIInfo>(getExecutor(), requestMonitor)); |
| } else { |
| requestMonitor.done(); |
| } |
| }}, |
| /* |
| * Source the gdbinit file specified in the launch |
| */ |
| new Step() { |
| @Override |
| public void execute(final RequestMonitor requestMonitor) { |
| try { |
| final String gdbinitFile = fGDBBackend.getGDBInitFile(); |
| |
| if (gdbinitFile != null && gdbinitFile.length() > 0) { |
| fCommandControl.queueCommand( |
| fCommandFactory.createCLISource(fCommandControl.getContext(), gdbinitFile), |
| new DataRequestMonitor<MIInfo>(getExecutor(), requestMonitor) { |
| @Override |
| protected void handleCompleted() { |
| // If the gdbinitFile is the default, then it may not exist and we |
| // should not consider this an error. |
| // If it is not the default, then the user must have specified it and |
| // we want to warn the user if we can't find it. |
| if (!gdbinitFile.equals(IGDBLaunchConfigurationConstants.DEBUGGER_GDB_INIT_DEFAULT )) { |
| requestMonitor.setStatus(getStatus()); |
| } |
| requestMonitor.done(); |
| } |
| }); |
| } else { |
| requestMonitor.done(); |
| } |
| } catch (CoreException e) { |
| requestMonitor.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot get gdbinit option", e)); //$NON-NLS-1$ |
| requestMonitor.done(); |
| } |
| }}, |
| /* |
| * Specify the arguments to the executable file |
| */ |
| new Step() { |
| @Override |
| public void execute(final RequestMonitor requestMonitor) { |
| try { |
| String args = fGDBBackend.getProgramArguments(); |
| |
| if (args != null) { |
| fCommandControl.queueCommand( |
| fCommandFactory.createMIGDBSetArgs(fCommandControl.getContext(), args), |
| new DataRequestMonitor<MIInfo>(getExecutor(), requestMonitor)); |
| } else { |
| requestMonitor.done(); |
| } |
| } catch (CoreException e) { |
| requestMonitor.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot get inferior arguments", e)); //$NON-NLS-1$ |
| requestMonitor.done(); |
| } |
| }}, |
| /* |
| * Specify environment variables if needed |
| */ |
| new Step() { |
| @Override |
| public void execute(final RequestMonitor requestMonitor) { |
| boolean clear = false; |
| Properties properties = new Properties(); |
| try { |
| clear = fGDBBackend.getClearEnvironment(); |
| properties = fGDBBackend.getEnvironmentVariables(); |
| } catch (CoreException e) { |
| requestMonitor.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot get environment information", e)); //$NON-NLS-1$ |
| requestMonitor.done(); |
| return; |
| } |
| |
| if (clear == true || properties.size() > 0) { |
| fCommandControl.setEnvironment(properties, clear, requestMonitor); |
| } else { |
| requestMonitor.done(); |
| } |
| }}, |
| /* |
| * Enable non-stop mode if necessary |
| */ |
| new Step() { |
| @Override |
| public void execute(final RequestMonitor requestMonitor) { |
| boolean isNonStop = false; |
| try { |
| isNonStop = fLaunch.getLaunchConfiguration().getAttribute(IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_NON_STOP, |
| IGDBLaunchConfigurationConstants.DEBUGGER_NON_STOP_DEFAULT); |
| } catch (CoreException e) { |
| } |
| |
| // GDBs that don't support non-stop don't allow you to set it to false. |
| // We really should set it to false when GDB supports it though. |
| // Something to fix later. |
| if (isNonStop) { |
| // The raw commands should not be necessary in the official GDB release |
| fCommandControl.queueCommand( |
| fCommandFactory.createMIGDBSetTargetAsync(fCommandControl.getContext(), true), |
| new DataRequestMonitor<MIInfo>(getExecutor(), requestMonitor) { |
| @Override |
| protected void handleSuccess() { |
| fCommandControl.queueCommand( |
| fCommandFactory.createMIGDBSetPagination(fCommandControl.getContext(), false), |
| new DataRequestMonitor<MIInfo>(getExecutor(), requestMonitor) { |
| @Override |
| protected void handleSuccess() { |
| fCommandControl.queueCommand( |
| fCommandFactory.createMIGDBSetNonStop(fCommandControl.getContext(), true), |
| new DataRequestMonitor<MIInfo>(getExecutor(), requestMonitor)); |
| } |
| }); |
| } |
| }); |
| } else { |
| requestMonitor.done(); |
| } |
| }}, |
| /* |
| * Tell GDB to automatically load or not the shared library symbols |
| */ |
| new Step() { |
| public void execute(RequestMonitor requestMonitor) { |
| try { |
| boolean autolib = fLaunch.getLaunchConfiguration().getAttribute(IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_AUTO_SOLIB, |
| IGDBLaunchConfigurationConstants.DEBUGGER_AUTO_SOLIB_DEFAULT); |
| fCommandControl.queueCommand( |
| fCommandFactory.createMIGDBSetAutoSolib(fCommandControl.getContext(), autolib), |
| new DataRequestMonitor<MIInfo>(getExecutor(), requestMonitor)); |
| } catch (CoreException e) { |
| requestMonitor.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot set shared library option", e)); //$NON-NLS-1$ |
| requestMonitor.done(); |
| } |
| }}, |
| /* |
| * Set the shared library paths |
| */ |
| new Step() { |
| @Override |
| public void execute(final RequestMonitor requestMonitor) { |
| try { |
| List<String> p = fGDBBackend.getSharedLibraryPaths(); |
| |
| if (p.size() > 0) { |
| String[] paths = p.toArray(new String[p.size()]); |
| fCommandControl.queueCommand( |
| fCommandFactory.createMIGDBSetSolibSearchPath(fCommandControl.getContext(), paths), |
| new DataRequestMonitor<MIInfo>(getExecutor(), requestMonitor) { |
| @Override |
| protected void handleSuccess() { |
| // Sysroot is not available in GDB6.6 and will make the launch fail in that case. |
| // Let's remove it for now |
| requestMonitor.done(); |
| // // If we are able to set the solib-search-path, |
| // // we should disable the sysroot variable, as indicated |
| // // in the GDB documentation. This is to avoid the sysroot |
| // // variable finding libraries that were not meant to be found. |
| // fCommandControl.queueCommand( |
| // new MIGDBSetSysroot(fCommandControl.getContext()), |
| // new DataRequestMonitor<MIInfo>(getExecutor(), requestMonitor)); |
| }; |
| }); |
| } else { |
| requestMonitor.done(); |
| } |
| } catch (CoreException e) { |
| requestMonitor.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot set share library paths", e)); //$NON-NLS-1$ |
| requestMonitor.done(); |
| } |
| }}, |
| |
| // -environment-directory with a lot of paths could |
| // make setting breakpoint incredibly slow, which makes |
| // the debug session un-workable. We simply stop |
| // using it because it's usefulness is unclear. |
| // Bug 225805 |
| // /* |
| // * Setup the source paths |
| // */ |
| // new Step() { |
| // @Override |
| // public void execute(RequestMonitor requestMonitor) { |
| // CSourceLookup sourceLookup = fTracker.getService(CSourceLookup.class); |
| // CSourceLookupDirector locator = (CSourceLookupDirector)fLaunch.getSourceLocator(); |
| // ISourceLookupDMContext sourceLookupDmc = (ISourceLookupDMContext)fCommandControl.getContext(); |
| // |
| // sourceLookup.setSourceLookupPath(sourceLookupDmc, locator.getSourceContainers(), requestMonitor); |
| // }}, |
| |
| // Below steps are specific to JTag hardware debugging |
| |
| /* |
| * Retrieve the IGDBJtagDevice instance |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| Exception exception = null; |
| try { |
| fGdbJtagDevice = getGDBJtagDevice(fLaunch.getLaunchConfiguration()); |
| } catch (NullPointerException e) { |
| exception = e; |
| } catch (CoreException e) { |
| exception = e; |
| } |
| if (fGdbJtagDevice == null) { |
| // Abort the launch |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot get Jtag device", exception)); //$NON-NLS-1$ |
| } |
| rm.done(); |
| }}, |
| /* |
| * Execute symbol loading |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| try { |
| if (config.getAttribute(IGDBJtagConstants.ATTR_LOAD_SYMBOLS, IGDBJtagConstants.DEFAULT_LOAD_SYMBOLS)) { |
| String symbolsFileName = null; |
| |
| // New setting in Helios. Default is true. Check for existence |
| // in order to support older launch configs |
| if (config.hasAttribute(IGDBJtagConstants.ATTR_USE_PROJ_BINARY_FOR_SYMBOLS) && |
| config.getAttribute(IGDBJtagConstants.ATTR_USE_PROJ_BINARY_FOR_SYMBOLS, IGDBJtagConstants.DEFAULT_USE_PROJ_BINARY_FOR_SYMBOLS)) { |
| IPath programFile = CDebugUtils.verifyProgramPath(config); |
| if (programFile != null) { |
| symbolsFileName = programFile.toOSString(); |
| } |
| } |
| else { |
| symbolsFileName = config.getAttribute(IGDBJtagConstants.ATTR_SYMBOLS_FILE_NAME, IGDBJtagConstants.DEFAULT_SYMBOLS_FILE_NAME); |
| if (symbolsFileName.length() > 0) { |
| symbolsFileName = VariablesPlugin.getDefault().getStringVariableManager().performStringSubstitution(symbolsFileName); |
| } else { |
| symbolsFileName = null; |
| } |
| } |
| |
| if (symbolsFileName == null) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, Messages.getString("GDBJtagDebugger.err_no_img_file"), null)); //$NON-NLS-1$ |
| rm.done(); |
| return; |
| } |
| |
| // Escape windows path separator characters TWICE, once for Java and once for GDB. |
| symbolsFileName = symbolsFileName.replace("\\", "\\\\"); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| String symbolsOffset = config.getAttribute(IGDBJtagConstants.ATTR_SYMBOLS_OFFSET, IGDBJtagConstants.DEFAULT_SYMBOLS_OFFSET); |
| if (symbolsOffset.length() > 0) { |
| symbolsOffset = "0x" + symbolsOffset; |
| } |
| List<String> commands = new ArrayList<String>(); |
| fGdbJtagDevice.doLoadSymbol(symbolsFileName, symbolsOffset, commands); |
| queueCommands(commands, rm); |
| |
| } else { |
| rm.done(); |
| } |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot load symbol", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| }}, |
| |
| /* |
| * Hook up to remote target |
| */ |
| new Step() { |
| @SuppressWarnings("deprecation") |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| try { |
| if (config.getAttribute(IGDBJtagConstants.ATTR_USE_REMOTE_TARGET, IGDBJtagConstants.DEFAULT_USE_REMOTE_TARGET)) { |
| List<String> commands = new ArrayList<String>(); |
| if (fGdbJtagDevice instanceof IGDBJtagConnection) { |
| URI uri = new URI(config.getAttribute(IGDBJtagConstants.ATTR_CONNECTION, IGDBJtagConstants.DEFAULT_CONNECTION)); |
| IGDBJtagConnection device = (IGDBJtagConnection)fGdbJtagDevice; |
| device.doRemote(uri.getSchemeSpecificPart(), commands); |
| } else { |
| // Handle legacy network device contributions that don't understand URIs |
| String ipAddress = config.getAttribute(IGDBJtagConstants.ATTR_IP_ADDRESS, IGDBJtagConstants.DEFAULT_IP_ADDRESS); |
| int portNumber = config.getAttribute(IGDBJtagConstants.ATTR_PORT_NUMBER, IGDBJtagConstants.DEFAULT_PORT_NUMBER); |
| fGdbJtagDevice.doRemote(ipAddress, portNumber, commands); |
| } |
| queueCommands(commands, rm); |
| } else { |
| rm.done(); |
| } |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot connect to remote target", e)); //$NON-NLS-1$ |
| rm.done(); |
| } catch (URISyntaxException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Invalid remote target connection syntax", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| }}, |
| /* |
| * Run device-specific code to reset the board |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| try { |
| if (config.getAttribute(IGDBJtagConstants.ATTR_DO_RESET, IGDBJtagConstants.DEFAULT_DO_RESET)) { |
| List<String> commands = new ArrayList<String>(); |
| fGdbJtagDevice.doReset(commands); |
| queueCommands(commands, rm); |
| } else { |
| rm.done(); |
| } |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot reset the remote target", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| }}, |
| /* |
| * Run device-specific code to delay the startup |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| int defaultDelay = fGdbJtagDevice.getDefaultDelay(); |
| try { |
| List<String> commands = new ArrayList<String>(); |
| fGdbJtagDevice.doDelay(config.getAttribute(IGDBJtagConstants.ATTR_DELAY, defaultDelay), commands); |
| queueCommands(commands, rm); |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot delay the remote target", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| }}, |
| /* |
| * Run device-specific code to halt the board |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| try { |
| if (config.getAttribute(IGDBJtagConstants.ATTR_DO_HALT, IGDBJtagConstants.DEFAULT_DO_HALT)) { |
| List<String> commands = new ArrayList<String>(); |
| fGdbJtagDevice.doHalt(commands); |
| queueCommands(commands, rm); |
| } else { |
| rm.done(); |
| } |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot halt the remote target", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| }}, |
| /* |
| * Execute any user defined init commands |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| try { |
| String userCmd = config.getAttribute(IGDBJtagConstants.ATTR_INIT_COMMANDS, IGDBJtagConstants.DEFAULT_INIT_COMMANDS); |
| userCmd = VariablesPlugin.getDefault().getStringVariableManager().performStringSubstitution(userCmd); |
| if (userCmd.length() > 0) { |
| String[] commands = userCmd.split("\\r?\\n"); //$NON-NLS-1$ |
| |
| CountingRequestMonitor crm = new CountingRequestMonitor(getExecutor(), rm); |
| crm.setDoneCount(commands.length); |
| for (int i = 0; i < commands.length; ++i) { |
| fCommandControl.queueCommand( |
| new CLICommand<MIInfo>(fCommandControl.getContext(), commands[i]), |
| new DataRequestMonitor<MIInfo>(getExecutor(), crm)); |
| } |
| } |
| else { |
| rm.done(); |
| } |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot run user defined init commands", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| }}, |
| /* |
| * Execute image loading |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| try { |
| String imageFileName = null; |
| if (config.getAttribute(IGDBJtagConstants.ATTR_LOAD_IMAGE, IGDBJtagConstants.DEFAULT_LOAD_IMAGE)) { |
| // New setting in Helios. Default is true. Check for existence |
| // in order to support older launch configs |
| if (config.hasAttribute(IGDBJtagConstants.ATTR_USE_PROJ_BINARY_FOR_IMAGE) && |
| config.getAttribute(IGDBJtagConstants.ATTR_USE_PROJ_BINARY_FOR_IMAGE, IGDBJtagConstants.DEFAULT_USE_PROJ_BINARY_FOR_IMAGE)) { |
| IPath programFile = CDebugUtils.verifyProgramPath(config); |
| if (programFile != null) { |
| imageFileName = programFile.toOSString(); |
| } |
| } |
| else { |
| imageFileName = config.getAttribute(IGDBJtagConstants.ATTR_IMAGE_FILE_NAME, IGDBJtagConstants.DEFAULT_IMAGE_FILE_NAME); //$NON-NLS-1$ |
| if (imageFileName.length() > 0) { |
| imageFileName = VariablesPlugin.getDefault().getStringVariableManager().performStringSubstitution(imageFileName); |
| } else { |
| imageFileName = null; |
| } |
| } |
| |
| if (imageFileName == null) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, Messages.getString("GDBJtagDebugger.err_no_img_file"), null)); //$NON-NLS-1$ |
| rm.done(); |
| return; |
| } |
| |
| // Escape windows path separator characters TWICE, once for Java and once for GDB. |
| imageFileName = imageFileName.replace("\\", "\\\\"); //$NON-NLS-1$ //$NON-NLS-2$ |
| |
| String imageOffset = config.getAttribute(IGDBJtagConstants.ATTR_IMAGE_OFFSET, IGDBJtagConstants.DEFAULT_IMAGE_OFFSET); |
| if (imageOffset.length() > 0) { |
| imageOffset = (imageFileName.endsWith(".elf")) ? "" : "0x" + config.getAttribute(IGDBJtagConstants.ATTR_IMAGE_OFFSET, IGDBJtagConstants.DEFAULT_IMAGE_OFFSET); //$NON-NLS-2$ //$NON-NLS-4$ |
| } |
| List<String> commands = new ArrayList<String>(); |
| fGdbJtagDevice.doLoadImage(imageFileName, imageOffset, commands); |
| queueCommands(commands, rm); |
| } |
| else { |
| rm.done(); |
| } |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot load image", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| }}, |
| /* |
| * Start tracking the breakpoints once we know we are connected to the target (necessary for remote debugging) |
| */ |
| new Step() { |
| @Override |
| public void execute(final RequestMonitor requestMonitor) { |
| if (fSessionType != SessionType.CORE) { |
| MIBreakpointsManager bpmService = fTracker.getService(MIBreakpointsManager.class); |
| IBreakpointsTargetDMContext breakpointDmc = (IBreakpointsTargetDMContext)fCommandControl.getContext(); |
| |
| bpmService.startTrackingBreakpoints(breakpointDmc, requestMonitor); |
| } else { |
| requestMonitor.done(); |
| } |
| }}, |
| /* |
| * Set the program counter |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| try { |
| if (config.getAttribute(IGDBJtagConstants.ATTR_SET_PC_REGISTER, IGDBJtagConstants.DEFAULT_SET_PC_REGISTER)) { |
| String pcRegister = config.getAttribute(IGDBJtagConstants.ATTR_PC_REGISTER, config.getAttribute(IGDBJtagConstants.ATTR_IMAGE_OFFSET, IGDBJtagConstants.DEFAULT_PC_REGISTER)); //$NON-NLS-1$ |
| List<String> commands = new ArrayList<String>(); |
| fGdbJtagDevice.doSetPC(pcRegister, commands); |
| queueCommands(commands, rm); |
| } else { |
| rm.done(); |
| } |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot set program counter", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| }}, |
| /* |
| * Execute the stop script |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| try { |
| if (config.getAttribute(IGDBJtagConstants.ATTR_SET_STOP_AT, IGDBJtagConstants.DEFAULT_SET_STOP_AT)) { |
| String stopAt = config.getAttribute(IGDBJtagConstants.ATTR_STOP_AT, IGDBJtagConstants.DEFAULT_STOP_AT); //$NON-NLS-1$ |
| List<String> commands = new ArrayList<String>(); |
| fGdbJtagDevice.doStopAt(stopAt, commands); |
| queueCommands(commands, rm); |
| } else { |
| rm.done(); |
| } |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot run the stop script", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| } |
| }, |
| /* |
| * Execute the resume script |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| try { |
| if (config.getAttribute(IGDBJtagConstants.ATTR_SET_RESUME, IGDBJtagConstants.DEFAULT_SET_RESUME)) { |
| List<String> commands = new ArrayList<String>(); |
| fGdbJtagDevice.doContinue(commands); |
| queueCommands(commands, rm); |
| } else { |
| rm.done(); |
| } |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot resume the remote target", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| }}, |
| /* |
| * Run any user defined commands to start debugging |
| */ |
| new Step() { |
| @Override |
| public void execute(RequestMonitor rm) { |
| ILaunchConfiguration config = fLaunch.getLaunchConfiguration(); |
| try { |
| String userCmd = config.getAttribute(IGDBJtagConstants.ATTR_RUN_COMMANDS, IGDBJtagConstants.DEFAULT_RUN_COMMANDS); //$NON-NLS-1$ |
| if (userCmd.length() > 0) { |
| userCmd = VariablesPlugin.getDefault().getStringVariableManager().performStringSubstitution(userCmd); |
| String[] commands = userCmd.split("\\r?\\n"); //$NON-NLS-1$ |
| |
| CountingRequestMonitor crm = new CountingRequestMonitor(getExecutor(), rm); |
| crm.setDoneCount(commands.length); |
| for (int i = 0; i < commands.length; ++i) { |
| fCommandControl.queueCommand( |
| new CLICommand<MIInfo>(fCommandControl.getContext(), commands[i]), |
| new DataRequestMonitor<MIInfo>(getExecutor(), crm)); |
| } |
| } |
| else { |
| rm.done(); |
| } |
| } catch (CoreException e) { |
| rm.setStatus(new Status(IStatus.ERROR, Activator.PLUGIN_ID, -1, "Cannot run user defined run commands", e)); //$NON-NLS-1$ |
| rm.done(); |
| } |
| }}, |
| |
| /* |
| * Indicate that the Data Model has been filled. This will trigger the Debug view to expand. |
| */ |
| new Step() { |
| @Override |
| public void execute(final RequestMonitor requestMonitor) { |
| fLaunch.getSession().dispatchEvent(new DataModelInitializedEvent(fCommandControl.getContext()), |
| fCommandControl.getProperties()); |
| requestMonitor.done(); |
| }}, |
| /* |
| * Cleanup |
| */ |
| new Step() { |
| @Override |
| public void execute(final RequestMonitor requestMonitor) { |
| fTracker.dispose(); |
| fTracker = null; |
| requestMonitor.done(); |
| }}, |
| }; |
| |
| GdbLaunch fLaunch; |
| SessionType fSessionType; |
| boolean fAttach; |
| |
| private IGDBControl fCommandControl; |
| private IGDBBackend fGDBBackend; |
| private IMIProcesses fProcService; |
| private CommandFactory fCommandFactory; |
| private IGDBJtagDevice fGdbJtagDevice; |
| |
| DsfServicesTracker fTracker; |
| |
| public GDBJtagDSFFinalLaunchSequence(DsfExecutor executor, GdbLaunch launch, SessionType sessionType, boolean attach, IProgressMonitor pm) { |
| super(executor, pm, LaunchMessages.getString("FinalLaunchSequence.0"), LaunchMessages.getString("FinalLaunchSequence.1")); //$NON-NLS-1$ //$NON-NLS-2$ |
| fLaunch = launch; |
| fSessionType = sessionType; |
| fAttach = attach; |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.cdt.dsf.gdb.launching.FinalLaunchSequence#getSteps() |
| */ |
| @Override |
| public Step[] getSteps() { |
| return fSteps; |
| } |
| |
| /** |
| * @param config |
| * @return IGDBJtagDevice the selected Jtag device |
| * @throws CoreException |
| * @throws NullPointerException |
| */ |
| private IGDBJtagDevice getGDBJtagDevice (ILaunchConfiguration config) |
| throws CoreException, NullPointerException { |
| IGDBJtagDevice gdbJtagDevice = null; |
| String jtagDeviceName = config.getAttribute(IGDBJtagConstants.ATTR_JTAG_DEVICE, IGDBJtagConstants.DEFAULT_JTAG_DEVICE); //$NON-NLS-1$ |
| GDBJtagDeviceContribution[] availableDevices = GDBJtagDeviceContributionFactory.getInstance().getGDBJtagDeviceContribution(); |
| for (GDBJtagDeviceContribution availableDevice : availableDevices) { |
| if (jtagDeviceName.equals(availableDevice.getDeviceName())) { |
| gdbJtagDevice = availableDevice.getDevice(); |
| break; |
| } |
| } |
| return gdbJtagDevice; |
| } |
| |
| /** |
| * @param commands |
| * @return String commands in String format |
| */ |
| private String composeCommand(Collection<String> commands) { |
| if (commands.isEmpty()) |
| return null; |
| StringBuffer sb = new StringBuffer(); |
| Iterator<String> it = commands.iterator(); |
| while (it.hasNext()) { |
| sb.append(it.next()); |
| } |
| return sb.toString(); |
| } |
| } |
