[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

1449

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

1461–1464

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

1467

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

1467–1468

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.

2963

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.

2971

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

2972

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

2973

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

2982

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'".

2985

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

30

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

33–39

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

1378–1380

Reverse this to avoid the negate?

1440–1444

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

2964

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

2972

Don't use auto

2973

don't use auto

2983

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

2995

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

3002

I assume env vars are being inherited from this process?

[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

2964

it seems there isn't

2995

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.

3002

yes, that's the default behavior

[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??

1484

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

27

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

10

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

10

@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

10

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,
                          debuggerRoot=None, runInTerminal=False):
         '''Build the default Makefile target, create the VSCode debug adaptor,
            and launch the process.
         '''
         self.build_and_create_debug_adaptor()
         self.assertTrue(os.path.exists(program), 'executable must exist')
 
-        self.launch(program, args, cwd, env, stopOnEntry, disableASLR,
+        return self.launch(program, args, cwd, env, stopOnEntry, disableASLR,
                     disableSTDIO, shellExpandArguments, trace,
                     initCommands, preRunCommands, stopCommands, exitCommands,
                     terminateCommands, sourcePath, debuggerRoot, runInTerminal=runInTerminal)

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
+import shutil
+import json
+from threading import Thread
 
 
 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'
-        self.build_and_launch(program, stopOnEntry=True, runInTerminal=True, args=["foobar"], env=["FOO=bar"])
+        self.build_and_launch(
+            program, stopOnEntry=True, runInTerminal=True, args=["foobar"],
+            env=["FOO=bar"])
+
         breakpoint_line = line_number(source, '// breakpoint')
 
         self.set_source_breakpoints(source, [breakpoint_line])
         self.continue_to_next_stop()
 
         # We verify we actually stopped inside the loop
         counter = int(self.vscode.get_local_variable_value('counter'))
         self.assertTrue(counter > 0)
 
         # We verify we were able to set the launch arguments
         argc = int(self.vscode.get_local_variable_value('argc'))
         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-file" to be specified', proc.stderr)
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_FakeAttachedRunInTerminalLauncherWithInvalidProgram(self):
+        comm_file = os.path.join(self.getBuildDir(), "comm-file")
+        os.mkfifo(comm_file)
+
+        proc = subprocess.Popen(
+            [self.lldbVSCodeExec, "--comm-file", comm_file, "--launch-target", "INVALIDPROGRAM"],
+            universal_newlines=True, stderr=subprocess.PIPE)
+
+        with open(comm_file, "r") as file:
+            file.readline() # read the pid message
+
+        with open(comm_file, "w") as file:
+            file.write(json.dumps({"kind": "didAttach"}) + "\n")
+
+        with open(comm_file, "r") as file:
+            self.assertIn("No such file or directory", file.readline()) # read the error
+        
+        _, stderr = proc.communicate()
+        self.assertIn("No such file or directory", stderr)
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_FakeAttachedRunInTerminalLauncherWithValidProgram(self):
+        comm_file = os.path.join(self.getBuildDir(), "comm-file")
+        os.mkfifo(comm_file)
+
+        proc = subprocess.Popen(
+            [self.lldbVSCodeExec, "--comm-file", comm_file, "--launch-target", "echo", "foo"],
+            universal_newlines=True, stdout=subprocess.PIPE)
+
+        with open(comm_file, "r") as file:
+            file.readline() # read the pid message
+
+        with open(comm_file, "w") as file:
+            file.write(json.dumps({"kind": "didAttach"}) + "\n")
+
+        stdout, _ = proc.communicate()
+        self.assertIn("foo", stdout)
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_FakeAttachedRunInTerminalLauncherAndCheckEnvironment(self):
+        comm_file = os.path.join(self.getBuildDir(), "comm-file")
+        os.mkfifo(comm_file)
+
+        proc = subprocess.Popen(
+            [self.lldbVSCodeExec, "--comm-file", comm_file, "--launch-target", "env"],
+            universal_newlines=True, stdout=subprocess.PIPE,
+            env={**os.environ, "FOO": "BAR"})
+        
+        with open(comm_file, "r") as file:
+            file.readline() # read the pid message
+
+        with open(comm_file, "w") as file:
+            file.write(json.dumps({"kind": "didAttach"}) + "\n")
+
+        stdout, _ = proc.communicate()
+        # We check the error message in both stderr and the error file
+        self.assertIn("FOO=BAR", stdout)
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_NonAttachedRunInTerminalLauncher(self):
+        comm_file = os.path.join(self.getBuildDir(), "comm-file")
+        os.mkfifo(comm_file)
+
+        proc = subprocess.Popen(
+            [self.lldbVSCodeExec, "--comm-file", comm_file, "--launch-target", "echo", "foo"],
+            universal_newlines=True, stderr=subprocess.PIPE,
+            env={**os.environ, "LLDB_VSCODE_RIT_TIMEOUT_IN_MS": "1000"})
+
+        with open(comm_file, "r") as file:
+            file.readline() # read the pid message
+        
+        _, stderr = proc.communicate()
+        # We check the error message in both stderr and the error file
+        self.assertIn("Timed out trying to get messages from the debug adaptor", stderr)

lldb/tools/lldb-vscode/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS Support)
 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(LLDBVSCodeOptionsTableGen)
 add_lldb_tool(lldb-vscode
   lldb-vscode.cpp
   BreakpointBase.cpp
   ExceptionBreakpoint.cpp
+  FifoFiles.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/FifoFiles.h

+//===-- FifoFiles.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_FIFOFILES_H
+#define LLDB_TOOLS_LLDB_VSCODE_FIFOFILES_H
+
+#include "llvm/Support/Error.h"
+
+#include "JSONUtils.h"
+
+namespace lldb_vscode {
+
+/// Struct that controls the life of a fifo file in the filesystem.
+///
+/// The file is destroyed when the destructor is invoked.
+struct FifoFile {
+  FifoFile(llvm::StringRef path);
+
+  ~FifoFile();
+
+  std::string path;
+};
+
+/// Create a fifo file in the filesystem.
+///
+/// \param[in] path
+///     The path for the fifo file.
+///
+/// \return
+///     A \a std::shared_ptr<FifoFile> if the file could be created, or an
+///     \a llvm::Error in case of failures.
+llvm::Expected<std::shared_ptr<FifoFile>> CreateFifoFile(llvm::StringRef path);
+
+class FifoFileIO {
+public:
+  /// \param[in] fifo_file
+  ///     The path to an input fifo file that exists in the file system.
+  ///
+  /// \param[in] other_endpoint_name
+  ///     A human readable name for the other endpoint that will communicate
+  ///     using this file. This is used for error messages.
+  FifoFileIO(llvm::StringRef fifo_file, llvm::StringRef other_endpoint_name);
+
+  /// Read the next JSON object from the underlying input fifo file.
+  ///
+  /// The JSON object is expected to be a single line delimited with \a
+  /// std::endl.
+  ///
+  /// \return
+  ///     An \a llvm::Error object indicating the success or failure of this
+  ///     operation. Failures arise if the timeout is hit, the next line of text
+  ///     from the fifo file is not a valid JSON object, or is it impossible to
+  ///     read from the file.
+  llvm::Expected<llvm::json::Value> ReadJSON(std::chrono::milliseconds timeout);
+
+  /// Serialize a JSON object and write it to the underlying output fifo file.
+  ///
+  /// \param[in] json
+  ///     The JSON object to send. It will be printed as a single line delimited
+  ///     with \a std::endl.
+  ///
+  /// \param[in] timeout
+  ///     A timeout for how long we should until for the data to be consumed.
+  ///
+  /// \return
+  ///     An \a llvm::Error object indicating whether the data was consumed by
+  ///     a reader or not.
+  llvm::Error SendJSON(
+      const llvm::json::Value &json,
+      std::chrono::milliseconds timeout = std::chrono::milliseconds(20000));
+
+private:
+  std::string m_fifo_file;
+  std::string m_other_endpoint_name;
+};
+
+} // namespace lldb_vscode
+
+#endif // LLDB_TOOLS_LLDB_VSCODE_FIFOFILES_H

lldb/tools/lldb-vscode/FifoFiles.cpp

+//===-- FifoFiles.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>
+#endif
+
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <thread>
+
+#include "llvm/Support/FileSystem.h"
+
+#include "lldb/lldb-defines.h"
+
+#include "FifoFiles.h"
+
+using namespace llvm;
+
+namespace lldb_vscode {
+
+FifoFile::FifoFile(StringRef path) : path(path) {}
+
+FifoFile::~FifoFile() {
+#if !defined(WIN32)
+  unlink(path.c_str());
+#endif
+};
+
+Expected<std::shared_ptr<FifoFile>> CreateFifoFile(StringRef path) {
+#if defined(WIN32)
+  return createStringError(inconvertibleErrorCode(), "Unimplemented");
+#else
+  if (int err = mkfifo(path.data(), 0600))
+    return createStringError(std::error_code(err, std::generic_category()),
+                             "Couldn't create fifo file: %s", path.data());
+  return std::make_shared<FifoFile>(path);
+#endif
+}
+
+FifoFileIO::FifoFileIO(StringRef fifo_file, StringRef other_endpoint_name)
+    : m_fifo_file(fifo_file), m_other_endpoint_name(other_endpoint_name) {}
+
+Expected<json::Value> FifoFileIO::ReadJSON(std::chrono::milliseconds timeout) {
+  // We use a pointer for this future, because otherwise its normal destructor
+  // would wait for the getline to end, rendering the timeout useless.
+  Optional<std::string> line;
+  std::future<void> *future =
+      new std::future<void>(std::async(std::launch::async, [&]() {
+        std::ifstream reader(m_fifo_file, std::ifstream::in);
+        std::string buffer;
+        std::getline(reader, buffer);
+        if (!buffer.empty())
+          line = buffer;
+      }));
+  if (future->wait_for(timeout) == std::future_status::timeout ||
+      !line.hasValue())
+    return createStringError(inconvertibleErrorCode(),
+                             "Timed out trying to get messages from the " +
+                                 m_other_endpoint_name);
+  delete future;
+  return json::parse(*line);
+}
+
+Error FifoFileIO::SendJSON(const json::Value &json,
+                           std::chrono::milliseconds timeout) {
+  bool done = false;
+  std::future<void> *future =
+      new std::future<void>(std::async(std::launch::async, [&]() {
+        std::ofstream writer(m_fifo_file, std::ofstream::out);
+        writer << JSONToString(json) << std::endl;
+        done = true;
+      }));
+  if (future->wait_for(timeout) == std::future_status::timeout || !done) {
+    return createStringError(inconvertibleErrorCode(),
+                             "Timed out trying to send messages to the " +
+                                 m_other_endpoint_name);
+  }
+  delete future;
+  return Error::success();
+}
+
+} // namespace lldb_vscode

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] comm_file
+///     The fifo file used to communicate the with the target launcher.
+///
 /// \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 comm_file);
+
+/// Convert a given JSON object to a string.
+std::string JSONToString(const llvm::json::Value &json);
 
 } // 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 comm_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(), "--comm-file", comm_file.str(),
+      "--launch-target", 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
   std::vector<std::string> envs = GetStrings(launch_request_arguments, "env");
   llvm::json::Object environment;
   for (const std::string &env : envs) {
     size_t index = env.find('=');
     environment.try_emplace(env.substr(0, index), env.substr(index + 1));
   }
   run_in_terminal_args.try_emplace("env",
                                    llvm::json::Value(std::move(environment)));
 
   reverse_request.try_emplace(
       "arguments", llvm::json::Value(std::move(run_in_terminal_args)));
   return reverse_request;
 }
 
