[lldb-vscode] Fix coredump load source mapping for first file

[ted]

Summary

SetSourceMapFromArguments is called after the core is loaded. This means
that the source file for the crashing code won't have the source map applied.
Move the call to SetSourceMapFromArguments in request_attach to just after
the call to RunInitCommands, matching request_launch behavior.

[clayborg]

This is how launch does it as well, so LGTM.

[wallace]

thanks!

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

def continue_to_exit(self, exitCode=0):
                         '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, coreFile=None,
                disconnectAutomatically=True, terminateCommands=None,
-               postRunCommands=None):
+               postRunCommands=None, sourceMap=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():
             if disconnectAutomatically:
                 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, terminateCommands=terminateCommands,
-            coreFile=coreFile, postRunCommands=postRunCommands)
+            coreFile=coreFile, postRunCommands=postRunCommands,
+            sourceMap=sourceMap)
         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):
                 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, terminateCommands=None,
-                       coreFile=None, postRunCommands=None):
+                       coreFile=None, postRunCommands=None,
+                       sourceMap=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:
def request_attach(self, program=None, pid=None, waitFor=None, trace=None,
         if terminateCommands:
             args_dict['terminateCommands'] = terminateCommands
         if attachCommands:
             args_dict['attachCommands'] = attachCommands
         if coreFile:
             args_dict['coreFile'] = coreFile
         if postRunCommands:
             args_dict['postRunCommands'] = postRunCommands
+        if sourceMap:
+            args_dict['sourceMap'] = sourceMap
         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

def test_core_file(self):
         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)
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_core_file_source_mapping(self):
+        ''' Test that sourceMap property is correctly applied when loading a core '''
+        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()
+
+        source_map = [["/home/labath/test", current_dir]]
+        self.attach(exe_file, coreFile=core_file, sourceMap=source_map)
+
+        self.assertTrue(current_dir in self.get_stackFrames()[0]['source']['path'])

lldb/test/API/tools/lldb-vscode/coreFile/main.c

+/* Fake source file for core dump source mapping test */

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

void request_attach(const llvm::json::Object &request) {
   // 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);
 
   // Run any initialize LLDB commands the user specified in the launch.json
   g_vsc.RunInitCommands();
 
+  SetSourceMapFromArguments(*arguments);
+
   lldb::SBError status;
   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 (attachCommands.empty()) {
     // 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() && 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");
     }