[lldb-vscode] Add an option for loading core files

[wallace]

Summary

Currently loading core files on lldb-vscode is broken because there's a check in the attach workflow that asserts that the PID is valid, which of course fails for this case.
Hence, I'm adding a "coreFile" argument for the attach request, which does the work correctly.

I have yet to make a test. So I'm asking for initial feedback in the meantime. I'll get some inspiration by the coredump tests in LLDB core.

This is a test debug config:

{
        "name": "Attach to coredump",
        "type": "fb-lldb",
        "request": "attach",
        "program": "/Users/wallace/Source/coredumptest/a.out",
        "coreFile": "/cores/core.33448",
}

And it worked on VSCode

[clayborg]

You might look around for a core file in another test location and be able to use that. Functionality looks good to me. This could have been done with attachCommands before, but it is nice to have a built in and supported way to do this.

[labath]

In D78839#2004278, @clayborg wrote:

You might look around for a core file in another test location and be able to use that.

Yep, there's plenty to choose from in test/API/functionalities/postmortem/elf-core/.

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

533–535

I can't tell what does this return from this snippet. I don't think this is a good use of auto.

576

Judging by this, it probably returns a StringRef. Is it always guaranteed to be null-terminated?

lldb/tools/lldb-vscode/package.json

226

Is the second part really true? lldb is able to open a core file without specifying the main executable (and in some cases it will even automatically find the matching executable).

[wallace]

Added a test, which was easier than I thought!
I tested it on mac as well, so I hope it'll work well on the buildbots.

I also removed that bad use of auto. It seems that all StringRefs gotten from the JSON object are null-terminated.

[labath]

Looks good. It may be interesting to tack a couple of resume/step-over/etc commands at the end of the test to make just the whole thing doesn't go berserk when those operations fail.

In D78839#2006698, @wallace wrote:

I also removed that bad use of auto. It seems that all StringRefs gotten from the JSON object are null-terminated.

Ok, json::parse is documented to return "self-contained" json object which owns its strings. It's not a big stretch to assume that those owned strings will also be null terminated, though it still seems moderately dangerous...

[wallace]

added the test suggested by @labath

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

def continue_to_exit(self, exitCode=0):
                         "stopped_events = {}".format(stopped_events))
         self.assertEquals(stopped_events[0]['event'], 'exited',
                         'make sure program ran to completion')
         self.assertEquals(stopped_events[0]['body']['exitCode'], exitCode,
                         'exitCode == %i' % (exitCode))
 
     def attach(self, program=None, pid=None, waitFor=None, trace=None,
                initCommands=None, preRunCommands=None, stopCommands=None,
-               exitCommands=None, attachCommands=None):
+               exitCommands=None, attachCommands=None, coreFile=None):
         '''Build the default Makefile target, create the VSCode debug adaptor,
            and attach to the process.
         '''
         # Make sure we disconnect and terminate the VSCode debug adaptor even
         # if we throw an exception during the test case.
         def cleanup():
             self.vscode.request_disconnect(terminateDebuggee=True)
             self.vscode.terminate()
 
         # Execute the cleanup function during test case tear down.
         self.addTearDownHook(cleanup)
         # Initialize and launch the program
         self.vscode.request_initialize()
         response = self.vscode.request_attach(
             program=program, pid=pid, waitFor=waitFor, trace=trace,
             initCommands=initCommands, preRunCommands=preRunCommands,
             stopCommands=stopCommands, exitCommands=exitCommands,
-            attachCommands=attachCommands)
+            attachCommands=attachCommands, coreFile=coreFile)
         if not (response and response['success']):
             self.assertTrue(response['success'],
                             '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,

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

def replay_packets(self, replay_file_path):
                     pprint.PrettyPrinter(indent=2).pprint(actual_response)
                 else:
                     print("error: didn't get a valid response")
                 mode = 'invalid'
 
     def request_attach(self, program=None, pid=None, waitFor=None, trace=None,
                        initCommands=None, preRunCommands=None,
                        stopCommands=None, exitCommands=None,
-                       attachCommands=None):
+                       attachCommands=None, coreFile=None):
         args_dict = {}
         if pid is not None:
             args_dict['pid'] = pid
         if program is not None:
             args_dict['program'] = program
         if waitFor is not None:
             args_dict['waitFor'] = waitFor
         if trace:
             args_dict['trace'] = trace
         args_dict['initCommands'] = self.init_commands
         if initCommands:
             args_dict['initCommands'].extend(initCommands)
         if preRunCommands:
             args_dict['preRunCommands'] = preRunCommands
         if stopCommands:
             args_dict['stopCommands'] = stopCommands
         if exitCommands:
             args_dict['exitCommands'] = exitCommands
         if attachCommands:
             args_dict['attachCommands'] = attachCommands
+        if coreFile:
+            args_dict['coreFile'] = coreFile
         command_dict = {
             'command': 'attach',
             'type': 'request',
             'arguments': args_dict
         }
         return self.send_recv(command_dict)
 
     def request_configurationDone(self):

lldb/test/API/tools/lldb-vscode/coreFile/TestVSCode_coreFile.py