+std::string JSONToString(const llvm::json::Value &json) {
+  std::string data;
+  llvm::raw_string_ostream os(data);
+  os << json;
+  os.flush();
+  return data;
+}
+
 } // namespace lldb_vscode

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 comm_file: Separate<["--", "-"], "comm-file">,
+  MetaVarName<"<file>">,
+  HelpText<"The fifo file used to communicate the with the debug adaptor"
+    "when using --launch-target.">;

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
+
+#include "FifoFiles.h"
+
+#include <future>
+#include <thread>
+
+namespace lldb_vscode {
+
+enum RunInTerminalMessageKind {
+  eRunInTerminalMessageKindPID = 0,
+  eRunInTerminalMessageKindError,
+  eRunInTerminalMessageKindDidAttach,
+};
+
+struct RunInTerminalMessage;
+struct RunInTerminalMessagePid;
+struct RunInTerminalMessageError;
+struct RunInTerminalMessageDidAttach;
+
+struct RunInTerminalMessage {
+  RunInTerminalMessage(RunInTerminalMessageKind kind);
+
+  virtual ~RunInTerminalMessage() = default;
+
+  /// Serialize this object to JSON
+  virtual llvm::json::Value ToJSON() const = 0;
+
+  const RunInTerminalMessagePid *GetAsPidMessage() const;
+
+  const RunInTerminalMessageError *GetAsErrorMessage() const;
+
+  RunInTerminalMessageKind kind;
+};
+
+using RunInTerminalMessageUP = std::unique_ptr<RunInTerminalMessage>;
+
+struct RunInTerminalMessagePid : RunInTerminalMessage {
+  RunInTerminalMessagePid(lldb::pid_t pid);
+
+  llvm::json::Value ToJSON() const override;
+
+  lldb::pid_t pid;
+};
+
+struct RunInTerminalMessageError : RunInTerminalMessage {
+  RunInTerminalMessageError(llvm::StringRef error);
+
+  llvm::json::Value ToJSON() const override;
+
+  std::string error;
+};
+
+struct RunInTerminalMessageDidAttach : RunInTerminalMessage {
+  RunInTerminalMessageDidAttach();
+
+  llvm::json::Value ToJSON() const override;
+};
+
+class RunInTerminalLauncherCommChannel {
+public:
+  RunInTerminalLauncherCommChannel(llvm::StringRef comm_file);
+
+  /// Wait until the debug adaptor attaches.
+  ///
+  /// \param[in] timeout
+  ///     How long to wait to be attached.
+  //
+  /// \return
+  ///     An \a llvm::Error object in case of errors or if this operation times
+  ///     out.
+  llvm::Error WaitUntilDebugAdaptorAttaches(std::chrono::milliseconds timeout);
+
+  /// Notify the debug adaptor this process' pid.
+  ///
+  /// \return
+  ///     An \a llvm::Error object in case of errors or if this operation times
+  ///     out.
+  llvm::Error NotifyPid();
+
+  /// Notify the debug adaptor that there's been an error.
+  void NotifyError(llvm::StringRef error);
+
+private:
+  FifoFileIO m_io;
+};
+
+class RunInTerminalDebugAdapterCommChannel {
+public:
+  RunInTerminalDebugAdapterCommChannel(llvm::StringRef comm_file);
+
+  /// Notify the runInTerminal launcher that it was attached.
+  ///
+  /// \return
+  ///     A future indicated whether the runInTerminal launcher received the
+  ///     message correctly or not.
+  std::future<llvm::Error> NotifyDidAttach();
+
+  /// Fetch the pid of the runInTerminal launcher.
+  ///
+  /// \return
+  ///     An \a llvm::Error object in case of errors or if this operation times
+  ///     out.
+  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:
+  FifoFileIO m_io;
+};
+
+/// Create a fifo file used to communicate the debug adaptor with
+/// the runInTerminal launcher.
+llvm::Expected<std::shared_ptr<FifoFile>> CreateRunInTerminalCommFile();
+
+} // namespace lldb_vscode
+
+#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>
+#endif
+
+#include <chrono>
+#include <fstream>
+#include <future>
+#include <thread>
+
+#include "llvm/Support/FileSystem.h"
+
+#include "lldb/lldb-defines.h"
+
+#include "RunInTerminal.h"
+
+using namespace llvm;
+
+namespace lldb_vscode {
+
+const RunInTerminalMessagePid *RunInTerminalMessage::GetAsPidMessage() const {
+  return static_cast<const RunInTerminalMessagePid *>(this);
+}
+
+const RunInTerminalMessageError *
+RunInTerminalMessage::GetAsErrorMessage() const {
+  return static_cast<const RunInTerminalMessageError *>(this);
+}
+
+RunInTerminalMessage::RunInTerminalMessage(RunInTerminalMessageKind kind)
+    : kind(kind) {}
+
+RunInTerminalMessagePid::RunInTerminalMessagePid(lldb::pid_t pid)
+    : RunInTerminalMessage(eRunInTerminalMessageKindPID), pid(pid) {}
+
+json::Value RunInTerminalMessagePid::ToJSON() const {
+  return json::Object{{"kind", "pid"}, {"pid", static_cast<int64_t>(pid)}};
+}
+
+RunInTerminalMessageError::RunInTerminalMessageError(StringRef error)
+    : RunInTerminalMessage(eRunInTerminalMessageKindError), error(error) {}
+
+json::Value RunInTerminalMessageError::ToJSON() const {
+  return json::Object{{"kind", "error"}, {"value", error}};
+}
+
+RunInTerminalMessageDidAttach::RunInTerminalMessageDidAttach()
+    : RunInTerminalMessage(eRunInTerminalMessageKindDidAttach) {}
+
+json::Value RunInTerminalMessageDidAttach::ToJSON() const {
+  return json::Object{{"kind", "didAttach"}};
+}
+
+static Expected<RunInTerminalMessageUP>
+ParseJSONMessage(const json::Value &json) {
+  if (const json::Object *obj = json.getAsObject()) {
+    if (Optional<StringRef> kind = obj->getString("kind")) {
+      if (*kind == "pid") {
+        if (Optional<int64_t> pid = obj->getInteger("pid"))
+          return std::make_unique<RunInTerminalMessagePid>(
+              static_cast<lldb::pid_t>(*pid));
+      } else if (*kind == "error") {
+        if (Optional<StringRef> error = obj->getString("error"))
+          return std::make_unique<RunInTerminalMessageError>(*error);
+      } else if (*kind == "didAttach") {
+        return std::make_unique<RunInTerminalMessageDidAttach>();
+      }
+    }
+  }
+
+  return createStringError(inconvertibleErrorCode(),
+                           "Incorrect JSON message: " + JSONToString(json));
+}
+
+static Expected<RunInTerminalMessageUP>
+GetNextMessage(FifoFileIO &io, std::chrono::milliseconds timeout) {
+  if (Expected<json::Value> json = io.ReadJSON(timeout))
+    return ParseJSONMessage(*json);
+  else
+    return json.takeError();
+}
+
+static Error ToError(const RunInTerminalMessage &message) {
+  if (message.kind == eRunInTerminalMessageKindError)
+    return createStringError(inconvertibleErrorCode(),
+                             message.GetAsErrorMessage()->error);
+  return createStringError(inconvertibleErrorCode(),
+                           "Unexpected JSON message: " +
+                               JSONToString(message.ToJSON()));
+}
+
+RunInTerminalLauncherCommChannel::RunInTerminalLauncherCommChannel(
+    StringRef comm_file)
+    : m_io(comm_file, "debug adaptor") {}
+
+Error RunInTerminalLauncherCommChannel::WaitUntilDebugAdaptorAttaches(
+    std::chrono::milliseconds timeout) {
+  if (Expected<RunInTerminalMessageUP> message =
+          GetNextMessage(m_io, timeout)) {
+    if (message.get()->kind == eRunInTerminalMessageKindDidAttach)
+      return Error::success();
+    else
+      return ToError(*message.get());
+  } else
+    return message.takeError();
+}
+
+Error RunInTerminalLauncherCommChannel::NotifyPid() {
+  return m_io.SendJSON(RunInTerminalMessagePid(getpid()).ToJSON());
+}
+
+void RunInTerminalLauncherCommChannel::NotifyError(StringRef error) {
+  if (Error err = m_io.SendJSON(RunInTerminalMessageError(error).ToJSON(),
+                                std::chrono::seconds(2)))
+    llvm::errs() << llvm::toString(std::move(err)) << "\n";
+}
+
+RunInTerminalDebugAdapterCommChannel::RunInTerminalDebugAdapterCommChannel(
+    StringRef comm_file)
+    : m_io(comm_file, "runInTerminal launcher") {}
+
+std::future<Error> RunInTerminalDebugAdapterCommChannel::NotifyDidAttach() {
+  return std::async(std::launch::async, [&]() {
+    return m_io.SendJSON(RunInTerminalMessageDidAttach().ToJSON());
+  });
+}
+
+Expected<lldb::pid_t> RunInTerminalDebugAdapterCommChannel::GetLauncherPid() {
+  if (Expected<RunInTerminalMessageUP> message =
+          GetNextMessage(m_io, std::chrono::seconds(20))) {
+    if (message.get()->kind == eRunInTerminalMessageKindPID)
+      return message.get()->GetAsPidMessage()->pid;
+    return ToError(*message.get());
+  } else {
+    return message.takeError();
+  }
+}
+
+std::string RunInTerminalDebugAdapterCommChannel::GetLauncherError() {
+  // We know there's been an error, so a small timeout is enough.
+  if (Expected<RunInTerminalMessageUP> message =
+          GetNextMessage(m_io, std::chrono::seconds(1)))
+    return toString(ToError(*message.get()));
+  else
+    return toString(message.takeError());
+}
+
+Expected<std::shared_ptr<FifoFile>> CreateRunInTerminalCommFile() {
+  SmallString<256> comm_file;
+  if (std::error_code EC = sys::fs::getPotentiallyUniqueTempFileName(
+          "lldb-vscode-run-in-terminal-comm", "", comm_file))
+    return createStringError(EC, "Error making unique file name for "
+                                 "runInTerminal communication files");
+
+  return CreateFifoFile(comm_file.str());
+}
+
+} // namespace lldb_vscode

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)));
           }
         }
       } else if (event.BroadcasterMatchesRef(g_vsc.broadcaster)) {
         if (event_mask & eBroadcastBitStopEventThread) {
           done = true;
         }
       }
     }
void request_initialize(const llvm::json::Object &request) {
   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.
   body.try_emplace("supportsRunInTerminalRequest", true);
   // 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.
   body.try_emplace("supportsGotoTargetsRequest", false);
void request_initialize(const llvm::json::Object &request) {
   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) {
   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<std::shared_ptr<FifoFile>> comm_file_or_err =
+      CreateRunInTerminalCommFile();
+  if (!comm_file_or_err)
+    return comm_file_or_err.takeError();
+  FifoFile &comm_file = *comm_file_or_err.get();
+
+  RunInTerminalDebugAdapterCommChannel comm_channel(comm_file.path);
+
+  llvm::json::Object reverse_request = CreateRunInTerminalReverseRequest(
+      launch_request, g_vsc.debug_adaptor_path, comm_file.path);
   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.");
+    return llvm::createStringError(llvm::inconvertibleErrorCode(),
+                                   "Process cannot be launched by the IDE. %s",
+                                   comm_channel.GetLauncherError().c_str());
 
-  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));
-
-    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());
+  // This will notify the runInTerminal launcher that we attached.
+  // We have to make this async, as the function won't return until the launcher
+  // resumes and reads the data.
+  std::future<llvm::Error> did_attach_message_success =
+      comm_channel.NotifyDidAttach();
+
+  // We just attached to the runInTerminal launcher, which was waiting to be
+  // attached. We now resume it, so it can receive the didAttach notification
+  // and then perform the exec. Upon continuing, the debugger will stop the
+  // process right in the middle of the exec. To the user, what we are doing is
+  // transparent, as they will only be able to see the process since the exec,
+  // completely unaware of the preparatory work.
+  g_vsc.target.GetProcess().Continue();
+
+  // Now that the actual target is just starting (i.e. exec was just invoked),
+  // we return the debugger to its async state.
+  g_vsc.debugger.SetAsync(true);
+
+  // If sending the notification failed, the launcher should be dead by now and
+  // the async didAttach notification should have an error message, so we
+  // return it. Otherwise, everything was a success.
+  did_attach_message_success.wait();
+  return did_attach_message_success.get();
 }
 
 // "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;
 }
 
+// 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 a fifo file in the
+// directory specified in the --comm-file argument.
+//
+// Regarding the actual flow, this launcher will first notify the debug adaptor
+// of 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.
+void LaunchRunInTerminalTarget(llvm::opt::Arg &target_arg,
+                               llvm::StringRef comm_file, char *argv[]) {
+#if defined(WIN_32)
+  llvm::errs() << "runInTerminal is not supported on Windows\n";
+  exit(EXIT_FAILURE);
+#else
+  RunInTerminalLauncherCommChannel comm_channel(comm_file);
+  if (llvm::Error err = comm_channel.NotifyPid()) {
+    llvm::errs() << llvm::toString(std::move(err)) << "\n";
+    exit(EXIT_FAILURE);
+  }
+
+  // We will wait to be attached with a timeout. We don't wait indefinitely
+  // using a signal to prevent being paused forever.
+
+  // This env var should be used only for tests.
+  const char *timeout_env_var = getenv("LLDB_VSCODE_RIT_TIMEOUT_IN_MS");
+  int timeout_in_ms =
+      timeout_env_var != nullptr ? atoi(timeout_env_var) : 20000;
+  if (llvm::Error err = comm_channel.WaitUntilDebugAdaptorAttaches(
+          std::chrono::milliseconds(timeout_in_ms))) {
+    llvm::errs() << llvm::toString(std::move(err)) << "\n";
+    exit(EXIT_FAILURE);
+  }
+
+  const char *target = target_arg.getValue();
+  execvp(target, argv);
+
+  std::string error = std::strerror(errno);
+  comm_channel.NotifyError(error);
+  llvm::errs() << error << "\n";
+  exit(EXIT_FAILURE);
+#endif
+}
+
 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 (llvm::opt::Arg *target_arg = input_args.getLastArg(OPT_launch_target)) {
+    if (llvm::opt::Arg *comm_file = input_args.getLastArg(OPT_comm_file)) {
+      int target_args_pos = argc;
+      for (int i = 0; i < argc; i++)
+        if (strcmp(argv[i], "--launch-target") == 0) {
+          target_args_pos = i + 1;
+          break;
+        }
+      LaunchRunInTerminalTarget(*target_arg, comm_file->getValue(),
+                                argv + target_args_pos);
+    } else {
+      llvm::errs() << "\"--launch-target\" requires \"--comm-file\" to be "
+                      "specified\n";
+      exit(EXIT_FAILURE);
+    }
+  }
 
   // Initialize LLDB first before we do anything.
   lldb::SBDebugger::Initialize();
 
   RegisterRequestCallbacks();
 
   int portno = -1;
 
-  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 (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;