public void SetUp()
{
logSpy = new LogSpy();
logSpy.Attach();
taskContext = new JoinableTaskContext();
returnObjectMock = Substitute.For <SbCommandReturnObject>();
returnObjectMock.GetDescription().Returns(COMMAND_DESCRIPTION);
commandInterpreterMock = Substitute.For <SbCommandInterpreter>();
commandInterpreterMock.WhenForAnyArgs(x => x.HandleCommand(DUMMY_COMMAND,
out returnObjectMock)).Do(x => x[1] = returnObjectMock);
debuggerMock = Substitute.For <SbDebugger>();
debuggerMock.GetCommandInterpreter().Returns(commandInterpreterMock);
commandWindowText = "";
commandWindowMock = Substitute.For <IVsCommandWindow>();
commandWindowMock.Print(Arg.Do <string>(x => commandWindowText += x));
commandWindowWriter = new CommandWindowWriter(taskContext, commandWindowMock);
shell = new YetiVSI.LLDBShell.LLDBShell(taskContext, commandWindowWriter);
shell.AddDebugger(debuggerMock);
}
public void SetUp()
{
_lldbShell = Substitute.For <ILLDBShell>();
_breakpointManager = Substitute.For <IBreakpointManager>();
_moduleFileLoader = Substitute.For <IModuleFileLoader>();
_debugger = Substitute.For <SbDebugger>();
_target = Substitute.For <RemoteTarget>();
_listenerSubscriber = Substitute.For <ILldbListenerSubscriber>();
_process = Substitute.For <SbProcess>();
_debugEngineHandler = Substitute.For <IDebugEngineHandler>();
_taskExecutor = Substitute.For <ITaskExecutor>();
_eventManager = Substitute.For <IEventManager>();
var exceptionManagerFactory =
new LldbExceptionManager.Factory(new Dictionary <int, YetiCommon.Signal>());
var exceptionManager = exceptionManagerFactory.Create(_process);
_debugModuleCache = Substitute.For <IDebugModuleCache>();
_debugProgram = Substitute.For <IGgpDebugProgram>();
_attachedProgram = new LldbAttachedProgram(
_breakpointManager, _eventManager, _lldbShell, _moduleFileLoader,
_debugEngineHandler, _taskExecutor, _debugProgram, _debugger, _target, _process,
exceptionManager, _debugModuleCache, _listenerSubscriber, _remotePid);
}
/// <summary>
/// LoadLocalLldbInit looks for a local LLDB config (~/.lldbinit), logs its contents and
/// then issues RPCs to load it in LLDB. Internally LLDB will try to load one of the
/// following files: ~/.lldbinit-{PROGRAM_NAME}, ~/.lldbinit, {CWD}/.lldbinit (in that
/// order). We check only for ~/.lldbinit and don't call `SourceInitFileInHomeDirectory`
/// if it doesn't exist.
/// </summary>
void LoadLocalLldbInit(SbDebugger debugger)
{
var lldbinitPath = SbDebuggerExtensions.GetLLDBInitPath();
string lldbinit;
try
{
lldbinit = _fileSystem.File.ReadAllText(lldbinitPath);
}
catch (FileNotFoundException)
{
Trace.WriteLine("No local ~/.lldbinit found, don't try loading it in LLDB.");
return;
}
catch (Exception e)
{
Trace.WriteLine($"Unexpected error while reading {lldbinitPath}: {e}");
return;
}
Trace.WriteLine($"Found ~/.lldbinit ({lldbinitPath}), LLDB will try to load it:" +
$"{Environment.NewLine}{lldbinit}{Environment.NewLine}EOF");
debugger.SkipLLDBInitFiles(false);
debugger.GetCommandInterpreter().SourceInitFileInHomeDirectory();
}
public static void SetDefaultLLDBSettings(this SbDebugger debugger)
{
foreach (string s in DefaultLLDBSettings)
{
debugger.GetCommandInterpreter().HandleAndLogCommand(s);
}
}
RemoteTarget CreateTarget(SbDebugger lldbDebugger, string executable)
{
RemoteTarget lldbTarget = lldbDebugger.CreateTarget(executable);
if (lldbTarget == null)
{
throw new AttachException(VSConstants.E_ABORT,
ErrorStrings.FailedToCreateDebugTarget);
}
return(lldbTarget);
}
SbPlatform CreateRemotePlatform(GrpcConnection grpcConnection, SbDebugger debugger)
{
string platformName;
if (debugger.IsPlatformAvailable(_remoteLldbPlatformName))
{
_stadiaPlatformAvailable = true;
platformName = _remoteLldbPlatformName;
}
else
{
platformName = _fallbackRemoteLldbPlatformName;
}
return(_lldbPlatformFactory.Create(platformName, grpcConnection));
}
/// <summary>
/// Create a new LLDB SBDebugger object locally. This SBDebugger object is then used for
/// all subsecent requests.
/// </summary>
public override Task <CreateResponse> Create(CreateRequest request,
ServerCallContext context)
{
// Lock around sbDebugger.
lock (thisLock)
{
// We only support creating one SBDebugger object, fail if there is an attempt to
// create more.
if (sbDebugger != null)
{
ErrorUtils.ThrowError(StatusCode.FailedPrecondition,
"Creating multiple SBDebugger objects is not supported.");
}
sbDebugger = sbDebuggerFactory.Create(request.SourceInitFiles);
if (sbDebugger == null)
{
ErrorUtils.ThrowError(StatusCode.Internal, "Could not create SBDebugger.");
}
return(Task.FromResult(new CreateResponse()));
}
}
public LldbAttachedProgram(IBreakpointManager breakpointManager, IEventManager eventManager,
ILLDBShell lldbShell, IModuleFileLoader moduleFileLoader,
IDebugEngineHandler debugEngineHandler,
ITaskExecutor taskExecutor, IGgpDebugProgram debugProgram,
SbDebugger debugger, RemoteTarget target, SbProcess process,
IExceptionManager exceptionManager,
IDebugModuleCache debugModuleCache,
ILldbListenerSubscriber listenerSubscriber, uint remotePid)
{
_debugProgram = debugProgram;
_breakpointManager = breakpointManager;
_eventManager = eventManager;
_lldbShell = lldbShell;
_moduleFileLoader = moduleFileLoader;
_debugEngineHandler = debugEngineHandler;
_taskExecutor = taskExecutor;
_debugger = debugger;
_target = target;
_process = process;
_exceptionManager = exceptionManager;
_debugModuleCache = debugModuleCache;
_listenerSubscriber = listenerSubscriber;
RemotePid = remotePid;
}
// Should only be called from the UI thread!
public void RemoveDebugger(SbDebugger debugger)
{
taskContext.ThrowIfNotOnMainThread();
debuggers.Remove(debugger);
}
// Should only be called from the UI thread!
public void AddDebugger(SbDebugger debugger)
{
taskContext.ThrowIfNotOnMainThread();
debuggers.Add(debugger);
}
public ILldbAttachedProgram Create(
IDebugProcess2 debugProcess, Guid programId, IDebugEngine2 debugEngine,
IDebugEventCallback2 callback, SbDebugger debugger, RemoteTarget target,
LldbListenerSubscriber listenerSubscriber, SbProcess process,
SbCommandInterpreter commandInterpreter, bool isCoreAttach,
IExceptionManager exceptionManager, IModuleSearchLogHolder moduleSearchLogHolder,
uint remotePid)
{
// Required due to an issue triggered by the proxy used to wrap debugProgramFactory.
// TODO: Remove assertion once the issue with Castle.DynamicProxy is
// fixed.
_taskContext.ThrowIfNotOnMainThread();
var debugEngineHandler = _debugEngineHandlerFactory.Create(debugEngine, callback);
var binaryLoader = _binaryLoaderFactory.Create(target);
var symbolLoader = _symbolLoaderFactory.Create(commandInterpreter);
var moduleFileLoader = _moduleFileLoaderFactory.Create(symbolLoader, binaryLoader,
moduleSearchLogHolder);
var debugModuleCache = _debugModuleCacheFactory.Create(
(lldbModule, loadOrder, ggpProgram) => _debugModuleFactory.Create(
moduleFileLoader, moduleSearchLogHolder, lldbModule, loadOrder,
debugEngineHandler, ggpProgram));
var ad7FrameInfoCreator = new AD7FrameInfoCreator(debugModuleCache);
var stackFrameCreator = new StackFramesProvider.StackFrameCreator(
(frame, thread, program) => _debugStackFrameCreator(
ad7FrameInfoCreator, frame, thread, debugEngineHandler, program));
var threadCreator = new DebugProgram.ThreadCreator(
(thread, program) => _debugThreadCreatorDelegate(
ad7FrameInfoCreator, stackFrameCreator, thread, program));
var debugProgram = _debugProgramFactory.Create(
debugEngineHandler, threadCreator, debugProcess, programId, process, target,
debugModuleCache, isCoreAttach);
_taskExecutor.StartAsyncTasks(
ex => debugEngineHandler.Abort(debugProgram, ExitInfo.Error(ex)));
var breakpointManager =
_breakpointManagerFactory.Create(debugEngineHandler, debugProgram);
var eventManager =
_eventManagerFactory.Create(debugEngineHandler, breakpointManager, debugProgram,
process, listenerSubscriber);
// TODO: Listen for module load/unload events from LLDB
binaryLoader.LldbModuleReplaced += (o, args) =>
{
debugModuleCache.GetOrCreate(args.AddedModule, debugProgram);
debugModuleCache.Remove(args.RemovedModule);
};
debugModuleCache.ModuleAdded += (o, args) =>
debugEngineHandler.OnModuleLoad(args.Module, debugProgram);
debugModuleCache.ModuleRemoved += (o, args) =>
debugEngineHandler.OnModuleUnload(args.Module, debugProgram);
return(new LldbAttachedProgram(breakpointManager, eventManager, _lldbShell,
moduleFileLoader, debugEngineHandler, _taskExecutor,
debugProgram, debugger, target, process,
exceptionManager, debugModuleCache,
listenerSubscriber, remotePid));
}
public static void SetLibrarySearchPath(this SbDebugger debugger, string path)
{
debugger.GetCommandInterpreter().HandleAndLogCommand(
CreateSetLibrarySearchPathCommand(path));
}
public static void EnableFastExpressionEvaluation(this SbDebugger debugger)
{
Trace.WriteLine("Enabling fast expression evaluation.");
debugger.GetCommandInterpreter().HandleAndLogCommand(FastExpressionEvaluationCommand);
}
