63e512100a
This is a modified version of a previous patch that was reverted: https://reviews.llvm.org/D119797 This version only waits for the process to stop when using "launchCommands" or "attachCommands"... ...and doesn't play with the async mode when doing normal launch/attach. We discovered that when using "launchCommands" or "attachCommands" that there was an issue where these commands were not being run synchronously. There were further problems in this case where we would get thread events for the process that was just launched or attached before the IDE was ready, which is after "configurationDone" was sent to lldb-vscode. This fix introduces the ability to wait for the process to stop after "launchCommands" or "attachCommands" are run to ensure that we have a stopped process point that is ready for the debug session to proceed. We spin up the thread that listens for process events before we start the launch or attach, but we don't want stop events being delivered through the DAP protocol until the "configurationDone" packet is received. We now always ignore the stop event with a stop ID of 1, which is the first stop. All normal launch and attach scenarios use the synchronous mode, and "launchCommands and "attachCommands" run an array of LLDB commands in async mode. This should make our launch with "launchCommands" and attach with "attachCommands" avoid a race condition when the process is being launched or attached. Differential Revision: https://reviews.llvm.org/D120755
280 lines
9.8 KiB
C++
280 lines
9.8 KiB
C++
//===-- VSCode.h ------------------------------------------------*- C++ -*-===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLDB_TOOLS_LLDB_VSCODE_VSCODE_H
|
|
#define LLDB_TOOLS_LLDB_VSCODE_VSCODE_H
|
|
|
|
#include "llvm/Config/llvm-config.h" // for LLVM_ON_UNIX
|
|
|
|
#include <condition_variable>
|
|
#include <cstdio>
|
|
#include <iosfwd>
|
|
#include <map>
|
|
#include <set>
|
|
#include <thread>
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/DenseSet.h"
|
|
#include "llvm/ADT/StringMap.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/Support/JSON.h"
|
|
#include "llvm/Support/raw_ostream.h"
|
|
|
|
#include "lldb/API/SBAttachInfo.h"
|
|
#include "lldb/API/SBBreakpoint.h"
|
|
#include "lldb/API/SBBreakpointLocation.h"
|
|
#include "lldb/API/SBCommandInterpreter.h"
|
|
#include "lldb/API/SBCommandReturnObject.h"
|
|
#include "lldb/API/SBCommunication.h"
|
|
#include "lldb/API/SBDebugger.h"
|
|
#include "lldb/API/SBEvent.h"
|
|
#include "lldb/API/SBHostOS.h"
|
|
#include "lldb/API/SBInstruction.h"
|
|
#include "lldb/API/SBInstructionList.h"
|
|
#include "lldb/API/SBLanguageRuntime.h"
|
|
#include "lldb/API/SBLaunchInfo.h"
|
|
#include "lldb/API/SBLineEntry.h"
|
|
#include "lldb/API/SBListener.h"
|
|
#include "lldb/API/SBProcess.h"
|
|
#include "lldb/API/SBStream.h"
|
|
#include "lldb/API/SBStringList.h"
|
|
#include "lldb/API/SBTarget.h"
|
|
#include "lldb/API/SBThread.h"
|
|
|
|
#include "ExceptionBreakpoint.h"
|
|
#include "FunctionBreakpoint.h"
|
|
#include "IOStream.h"
|
|
#include "ProgressEvent.h"
|
|
#include "RunInTerminal.h"
|
|
#include "SourceBreakpoint.h"
|
|
#include "SourceReference.h"
|
|
|
|
#define VARREF_LOCALS (int64_t)1
|
|
#define VARREF_GLOBALS (int64_t)2
|
|
#define VARREF_REGS (int64_t)3
|
|
#define VARREF_FIRST_VAR_IDX (int64_t)4
|
|
#define NO_TYPENAME "<no-type>"
|
|
|
|
namespace lldb_vscode {
|
|
|
|
typedef llvm::DenseMap<uint32_t, SourceBreakpoint> SourceBreakpointMap;
|
|
typedef llvm::StringMap<FunctionBreakpoint> FunctionBreakpointMap;
|
|
enum class OutputType { Console, Stdout, Stderr, Telemetry };
|
|
|
|
enum VSCodeBroadcasterBits {
|
|
eBroadcastBitStopEventThread = 1u << 0,
|
|
eBroadcastBitStopProgressThread = 1u << 1
|
|
};
|
|
|
|
typedef void (*RequestCallback)(const llvm::json::Object &command);
|
|
|
|
enum class PacketStatus {
|
|
Success = 0,
|
|
EndOfFile,
|
|
JSONMalformed,
|
|
JSONNotObject
|
|
};
|
|
|
|
struct Variables {
|
|
/// Variable_reference start index of permanent expandable variable.
|
|
static constexpr int64_t PermanentVariableStartIndex = (1ll << 32);
|
|
|
|
lldb::SBValueList locals;
|
|
lldb::SBValueList globals;
|
|
lldb::SBValueList registers;
|
|
|
|
int64_t next_temporary_var_ref{VARREF_FIRST_VAR_IDX};
|
|
int64_t next_permanent_var_ref{PermanentVariableStartIndex};
|
|
|
|
/// Expandable variables that are alive in this stop state.
|
|
/// Will be cleared when debuggee resumes.
|
|
llvm::DenseMap<int64_t, lldb::SBValue> expandable_variables;
|
|
/// Expandable variables that persist across entire debug session.
|
|
/// These are the variables evaluated from debug console REPL.
|
|
llvm::DenseMap<int64_t, lldb::SBValue> expandable_permanent_variables;
|
|
|
|
/// Check if \p var_ref points to a variable that should persist for the
|
|
/// entire duration of the debug session, e.g. repl expandable variables
|
|
static bool IsPermanentVariableReference(int64_t var_ref);
|
|
|
|
/// \return a new variableReference.
|
|
/// Specify is_permanent as true for variable that should persist entire
|
|
/// debug session.
|
|
int64_t GetNewVariableRefence(bool is_permanent);
|
|
|
|
/// \return the expandable variable corresponding with variableReference
|
|
/// value of \p value.
|
|
/// If \p var_ref is invalid an empty SBValue is returned.
|
|
lldb::SBValue GetVariable(int64_t var_ref) const;
|
|
|
|
/// Insert a new \p variable.
|
|
/// \return variableReference assigned to this expandable variable.
|
|
int64_t InsertExpandableVariable(lldb::SBValue variable, bool is_permanent);
|
|
|
|
/// Clear all scope variables and non-permanent expandable variables.
|
|
void Clear();
|
|
};
|
|
|
|
struct VSCode {
|
|
std::string debug_adaptor_path;
|
|
InputStream input;
|
|
OutputStream output;
|
|
lldb::SBDebugger debugger;
|
|
lldb::SBTarget target;
|
|
Variables variables;
|
|
lldb::SBBroadcaster broadcaster;
|
|
std::thread event_thread;
|
|
std::thread progress_event_thread;
|
|
std::unique_ptr<std::ofstream> log;
|
|
llvm::DenseMap<lldb::addr_t, int64_t> addr_to_source_ref;
|
|
llvm::DenseMap<int64_t, SourceReference> source_map;
|
|
llvm::StringMap<SourceBreakpointMap> source_breakpoints;
|
|
FunctionBreakpointMap function_breakpoints;
|
|
std::vector<ExceptionBreakpoint> exception_breakpoints;
|
|
std::vector<std::string> init_commands;
|
|
std::vector<std::string> pre_run_commands;
|
|
std::vector<std::string> exit_commands;
|
|
std::vector<std::string> stop_commands;
|
|
std::vector<std::string> terminate_commands;
|
|
lldb::tid_t focus_tid;
|
|
bool sent_terminated_event;
|
|
bool stop_at_entry;
|
|
bool is_attach;
|
|
bool configuration_done_sent;
|
|
uint32_t reverse_request_seq;
|
|
std::map<std::string, RequestCallback> request_handlers;
|
|
bool waiting_for_run_in_terminal;
|
|
ProgressEventReporter progress_event_reporter;
|
|
// Keep track of the last stop thread index IDs as threads won't go away
|
|
// unless we send a "thread" event to indicate the thread exited.
|
|
llvm::DenseSet<lldb::tid_t> thread_ids;
|
|
VSCode();
|
|
~VSCode();
|
|
VSCode(const VSCode &rhs) = delete;
|
|
void operator=(const VSCode &rhs) = delete;
|
|
int64_t GetLineForPC(int64_t sourceReference, lldb::addr_t pc) const;
|
|
ExceptionBreakpoint *GetExceptionBreakpoint(const std::string &filter);
|
|
ExceptionBreakpoint *GetExceptionBreakpoint(const lldb::break_id_t bp_id);
|
|
|
|
// Serialize the JSON value into a string and send the JSON packet to
|
|
// the "out" stream.
|
|
void SendJSON(const llvm::json::Value &json);
|
|
|
|
std::string ReadJSON();
|
|
|
|
void SendOutput(OutputType o, const llvm::StringRef output);
|
|
|
|
void SendProgressEvent(uint64_t progress_id, const char *message,
|
|
uint64_t completed, uint64_t total);
|
|
|
|
void __attribute__((format(printf, 3, 4)))
|
|
SendFormattedOutput(OutputType o, const char *format, ...);
|
|
|
|
static int64_t GetNextSourceReference();
|
|
|
|
ExceptionBreakpoint *GetExceptionBPFromStopReason(lldb::SBThread &thread);
|
|
|
|
lldb::SBThread GetLLDBThread(const llvm::json::Object &arguments);
|
|
|
|
lldb::SBFrame GetLLDBFrame(const llvm::json::Object &arguments);
|
|
|
|
llvm::json::Value CreateTopLevelScopes();
|
|
|
|
void RunLLDBCommands(llvm::StringRef prefix,
|
|
const std::vector<std::string> &commands);
|
|
|
|
void RunInitCommands();
|
|
void RunPreRunCommands();
|
|
void RunStopCommands();
|
|
void RunExitCommands();
|
|
void RunTerminateCommands();
|
|
|
|
/// Create a new SBTarget object from the given request arguments.
|
|
/// \param[in] arguments
|
|
/// Launch configuration arguments.
|
|
///
|
|
/// \param[out] error
|
|
/// An SBError object that will contain an error description if
|
|
/// function failed to create the target.
|
|
///
|
|
/// \return
|
|
/// An SBTarget object.
|
|
lldb::SBTarget CreateTargetFromArguments(const llvm::json::Object &arguments,
|
|
lldb::SBError &error);
|
|
|
|
/// Set given target object as a current target for lldb-vscode and start
|
|
/// listeing for its breakpoint events.
|
|
void SetTarget(const lldb::SBTarget target);
|
|
|
|
const std::map<std::string, RequestCallback> &GetRequestHandlers();
|
|
|
|
PacketStatus GetNextObject(llvm::json::Object &object);
|
|
bool HandleObject(const llvm::json::Object &object);
|
|
|
|
/// Send a Debug Adapter Protocol reverse request to the IDE
|
|
///
|
|
/// \param[in] request
|
|
/// The payload of the request to send.
|
|
///
|
|
/// \param[out] response
|
|
/// The response of the IDE. It might be undefined if there was an error.
|
|
///
|
|
/// \return
|
|
/// A \a PacketStatus object indicating the sucess or failure of the
|
|
/// request.
|
|
PacketStatus SendReverseRequest(llvm::json::Object request,
|
|
llvm::json::Object &response);
|
|
|
|
/// Registers a callback handler for a Debug Adapter Protocol request
|
|
///
|
|
/// \param[in] request
|
|
/// The name of the request following the Debug Adapter Protocol
|
|
/// specification.
|
|
///
|
|
/// \param[in] callback
|
|
/// The callback to execute when the given request is triggered by the
|
|
/// IDE.
|
|
void RegisterRequestCallback(std::string request, RequestCallback callback);
|
|
|
|
/// Debuggee will continue from stopped state.
|
|
void WillContinue() { variables.Clear(); }
|
|
|
|
/// Poll the process to wait for it to reach the eStateStopped state.
|
|
///
|
|
/// Wait for the process hit a stopped state. When running a launch with
|
|
/// "launchCommands", or attach with "attachCommands", the calls might take
|
|
/// some time to stop at the entry point since the command is asynchronous. We
|
|
/// need to sync up with the process and make sure it is stopped before we
|
|
/// proceed to do anything else as we will soon be asked to set breakpoints
|
|
/// and other things that require the process to be stopped. We must use
|
|
/// polling because "attachCommands" or "launchCommands" may or may not send
|
|
/// process state change events depending on if the user modifies the async
|
|
/// setting in the debugger. Since both "attachCommands" and "launchCommands"
|
|
/// could end up using any combination of LLDB commands, we must ensure we can
|
|
/// also catch when the process stops, so we must poll the process to make
|
|
/// sure we handle all cases.
|
|
///
|
|
/// \param[in] seconds
|
|
/// The number of seconds to poll the process to wait until it is stopped.
|
|
///
|
|
/// \return Error if waiting for the process fails, no error if succeeds.
|
|
lldb::SBError WaitForProcessToStop(uint32_t seconds);
|
|
|
|
private:
|
|
// Send the JSON in "json_str" to the "out" stream. Correctly send the
|
|
// "Content-Length:" field followed by the length, followed by the raw
|
|
// JSON bytes.
|
|
void SendJSON(const std::string &json_str);
|
|
};
|
|
|
|
extern VSCode g_vsc;
|
|
|
|
} // namespace lldb_vscode
|
|
|
|
#endif
|