+"""
+Test lldb-vscode coreFile attaching
+"""
+
+
+import unittest2
+import vscode
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+
+
+class TestVSCode_coreFile(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipIfWindows
+    @skipIfRemote
+    @skipIfLLVMTargetMissing("X86")
+    def test_core_file(self):
+        current_dir = os.path.dirname(os.path.realpath(__file__))
+        exe_file = os.path.join(current_dir, "linux-x86_64.out")
+        core_file = os.path.join(current_dir, "linux-x86_64.core")
+
+        self.create_debug_adaptor()
+        self.attach(exe_file, coreFile=core_file)
+
+        expected_frames = [
+            {'column': 0, 'id': 524288, 'line': 4, 'name': 'bar', 'source': {'name': 'main.c', 'path': '/home/labath/test/main.c'}},
+            {'column': 0, 'id': 524289, 'line': 10, 'name': 'foo', 'source': {'name': 'main.c', 'path': '/home/labath/test/main.c'}},
+            {'column': 0, 'id': 524290, 'line': 16, 'name': '_start', 'source': {'name': 'main.c', 'path': '/home/labath/test/main.c'}},
+        ]
+
+        self.assertEquals(self.get_stackFrames(), expected_frames)
+
+        # Resuming should have no effect and keep the process stopped
+        self.continue_to_next_stop()
+        self.assertEquals(self.get_stackFrames(), expected_frames)
+
+        self.vscode.request_next(threadId=32259)
+        self.assertEquals(self.get_stackFrames(), expected_frames)

lldb/tools/lldb-vscode/README.md

 ```
 
 This will work as long as the architecture, vendor and OS supports waiting
 for processes. Currently MacOS is the only platform that supports this.
 
 
 ### Loading a Core File
 
-Loading a core file can use the `"attach"` request along with the
-`"attachCommands"` to implement a custom attach:
+This loads the coredump file `/cores/123.core` associated with the program
+`/tmp/a.out`:
 
 ```javascript
 {
-  "name": "Attach to Name (wait)",
+  "name": "Load coredump",
   "type": "lldb-vscode",
   "request": "attach",
-  "attachCommands": ["target create -c /path/to/123.core /path/to/executable"],
-  "stopOnEntry": false
+  "coreFile": "/cores/123.core",
+  "program": "/tmp/a.out"
 }
 ```

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

if (pid != LLDB_INVALID_PROCESS_ID)
     attach_info.SetProcessID(pid);
   const auto wait_for = GetBoolean(arguments, "waitFor", false);
   attach_info.SetWaitForLaunch(wait_for, false /*async*/);
   g_vsc.init_commands = GetStrings(arguments, "initCommands");
   g_vsc.pre_run_commands = GetStrings(arguments, "preRunCommands");
   g_vsc.stop_commands = GetStrings(arguments, "stopCommands");
   g_vsc.exit_commands = GetStrings(arguments, "exitCommands");
   auto attachCommands = GetStrings(arguments, "attachCommands");
-  g_vsc.stop_at_entry = GetBoolean(arguments, "stopOnEntry", false);
+  llvm::StringRef core_file = GetString(arguments, "coreFile");
+  g_vsc.stop_at_entry =
+      core_file.empty() ? GetBoolean(arguments, "stopOnEntry", false) : true;
   const llvm::StringRef debuggerRoot = GetString(arguments, "debuggerRoot");
 
   // This is a hack for loading DWARF in .o files on Mac where the .o files
   // in the debug map of the main executable have relative paths which require
   // the lldb-vscode binary to have its working directory set to that relative
   // root for the .o files in order to be able to load debug info.
   if (!debuggerRoot.empty())
     llvm::sys::fs::set_current_path(debuggerRoot);
if (pid == LLDB_INVALID_PROCESS_ID && wait_for) {
     g_vsc.SendOutput(OutputType::Console,
                      llvm::StringRef(attach_msg, attach_msg_len));
   }
   if (attachCommands.empty()) {
     // No "attachCommands", just attach normally.
     // Disable async events so the attach will be successful when we return from
     // the launch call and the launch will happen synchronously
     g_vsc.debugger.SetAsync(false);
+    if (core_file.empty())
       g_vsc.target.Attach(attach_info, error);
+    else
+      g_vsc.target.LoadCore(core_file.data(), error);
     // Reenable async events
     g_vsc.debugger.SetAsync(true);
   } else {
     // We have "attachCommands" that are a set of commands that are expected
     // to execute the commands after which a process should be created. If there
     // is no valid process after running these commands, we have failed.
     g_vsc.RunLLDBCommands("Running attachCommands:", attachCommands);
     // 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();
   }
 
   SetSourceMapFromArguments(*arguments);
 
-  if (error.Success()) {
+  if (error.Success() && core_file.empty()) {
     auto attached_pid = g_vsc.target.GetProcess().GetProcessID();
     if (attached_pid == LLDB_INVALID_PROCESS_ID) {
       if (attachCommands.empty())
         error.SetErrorString("failed to attach to a process");
       else
         error.SetErrorString("attachCommands failed to attach to a process");
     }
   }

lldb/tools/lldb-vscode/package.json

"debuggers": [
               },
               "stopCommands": {
                 "type": "array",
                 "description": "Commands executed each time the program stops.",
                 "default": []
               },
               "exitCommands": {
                 "type": "array",
-                  "description": "Commands executed at the end of debugging session.",
-                  "default": []
+              },
+              "coreFile": {
+                "type": "string",
+                "description": "Path to the core file to debug."
               }
             }
           }
         },
         "initialConfigurations": [
           {
             "type": "lldb-vscode",
             "request": "launch",