mirror of
https://github.com/eclipse-cdt/cdt
synced 2025-04-23 14:42:11 +02:00
Bug 488661: Simplification of reverse debugging code
Most changes are cosmetics (name of local variables, javadoc, etc). The note-worthy ones are: 1- Change terminology in IChangeReverseMethodHandler to be a little clearer. This causes changes in multiple files, but it was all automated. 2- Remove ReverseDebugMethod.INVALID which was used as an error code and not a ReverseDebugMethod value. 3- In GdbReverseToggleCommand, provide a different error message if there is a failure to set ProcessTrace vs BranchTrace and tell user what to do. 4- Reworked GdbReverseToggleCommand#getReverseDebugMethod in attempt to make the code easier to understand. No actual change in functionality. Change-Id: Ibdc14faff1220e6a20319644b49e641c2101e762
This commit is contained in:
Marc Khouzam
parent
64e7137959
commit
6d5e31038c
12 changed files with 188 additions and 143 deletions
|
|
@ -1,5 +1,5 @@
|
|||
/*******************************************************************************
|
||||
* Copyright (c) 2015 Intel Corporation and others.
|
||||
* Copyright (c) 2015, 2016 Intel 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
|
||||
|
|
@ -13,22 +13,30 @@ package org.eclipse.cdt.debug.core.model;
|
|||
import org.eclipse.debug.core.commands.IDebugCommandHandler;
|
||||
|
||||
/**
|
||||
* Handler interface for the reverse debug change trace method command
|
||||
* Handler interface for the reverse debug change method command
|
||||
*
|
||||
* @since 8.0
|
||||
*/
|
||||
public interface IChangeReverseMethodHandler extends IReverseToggleHandler, IDebugCommandHandler {
|
||||
|
||||
public enum ReverseTraceMethod {INVALID, STOP_TRACE, FULL_TRACE, HARDWARE_TRACE, BRANCH_TRACE, PROCESSOR_TRACE, GDB_TRACE};
|
||||
/**
|
||||
* List of different values for the reverse debugging method.
|
||||
*/
|
||||
enum ReverseDebugMethod {OFF, SOFTWARE, HARDWARE, BRANCH_TRACE, PROCESSOR_TRACE, GDB_TRACE};
|
||||
|
||||
void setTraceMethod(ReverseTraceMethod traceMethod);
|
||||
/**
|
||||
* Sets the value for the reverse debugging method to be used when the button is toggled.
|
||||
*/
|
||||
void setReverseDebugMethod(ReverseDebugMethod traceMethod);
|
||||
|
||||
/**
|
||||
* get the trace method
|
||||
* @return FullTrace, BranchTrace, ProcessorTrace
|
||||
*
|
||||
* Return the reverse debugging method currently selected.
|
||||
*/
|
||||
ReverseTraceMethod getTraceMethod(Object context);
|
||||
ReverseDebugMethod getReverseDebugMethod(Object context);
|
||||
|
||||
ReverseTraceMethod getLastTraceMethod(Object context);
|
||||
/**
|
||||
* Return the reverse debugging method that was selected before the
|
||||
* currently selected one.
|
||||
*/
|
||||
ReverseDebugMethod getPreviousReverseDebugMethod(Object context);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ import java.net.URL;
|
|||
import java.util.Map;
|
||||
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseTraceMethod;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseDebugMethod;
|
||||
import org.eclipse.cdt.debug.core.model.IReverseToggleHandler;
|
||||
import org.eclipse.core.commands.ExecutionEvent;
|
||||
import org.eclipse.core.commands.ExecutionException;
|
||||
|
|
@ -80,9 +80,9 @@ public class ReverseToggleCommandHandler extends DebugCommandHandler implements
|
|||
// We must hard-code the command id so as to know it from the very start (bug 290699)
|
||||
private static final String REVERSE_TOGGLE_COMMAND_ID = "org.eclipse.cdt.debug.ui.command.reverseToggle"; //$NON-NLS-1$
|
||||
|
||||
private Object fActiveContext = null;
|
||||
private IReverseToggleHandler fTargetAdapter = null;
|
||||
private IDebugContextService fContextService = null;
|
||||
private Object fActiveContext;
|
||||
private IReverseToggleHandler fTargetAdapter;
|
||||
private IDebugContextService fContextService;
|
||||
|
||||
private static ImageDescriptor getImageDescriptor (String path) {
|
||||
Bundle bundle = Platform.getBundle("org.eclipse.cdt.debug.ui"); //$NON-NLS-1$
|
||||
|
|
@ -106,7 +106,6 @@ public class ReverseToggleCommandHandler extends DebugCommandHandler implements
|
|||
// This constructor might be called after the launch, so we must refresh here too.
|
||||
// This can happen if we activate the action set after the launch.
|
||||
refresh(fContextService.getActiveContext());
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -165,7 +164,7 @@ public class ReverseToggleCommandHandler extends DebugCommandHandler implements
|
|||
|
||||
@Override
|
||||
public Object execute(ExecutionEvent event) throws ExecutionException {
|
||||
ReverseTraceMethod traceMethod;
|
||||
ReverseDebugMethod newMethod;
|
||||
try {
|
||||
if (HandlerUtil.matchesRadioState(event)) {
|
||||
return null;
|
||||
|
|
@ -174,11 +173,11 @@ public class ReverseToggleCommandHandler extends DebugCommandHandler implements
|
|||
String radioState = event.getParameter(RadioState.PARAMETER_ID);
|
||||
|
||||
if (radioState.equals("UseSoftTrace")) { //$NON-NLS-1$
|
||||
traceMethod = ReverseTraceMethod.FULL_TRACE;
|
||||
newMethod = ReverseDebugMethod.SOFTWARE;
|
||||
} else if (radioState.equals("TraceOff")) { //$NON-NLS-1$
|
||||
traceMethod = ReverseTraceMethod.STOP_TRACE;
|
||||
newMethod = ReverseDebugMethod.OFF;
|
||||
} else if (radioState.equals("UseHardTrace")) { //$NON-NLS-1$
|
||||
traceMethod = ReverseTraceMethod.HARDWARE_TRACE;
|
||||
newMethod = ReverseDebugMethod.HARDWARE;
|
||||
} else {
|
||||
// undefined trace method
|
||||
throw new ExecutionException(Messages.ReverseDebugging_UndefinedTraceMethod);
|
||||
|
|
@ -186,10 +185,11 @@ public class ReverseToggleCommandHandler extends DebugCommandHandler implements
|
|||
|
||||
// store the parameter in the gdb command handler class
|
||||
if (fTargetAdapter != null && fTargetAdapter instanceof IChangeReverseMethodHandler) {
|
||||
ReverseTraceMethod currMethod = ((IChangeReverseMethodHandler)fTargetAdapter).getTraceMethod(fActiveContext);
|
||||
if (currMethod == traceMethod)
|
||||
ReverseDebugMethod currMethod = ((IChangeReverseMethodHandler)fTargetAdapter).getReverseDebugMethod(fActiveContext);
|
||||
if (currMethod == newMethod) {
|
||||
return null;
|
||||
((IChangeReverseMethodHandler)fTargetAdapter).setTraceMethod(traceMethod);
|
||||
}
|
||||
((IChangeReverseMethodHandler)fTargetAdapter).setReverseDebugMethod(newMethod);
|
||||
}
|
||||
|
||||
// execute the event
|
||||
|
|
@ -203,18 +203,18 @@ public class ReverseToggleCommandHandler extends DebugCommandHandler implements
|
|||
// Disable tracing
|
||||
if (fTargetAdapter != null && fTargetAdapter instanceof IChangeReverseMethodHandler) {
|
||||
if (fTargetAdapter.toggleNeedsUpdating()) {
|
||||
ReverseTraceMethod LastTraceMethod = ((IChangeReverseMethodHandler)fTargetAdapter).getLastTraceMethod(fActiveContext);
|
||||
ReverseTraceMethod currMethod = ((IChangeReverseMethodHandler)fTargetAdapter).getTraceMethod(fActiveContext);
|
||||
if (currMethod == ReverseTraceMethod.STOP_TRACE) {
|
||||
if (LastTraceMethod == ReverseTraceMethod.HARDWARE_TRACE) {
|
||||
traceMethod = ReverseTraceMethod.HARDWARE_TRACE;
|
||||
ReverseDebugMethod currMethod = ((IChangeReverseMethodHandler)fTargetAdapter).getReverseDebugMethod(fActiveContext);
|
||||
if (currMethod == ReverseDebugMethod.OFF) {
|
||||
ReverseDebugMethod prevMethod = ((IChangeReverseMethodHandler)fTargetAdapter).getPreviousReverseDebugMethod(fActiveContext);
|
||||
if (prevMethod == ReverseDebugMethod.HARDWARE) {
|
||||
newMethod = ReverseDebugMethod.HARDWARE;
|
||||
} else {
|
||||
traceMethod = ReverseTraceMethod.FULL_TRACE;
|
||||
newMethod = ReverseDebugMethod.SOFTWARE;
|
||||
}
|
||||
} else {
|
||||
traceMethod = ReverseTraceMethod.STOP_TRACE;
|
||||
newMethod = ReverseDebugMethod.OFF;
|
||||
}
|
||||
((IChangeReverseMethodHandler)fTargetAdapter).setTraceMethod(traceMethod);
|
||||
((IChangeReverseMethodHandler)fTargetAdapter).setReverseDebugMethod(newMethod);
|
||||
}
|
||||
}
|
||||
super.execute(event);
|
||||
|
|
@ -269,24 +269,24 @@ public class ReverseToggleCommandHandler extends DebugCommandHandler implements
|
|||
public void updateElement(UIElement element,
|
||||
@SuppressWarnings("rawtypes") Map parameters) {
|
||||
if (fTargetAdapter != null && fTargetAdapter instanceof IChangeReverseMethodHandler) {
|
||||
ReverseTraceMethod reverseMethod = ((IChangeReverseMethodHandler)fTargetAdapter).getTraceMethod(fActiveContext);
|
||||
ReverseTraceMethod LastTraceMethod = ((IChangeReverseMethodHandler)fTargetAdapter).getLastTraceMethod(fActiveContext);
|
||||
ReverseDebugMethod currMethod = ((IChangeReverseMethodHandler)fTargetAdapter).getReverseDebugMethod(fActiveContext);
|
||||
ICommandService commandService = PlatformUI.getWorkbench().getService(ICommandService.class);
|
||||
try{
|
||||
if (reverseMethod == ReverseTraceMethod.HARDWARE_TRACE) {
|
||||
if (currMethod == ReverseDebugMethod.HARDWARE) {
|
||||
HandlerUtil.updateRadioState(commandService.getCommand(REVERSE_TOGGLE_COMMAND_ID), "UseHardTrace"); //$NON-NLS-1$
|
||||
element.setTooltip(Messages.ReverseDebugging_ToggleHardwareTrace);
|
||||
element.setIcon(REVERSE_TOGGLE_HARDWARE_ON_IMAGE);
|
||||
} else if (reverseMethod == ReverseTraceMethod.FULL_TRACE) {
|
||||
} else if (currMethod == ReverseDebugMethod.SOFTWARE) {
|
||||
HandlerUtil.updateRadioState(commandService.getCommand(REVERSE_TOGGLE_COMMAND_ID), "UseSoftTrace"); //$NON-NLS-1$
|
||||
element.setTooltip(Messages.ReverseDebugging_ToggleSoftwareTrace);
|
||||
element.setIcon(REVERSE_TOGGLE_SOFTWARE_ON_IMAGE);
|
||||
} else {
|
||||
element.setTooltip(Messages.ReverseDebugging_ToggleReverseDebugging);
|
||||
HandlerUtil.updateRadioState(commandService.getCommand(REVERSE_TOGGLE_COMMAND_ID), "TraceOff"); //$NON-NLS-1$
|
||||
if (LastTraceMethod == ReverseTraceMethod.HARDWARE_TRACE) {
|
||||
element.setTooltip(Messages.ReverseDebugging_ToggleReverseDebugging);
|
||||
ReverseDebugMethod prevMethod = ((IChangeReverseMethodHandler)fTargetAdapter).getPreviousReverseDebugMethod(fActiveContext);
|
||||
if (prevMethod == ReverseDebugMethod.HARDWARE) {
|
||||
element.setIcon(REVERSE_TOGGLE_HARDWARE_OFF_IMAGE);
|
||||
} else if (LastTraceMethod == ReverseTraceMethod.FULL_TRACE) {
|
||||
} else if (prevMethod == ReverseDebugMethod.SOFTWARE) {
|
||||
element.setIcon(REVERSE_TOGGLE_SOFTWARE_OFF_IMAGE);
|
||||
} else {
|
||||
element.setIcon(REVERSE_TOGGLE_DEFAULT_IMAGE);
|
||||
|
|
|
|||
|
|
@ -14,12 +14,16 @@ package org.eclipse.cdt.dsf.gdb.internal.ui.commands;
|
|||
|
||||
import java.util.concurrent.ExecutionException;
|
||||
import java.util.concurrent.RejectedExecutionException;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.concurrent.TimeoutException;
|
||||
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler;
|
||||
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
|
||||
import org.eclipse.cdt.dsf.concurrent.DsfExecutor;
|
||||
import org.eclipse.cdt.dsf.concurrent.DsfRunnable;
|
||||
import org.eclipse.cdt.dsf.concurrent.ImmediateDataRequestMonitor;
|
||||
import org.eclipse.cdt.dsf.concurrent.Query;
|
||||
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
|
||||
import org.eclipse.cdt.dsf.datamodel.DMContexts;
|
||||
import org.eclipse.cdt.dsf.datamodel.IDMContext;
|
||||
import org.eclipse.cdt.dsf.debug.service.IRunControl;
|
||||
|
|
@ -59,17 +63,20 @@ public class GdbReverseToggleCommand extends AbstractDebugCommand implements ICh
|
|||
private final DsfServicesTracker fTracker;
|
||||
private final DsfSession fSession;
|
||||
|
||||
private ReverseTraceMethod fTraceMethod = null;
|
||||
private ReverseTraceMethod fLastTraceMethod = null;
|
||||
private ReverseTraceMethod fNextTraceMethod = null;
|
||||
/** The reverse debugging method that was last returned by the service **/
|
||||
private ReverseDebugMethod fCurrentMethod;
|
||||
/** The reverse debugging method that was used before the new method was selected **/
|
||||
private ReverseDebugMethod fPreviousMethod;
|
||||
/** The reverse debugging method to be used when the toggle button is selected */
|
||||
private ReverseDebugMethod fNextMethod;
|
||||
|
||||
public GdbReverseToggleCommand(DsfSession session) {
|
||||
fExecutor = session.getExecutor();
|
||||
fTracker = new DsfServicesTracker(GdbUIPlugin.getBundleContext(), session.getId());
|
||||
fSession = session;
|
||||
fTraceMethod = ReverseTraceMethod.STOP_TRACE;
|
||||
fLastTraceMethod = ReverseTraceMethod.STOP_TRACE;
|
||||
fNextTraceMethod = ReverseTraceMethod.STOP_TRACE;
|
||||
fCurrentMethod = ReverseDebugMethod.OFF;
|
||||
fPreviousMethod = ReverseDebugMethod.OFF;
|
||||
fNextMethod = ReverseDebugMethod.OFF;
|
||||
|
||||
try {
|
||||
fExecutor.execute(new DsfRunnable() {
|
||||
|
|
@ -113,21 +120,23 @@ public class GdbReverseToggleCommand extends AbstractDebugCommand implements ICh
|
|||
final IReverseRunControl2 runControl = fTracker.getService(IReverseRunControl2.class);
|
||||
|
||||
if (runControl != null) {
|
||||
ReverseTraceMethod traceMethod = fNextTraceMethod;
|
||||
if (fNextTraceMethod == ReverseTraceMethod.HARDWARE_TRACE) {
|
||||
final ReverseDebugMethod newMethod;
|
||||
if (fNextMethod == ReverseDebugMethod.HARDWARE) {
|
||||
String defaultValue = Platform.getPreferencesService().getString(GdbPlugin.PLUGIN_ID,
|
||||
IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_HARDWARE,
|
||||
IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_GDB_TRACE, null);
|
||||
|
||||
if (defaultValue.equals(IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_BRANCH_TRACE)) {
|
||||
traceMethod = ReverseTraceMethod.BRANCH_TRACE; // Branch Trace
|
||||
newMethod = ReverseDebugMethod.BRANCH_TRACE;
|
||||
} else if (defaultValue.equals(IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_PROCESSOR_TRACE)) {
|
||||
traceMethod = ReverseTraceMethod.PROCESSOR_TRACE; // Processor Trace
|
||||
newMethod = ReverseDebugMethod.PROCESSOR_TRACE;
|
||||
} else {
|
||||
traceMethod = ReverseTraceMethod.GDB_TRACE; // GDB Selected Option
|
||||
newMethod = ReverseDebugMethod.GDB_TRACE;
|
||||
}
|
||||
} else {
|
||||
newMethod = fNextMethod;
|
||||
}
|
||||
runControl.enableReverseMode(controlDmc, traceMethod, new DataRequestMonitor<Boolean>(fExecutor, rm) {
|
||||
runControl.enableReverseMode(controlDmc, newMethod, new RequestMonitor(fExecutor, rm) {
|
||||
@Override
|
||||
public void handleError() {
|
||||
// Call the parent function
|
||||
|
|
@ -137,16 +146,21 @@ public class GdbReverseToggleCommand extends AbstractDebugCommand implements ICh
|
|||
// avoid the default dialog box from eclipse and we propagate the error
|
||||
// with the plugin specific code of 1, here the ReverseToggleCommandHandler
|
||||
// interprets it as, the selected trace method is not available
|
||||
request.setStatus(new Status(IStatus.OK, GdbPlugin.PLUGIN_ID, 1, Messages.GdbReverseDebugging_HardwareTracingNotAvailable, null));
|
||||
if (newMethod == ReverseDebugMethod.PROCESSOR_TRACE) {
|
||||
request.setStatus(new Status(IStatus.OK, GdbPlugin.PLUGIN_ID, 1, Messages.GdbReverseDebugging_ProcessorTraceReverseDebugNotAvailable, null));
|
||||
} else if (newMethod == ReverseDebugMethod.BRANCH_TRACE || newMethod == ReverseDebugMethod.GDB_TRACE) {
|
||||
request.setStatus(new Status(IStatus.OK, GdbPlugin.PLUGIN_ID, 1, Messages.GdbReverseDebugging_HardwareReverseDebugNotAvailable, null));
|
||||
} else {
|
||||
request.setStatus(new Status(IStatus.OK, GdbPlugin.PLUGIN_ID, 1, Messages.GdbReverseDebugging_ReverseDebugNotAvailable, null));
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
} else {
|
||||
final IReverseRunControl runControl_old = fTracker.getService(IReverseRunControl.class);
|
||||
if (runControl_old != null) {
|
||||
if (fTraceMethod != ReverseTraceMethod.STOP_TRACE && fTraceMethod != ReverseTraceMethod.FULL_TRACE) {
|
||||
if (fCurrentMethod != ReverseDebugMethod.OFF && fCurrentMethod != ReverseDebugMethod.SOFTWARE) {
|
||||
runControl_old.enableReverseMode(controlDmc, false, rm); // Switch Off tracing
|
||||
request.setStatus(new Status(IStatus.OK, GdbPlugin.PLUGIN_ID, 1, Messages.GdbReverseDebugging_HardwareTracingNotAvailable, null));
|
||||
request.setStatus(new Status(IStatus.OK, GdbPlugin.PLUGIN_ID, 1, Messages.GdbReverseDebugging_HardwareReverseDebugNotAvailable, null));
|
||||
return;
|
||||
}
|
||||
runControl_old.isReverseModeEnabled(controlDmc, new DataRequestMonitor<Boolean>(fExecutor, rm) {
|
||||
|
|
@ -302,12 +316,12 @@ public class GdbReverseToggleCommand extends AbstractDebugCommand implements ICh
|
|||
}
|
||||
|
||||
@Override
|
||||
public void setTraceMethod(ReverseTraceMethod traceMethod) {
|
||||
fNextTraceMethod = traceMethod;
|
||||
public void setReverseDebugMethod(ReverseDebugMethod traceMethod) {
|
||||
fNextMethod = traceMethod;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ReverseTraceMethod getTraceMethod(final Object context) {
|
||||
public ReverseDebugMethod getReverseDebugMethod(final Object context) {
|
||||
IDMContext dmc;
|
||||
|
||||
if (context instanceof IDMContext) {
|
||||
|
|
@ -315,52 +329,74 @@ public class GdbReverseToggleCommand extends AbstractDebugCommand implements ICh
|
|||
} else if (context instanceof IDMVMContext) {
|
||||
dmc = ((IDMVMContext)context).getDMContext();
|
||||
} else {
|
||||
return ReverseTraceMethod.STOP_TRACE;
|
||||
return ReverseDebugMethod.OFF;
|
||||
}
|
||||
|
||||
final ICommandControlDMContext controlDmc = DMContexts.getAncestorOfType(dmc, ICommandControlDMContext.class);
|
||||
if (controlDmc == null) {
|
||||
return ReverseTraceMethod.STOP_TRACE;
|
||||
return ReverseDebugMethod.OFF;
|
||||
}
|
||||
|
||||
Query<ReverseTraceMethod> ReverseMethodQuery = new Query<ReverseTraceMethod>() {
|
||||
@Override
|
||||
public void execute(final DataRequestMonitor<ReverseTraceMethod> rm) {
|
||||
final IReverseRunControl2 runControl = fTracker.getService(IReverseRunControl2.class);
|
||||
if (runControl != null) {
|
||||
runControl.getReverseTraceMethod(controlDmc, rm);
|
||||
}
|
||||
else {
|
||||
rm.setData(ReverseTraceMethod.INVALID);
|
||||
rm.done();
|
||||
}
|
||||
}
|
||||
};
|
||||
try {
|
||||
fExecutor.execute(ReverseMethodQuery);
|
||||
ReverseTraceMethod returnedTrace = ReverseMethodQuery.get();
|
||||
ReverseTraceMethod currTrace = ReverseTraceMethod.INVALID;
|
||||
if (returnedTrace == ReverseTraceMethod.INVALID)
|
||||
currTrace = isReverseToggled(context) ? ReverseTraceMethod.FULL_TRACE : ReverseTraceMethod.STOP_TRACE ;
|
||||
else
|
||||
currTrace = (returnedTrace == ReverseTraceMethod.BRANCH_TRACE ||
|
||||
returnedTrace == ReverseTraceMethod.PROCESSOR_TRACE ||
|
||||
returnedTrace == ReverseTraceMethod.GDB_TRACE ) ? ReverseTraceMethod.HARDWARE_TRACE : returnedTrace;
|
||||
if (currTrace != fTraceMethod) {
|
||||
fLastTraceMethod = fTraceMethod;
|
||||
fTraceMethod = currTrace;
|
||||
}
|
||||
return fTraceMethod;
|
||||
} catch (InterruptedException e) {
|
||||
} catch (ExecutionException e) {
|
||||
} catch (RejectedExecutionException e) {
|
||||
}
|
||||
Query<ReverseDebugMethod> reverseMethodQuery = new Query<ReverseDebugMethod>() {
|
||||
@Override
|
||||
public void execute(DataRequestMonitor<ReverseDebugMethod> rm) {
|
||||
IReverseRunControl2 runControl = fTracker.getService(IReverseRunControl2.class);
|
||||
if (runControl != null) {
|
||||
runControl.getReverseTraceMethod(controlDmc, new ImmediateDataRequestMonitor<ReverseDebugMethod>(rm) {
|
||||
@Override
|
||||
protected void handleCompleted() {
|
||||
if (!isSuccess()) {
|
||||
rm.done(ReverseDebugMethod.OFF);
|
||||
} else {
|
||||
ReverseDebugMethod method = getData();
|
||||
if (method == ReverseDebugMethod.BRANCH_TRACE ||
|
||||
method == ReverseDebugMethod.PROCESSOR_TRACE ||
|
||||
method == ReverseDebugMethod.GDB_TRACE) {
|
||||
method = ReverseDebugMethod.HARDWARE;
|
||||
}
|
||||
rm.done(method);
|
||||
}
|
||||
}
|
||||
});
|
||||
} else {
|
||||
IReverseRunControl runControl_old = fTracker.getService(IReverseRunControl.class);
|
||||
if (runControl_old != null) {
|
||||
runControl_old.isReverseModeEnabled(controlDmc, new ImmediateDataRequestMonitor<Boolean>(rm) {
|
||||
@Override
|
||||
protected void handleCompleted() {
|
||||
if (isSuccess() && getData()) {
|
||||
rm.done(ReverseDebugMethod.SOFTWARE);
|
||||
} else {
|
||||
rm.done(ReverseDebugMethod.OFF);
|
||||
}
|
||||
}
|
||||
});
|
||||
} else {
|
||||
rm.done(ReverseDebugMethod.OFF);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
try {
|
||||
fExecutor.execute(reverseMethodQuery);
|
||||
ReverseDebugMethod currMethod = reverseMethodQuery.get(500, TimeUnit.MILLISECONDS);
|
||||
|
||||
if (currMethod != fCurrentMethod) {
|
||||
fPreviousMethod = fCurrentMethod;
|
||||
fCurrentMethod = currMethod;
|
||||
}
|
||||
return fCurrentMethod;
|
||||
} catch (InterruptedException e) {
|
||||
} catch (ExecutionException e) {
|
||||
} catch (RejectedExecutionException e) {
|
||||
} catch (TimeoutException e) {
|
||||
}
|
||||
|
||||
return ReverseTraceMethod.STOP_TRACE;
|
||||
return ReverseDebugMethod.OFF;
|
||||
}
|
||||
|
||||
@Override
|
||||
public ReverseTraceMethod getLastTraceMethod(Object context) {
|
||||
return fLastTraceMethod;
|
||||
public ReverseDebugMethod getPreviousReverseDebugMethod(Object context) {
|
||||
return fPreviousMethod;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -49,7 +49,11 @@ public class Messages extends NLS {
|
|||
|
||||
public static String GdbDebugNewExecutableCommand_Select_binary_and_specify_arguments;
|
||||
|
||||
public static String GdbReverseDebugging_HardwareTracingNotAvailable;
|
||||
public static String GdbReverseDebugging_HardwareReverseDebugNotAvailable;
|
||||
|
||||
public static String GdbReverseDebugging_ProcessorTraceReverseDebugNotAvailable;
|
||||
|
||||
public static String GdbReverseDebugging_ReverseDebugNotAvailable;
|
||||
|
||||
public static String GdbConnectCommand_Error;
|
||||
|
||||
|
|
|
|||
|
|
@ -27,7 +27,8 @@ GdbDebugNewExecutableCommand_Select_binaries_on_host_and_target=Select binaries
|
|||
GdbDebugNewExecutableCommand_Select_Binary=Select Binary
|
||||
GdbDebugNewExecutableCommand_Select_binary_and_specify_arguments=Select a binary and specify the arguments
|
||||
|
||||
GdbReverseDebugging_HardwareTracingNotAvailable=Hardware Tracing Method not available, Reverse debugging is switched Off, please select another method
|
||||
|
||||
GdbReverseDebugging_HardwareReverseDebugNotAvailable=Hardware reverse debugging not available. Reverse debugging has been turned off. Please select software reverse debugging explicitly.
|
||||
GdbReverseDebugging_ProcessorTraceReverseDebugNotAvailable=Hardware reverse debugging based on Processor Trace not available. Reverse debugging has been turned off. Please select software reverse debugging or go to the Reverse Debugging preference page to try another type of hardware reverse debugging.
|
||||
GdbReverseDebugging_ReverseDebugNotAvailable=Unable to toggle reverse debugging.
|
||||
GdbConnectCommand_FailureMessage=Failure to attach to process:
|
||||
GdbConnectCommand_Error=Error:
|
||||
|
|
@ -12,7 +12,7 @@ package org.eclipse.cdt.dsf.gdb.service;
|
|||
|
||||
import java.util.Map;
|
||||
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseTraceMethod;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseDebugMethod;
|
||||
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
|
||||
import org.eclipse.cdt.dsf.concurrent.DsfExecutor;
|
||||
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
|
||||
|
|
@ -61,18 +61,18 @@ public class GDBProcesses_7_10 extends GDBProcesses_7_4 {
|
|||
launch.getLaunchConfiguration().getAttribute(IGDBLaunchConfigurationConstants.ATTR_DEBUGGER_REVERSE_MODE,
|
||||
IGDBLaunchConfigurationConstants.DEBUGGER_REVERSE_MODE_DEFAULT);
|
||||
if (reverseMode.equals(IGDBLaunchConfigurationConstants.DEBUGGER_REVERSE_MODE_SOFTWARE)) {
|
||||
reverseService.enableReverseMode(controlContext, ReverseTraceMethod.FULL_TRACE, rm);
|
||||
reverseService.enableReverseMode(controlContext, ReverseDebugMethod.SOFTWARE, rm);
|
||||
}
|
||||
else if (reverseMode.equals(IGDBLaunchConfigurationConstants.DEBUGGER_REVERSE_MODE_HARDWARE)) {
|
||||
String defaultValue = Platform.getPreferencesService().getString(GdbPlugin.PLUGIN_ID,
|
||||
IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_HARDWARE,
|
||||
IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_GDB_TRACE, null);
|
||||
|
||||
ReverseTraceMethod traceMethod = ReverseTraceMethod.GDB_TRACE;
|
||||
ReverseDebugMethod traceMethod = ReverseDebugMethod.GDB_TRACE;
|
||||
if (defaultValue.equals(IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_BRANCH_TRACE)) {
|
||||
traceMethod = ReverseTraceMethod.BRANCH_TRACE;
|
||||
traceMethod = ReverseDebugMethod.BRANCH_TRACE;
|
||||
} else if (defaultValue.equals(IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_PROCESSOR_TRACE)) {
|
||||
traceMethod = ReverseTraceMethod.PROCESSOR_TRACE;
|
||||
traceMethod = ReverseDebugMethod.PROCESSOR_TRACE;
|
||||
}
|
||||
|
||||
reverseService.enableReverseMode(controlContext, traceMethod, rm);
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ package org.eclipse.cdt.dsf.gdb.service;
|
|||
|
||||
import java.util.Hashtable;
|
||||
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseTraceMethod;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseDebugMethod;
|
||||
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
|
||||
import org.eclipse.cdt.dsf.concurrent.ImmediateRequestMonitor;
|
||||
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
|
||||
|
|
@ -35,7 +35,7 @@ public class GDBRunControl_7_10 extends GDBRunControl_7_6 implements IReverseRun
|
|||
private IMICommandControl fCommandControl;
|
||||
private CommandFactory fCommandFactory;
|
||||
|
||||
private ReverseTraceMethod fReverseTraceMethod; // default: no trace
|
||||
private ReverseDebugMethod fReverseTraceMethod; // default: no trace
|
||||
|
||||
public GDBRunControl_7_10(DsfSession session) {
|
||||
super(session);
|
||||
|
|
@ -56,7 +56,7 @@ public class GDBRunControl_7_10 extends GDBRunControl_7_6 implements IReverseRun
|
|||
|
||||
fCommandControl = getServicesTracker().getService(IMICommandControl.class);
|
||||
fCommandFactory = fCommandControl.getCommandFactory();
|
||||
fReverseTraceMethod = ReverseTraceMethod.STOP_TRACE;
|
||||
fReverseTraceMethod = ReverseDebugMethod.OFF;
|
||||
|
||||
if (fCommandControl == null) {
|
||||
requestMonitor.done(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, "Service is not available")); //$NON-NLS-1$
|
||||
|
|
@ -72,13 +72,13 @@ public class GDBRunControl_7_10 extends GDBRunControl_7_6 implements IReverseRun
|
|||
}
|
||||
|
||||
@Override
|
||||
public void getReverseTraceMethod(ICommandControlDMContext context, DataRequestMonitor<ReverseTraceMethod> rm) {
|
||||
public void getReverseTraceMethod(ICommandControlDMContext context, DataRequestMonitor<ReverseDebugMethod> rm) {
|
||||
rm.setData(fReverseTraceMethod);
|
||||
rm.done();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void enableReverseMode(final ICommandControlDMContext context,final ReverseTraceMethod traceMethod, final RequestMonitor rm) {
|
||||
public void enableReverseMode(final ICommandControlDMContext context,final ReverseDebugMethod traceMethod, final RequestMonitor rm) {
|
||||
if (!getReverseSupported()) {
|
||||
rm.done(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, NOT_SUPPORTED, "Reverse mode is not supported.", null)); //$NON-NLS-1$
|
||||
return;
|
||||
|
|
@ -89,7 +89,7 @@ public class GDBRunControl_7_10 extends GDBRunControl_7_6 implements IReverseRun
|
|||
return;
|
||||
}
|
||||
|
||||
if (fReverseTraceMethod == ReverseTraceMethod.STOP_TRACE || traceMethod == ReverseTraceMethod.STOP_TRACE) {
|
||||
if (fReverseTraceMethod == ReverseDebugMethod.OFF || traceMethod == ReverseDebugMethod.OFF) {
|
||||
getConnection().queueCommand(
|
||||
fCommandFactory.createCLIRecord(context, traceMethod),
|
||||
new DataRequestMonitor<MIInfo>(getExecutor(), rm) {
|
||||
|
|
@ -97,7 +97,7 @@ public class GDBRunControl_7_10 extends GDBRunControl_7_6 implements IReverseRun
|
|||
public void handleSuccess() {
|
||||
boolean enabled = false;
|
||||
fReverseTraceMethod = traceMethod;
|
||||
if (fReverseTraceMethod != ReverseTraceMethod.STOP_TRACE) {
|
||||
if (fReverseTraceMethod != ReverseDebugMethod.OFF) {
|
||||
enabled = true;
|
||||
}
|
||||
setReverseModeEnabled(enabled );
|
||||
|
|
@ -112,7 +112,7 @@ public class GDBRunControl_7_10 extends GDBRunControl_7_6 implements IReverseRun
|
|||
}
|
||||
|
||||
getConnection().queueCommand(
|
||||
fCommandFactory.createCLIRecord(context, ReverseTraceMethod.STOP_TRACE),
|
||||
fCommandFactory.createCLIRecord(context, ReverseDebugMethod.OFF),
|
||||
new DataRequestMonitor<MIInfo>(getExecutor(), rm) {
|
||||
@Override
|
||||
public void handleSuccess() {
|
||||
|
|
@ -130,7 +130,7 @@ public class GDBRunControl_7_10 extends GDBRunControl_7_6 implements IReverseRun
|
|||
public void handleFailure() {
|
||||
rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, INVALID_STATE, "Trace method could not be selected", null)); //$NON-NLS-1$
|
||||
setReverseModeEnabled(false);
|
||||
fReverseTraceMethod = ReverseTraceMethod.STOP_TRACE;
|
||||
fReverseTraceMethod = ReverseDebugMethod.OFF;
|
||||
rm.done();
|
||||
}
|
||||
});
|
||||
|
|
@ -151,7 +151,7 @@ public class GDBRunControl_7_10 extends GDBRunControl_7_6 implements IReverseRun
|
|||
if ("record-started".equals(asyncClass) || //$NON-NLS-1$
|
||||
"record-stopped".equals(asyncClass)) { //$NON-NLS-1$
|
||||
if ("record-stopped".equals(asyncClass)) { //$NON-NLS-1$
|
||||
fReverseTraceMethod = ReverseTraceMethod.STOP_TRACE;
|
||||
fReverseTraceMethod = ReverseDebugMethod.OFF;
|
||||
setReverseModeEnabled(false);
|
||||
} else {
|
||||
getConnection().queueCommand(
|
||||
|
|
@ -163,7 +163,7 @@ public class GDBRunControl_7_10 extends GDBRunControl_7_6 implements IReverseRun
|
|||
fReverseTraceMethod = getData().getReverseMethod();
|
||||
} else {
|
||||
// Use a default value in case of error
|
||||
fReverseTraceMethod = ReverseTraceMethod.FULL_TRACE;
|
||||
fReverseTraceMethod = ReverseDebugMethod.SOFTWARE;
|
||||
}
|
||||
setReverseModeEnabled(true);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -10,25 +10,21 @@
|
|||
*******************************************************************************/
|
||||
package org.eclipse.cdt.dsf.gdb.service;
|
||||
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseDebugMethod;
|
||||
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
|
||||
import org.eclipse.cdt.dsf.concurrent.RequestMonitor;
|
||||
import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService.ICommandControlDMContext;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseTraceMethod;
|
||||
|
||||
/** @since 5.0 */
|
||||
public interface IReverseRunControl2 extends IReverseRunControl {
|
||||
|
||||
/**
|
||||
* Get the reverse debugging trace method.
|
||||
*
|
||||
* @param rm Will contain the result of the operation, true or false, not null.
|
||||
* Get the reverse debugging method.
|
||||
*/
|
||||
void getReverseTraceMethod(ICommandControlDMContext context, DataRequestMonitor<ReverseTraceMethod> rm);
|
||||
void getReverseTraceMethod(ICommandControlDMContext context, DataRequestMonitor<ReverseDebugMethod> rm);
|
||||
|
||||
/**
|
||||
* Change reverse debugging trace method based on the method parameter.
|
||||
*
|
||||
* @param set the reverse debugging trace method to Full Trace, Branch Trace or Processor Trace
|
||||
* Change reverse debugging method based on the method parameter.
|
||||
*/
|
||||
void enableReverseMode(ICommandControlDMContext context, ReverseTraceMethod traceMethod, RequestMonitor rm);
|
||||
void enableReverseMode(ICommandControlDMContext context, ReverseDebugMethod traceMethod, RequestMonitor rm);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ import java.util.List;
|
|||
import java.util.Map;
|
||||
|
||||
import org.eclipse.cdt.debug.core.CDebugUtils;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseTraceMethod;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseDebugMethod;
|
||||
import org.eclipse.cdt.dsf.concurrent.DataRequestMonitor;
|
||||
import org.eclipse.cdt.dsf.concurrent.DsfExecutor;
|
||||
import org.eclipse.cdt.dsf.concurrent.IDsfStatusConstants;
|
||||
|
|
@ -39,7 +39,7 @@ public class StartOrRestartProcessSequence_7_10 extends StartOrRestartProcessSeq
|
|||
|
||||
private IGDBControl fCommandControl;
|
||||
private IReverseRunControl2 fReverseService;
|
||||
private ReverseTraceMethod fReverseMode = ReverseTraceMethod.FULL_TRACE;
|
||||
private ReverseDebugMethod fReverseMode = ReverseDebugMethod.SOFTWARE;
|
||||
private final Map<String, Object> fAttributes;
|
||||
|
||||
public StartOrRestartProcessSequence_7_10(DsfExecutor executor, IContainerDMContext containerDmc,
|
||||
|
|
@ -94,14 +94,14 @@ public class StartOrRestartProcessSequence_7_10 extends StartOrRestartProcessSeq
|
|||
IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_GDB_TRACE, null);
|
||||
|
||||
if (hwTracePref.equals(IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_BRANCH_TRACE)) {
|
||||
fReverseMode = ReverseTraceMethod.BRANCH_TRACE;
|
||||
fReverseMode = ReverseDebugMethod.BRANCH_TRACE;
|
||||
} else if (hwTracePref.equals(IGdbDebugPreferenceConstants.PREF_REVERSE_TRACE_METHOD_PROCESSOR_TRACE)) {
|
||||
fReverseMode = ReverseTraceMethod.PROCESSOR_TRACE;
|
||||
fReverseMode = ReverseDebugMethod.PROCESSOR_TRACE;
|
||||
} else {
|
||||
fReverseMode = ReverseTraceMethod.GDB_TRACE;
|
||||
fReverseMode = ReverseDebugMethod.GDB_TRACE;
|
||||
}
|
||||
} else if (reverseMode.equals(IGDBLaunchConfigurationConstants.DEBUGGER_REVERSE_MODE_SOFTWARE)) {
|
||||
fReverseMode = ReverseTraceMethod.FULL_TRACE;
|
||||
fReverseMode = ReverseDebugMethod.SOFTWARE;
|
||||
} else {
|
||||
rm.setStatus(new Status(IStatus.ERROR, GdbPlugin.PLUGIN_ID, IDsfStatusConstants.INTERNAL_ERROR, "Unexpected reverse debugging type: " + reverseMode, null)); //$NON-NLS-1$
|
||||
}
|
||||
|
|
|
|||
|
|
@ -243,7 +243,7 @@ import org.eclipse.cdt.dsf.mi.service.command.output.MIVarShowAttributesInfo;
|
|||
import org.eclipse.cdt.dsf.mi.service.command.output.MIVarShowFormatInfo;
|
||||
import org.eclipse.cdt.dsf.mi.service.command.output.MIVarUpdateInfo;
|
||||
import org.eclipse.cdt.dsf.mi.service.command.output.CLIInfoRecordInfo;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseTraceMethod;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseDebugMethod;
|
||||
|
||||
/**
|
||||
* Factory to create MI/CLI commands.
|
||||
|
|
@ -329,7 +329,7 @@ public class CommandFactory {
|
|||
}
|
||||
|
||||
/** @since 5.0*/
|
||||
public ICommand<MIInfo> createCLIRecord(ICommandControlDMContext ctx, ReverseTraceMethod traceMethod) {
|
||||
public ICommand<MIInfo> createCLIRecord(ICommandControlDMContext ctx, ReverseDebugMethod traceMethod) {
|
||||
return new CLIRecord(ctx, traceMethod);
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ package org.eclipse.cdt.dsf.mi.service.command.commands;
|
|||
|
||||
import org.eclipse.cdt.dsf.debug.service.command.ICommandControlService.ICommandControlDMContext;
|
||||
import org.eclipse.cdt.dsf.mi.service.command.output.MIInfo;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseTraceMethod;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseDebugMethod;
|
||||
|
||||
/**
|
||||
* This command turns on on off the recording of "Process Record and Replay".
|
||||
|
|
@ -28,23 +28,23 @@ public class CLIRecord extends CLICommand<MIInfo> {
|
|||
|
||||
/** Only available for GDB >= 7.10 */
|
||||
/** @since 5.0 */
|
||||
public CLIRecord(ICommandControlDMContext ctx, ReverseTraceMethod traceMethod) {
|
||||
public CLIRecord(ICommandControlDMContext ctx, ReverseDebugMethod traceMethod) {
|
||||
super(ctx, "record" + createRecordParams(traceMethod)); //$NON-NLS-1$
|
||||
}
|
||||
|
||||
private static String createRecordParams(ReverseTraceMethod traceMethod)
|
||||
private static String createRecordParams(ReverseDebugMethod traceMethod)
|
||||
{
|
||||
String recordParam;
|
||||
|
||||
if (traceMethod == ReverseTraceMethod.STOP_TRACE) {
|
||||
if (traceMethod == ReverseDebugMethod.OFF) {
|
||||
recordParam = " stop"; //$NON-NLS-1$
|
||||
} else if (traceMethod == ReverseTraceMethod.FULL_TRACE) {
|
||||
} else if (traceMethod == ReverseDebugMethod.SOFTWARE) {
|
||||
recordParam = " full"; //$NON-NLS-1$
|
||||
} else if (traceMethod == ReverseTraceMethod.BRANCH_TRACE) {
|
||||
} else if (traceMethod == ReverseDebugMethod.BRANCH_TRACE) {
|
||||
recordParam = " btrace bts"; //$NON-NLS-1$
|
||||
} else if (traceMethod == ReverseTraceMethod.PROCESSOR_TRACE) {
|
||||
} else if (traceMethod == ReverseDebugMethod.PROCESSOR_TRACE) {
|
||||
recordParam = " btrace pt"; //$NON-NLS-1$
|
||||
} else if (traceMethod == ReverseTraceMethod.GDB_TRACE) {
|
||||
} else if (traceMethod == ReverseDebugMethod.GDB_TRACE) {
|
||||
recordParam = " btrace"; //$NON-NLS-1$
|
||||
} else {// no trace method defined
|
||||
recordParam = ""; //$NON-NLS-1$
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@
|
|||
*******************************************************************************/
|
||||
package org.eclipse.cdt.dsf.mi.service.command.output;
|
||||
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseTraceMethod;
|
||||
import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseDebugMethod;
|
||||
|
||||
/**
|
||||
* 'info record' returns the selected reverse trace method.
|
||||
|
|
@ -28,7 +28,7 @@ import org.eclipse.cdt.debug.core.model.IChangeReverseMethodHandler.ReverseTrace
|
|||
|
||||
public class CLIInfoRecordInfo extends MIInfo {
|
||||
|
||||
private ReverseTraceMethod fReverseMethod;
|
||||
private ReverseDebugMethod fReverseMethod;
|
||||
|
||||
public CLIInfoRecordInfo(MIOutput record) {
|
||||
super(record);
|
||||
|
|
@ -52,17 +52,17 @@ public class CLIInfoRecordInfo extends MIInfo {
|
|||
|
||||
protected void parseReverseMethod(String output) {
|
||||
if (output.contains("Processor")) { //$NON-NLS-1$
|
||||
fReverseMethod = ReverseTraceMethod.PROCESSOR_TRACE;
|
||||
fReverseMethod = ReverseDebugMethod.PROCESSOR_TRACE;
|
||||
} else if (output.contains("Branch")) { //$NON-NLS-1$
|
||||
fReverseMethod = ReverseTraceMethod.BRANCH_TRACE;
|
||||
fReverseMethod = ReverseDebugMethod.BRANCH_TRACE;
|
||||
} else if (output.contains("full")) { //$NON-NLS-1$
|
||||
fReverseMethod = ReverseTraceMethod.FULL_TRACE;
|
||||
fReverseMethod = ReverseDebugMethod.SOFTWARE;
|
||||
} else {
|
||||
fReverseMethod = ReverseTraceMethod.STOP_TRACE;
|
||||
fReverseMethod = ReverseDebugMethod.OFF;
|
||||
}
|
||||
}
|
||||
|
||||
public ReverseTraceMethod getReverseMethod() {
|
||||
public ReverseDebugMethod getReverseMethod() {
|
||||
return fReverseMethod;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue