[vscode] Improve runInTerminal and support linux

[wallace]

Summary

Depends on D93874.

runInTerminal was using --wait-for, but it was some problems because it uses process polling looking for a single instance of the debuggee:

• it gets to know of the target late, which renders breakpoints in the main function almost impossible
• polling might fail if there are already other processes with the same name
• polling might also fail on some linux machine, as it's implemented with the ps command, and the ps command's args and output are not standard everywhere

As a better way to implement this so that it works well on Darwin and Linux, I'm using now the following process:

• lldb-vscode notices the runInTerminal, so it spawns lldb-vscode with a special flag --launch-target <target>. This flags tells lldb-vscode to wait to be attached and then it execs the target program. I'm using lldb-vscode itself to do this, because it makes finding the launcher program easier. Also no CMAKE INSTALL scripts are needed.
• Besides this, the debugger creates a temporary FIFO file where the launcher program will write its pid to. That way the debugger will be sure of which program to attach.
• Once attach happend, the debugger creates a second temporary file to notify the launcher program that it has been attached, so that it can then exec. I'm using this instead of using a signal or a similar mechanism because I don't want the launcher program to wait indefinitely to be attached in case the debugger crashed. That would pollute the process list with a lot of hanging processes. Instead, I'm setting a 20 seconds timeout (that's an overkill) and the launcher program seeks in intervals the second tepmorary file.

Some notes:

• I also fixed a small issue preventing preRunCommands to be executed with runInTerminal
• stopOnEntry true and false values work correctly as well
• I preferred not to use sockets because it requires a lot of code and I only need a pid. It would also require a lot of code when windows support is implemented.
• I didn't add Windows support, as I don't have a windows machine, but adding support for it should be easy, as the FIFO file can be implemented with a named pipe, which is standard on Windows and works pretty much the same way.

The existing test which didn't pass on Linux, now passes.

[wallace]

nit

[clayborg]

Great stuff! See inline comments.

A few new tests need to be added:

• test running lldb-vscode with invalid "--launch-target" executable path so things fail to exec and verify we get as nice of an error message as possible
• test running lldb-vscode with valid "--launch-target" and no "--pid-file" option to make sure lldb-vscode fails gracefully with an error and appropriate message
• test running lldb-vscode with valid "--launch-target" and an invalid "--pid-file" path with an invalid directory
• test running lldb-vscode with valid "--launch-target" and an invalid "--pid-file" path that points somewhere we don't have permissions

All these tests will ensure we don't end up with a deadlock situation when trying to launch in terminal.

lldb/tools/lldb-vscode/lldb-vscode.cpp

1451

If windows is not supported, should we avoid calling this function (CreateRunInTerminalPidFile) in the first place?

1468–1471

Check for invalid LLDB_INVALID_PROCESS_ID here in case something went wrong when trying to read the "pid" and return an error

1469

What happens if the pid never gets written to the stream? Deadlock forever?

Also, what happens if an error happens during the read? Can we check if the stream has an error after readind "pid" just in case? If there is error, (like what if the other process wrote "hello" to the stream instead of "123"), what ends up in "pid"? Is it set to zero? Or just left as a random number? If it is left alone, we should initialize "pid" with the LLDB_INVALID_PROCESS_ID on line 1470

1474–1475

Do we need more to this comment? Aren't we continuing the lldb-vscode that will exec into our program here? If we are, we should clearly explain what is happening here.

3017

This path can be relative, so we might need to resolve it using a llvm path call? I can't remember if execv() can use a relative path or not.

3025

We need a nice beefy comment here as to what is going on explaining everything.

3026

Does the llvm argument parser already guarantee that we have a valid value in pid_file? If not, we need to make sure "pid_file" is not empty here and return an error if it wasn't specified

3027

error check that the creation of the ofstream succeeded and return an error if it fails and exit with EXIT_FAILURE

3036

Should we verify that "target" is a valid file that exists prior to just calling execv? We might be able to return a better error message. Or we can check if the file exists after the "execv(...)" call and return a better error message than "Couldn't launch target" like "Failed to launch '/path/that/doesnt/exists/a.out'".

3039

So is the code calling lldb-vscode with "--launch-target ... --pid-file ..." watching for a non zero return value? If something goes wrong does this show up in the terminal for the process?

[wallace]

Address all comments.

• Moved all the communication logic between the debug adaptor and the launcher to classes, simplifying the code in lldb-vscode.
• Added more comments and tests
• Created a file where lldb-vscode can write errors to.
• Now returning any error messages to the IDE, so that the user can see what's going on. No exit() calls are using in the debug adaptor side.

Errors in the IDE are displayed like this:

[clayborg]

So I like that we are using files in the file system for things, but we are using 3 of them and that seems excessive. See inlined comments and see if we can get down to using just one? Also, what is stopping us from being able to support windows here? Just mkfifo?

lldb/tools/lldb-vscode/RunInTerminal.cpp

29

These permissions seem bad, probably should be 0600 to only allow current user to access for security purposes.

Also, any reason we are using mkfifo over just a normal temp file? Is this the only thing that keeps us from using this on windows? Could we have windows support if just create a normal file like std::ofstream and std::ifstream?

lldb/tools/lldb-vscode/RunInTerminal.h

32–38

Can we avoid using more than one file here? Might be nice to require just one file that gets a JSON dictionary as the contents?

{ "pid": 123 }

or

{ "error" : "<error message>" }

Then we need to read data until we get correctly formed JSON or timeout.

lldb/tools/lldb-vscode/lldb-vscode.cpp

1377–1381

Reverse this to avoid the negate?

1442–1446

We shouldn't need any #if define(_WIN32) since we didn't enable this feature in the response to "initialize" right?

2982

Is "[[noreturn]]" supported by all compilers that compile LLDB? There might be some LLVM define that we should use?

2994

Why are we using env vars for some things and options values for others? We should probably pass this in as an argument. We are also polluting the env vars of the new process we will exec if we leave this in the environment

3001

I assume env vars are being inherited from this process?

3018

Might be worth checking if there is a llvm file system call to determine the program path already?

3026

Don't use auto

3027

don't use auto

[clayborg]

We should also add a test that makes sure that env vars set in the launch config are received in the program that runs in the terminal

[clayborg]

And a test for current working directory

[wallace]

I'll follow your recommendations.

Regarding Windows, mkfifo can be replaced with CreateNamedPipe and should lead to the same behavior. Sadly, I don't have a Windows machine where I could even compile it... So this should be left for someone else or for when I can get my laptop from the office.

And why are fifo files needed? Well, when you open a normal text file, c++ doesn't just know when the file gets updated. Its pointer to the end of the file is set when you open the file. So if you want to get updates, you have to reopen the file in a polling fashion. Fifo files, on the other hand, which are the same as pipes, behave the same way as stdin, so c++ keeps reading it until it's empty and closed at OS level, aware of new data being written to it

[wallace]

I'll think about just writing this as tcp sockets. That would for sure be cross platform

[wallace]

lldb/tools/lldb-vscode/lldb-vscode.cpp

2994

I'm only using this for testing, so that the python tests doesn't take 10 seconds waiting for the timeout to happen. The user shouldn't need to change this for any reason.

3001

yes, that's the default behavior

3018

it seems there isn't

[wallace]

Followed all the suggestions:

• This is POSIX-only, but making it work for windows should only require deleting a few #ifdef blocks and using the CreateNamedPipe API instead of mkfifo. I'll do it later in another diff.
• Added more tests covering different possible failures and making sure that environment variables are passed correctly.
• Now using JSON for the messages. That will make more robust if in the future we need to send more information back to the debugger.
• I tried to keep it as simple as possible, but still created a few abstractions to keep each piece very readable.

[clayborg]

Can we still try to use just one file? Isn't this file both read and write? The flow would be:

• create 1 file using mkfifo(...) and pass it down as argument
• launcher lldb-vscode will write pid or error JSON back into the stream, and will start to wait for some data from the same fifo file
• normal lldb-vscode will write some JSON to fifo file to indicate it has attached after it has attached
• launcher lldb-vscode reads that it attached and then does the exec

It would really simplify everything if we can use just one file

lldb/tools/lldb-vscode/RunInTerminal.cpp

94

Need to use the llvm file system appending stuff so this will work on windows.

llvm::SmallString<64> current_path = comm_dir.str(); // this might not compile, but you get the idea...
style = ...; // Set this correctly with #ifdef for windows
llvm::sys::path::append(comm_dir, style, "to_adaptor");

98

ditto

lldb/tools/lldb-vscode/lldb-vscode.cpp

459

Is this intentional??

1491

Do we want to set async to true prior to doing the continue?

[wallace]

Addressed all comments:

• Now using a single file for all the communication. Did indeed simplified a lot of code
• Now adding timeouts to Send operations. This will help prevent the adaptor from undefinitely waiting for the launcher to read the data.
• I added more comments, specially in the part where the process attaches and resumes

[wallace]

improve tests

[clayborg]

Just one rename of an instance variable and this is good to go! Much cleaner without the directory and multiple files.

lldb/tools/lldb-vscode/FifoFiles.h

26 ↗

(On Diff #315655)

rename to "m_path" since this is an instance variable.

[stella.stamenova]

It looks like this broke the windows lldb bot:

lab.llvm.org:8011/%23/builders/83/builds/3021

[wallace]

I've already submitted a fix, let's see if the buildbot gets fixed

Il giorno lun 25 gen 2021 alle ore 14:18 Stella Stamenova via Phabricator <
[e-mail]> ha scritto:

stella.stamenova added a comment.

It looks like this broke the windows lldb bot:

Repository:

rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION

https://reviews.llvm.org/D93951/new/

https://reviews.llvm.org/D93951

[stella.stamenova]

I am seeing this consistently fail on our internal Ubuntu bot:

ERROR: test_missingArgInRunInTerminalLauncher (TestVSCode_runInTerminal.TestVSCode_runInTerminal)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/mnt/_work/5/s/lldb/packages/Python/lldbsuite/test/decorators.py", line 135, in wrapper
    return func(*args, **kwargs)
  File "/mnt/_work/5/s/lldb/test/API/tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.py", line 92, in test_missingArgInRunInTerminalLauncher
    capture_output=True, universal_newlines=True)
  File "/usr/lib/python3.6/subprocess.py", line 423, in run
    with Popen(*popenargs, **kwargs) as process:
TypeError: __init__() got an unexpected keyword argument 'capture_output'
Config=x86_64-/mnt/_work/5/b/llvm/bin/clang
======================================================================
FAIL: test_runInTerminal (TestVSCode_runInTerminal.TestVSCode_runInTerminal)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/mnt/_work/5/s/lldb/packages/Python/lldbsuite/test/decorators.py", line 135, in wrapper
    return func(*args, **kwargs)
  File "/mnt/_work/5/s/lldb/test/API/tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.py", line 54, in test_runInTerminal
    env=["FOO=bar"])
  File "/mnt/_work/5/s/lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py", line 353, in build_and_launch
    terminateCommands, sourcePath, debuggerRoot, runInTerminal=runInTerminal)
  File "/mnt/_work/5/s/lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py", line 329, in launch
    'launch failed (%s)' % (response['message']))
AssertionError: False is not True : launch failed (Failed to attach to the target process. Timed out trying to get messages from the runInTerminal launcher)
Config=x86_64-/mnt/_work/5/b/llvm/bin/clang
----------------------------------------------------------------------
Ran 7 tests in 2.447s

RESULT: FAILED (5 passes, 1 failures, 1 errors, 0 skipped, 0 expected failures, 0 unexpected successes)
Timed out trying to get messages from the debug adaptor

[wallace]

@stella.stamenova , is that build a Debug or Release build? I think that will help me determine why it's failing

[stella.stamenova]

In D93951#2523886, @wallace wrote:

@stella.stamenova , is that build a Debug or Release build? I think that will help me determine why it's failing

Release. It passed in Debug.

[wallace]

I'll send a diff tomorrow morning

[stella.stamenova]

lldb/tools/lldb-vscode/FifoFiles.cpp

9 ↗

(On Diff #319090)

Also, this is no good. It works if you are targeting windows on windows, but not if you are targeting something else and building on windows. There are a few different ways this is done in LLVM/clang and they are generally not based on defined(WIN32). Here are a couple of examples:

From llvm\lib\Support\Path.cpp:

#if !defined(_MSC_VER) && !defined(__MINGW32__)

From clang\lib\Driver\Driver.cpp:

#if LLVM_ON_UNIX

From llvm\lib\Support\ErrorHandling.cpp:

#if defined(HAVE_UNISTD_H)

I suggest browsing through the code and finding the most appropriate way to manage your includes. In the mean time, this is breaking our internal builds that run on Windows but do not target Windows.

[wallace]

Good to know. I'll work on that right now. Thanks!

Il giorno mer 27 gen 2021 alle ore 11:41 Stella Stamenova via Phabricator <
[e-mail]> ha scritto:

stella.stamenova added inline comments.

Comment at: lldb/tools/lldb-vscode/FifoFiles.cpp:9
+
+#if !defined(WIN32)

+#include <sys/stat.h>

Also, this is no good. It works if you are targeting windows on windows,
but not if you are targeting something else and building on windows. There
are a few different ways this is done in LLVM/clang and they are generally
not based on defined(WIN32). Here are a couple of examples:

From llvm\lib\Support\Path.cpp:

#if !defined(_MSC_VER) && !defined(__MINGW32__)

From clang\lib\Driver\Driver.cpp:

#if LLVM_ON_UNIX

From llvm\lib\Support\ErrorHandling.cpp:

#if defined(HAVE_UNISTD_H)

I suggest browsing through the code and finding the most appropriate way
to manage your includes. In the mean time, this is breaking our internal
builds that run on Windows but do not target Windows.

Repository:

rG LLVM Github Monorepo

CHANGES SINCE LAST ACTION

https://reviews.llvm.org/D93951/new/

https://reviews.llvm.org/D93951

[wallace]

@stella.stamenova , I've just pushed a fix. Let me know if it actually works.

[mstorsjo]

lldb/tools/lldb-vscode/FifoFiles.cpp

9 ↗

(On Diff #319090)

@stella.stamenova defined(WIN32) shouldn't be used (as that isn't predefined by the compiler), but defined(_WIN32) should be just fine (and is used a lot within LLDB already, 176 occurrances). If cross compiling on windows, targeting another os, neither of them should be defined, so it should be just fine, no?

Or is this a case of cygwin, where the lines are blurred even more?

Does the current main branch work fine for you?

[stella.stamenova]

lldb/tools/lldb-vscode/FifoFiles.cpp

9 ↗

(On Diff #319090)

defined(_WIN32) is fine for us, since we build on Windows (and not cygwin). I have not tried the lldb-vscode build on cygwin, so that may or may not work with the current setup.

In general, there are too many ways in LLVM to achieve the same excludes/includes right now and the lack of unity is only creating issues and confusion.

[aeubanks]

Hi, sorry to ping a very old patch but TestVSCode_runInTerminal.py is still failing on my linux machine (and a coworker said the same thing). Searching my email for the test name, some 12.0.0 and 13.0.0 release email threads also mention this test failing.

Commenting out all the tests except for test_runInTerminal and with the following print:

--- a/lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py
+++ b/lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py
@@ -329,6 +329,7 @@ class VSCodeTestCaseBase(TestBase):
             return response
 
         if not (response and response['success']):
+            print(response)
             self.assertTrue(response['success'],
                             'launch failed (%s)' % (response['message']))
         # We need to trigger a request_configurationDone after we've successfully
$ ./bin/llvm-lit -vv ../../lldb/test/API/tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.py
-- Testing: 1 tests, 1 workers --
FAIL: lldb-api :: tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.py (1 of 1)
******************** TEST 'lldb-api :: tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.py' FAILED ********************
Script:
--
/usr/local/google/home/aeubanks/repos/sysroot/usr/bin/python3.10 /usr/local/google/home/aeubanks/repos/llvm-project/lldb/test/API/dotest.py -u CXXFLAGS -u CFLAGS --env ARCHIVER=/usr/local/google/home/aeubanks/repos/sysroot/usr/local/google/home/aeubanks/repos/chromium/src/third_party/llvm-build/Release+Asserts/bin/llvm-ar --env OBJCOPY=/usr/local/google/home/aeubanks/repos/sysroot/usr/local/google/home/aeubanks/repos/chromium/src/third_party/llvm-build/Release+Asserts/bin/llvm-objcopy --env LLVM_LIBS_DIR=/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/./lib --env LLVM_INCLUDE_DIR=/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/include --env LLVM_TOOLS_DIR=/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/./bin --hermetic-libcxx --arch x86_64 --build-dir /usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/lldb-test-build.noindex --lldb-module-cache-dir /usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/lldb-test-build.noindex/module-cache-lldb/lldb-api --clang-module-cache-dir /usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/lldb-test-build.noindex/module-cache-clang/lldb-api --executable /usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/./bin/lldb --compiler /usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/./bin/clang --dsymutil /usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/./bin/dsymutil --llvm-tools-dir /usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/./bin --lldb-libs-dir /usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/./lib /usr/local/google/home/aeubanks/repos/llvm-project/lldb/test/API/tools/lldb-vscode/runInTerminal -p TestVSCode_runInTerminal.py
--
Exit Code: 1

Command Output (stdout):
--
lldb version 15.0.0git ([e-mail]:aeubanks/llvm-project.git revision 2f11b3a6d7b8083be570f79f4ca18dfb2648eda3)
  clang revision 2f11b3a6d7b8083be570f79f4ca18dfb2648eda3
  llvm revision 2f11b3a6d7b8083be570f79f4ca18dfb2648eda3
Skipping the following test categories: ['libc++', 'dsym', 'gmodules', 'debugserver', 'objc']
{'command': 'launch', 'message': 'Failed to attach to the target process. Timed out trying to get messages from the runInTerminal launcher', 'request_seq': 2, 'seq': 0, 'success': False, 'type': 'response'}
========= DEBUG ADAPTER PROTOCOL LOGS =========
--> 
Content-Length: 284

{"command":"initialize","type":"request","arguments":{"adapterID":"lldb-native","clientID":"vscode","columnsStartAt1":true,"linesStartAt1":true,"locale":"en-us","pathFormat":"path","supportsRunInTerminalRequest":true,"supportsVariablePaging":true,"supportsVariableType":true},"seq":1}
<-- 
Content-Length: 1246

{"body":{"exceptionBreakpointFilters":[{"default":false,"filter":"cpp_catch","label":"C++ Catch"},{"default":false,"filter":"cpp_throw","label":"C++ Throw"},{"default":false,"filter":"objc_catch","label":"Objective-C Catch"},{"default":false,"filter":"objc_throw","label":"Objective-C Throw"},{"default":false,"filter":"swift_catch","label":"Swift Catch"},{"default":false,"filter":"swift_throw","label":"Swift Throw"}],"supportTerminateDebuggee":true,"supportsCompletionsRequest":false,"supportsConditionalBreakpoints":true,"supportsConfigurationDoneRequest":true,"supportsDelayedStackTraceLoading":true,"supportsEvaluateForHovers":true,"supportsExceptionInfoRequest":true,"supportsExceptionOptions":true,"supportsFunctionBreakpoints":true,"supportsGotoTargetsRequest":false,"supportsHitConditionalBreakpoints":true,"supportsLoadedSourcesRequest":false,"supportsLogPoints":true,"supportsModulesRequest":true,"supportsProgressReporting":true,"supportsRestartFrame":false,"supportsRestartRequest":false,"supportsRunInTerminalRequest":true,"supportsSetVariable":true,"supportsStepBack":false,"supportsStepInTargetsRequest":false,"supportsValueFormattingOptions":true},"command":"initialize","request_seq":1,"seq":0,"success":true,"type":"response"}
--> 
Content-Length: 871

{"command":"launch","type":"request","arguments":{"program":"/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/lldb-test-build.noindex/tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.test_runInTerminal/a.out","args":["foobar"],"env":["FOO=bar"],"stopOnEntry":true,"disableASLR":true,"initCommands":["settings clear -all","settings set symbols.enable-external-lookup false","settings set target.inherit-tcc true","settings set target.detach-on-error false","settings set target.auto-apply-fixits false","settings set plugin.process.gdb-remote.packet-timeout 60","settings set symbols.clang-modules-cache-path \"/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/lldb-test-build.noindex/module-cache-lldb/lldb-api\"","settings set use-color false","setting set target.prefer-dynamic-value no-dynamic-values"],"runInTerminal":true},"seq":2}
<-- 
Content-Length: 679

{"body":{"category":"console","output":"Running initCommands:\n(lldb) settings clear -all\n(lldb) settings set symbols.enable-external-lookup false\n(lldb) settings set target.inherit-tcc true\n(lldb) settings set target.detach-on-error false\n(lldb) settings set target.auto-apply-fixits false\n(lldb) settings set plugin.process.gdb-remote.packet-timeout 60\n(lldb) settings set symbols.clang-modules-cache-path \"/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/lldb-test-build.noindex/module-cache-lldb/lldb-api\"\n(lldb) settings set use-color false\n(lldb) setting set target.prefer-dynamic-value no-dynamic-values\n"},"event":"output","seq":0,"type":"event"}
<-- 
Content-Length: 472

{"arguments":{"args":["/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/bin/lldb-vscode","--comm-file","/tmp/lit-tmp-sj_rgdfo/lldb-vscode-run-in-terminal-comm-82bc83","--launch-target","/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/lldb-test-build.noindex/tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.test_runInTerminal/a.out","foobar"],"env":{"FOO":"bar"},"kind":"integrated"},"command":"runInTerminal","seq":1,"type":"request"}
--> 
Content-Length: 95

{"type":"response","seq":-1,"request_seq":1,"success":true,"command":"runInTerminal","body":{}}
<-- 
Content-Length: 195

{"command":"launch","message":"Failed to attach to the target process. Timed out trying to get messages from the runInTerminal launcher","request_seq":2,"seq":0,"success":false,"type":"response"}
<-- 
Content-Length: 299

{"body":{"isLocalProcess":true,"name":"/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/lldb-test-build.noindex/tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.test_runInTerminal/a.out","startMethod":"attach","systemProcessId":531529},"event":"process","seq":0,"type":"event"}
<-- 
Content-Length: 46

{"event":"initialized","seq":0,"type":"event"}
--> 
Content-Length: 88

{"command":"disconnect","type":"request","arguments":{"terminateDebuggee":true},"seq":3}
<-- 
Content-Length: 45

{"event":"terminated","seq":0,"type":"event"}
<-- 
Content-Length: 81

{"command":"disconnect","request_seq":3,"seq":0,"success":true,"type":"response"}

========= END =========

--
Command Output (stderr):
--
FAIL: LLDB (/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/bin/clang-x86_64) :: test_runInTerminal (TestVSCode_runInTerminal.TestVSCode_runInTerminal)
======================================================================
FAIL: test_runInTerminal (TestVSCode_runInTerminal.TestVSCode_runInTerminal)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/usr/local/google/home/aeubanks/repos/llvm-project/lldb/packages/Python/lldbsuite/test/decorators.py", line 157, in wrapper
    return func(*args, **kwargs)
  File "/usr/local/google/home/aeubanks/repos/llvm-project/lldb/test/API/tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.py", line 60, in test_runInTerminal
    self.build_and_launch(
  File "/usr/local/google/home/aeubanks/repos/llvm-project/lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py", line 357, in build_and_launch
    return self.launch(program, args, cwd, env, stopOnEntry, disableASLR,
  File "/usr/local/google/home/aeubanks/repos/llvm-project/lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py", line 333, in launch
    self.assertTrue(response['success'],
AssertionError: False is not True : launch failed (Failed to attach to the target process. Timed out trying to get messages from the runInTerminal launcher)
Config=x86_64-/usr/local/google/home/aeubanks/repos/llvm-project/build/cmake/bin/clang
----------------------------------------------------------------------
Ran 1 test in 1.386s

RESULT: FAILED (0 passes, 1 failures, 0 errors, 0 skipped, 0 expected failures, 0 unexpected successes)
Timed out trying to get messages from the debug adaptor

--

********************
********************
Failed Tests (1):
  lldb-api :: tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.py


Testing Time: 20.90s
  Failed: 1

any ideas on what's going wrong and/or how to debug?

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py

def attach(self, program=None, pid=None, waitFor=None, trace=None,
                             'attach failed (%s)' % (response['message']))
 
     def launch(self, program=None, args=None, cwd=None, env=None,
                stopOnEntry=False, disableASLR=True,
                disableSTDIO=False, shellExpandArguments=False,
                trace=False, initCommands=None, preRunCommands=None,
                stopCommands=None, exitCommands=None, terminateCommands=None,
                sourcePath=None, debuggerRoot=None, launchCommands=None,
-               sourceMap=None, disconnectAutomatically=True, runInTerminal=False):
+               sourceMap=None, disconnectAutomatically=True, runInTerminal=False,
+               expectFailure=False):
         '''Sending launch request to vscode
         '''
 
         # Make sure we disconnect and terminate the VSCode debug adapter,
         # if we throw an exception during the test case
         def cleanup():
             if disconnectAutomatically:
                 self.vscode.request_disconnect(terminateDebuggee=True)
def launch(self, program=None, args=None, cwd=None, env=None,
             preRunCommands=preRunCommands,
             stopCommands=stopCommands,
             exitCommands=exitCommands,
             terminateCommands=terminateCommands,
             sourcePath=sourcePath,
             debuggerRoot=debuggerRoot,
             launchCommands=launchCommands,
             sourceMap=sourceMap,
-            runInTerminal=runInTerminal)
+            runInTerminal=runInTerminal,
+            expectFailure=expectFailure)
+        
+        if expectFailure:
+            return response
+
         if not (response and response['success']):
             self.assertTrue(response['success'],
                             'launch failed (%s)' % (response['message']))
         # We need to trigger a request_configurationDone after we've successfully
         # attached a runInTerminal process to finish initialization.
         if runInTerminal:
             self.vscode.request_configurationDone()
+        return response
 
 
     def build_and_launch(self, program, args=None, cwd=None, env=None,
                          stopOnEntry=False, disableASLR=True,
                          disableSTDIO=False, shellExpandArguments=False,
                          trace=False, initCommands=None, preRunCommands=None,
                          stopCommands=None, exitCommands=None,
                          terminateCommands=None, sourcePath=None,

lldb/packages/Python/lldbsuite/test/tools/lldb-vscode/vscode.py

class DebugCommunication(object):
 
     def request_launch(self, program, args=None, cwd=None, env=None,
                        stopOnEntry=False, disableASLR=True,
                        disableSTDIO=False, shellExpandArguments=False,
                        trace=False, initCommands=None, preRunCommands=None,
                        stopCommands=None, exitCommands=None,
                        terminateCommands=None ,sourcePath=None,
                        debuggerRoot=None, launchCommands=None, sourceMap=None,
-                       runInTerminal=False):
+                       runInTerminal=False, expectFailure=False):
         args_dict = {
             'program': program
         }
         if args:
             args_dict['args'] = args
         if cwd:
             args_dict['cwd'] = cwd
         if env:
def request_launch(self, program, args=None, cwd=None, env=None,
             args_dict['runInTerminal'] = runInTerminal
         command_dict = {
             'command': 'launch',
             'type': 'request',
             'arguments': args_dict
         }
         response = self.send_recv(command_dict)
 
+        if not expectFailure:
             # Wait for a 'process' and 'initialized' event in any order
             self.wait_for_event(filter=['process', 'initialized'])
             self.wait_for_event(filter=['process', 'initialized'])
         return response
 
     def request_next(self, threadId):
         if self.exit_status is not None:
             raise ValueError('request_continue called after process exited')
         args_dict = {'threadId': threadId}
         command_dict = {
             'command': 'next',

lldb/test/API/tools/lldb-vscode/runInTerminal/TestVSCode_runInTerminal.py

 """
 Test lldb-vscode runInTerminal reverse request
 """
 
 
 import unittest2
 import vscode
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 import lldbvscode_testcase
 import time
 import os
+import subprocess
 
 
 class TestVSCode_runInTerminal(lldbvscode_testcase.VSCodeTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @skipUnlessDarwin
+    @skipIfWindows
     @skipIfRemote
     def test_runInTerminal(self):
         '''
             Tests the "runInTerminal" reverse request. It makes sure that the IDE can
             launch the inferior with the correct environment variables and arguments.
         '''
         program = self.getBuildArtifact("a.out")
         source = 'main.c'
def test_runInTerminal(self):
         self.assertEqual(argc, 2)
 
         argv1 = self.vscode.request_evaluate('argv[1]')['body']['result']
         self.assertIn('foobar', argv1)
 
         # We verify we were able to set the environment
         env = self.vscode.request_evaluate('foo')['body']['result']
         self.assertIn('bar', env)
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_runInTerminalInvalidTarget(self):
+        self.build_and_create_debug_adaptor()
+        response = self.launch(
+            "INVALIDPROGRAM", stopOnEntry=True, runInTerminal=True, args=["foobar"], env=["FOO=bar"], expectFailure=True)
+        self.assertFalse(response['success'])
+        self.assertIn("Could not create a target for a program 'INVALIDPROGRAM': unable to find executable",
+            response['message'])
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_missingArgInRunInTerminalLauncher(self):
+        proc = subprocess.run([self.lldbVSCodeExec,  "--launch-target", "INVALIDPROGRAM"],
+            capture_output=True, universal_newlines=True)
+        self.assertTrue(proc.returncode != 0)
+        self.assertIn('"--launch-target" requires "--comm-files-prefix" to be specified', proc.stderr)
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_NonAttachedRunInTerminalLauncher(self):
+        prefix = "/tmp/lldb-vscode-runInTerminal-test"
+        # We clear the error file
+        with open(prefix + ".err", "w") as f:
+            pass
+
+        proc = subprocess.run([self.lldbVSCodeExec, "--comm-files-prefix", prefix, "--launch-target", "INVALIDPROGRAM"],
+            capture_output=True, universal_newlines=True, env={"LLDB_VSCODE_RIT_TIMEOUT_IN_MS": "1000"})
+        
+        # We check the error message in both stderr and the error file
+        self.assertIn("lldb-vscode didn't attach to this process", proc.stderr)
+        with open(prefix + ".err", "r") as f:
+            self.assertIn("lldb-vscode didn't attach to this process", f.readline())

lldb/tools/lldb-vscode/CMakeLists.txt

 add_lldb_tool(lldb-vscode
   lldb-vscode.cpp
   BreakpointBase.cpp
   ExceptionBreakpoint.cpp
   FunctionBreakpoint.cpp
   IOStream.cpp
   JSONUtils.cpp
   LLDBUtils.cpp
+  RunInTerminal.cpp
   SourceBreakpoint.cpp
   VSCode.cpp
 
   LINK_LIBS
     liblldb
     ${host_lib}
     ${extra_libs}
 

lldb/tools/lldb-vscode/JSONUtils.h

 //===-- JSONUtils.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_JSONUTILS_H
 #define LLDB_TOOLS_LLDB_VSCODE_JSONUTILS_H
 
 #include "VSCodeForward.h"
 #include "lldb/API/SBModule.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/JSON.h"
 #include <stdint.h>
 
 namespace lldb_vscode {
 
 /// Emplace a StringRef in a json::Object after enusring that the
 /// string is valid UTF8. If not, first call llvm::json::fixUTF8

 llvm::json::Value CreateCompileUnit(lldb::SBCompileUnit unit);
 
 /// Create a runInTerminal reverse request object
 ///
 /// \param[in] launch_request
 ///     The original launch_request object whose fields are used to construct
 ///     the reverse request object.
 ///
+/// \param[in] debug_adaptor_path
+///     Path to the current debug adaptor. It will be used to delegate the
+///     launch of the target.
+///
+/// \param[in] pid_file
+///     A file that will be used to communicate the pid of the debuggee.
+///
 /// \return
 ///     A "runInTerminal" JSON object that follows the specification outlined by
 ///     Microsoft.
 llvm::json::Object
-CreateRunInTerminalReverseRequest(const llvm::json::Object &launch_request);
+CreateRunInTerminalReverseRequest(const llvm::json::Object &launch_request,
+                                  llvm::StringRef debug_adaptor_path,
+                                  llvm::StringRef pid_file);
 
 } // namespace lldb_vscode
 
 #endif

lldb/tools/lldb-vscode/JSONUtils.cpp

 #include <iomanip>
 #include <sstream>
 
 #include "llvm/ADT/Optional.h"
 #include "llvm/Support/FormatAdapters.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/ScopedPrinter.h"
 
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBBreakpointLocation.h"
 #include "lldb/API/SBValue.h"
 #include "lldb/Host/PosixApi.h"
 
 #include "ExceptionBreakpoint.h"
 #include "JSONUtils.h"
 #include "LLDBUtils.h"
 #include "VSCode.h"
llvm::json::Value CreateCompileUnit(lldb::SBCompileUnit unit) {
   std::string unit_path(unit_path_arr);
   object.try_emplace("compileUnitPath", unit_path);
   return llvm::json::Value(std::move(object));
 }
 
 /// See
 /// https://microsoft.github.io/debug-adapter-protocol/specification#Reverse_Requests_RunInTerminal
 llvm::json::Object
-CreateRunInTerminalReverseRequest(const llvm::json::Object &launch_request) {
+CreateRunInTerminalReverseRequest(const llvm::json::Object &launch_request,
+                                  llvm::StringRef debug_adaptor_path,
+                                  llvm::StringRef pid_file) {
   llvm::json::Object reverse_request;
   reverse_request.try_emplace("type", "request");
   reverse_request.try_emplace("command", "runInTerminal");
 
   llvm::json::Object run_in_terminal_args;
   // This indicates the IDE to open an embedded terminal, instead of opening the
   // terminal in a new window.
   run_in_terminal_args.try_emplace("kind", "integrated");
 
   auto launch_request_arguments = launch_request.getObject("arguments");
-  std::vector<std::string> args = GetStrings(launch_request_arguments, "args");
   // The program path must be the first entry in the "args" field
-  args.insert(args.begin(),
-              GetString(launch_request_arguments, "program").str());
+  std::vector<std::string> args = {
+      debug_adaptor_path.str(), "-f", pid_file.str(), "-t",
+      GetString(launch_request_arguments, "program").str()};
+  std::vector<std::string> target_args =
+      GetStrings(launch_request_arguments, "args");
+  args.insert(args.end(), target_args.begin(), target_args.end());
   run_in_terminal_args.try_emplace("args", args);
 
   const auto cwd = GetString(launch_request_arguments, "cwd");
   if (!cwd.empty())
     run_in_terminal_args.try_emplace("cwd", cwd);
 
   // We need to convert the input list of environments variables into a
   // dictionary

lldb/tools/lldb-vscode/Options.td

def: Flag<["-"], "g">,
   HelpText<"Alias for --wait-for-debugger">;
 
 def port: Separate<["--", "-"], "port">,
   MetaVarName<"<port>">,
   HelpText<"Communicate with the lldb-vscode tool over the defined port.">;
 def: Separate<["-"], "p">,
   Alias<port>,
   HelpText<"Alias for --port">;
+
+def launch_target: Separate<["--", "-"], "launch-target">,
+  MetaVarName<"<target>">,
+  HelpText<"Launch a target for the launchInTerminal request. Any argument "
+    "provided after this one will be passed to the target. The parameter "
+    "--comm-files-prefix must also be specified.">;
+def: Separate<["-"], "t">,
+  Alias<launch_target>,
+  HelpText<"Alias for --launch-target">;
+
+def comm_files_prefix: Separate<["--", "-"], "comm-files-prefix">,
+  MetaVarName<"<path>">,
+  HelpText<"Prefix to files used to communicate with the debug adaptor when "
+    "using --launch-target.">;
+def: Separate<["-"], "f">,
+  Alias<comm_files_prefix>,
+  HelpText<"Alias for --comm-files-prefix">;

lldb/tools/lldb-vscode/RunInTerminal.h

+//===-- RunInTerminal.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_RUNINTERMINAL_H
+#define LLDB_TOOLS_LLDB_VSCODE_RUNINTERMINAL_H
+
+// TODO: In order to implement Windows support for this feature, basically the
+// mkfifo API should be replaced by CreateNamedPipe.
+#if !defined(_WIN32)
+
+#include <string>
+
+#include "llvm/Support/Error.h"
+
+namespace lldb_vscode {
+
+/// Struct holding a list of files used to communicate the runInTerminal
+/// launcher with the debug adaptor. All these files have a common prefix for
+/// convenience.
+struct RunInTerminalCommunicationFiles {
+  RunInTerminalCommunicationFiles(llvm::StringRef file_prefix);
+
+  void DeleteFiles();
+
+  /// Prefix path for all the files in this struct
+  std::string prefix;
+  /// File the runInTerminal launcher can write its pid to
+  std::string pid_file;
+  /// File the runInTerminal launcher can write error messages to
+  std::string err_file;
+  /// File whose existance indicates that the debug adaptor has attached to the
+  /// runInTerminal launcher.
+  std::string did_attach_file;
+};
+
+class RunInTerminalDebugAdaptorCommChannel;
+
+using RunInTerminalDebugAdaptorCommChannelUP =
+    std::unique_ptr<RunInTerminalDebugAdaptorCommChannel>;
+
+class RunInTerminalDebugAdaptorCommChannel {
+public:
+  static llvm::Expected<RunInTerminalDebugAdaptorCommChannelUP> Create();
+
+  ~RunInTerminalDebugAdaptorCommChannel();
+
+  /// Get the common path prefix for all files used for communication.
+  llvm::StringRef GetCommFilesPrefix();
+
+  /// Notify the runInTerminal launcher that it was attached.
+  void NotifyDidAttach();
+
+  /// Fetch the pid of the runInTerminal launcher or return an error
+  /// if a certain timeout if reached.
+  llvm::Expected<lldb::pid_t> GetLauncherPid();
+
+  /// Fetch any errors emitted by the runInTerminal launcher or return a
+  /// default error message if a certain timeout if reached.
+  std::string GetLauncherError();
+
+private:
+  RunInTerminalDebugAdaptorCommChannel(llvm::StringRef prefix);
+
+  RunInTerminalCommunicationFiles m_comm_files;
+};
+
+class RunInTerminalLauncherCommChannel {
+public:
+  RunInTerminalLauncherCommChannel(llvm::StringRef prefix);
+
+  /// Check if the debug adaptor has attach to the current process.
+  bool HasDebugAdaptorAttached();
+
+  /// Notify the debug adaptor this process' pid.
+  void NotifyPid();
+
+  /// Notify the debug adaptor that there's been an error.
+  void NotifyError(llvm::StringRef error);
+
+private:
+  RunInTerminalCommunicationFiles m_comm_files;
+};
+
+} // namespace lldb_vscode
+
+#endif
+#endif // LLDB_TOOLS_LLDB_VSCODE_RUNINTERMINAL_H

lldb/tools/lldb-vscode/RunInTerminal.cpp

+//===-- RunInTerminal.cpp ---------------------------------------*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#if !defined(_WIN32)
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <thread>
+
+#include "llvm/Support/FileSystem.h"
+
+#include "lldb/lldb-defines.h"
+
+#include "RunInTerminal.h"
+
+namespace lldb_vscode {
+
+static llvm::Error CreateFifoFile(const std::string &path) {
+  if (int err = mkfifo(path.c_str(), 0666))
+    return llvm::createStringError(
+        std::error_code(err, std::generic_category()),
+        "Couldn't create fifo file: %s", path.c_str());
+  return llvm::Error::success();
+}
+
+RunInTerminalCommunicationFiles::RunInTerminalCommunicationFiles(
+    llvm::StringRef file_prefix)
+    : prefix(file_prefix.str()) {
+  pid_file = prefix + ".pid";
+  err_file = prefix + ".err";
+  did_attach_file = prefix + ".attached";
+}
+
+void RunInTerminalCommunicationFiles::DeleteFiles() {
+  unlink(pid_file.c_str());
+  unlink(err_file.c_str());
+  unlink(did_attach_file.c_str());
+}
+
+llvm::Expected<RunInTerminalDebugAdaptorCommChannelUP>
+RunInTerminalDebugAdaptorCommChannel::Create() {
+  llvm::SmallString<256> comm_files_prefix;
+  if (std::error_code EC = llvm::sys::fs::getPotentiallyUniqueTempFileName(
+          "lldb-vscode-run-in-terminal-", "", comm_files_prefix))
+    return llvm::createStringError(
+        EC,
+        "Error making unique filename for runInTerminal communication files");
+
+  // Can't use std::make_unique because the constructor is private
+  RunInTerminalDebugAdaptorCommChannelUP comm_channel(
+      new RunInTerminalDebugAdaptorCommChannel(comm_files_prefix.str()));
+  llvm::Error err =
+      llvm::joinErrors(CreateFifoFile(comm_channel->m_comm_files.pid_file),
+                       CreateFifoFile(comm_channel->m_comm_files.err_file));
+  if (err)
+    return std::move(err);
+  return comm_channel;
+}
+
+RunInTerminalDebugAdaptorCommChannel::~RunInTerminalDebugAdaptorCommChannel() {
+  m_comm_files.DeleteFiles();
+}
+
+llvm::StringRef RunInTerminalDebugAdaptorCommChannel::GetCommFilesPrefix() {
+  return m_comm_files.prefix;
+}
+
+void RunInTerminalDebugAdaptorCommChannel::NotifyDidAttach() {
+  std::ofstream did_attach_file_write(m_comm_files.did_attach_file);
+}
+
+llvm::Expected<lldb::pid_t>
+RunInTerminalDebugAdaptorCommChannel::GetLauncherPid() {
+  lldb::pid_t pid = LLDB_INVALID_PROCESS_ID;
+  std::thread pid_reader([&]() {
+    std::ifstream reader(m_comm_files.pid_file, std::ifstream::in);
+    reader >> pid;
+  });
+  auto future = std::async(std::launch::async, &std::thread::join, &pid_reader);
+  // We try to read with a timeout, in case the launcher is borked.
+  if (future.wait_for(std::chrono::seconds(10)) == std::future_status::timeout)
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "Timed out trying to get the pid from the runInTerminal launcher\n");
+  if (pid == LLDB_INVALID_PROCESS_ID)
+    return llvm::createStringError(
+        llvm::inconvertibleErrorCode(),
+        "Couldn't get a valid pid from the runInTerminal launcher\n");
+  return pid;
+}
+
+std::string RunInTerminalDebugAdaptorCommChannel::GetLauncherError() {
+  std::string error_message;
+  std::thread error_reader([&]() {
+    std::ifstream reader(m_comm_files.err_file, std::ifstream::in);
+    std::getline(reader, error_message);
+  });
+  auto future =
+      std::async(std::launch::async, &std::thread::join, &error_reader);
+  // We try to read with a timeout, in case the launcher is borked.
+  // We don't need to wait long, as we already know there's been an error.
+  if (future.wait_for(std::chrono::seconds(2)) == std::future_status::timeout)
+    return "Timed out trying to get error messages from the runInTerminal "
+           "launcher";
+  return error_message;
+}
+
+RunInTerminalDebugAdaptorCommChannel::RunInTerminalDebugAdaptorCommChannel(
+    llvm::StringRef prefix)
+    : m_comm_files(prefix.str()) {}
+
+RunInTerminalLauncherCommChannel::RunInTerminalLauncherCommChannel(
+    llvm::StringRef prefix)
+    : m_comm_files(prefix) {}
+
+bool RunInTerminalLauncherCommChannel::HasDebugAdaptorAttached() {
+  return llvm::sys::fs::exists(m_comm_files.did_attach_file);
+}
+
+void RunInTerminalLauncherCommChannel::NotifyPid() {
+  std::ofstream writer(m_comm_files.pid_file, std::ofstream::out);
+  writer << getpid() << std::endl;
+}
+
+void RunInTerminalLauncherCommChannel::NotifyError(llvm::StringRef error) {
+  std::ofstream writer(m_comm_files.err_file, std::ofstream::out);
+  writer << error.str() << std::endl;
+}
+} // namespace lldb_vscode
+
+#endif

lldb/tools/lldb-vscode/VSCode.h

 
 #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 "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 VARREF_IS_SCOPE(v) (VARREF_LOCALS <= 1 && v < VARREF_FIRST_VAR_IDX)

 enum class PacketStatus {
   Success = 0,
   EndOfFile,
   JSONMalformed,
   JSONNotObject
 };
 
 struct VSCode {
+  std::string debug_adaptor_path;
   InputStream input;
   OutputStream output;
   lldb::SBDebugger debugger;
   lldb::SBTarget target;
   lldb::SBValueList variables;
   lldb::SBBroadcaster broadcaster;
   int64_t num_regs;
   int64_t num_locals;
struct VSCode {
   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;
   uint32_t reverse_request_seq;
   std::map<std::string, RequestCallback> request_handlers;
-  std::condition_variable request_in_terminal_cv;
   bool waiting_for_run_in_terminal;
   // 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;

lldb/tools/lldb-vscode/lldb-vscode.cpp

if (listener.WaitForEvent(1, event)) {
           case lldb::eStateStepping:
             break;
           case lldb::eStateCrashed:
             break;
           case lldb::eStateDetached:
             break;
           case lldb::eStateSuspended:
             break;
-          case lldb::eStateStopped: {
-            if (g_vsc.waiting_for_run_in_terminal) {
-              g_vsc.waiting_for_run_in_terminal = false;
-              g_vsc.request_in_terminal_cv.notify_one();
-            }
-          }
+          case lldb::eStateStopped:
             // Only report a stopped event if the process was not restarted.
             if (!lldb::SBProcess::GetRestartedFromEvent(event)) {
               SendStdOutStdErr(process);
               SendThreadStoppedEvent();
             }
             break;
           case lldb::eStateRunning:
             break;
if (listener.WaitForEvent(1, event)) {
                        lldb::SBTarget::eBroadcastBitModulesUnloaded) {
               body.try_emplace("reason", "removed");
             } else if (event_mask &
                        lldb::SBTarget::eBroadcastBitSymbolsLoaded) {
               body.try_emplace("reason", "changed");
             }
             body.try_emplace("module", module_value);
             module_event.try_emplace("body", std::move(body));
-            g_vsc.SendJSON(llvm::json::Value(std::move(module_event)));
+            // g_vsc.SendJSON(llvm::json::Value(std::move(module_event)));
           }
         }
       } else if (event.BroadcasterMatchesRef(g_vsc.broadcaster)) {
         if (event_mask & eBroadcastBitStopEventThread) {
           done = true;
         }
       }
     }
void request_initialize(const llvm::json::Object &request) {
   // data hovers.
   body.try_emplace("supportsEvaluateForHovers", true);
   // Available filters or options for the setExceptionBreakpoints request.
   llvm::json::Array filters;
   for (const auto &exc_bp : g_vsc.exception_breakpoints) {
     filters.emplace_back(CreateExceptionBreakpointFilter(exc_bp));
   }
   body.try_emplace("exceptionBreakpointFilters", std::move(filters));
-  // The debug adapter supports launching a debugee in intergrated VSCode
-  // terminal.
+#if !defined(_WIN32)
   body.try_emplace("supportsRunInTerminalRequest", true);
+#else
+  body.try_emplace("supportsRunInTerminalRequest", false);
+#endif
   // The debug adapter supports stepping back via the stepBack and
   // reverseContinue requests.
   body.try_emplace("supportsStepBack", false);
   // The debug adapter supports setting a variable to a value.
   body.try_emplace("supportsSetVariable", true);
   // The debug adapter supports restarting a frame.
   body.try_emplace("supportsRestartFrame", false);
   // The debug adapter supports the gotoTargetsRequest.
#endif
   body.try_emplace("supportsDelayedStackTraceLoading", true);
   // The debug adapter supports the 'loadedSources' request.
   body.try_emplace("supportsLoadedSourcesRequest", false);
 
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
-void request_runInTerminal(const llvm::json::Object &launch_request,
-                           llvm::json::Object &launch_response) {
-  // We have already created a target that has a valid "program" path to the
-  // executable. We will attach to the next process whose name matches that
-  // of the target's.
+llvm::Error request_runInTerminal(const llvm::json::Object &launch_request) {
+#if defined(_WIN32)
+  return llvm::createStringError(
+      llvm::inconvertibleErrorCode(),
+      "\"runInTerminal\" is not supported on Windows");
+#else
   g_vsc.is_attach = true;
   lldb::SBAttachInfo attach_info;
-  lldb::SBError error;
-  attach_info.SetWaitForLaunch(true, /*async*/ true);
-  g_vsc.target.Attach(attach_info, error);
 
-  llvm::json::Object reverse_request =
-      CreateRunInTerminalReverseRequest(launch_request);
+  llvm::Expected<RunInTerminalDebugAdaptorCommChannelUP> comm_channel_or_err =
+      RunInTerminalDebugAdaptorCommChannel::Create();
+  if (!comm_channel_or_err)
+    return comm_channel_or_err.takeError();
+  RunInTerminalDebugAdaptorCommChannel &comm_channel =
+      *comm_channel_or_err.get();
+
+  llvm::json::Object reverse_request = CreateRunInTerminalReverseRequest(
+      launch_request, g_vsc.debug_adaptor_path,
+      comm_channel.GetCommFilesPrefix());
   llvm::json::Object reverse_response;
   lldb_vscode::PacketStatus status =
       g_vsc.SendReverseRequest(reverse_request, reverse_response);
   if (status != lldb_vscode::PacketStatus::Success)
-    error.SetErrorString("Process cannot be launched by IDE.");
-
-  if (error.Success()) {
-    // Wait for the attach stop event to happen or for a timeout.
-    g_vsc.waiting_for_run_in_terminal = true;
-    static std::mutex mutex;
-    std::unique_lock<std::mutex> locker(mutex);
-    g_vsc.request_in_terminal_cv.wait_for(locker, std::chrono::seconds(10));
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Process cannot be launched by the IDE. %s",
+                                   comm_channel.GetLauncherError().c_str());
 
-    auto attached_pid = g_vsc.target.GetProcess().GetProcessID();
-    if (attached_pid == LLDB_INVALID_PROCESS_ID)
-      error.SetErrorString("Failed to attach to a process");
-    else
-      SendProcessEvent(Attach);
-  }
+  if (llvm::Expected<lldb::pid_t> pid = comm_channel.GetLauncherPid())
+    attach_info.SetProcessID(*pid);
+    return pid.takeError();
 
-  if (error.Fail()) {
-    launch_response["success"] = llvm::json::Value(false);
-    EmplaceSafeString(launch_response, "message",
-                      std::string(error.GetCString()));
-  } else {
-    launch_response["success"] = llvm::json::Value(true);
-    g_vsc.SendJSON(CreateEventObject("initialized"));
-  }
+  g_vsc.debugger.SetAsync(false);
+  lldb::SBError error;
+  g_vsc.target.Attach(attach_info, error);
+
+  if (error.Fail())
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Failed to attach to the target process. %s",
+                                   comm_channel.GetLauncherError().c_str());
+  // We just attached to the runInTerminal launcher, which was waiting to be
+  // attached. After resuming, it will exec and become the original target the
+  // user provided.
+
+  // This will notify the runInTerminal launcher that we attached.
+  comm_channel.NotifyDidAttach();
+
+  // Here, we resume the process so that it can exec. It'll be stopped at the
+  // exec point.
+  g_vsc.target.GetProcess().Continue();
+
+  g_vsc.debugger.SetAsync(true);
+
+  return llvm::Error::success();
+#endif
 }
 
 // "LaunchRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Launch request; value of command field is 'launch'.",
 //     "properties": {
 //       "command": {
void request_launch(const llvm::json::Object &request) {
   g_vsc.SetTarget(g_vsc.CreateTargetFromArguments(*arguments, status));
   if (status.Fail()) {
     response["success"] = llvm::json::Value(false);
     EmplaceSafeString(response, "message", status.GetCString());
     g_vsc.SendJSON(llvm::json::Value(std::move(response)));
     return;
   }
 
-  if (GetBoolean(arguments, "runInTerminal", false)) {
-    request_runInTerminal(request, response);
-    g_vsc.SendJSON(llvm::json::Value(std::move(response)));
-    return;
-  }
-
   // Instantiate a launch info instance for the target.
   auto launch_info = g_vsc.target.GetLaunchInfo();
 
   // Grab the current working directory if there is one and set it in the
   // launch info.
   const auto cwd = GetString(arguments, "cwd");
   if (!cwd.empty())
     launch_info.SetWorkingDirectory(cwd.data());
if (GetBoolean(arguments, "shellExpandArguments", false))
     flags |= lldb::eLaunchFlagShellExpandArguments;
   const bool detatchOnError = GetBoolean(arguments, "detachOnError", false);
   launch_info.SetDetachOnError(detatchOnError);
   launch_info.SetLaunchFlags(flags | lldb::eLaunchFlagDebug |
                              lldb::eLaunchFlagStopAtEntry);
 
   // Run any pre run LLDB commands the user specified in the launch.json
   g_vsc.RunPreRunCommands();
-  if (launchCommands.empty()) {
+
+  if (GetBoolean(arguments, "runInTerminal", false)) {
+    if (llvm::Error err = request_runInTerminal(request))
+      error.SetErrorString(llvm::toString(std::move(err)).c_str());
+  } else if (launchCommands.empty()) {
     // Disable async events so the launch will be successful when we return from
     // the launch call and the launch will happen synchronously
     g_vsc.debugger.SetAsync(false);
     g_vsc.target.Launch(launch_info, error);
     g_vsc.debugger.SetAsync(true);
   } else {
     g_vsc.RunLLDBCommands("Running launchCommands:", launchCommands);
     // The custom commands might have created a new target so we should use the
     // selected target after these commands are run.
     g_vsc.target = g_vsc.debugger.GetSelectedTarget();
   }
 
   if (error.Fail()) {
     response["success"] = llvm::json::Value(false);
     EmplaceSafeString(response, "message", std::string(error.GetCString()));
   }
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 
+  if (g_vsc.is_attach)
+    SendProcessEvent(Attach); // this happens when doing runInTerminal
+  else
     SendProcessEvent(Launch);
   g_vsc.SendJSON(llvm::json::Value(CreateEventObject("initialized")));
-  // Reenable async events and start the event thread to catch async events.
-  // g_vsc.debugger.SetAsync(true);
 }
 
 // "NextRequest": {
 //   "allOf": [ { "$ref": "#/definitions/Request" }, {
 //     "type": "object",
 //     "description": "Next request; value of command field is 'next'. The
 //                     request starts the debuggee to run again for one step.
 //                     The debug adapter first sends the NextResponse and then
EXAMPLES:
   Passing --wait-for-debugger will pause the process at startup and wait for a
   debugger to attach to the process.
 
     lldb-vscode -g
   )___";
   llvm::outs() << examples;
 }
 
-int main(int argc, char *argv[]) {
+// If --launch-target is provided, this instance of lldb-vscode becomes a
+// runInTerminal launcher. It will ultimately launch the program specified in
+// the --launch-target argument, which is the original program the user wanted
+// to debug. This is done in such a way that the actual debug adaptor can
+// place breakpoints at the beginning of the program.
+//
+// The launcher will communicate with the debug adaptor using files whose path
+// prefix is specified in the --comm-files-prefix argument. Both this launcher
+// and the debug adaptor should use the same path prefix to guarantee correct
+// communication.
+//
+// Regarding the actual flow, this launcher will first notify the debug adaptor
+// its pid. Then, the launcher will be in a pending state waiting to be attached
+// by the adaptor.
+//
+// Once attached and resumed, the launcher will exec and become the program
+// specified by --launch-target, which is the original target the
+// user wanted to run.
+//
+// In case of errors launching the target, a suitable error message will be
+// emitted to the debug adaptor.
+[[noreturn]] void LaunchRunInTerminalTarget(llvm::opt::Arg &target_arg,
+                                            llvm::StringRef comm_files_prefix,
+                                            char *argv[]) {
+#if defined(_WIN32)
+  llvm::errs() << "\"--launch-target\" is not supported on Windows\n";
+  exit(EXIT_FAILURE);
+#else
+  RunInTerminalLauncherCommChannel comm_channel(comm_files_prefix);
+  comm_channel.NotifyPid();
 
-  // Initialize LLDB first before we do anything.
-  lldb::SBDebugger::Initialize();
+  // Some seconds waiting to be attached. We don't wait indefinitely using a
+  // signal to prevent being paused forever.
+  const char *timeout_env_var = getenv("LLDB_VSCODE_RIT_TIMEOUT_IN_MS");
+  int timeout_in_ms =
+      timeout_env_var != nullptr ? atoi(timeout_env_var) : 10000;
+  for (int i = 0; i < timeout_in_ms / 10; i++) {
+    std::this_thread::sleep_for(std::chrono::milliseconds(10));
+    if (comm_channel.HasDebugAdaptorAttached()) {
+      const char *target = target_arg.getValue();
+      execv(target, argv + target_arg.getIndex() + 2);
+
+      comm_channel.NotifyError(std::strerror(errno));
+      llvm::errs() << std::strerror(errno) << "\n";
+
+      exit(EXIT_FAILURE);
+    }
+  }
 
-  RegisterRequestCallbacks();
+  comm_channel.NotifyError("lldb-vscode didn't attach to this process");
+  llvm::errs() << "lldb-vscode didn't attach to this process\n";
+  exit(EXIT_FAILURE);
+#endif
+}
 
-  int portno = -1;
+int main(int argc, char *argv[]) {
+  llvm::SmallString<256> program_path(argv[0]);
+  llvm::sys::fs::make_absolute(program_path);
+  g_vsc.debug_adaptor_path = program_path.str().str();
 
   LLDBVSCodeOptTable T;
   unsigned MAI, MAC;
   llvm::ArrayRef<const char *> ArgsArr = llvm::makeArrayRef(argv + 1, argc);
   llvm::opt::InputArgList input_args = T.ParseArgs(ArgsArr, MAI, MAC);
 
+  if (auto *target_arg = input_args.getLastArg(OPT_launch_target)) {
+    if (auto *comm_file_prefix = input_args.getLastArg(OPT_comm_files_prefix))
+      LaunchRunInTerminalTarget(*target_arg, comm_file_prefix->getValue(),
+                                argv);
+    else {
+      llvm::errs() << "\"--launch-target\" requires \"--comm-files-prefix\" to "
+                      "be specified\n";
+      exit(EXIT_FAILURE);
+    }
+  }
+
+  // Initialize LLDB first before we do anything.
+  lldb::SBDebugger::Initialize();
+
+  RegisterRequestCallbacks();
+
+  int portno = -1;
+
   if (input_args.hasArg(OPT_help)) {
     printHelp(T, llvm::sys::path::filename(argv[0]));
     return 0;
   }
 
   if (auto *arg = input_args.getLastArg(OPT_port)) {
     auto optarg = arg->getValue();
     char *remainder;