Support logpoints in lldb-vscode

[yinghuitan]

Summary

This patch implements VSCode DAP logpoints feature (also called tracepoint
in VS debugger).
This will provide a convenient way for user to do printf style logging
debugging without pausing debuggee.

[clayborg]

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_logpoints.py

61

Any reason we have an empty dictionary at the end here?

121

Any reason we have an empty dictionary at the end here?

lldb/tools/lldb-vscode/BreakpointBase.cpp

46

Might be easier to use a std::map<int, int> here instead of a vector of pairs?

91

If the is a '{' at the start of the string, this code seems like it pushes an empty string. this must be needed because we have two vectors (rawTextMessages and evalExpressions)?

124

If we use a single vector of LogMessagePart objects, this code becomes simpler:

for (const LogMessagePart &part: bp->logMessageParts) {
  if (part.is_expr) {
    lldb::SBValue value = frame.EvaluateExpression(part.text.str().c_str());
    const char *expr_result = value.GetValue();
    if (expr_result)
      output += expr_result;
   } else {
     output += part.text.str();
   }
}

128

This will crash if "value.GetValue()" returns NULL.

lldb/tools/lldb-vscode/BreakpointBase.h

35–36

How do we know what order to emit things with here between "rawTextMessages" and "evalExpressions" in the breakpoint hit callback?

35–36

Seems like it would be easier to understand the code if we used:

struct LogMessagePart {
  llvm::StringRef text;
  bool is_expr;
};
std::vector<LogMessagePart> logMessageParts;

Right now you have two arrays and it isn't clear that each of these arrays must be the same size, or which one would be emitted first.

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

2084–2088

Why was this changed? I seemed clearer before this change and I can't see anything that is different here?

2312–2314

Why was this changed? Revert?

[clayborg]

lldb/tools/lldb-vscode/BreakpointBase.cpp

126

I would definitely try an local variable paths first via:

lldb::SBValue value = frame.GetValueForVariablePath(part.text.str().c_str(), lldb::eDynamicDontRunTarget);

before doing the evaluate expression due to performance which will be important in this case.

[yinghuitan]

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_logpoints.py

61

We are setting two source line breakpoints here, the first one has logMessage while the second one does not have any condition. I am explicitly using {} for second breakpoint to be clear.

121

{} means no logMessage for second breakpoint (after_loop_line).

lldb/tools/lldb-vscode/BreakpointBase.cpp

46

I do not think so. We never need fast key lookup from the data structure. All the operations are checking/popping/pushing the back of the vector. It is more like a stack.

91

Correct. We assume there is always a prefix raw text before any expressions, so rawTextMessages is always one element larger than expressions, I will enhance the documentation (see my format comment above):

assert(rawTextMessages.size() == evalExpressions.size() + 1);

124

Can you elaborate how is the suggested code simpler than what we have here? The only difference seems to be that the suggested code added a if...else branch while the code here does not branch? Seems not much difference.

128

Good catch, will handle null.

lldb/tools/lldb-vscode/BreakpointBase.h

35–36

Sorry, I think I forgot to document this. The format of the logMessage is parsed as:

prefixRawText/expression1/rawText1/expression2/rawText2..../expressionN/rawTextN

Basically rawTextMessages wraps expressions. This is enforced by invariant assert(rawTextMessages.size() == evalExpressions.size() + 1); in the cpp file.
Let me add this as documentation.

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

2084–2088

This change is required because BreakpointBase::SetBreakpoint() will trigger BreakpointBase::SetLogMessage() which stores this pointer for BreakpointBase::BreakpointHitCallback callback access now. This means SetBreakpoint() can't be called on Breakpoint object on stack (src_bp is on stack). The new code solves the issue by storing stack object src_bp into g_vsc.source_breakpoints (on heap) then call SetBreakpoint() on the heap object.

2312–2314

The same see my comment above.

[clayborg]

I would like to get to one array solution of LogMessagePart entries and avoid having two arrays of strings that need to stay in sync (rawTextMessages and evalExpressions). Simpler to understand and no need to document the interdependence of rawTextMessages and evalExpressions.

lldb/tools/lldb-vscode/BreakpointBase.cpp

91

I would like to avoid having two arrays that need to stay in sync here if possible. See comment on using just a single array of "LogMessagePart" entries. Simpler code without the need to document that rawTextMessages and evalExpressions need to be in some specific order.

124

There is only one array and there is no need to document that the usage of two arrays and their codependence, such as you are doing with invariants above:

assert(bp->rawTextMessages.size() == bp->evalExpressions.size() + 1);

[yinghuitan]

Using a single structured LogMessagePart per suggestion.

[thakis]

Looks like this might not build: http://45.33.8.238/linux/79194/step_4.txt

Please take a look and revert for now if it takes a while to fix.

[thakis]

Here too: https://lab.llvm.org/buildbot#builders/83/builds/20210

[yinghuitan]

Sorry, I was fooled by the buildbot which says everything is green. Working on a fix for the build break now.

[yinghuitan]

Fixed in https://reviews.llvm.org/D128234

[cmtice]

Just FYI, this commit appears to cause lldb//test/API/commands/target/auto-install-main-executable/TestAutoInstallMainExecutable.py to fail. The error I'm seeing is:

Traceback (most recent call last):

File "../lldb/test/API/commands/target/auto-install-main-executable/TestAutoInstallMainExecutable.py", line 72, in test_target_auto_install_main_executable
  self.expect("process launch", substrs=["exited with status = 74"])
File ".../lldb/packages/Python/lldbsuite/test/lldbtest.py", line 2295, in expect
  self.runCmd(
File ".../lldb/packages/Python/lldbsuite/test/lldbtest.py", line 1998, in runCmd
  self.assertTrue(self.res.Succeeded(),

AssertionError: False is not True : Command 'process launch
Error output:
error: failed to get reply to handshake packet within timeout of 0.0 seconds
' did not return successfully

[yinghuitan]

@cmtice, are you sure the failure is caused by/related with this patch? This is a pure lldb-vscode change which is not used by normal lldb. Also, no mention of code in this patch in the error message.

[cmtice]

I apologize; I was looking at several commits, and I accidentally added my comment to the wrong one. No, this commit is not the one that caused my problem (I am very sorry about the confusion).

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

def create_debug_adaptor(self, lldbVSCodeEnv=None):
         self.vscode = vscode.DebugAdaptor(
             executable=self.lldbVSCodeExec, init_commands=self.setUpCommands(),
             log_file=log_file_path, env=lldbVSCodeEnv)
 
     def build_and_create_debug_adaptor(self, lldbVSCodeEnv=None):
         self.build()
         self.create_debug_adaptor(lldbVSCodeEnv)
 
-    def set_source_breakpoints(self, source_path, lines, condition=None,
-                               hitCondition=None):
+    def set_source_breakpoints(self, source_path, lines, data=None):
         '''Sets source breakpoints and returns an array of strings containing
            the breakpoint IDs ("1", "2") for each breakpoint that was set.
+           Parameter data is array of data objects for breakpoints.
+           Each object in data is 1:1 mapping with the entry in lines.
+           It contains optional location/hitCondition/logMessage parameters.
         '''
         response = self.vscode.request_setBreakpoints(
-            source_path, lines, condition=condition, hitCondition=hitCondition)
+            source_path, lines, data)
         if response is None:
             return []
         breakpoints = response['body']['breakpoints']
         breakpoint_ids = []
         for breakpoint in breakpoints:
             breakpoint_ids.append('%i' % (breakpoint['id']))
         return breakpoint_ids
 

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

def request_scopes(self, frameId):
         args_dict = {'frameId': frameId}
         command_dict = {
             'command': 'scopes',
             'type': 'request',
             'arguments': args_dict
         }
         return self.send_recv(command_dict)
 
-    def request_setBreakpoints(self, file_path, line_array, condition=None,
-                               hitCondition=None):
+    def request_setBreakpoints(self, file_path, line_array, data=None):
+        ''' data is array of parameters for breakpoints in line_array.
+            Each parameter object is 1:1 mapping with entries in line_entry.
+            It contains optional location/hitCondition/logMessage parameters.
+        '''
         (dir, base) = os.path.split(file_path)
         source_dict = {
             'name': base,
             'path': file_path
         }
         args_dict = {
             'source': source_dict,
             'sourceModified': False,
         }
         if line_array is not None:
             args_dict['lines'] = '%s' % line_array
             breakpoints = []
-            for line in line_array:
+            for i, line in enumerate(line_array):
+                breakpoint_data = None
+                if data is not None and i < len(data):
+                    breakpoint_data = data[i]
                 bp = {'line': line}
-                if condition is not None:
-                    bp['condition'] = condition
-                if hitCondition is not None:
-                    bp['hitCondition'] = hitCondition
+                if breakpoint_data is not None:
+                    if 'condition' in breakpoint_data and breakpoint_data['condition']:
+                        bp['condition'] = breakpoint_data['condition']
+                    if 'hitCondition' in breakpoint_data and breakpoint_data['hitCondition']:
+                        bp['hitCondition'] = breakpoint_data['hitCondition']
+                    if 'logMessage' in breakpoint_data and breakpoint_data['logMessage']:
+                        bp['logMessage'] = breakpoint_data['logMessage']
                 breakpoints.append(bp)
             args_dict['breakpoints'] = breakpoints
 
         command_dict = {
             'command': 'setBreakpoints',
             'type': 'request',
             'arguments': args_dict
         }

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_logpoints.py

+"""
+Test lldb-vscode logpoints feature.
+"""
+
+
+import unittest2
+import vscode
+import shutil
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+import lldbvscode_testcase
+import os
+
+
+class TestVSCode_logpoints(lldbvscode_testcase.VSCodeTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        lldbvscode_testcase.VSCodeTestCaseBase.setUp(self)
+
+        self.main_basename = 'main-copy.cpp'
+        self.main_path = os.path.realpath(self.getBuildArtifact(self.main_basename))
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_logmessage_basic(self):
+        '''Tests breakpoint logmessage basic functionality.'''
+        before_loop_line = line_number('main.cpp', '// before loop')
+        loop_line = line_number('main.cpp', '// break loop')
+        after_loop_line = line_number('main.cpp', '// after loop')
+
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+
+        # Set a breakpoint at a line before loop
+        before_loop_breakpoint_ids = self.set_source_breakpoints(
+            self.main_path,
+            [before_loop_line])
+        self.assertEquals(len(before_loop_breakpoint_ids), 1, "expect one breakpoint")
+
+        self.vscode.request_continue()
+
+        # Verify we hit the breakpoint before loop line
+        self.verify_breakpoint_hit(before_loop_breakpoint_ids)
+
+        # Swallow old console output
+        self.get_console()
+
+        # Set two breakpoints:
+        # 1. First at the loop line with logMessage
+        # 2. Second guard breakpoint at a line after loop
+        logMessage_prefix = "This is log message for { -- "
+        # Trailing newline is needed for splitlines()
+        logMessage = logMessage_prefix + "{i + 3}\n"
+        [loop_breakpoint_id, post_loop_breakpoint_id] = self.set_source_breakpoints(
+            self.main_path,
+            [loop_line, after_loop_line],
+            [{'logMessage': logMessage}, {}]
+        )
+
+        # Continue to trigger the breakpoint with log messages
+        self.vscode.request_continue()
+
+        # Verify we hit the breakpoint after loop line
+        self.verify_breakpoint_hit([post_loop_breakpoint_id])
+
+        output = self.get_console()
+        lines = output.splitlines()
+        logMessage_output = []
+        for line in lines:
+            if line.startswith(logMessage_prefix):
+                logMessage_output.append(line)
+
+        # Verify logMessage count
+        loop_count = 10
+        self.assertEqual(len(logMessage_output), loop_count)
+
+        # Verify log message match
+        for idx, logMessage_line in enumerate(logMessage_output):
+            result = idx + 3
+            self.assertEqual(logMessage_line, logMessage_prefix + str(result))
+
+
+    @skipIfWindows
+    @skipIfRemote
+    def test_logmessage_advanced(self):
+        '''Tests breakpoint logmessage functionality for complex expression.'''
+        before_loop_line = line_number('main.cpp', '// before loop')
+        loop_line = line_number('main.cpp', '// break loop')
+        after_loop_line = line_number('main.cpp', '// after loop')
+
+        program = self.getBuildArtifact("a.out")
+        self.build_and_launch(program)
+
+        # Set a breakpoint at a line before loop
+        before_loop_breakpoint_ids = self.set_source_breakpoints(
+            self.main_path,
+            [before_loop_line])
+        self.assertEquals(len(before_loop_breakpoint_ids), 1, "expect one breakpoint")
+
+        self.vscode.request_continue()
+
+        # Verify we hit the breakpoint before loop line
+        self.verify_breakpoint_hit(before_loop_breakpoint_ids)
+
+        # Swallow old console output
+        self.get_console()
+
+        # Set two breakpoints:
+        # 1. First at the loop line with logMessage
+        # 2. Second guard breakpoint at a line after loop
+        logMessage_prefix = "This is log message for { -- "
+        # Trailing newline is needed for splitlines()
+        logMessage = logMessage_prefix + "{int y = 0; if (i % 3 == 0) { y = i + 3;} else {y = i * 3;} y}\n"
+        [loop_breakpoint_id, post_loop_breakpoint_id] = self.set_source_breakpoints(
+            self.main_path,
+            [loop_line, after_loop_line],
+            [{'logMessage': logMessage}, {}]
+        )
+
+        # Continue to trigger the breakpoint with log messages
+        self.vscode.request_continue()
+
+        # Verify we hit the breakpoint after loop line
+        self.verify_breakpoint_hit([post_loop_breakpoint_id])
+
+        output = self.get_console()
+        lines = output.splitlines()
+        logMessage_output = []
+        for line in lines:
+            if line.startswith(logMessage_prefix):
+                logMessage_output.append(line)
+
+        # Verify logMessage count
+        loop_count = 10
+        self.assertEqual(len(logMessage_output), loop_count)
+
+        # Verify log message match
+        for idx, logMessage_line in enumerate(logMessage_output):
+            result = idx + 3 if idx % 3 == 0 else idx * 3
+            self.assertEqual(logMessage_line, logMessage_prefix + str(result))

lldb/test/API/tools/lldb-vscode/breakpoint/TestVSCode_setBreakpoints.py

def test_functionality(self):
 
         # Make sure i is zero at first breakpoint
         i = int(self.vscode.get_local_variable_value('i'))
         self.assertEquals(i, 0, 'i != 0 after hitting breakpoint')
 
         # Update the condition on our breakpoint
         new_breakpoint_ids = self.set_source_breakpoints(self.main_path,
                                                          [loop_line],
-                                                         condition="i==4")
+                                                         [{'condition': "i==4"}])
         self.assertEquals(breakpoint_ids, new_breakpoint_ids,
                         "existing breakpoint should have its condition "
                         "updated")
 
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))
         self.assertEquals(i, 4,
                         'i != 4 showing conditional works')
 
         new_breakpoint_ids = self.set_source_breakpoints(self.main_path,
                                                          [loop_line],
-                                                         hitCondition="2")
+                                                         [{'hitCondition':"2"}])
 
         self.assertEquals(breakpoint_ids, new_breakpoint_ids,
                         "existing breakpoint should have its condition "
                         "updated")
 
         # Continue with a hitCondition of 2 and expect it to skip 1 value
         self.continue_to_breakpoints(breakpoint_ids)
         i = int(self.vscode.get_local_variable_value('i'))

lldb/test/API/tools/lldb-vscode/breakpoint/main.cpp

if (handle == nullptr) {
     exit(1);
   }
 
   int (*foo)(int) = (int (*)(int))dlsym(handle, "foo");
   if (foo == nullptr) {
     fprintf(stderr, "%s\n", dlerror());
     exit(2);
   }
-  foo(12);
+  foo(12); // before loop
 
   for (int i=0; i<10; ++i) {
     int x = twelve(i) + thirteen(i) + a::fourteen(i); // break loop
   }
   try {
     throw std::invalid_argument( "throwing exception for testing" );
   } catch (...) {
     puts("caught exception...");
   }
-  return 0;
+  return 0; // after loop
 }

lldb/tools/lldb-vscode/BreakpointBase.h

 //===-- BreakpointBase.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_BREAKPOINTBASE_H
 #define LLDB_TOOLS_LLDB_VSCODE_BREAKPOINTBASE_H
 
 #include "JSONUtils.h"
 #include "lldb/API/SBBreakpoint.h"
 #include "llvm/Support/JSON.h"
 #include <string>
+#include <vector>
 
 namespace lldb_vscode {
 
 struct BreakpointBase {
-
+  // logMessage part can be either a raw text or an expression.
+  struct LogMessagePart {
+    llvm::StringRef text;
+    bool is_expr;
+  };
   // An optional expression for conditional breakpoints.
   std::string condition;
   // An optional expression that controls how many hits of the breakpoint are
   // ignored. The backend is expected to interpret the expression as needed
   std::string hitCondition;
   // If this attribute exists and is non-empty, the backend must not 'break'
   // (stop) but log the message instead. Expressions within {} are
   // interpolated.
   std::string logMessage;
+  std::vector<LogMessagePart> logMessageParts;
   // The LLDB breakpoint associated wit this source breakpoint
   lldb::SBBreakpoint bp;
 
   BreakpointBase() = default;
   BreakpointBase(const llvm::json::Object &obj);
 
   void SetCondition();
   void SetHitCondition();
+  void SetLogMessage();
   void UpdateBreakpoint(const BreakpointBase &request_bp);
   static const char *GetBreakpointLabel();
+  static bool BreakpointHitCallback(void *baton, lldb::SBProcess &process,
+                                    lldb::SBThread &thread,
+                                    lldb::SBBreakpointLocation &location);
 };
 
 } // namespace lldb_vscode
 
 #endif

lldb/tools/lldb-vscode/BreakpointBase.cpp

 //===-- BreakpointBase.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "BreakpointBase.h"
+#include "VSCode.h"
 #include "llvm/ADT/StringExtras.h"
 
 using namespace lldb_vscode;
 
 BreakpointBase::BreakpointBase(const llvm::json::Object &obj)
     : condition(std::string(GetString(obj, "condition"))),
       hitCondition(std::string(GetString(obj, "hitCondition"))),
       logMessage(std::string(GetString(obj, "logMessage"))) {}
 
 void BreakpointBase::SetCondition() { bp.SetCondition(condition.c_str()); }
 
 void BreakpointBase::SetHitCondition() {
   uint64_t hitCount = 0;
   if (llvm::to_integer(hitCondition, hitCount))
     bp.SetIgnoreCount(hitCount - 1);
 }
 
+// logMessage will be divided into array of LogMessagePart as two kinds:
+// 1. raw print text message, and
+// 2. interpolated expression for evaluation which is inside matching curly
+//    braces.
+//
+// The function tries to parse logMessage into a list of LogMessageParts
+// for easy later access in BreakpointHitCallback.
+void BreakpointBase::SetLogMessage() {
+  logMessageParts.clear();
+
+  // Contains unmatched open curly braces indices.
+  std::vector<int> unmatched_curly_braces;
+
+  // Contains all matched curly braces in logMessage.
+  // Loop invariant: matched_curly_braces_ranges are sorted by start index in
+  // ascending order without any overlap between them.
+  std::vector<std::pair<int, int>> matched_curly_braces_ranges;
+
+  // Part1 - parse matched_curly_braces_ranges.
+  // locating all curly braced expression ranges in logMessage.
+  // The algorithm takes care of nested and imbalanced curly braces.
+  for (size_t i = 0; i < logMessage.size(); ++i) {
+    if (logMessage[i] == '{') {
+      unmatched_curly_braces.push_back(i);
+    } else if (logMessage[i] == '}') {
+      if (unmatched_curly_braces.empty())
+        // Nothing to match.
+        continue;
+
+      int last_unmatched_index = unmatched_curly_braces.back();
+      unmatched_curly_braces.pop_back();
+
+      // Erase any matched ranges included in the new match.
+      while (!matched_curly_braces_ranges.empty()) {
+        assert(matched_curly_braces_ranges.back().first !=
+                   last_unmatched_index &&
+               "How can a curley brace be matched twice?");
+        if (matched_curly_braces_ranges.back().first < last_unmatched_index)
+          break;
+
+        // This is a nested range let's earse it.
+        assert((size_t)matched_curly_braces_ranges.back().second < i);
+        matched_curly_braces_ranges.pop_back();
+      }
+
+      // Assert invariant.
+      assert(matched_curly_braces_ranges.empty() ||
+             matched_curly_braces_ranges.back().first < last_unmatched_index);
+      matched_curly_braces_ranges.emplace_back(last_unmatched_index, i);
+    }
+  }
+
+  // Part2 - parse raw text and expresions parts.
+  // All expression ranges have been parsed in matched_curly_braces_ranges.
+  // The code below uses matched_curly_braces_ranges to divide logMessage
+  // into raw text parts and expression parts.
+  int last_raw_text_start = 0;
+  for (const std::pair<int, int> &curly_braces_range :
+       matched_curly_braces_ranges) {
+    // Raw text before open curly brace.
+    assert(curly_braces_range.first >= last_raw_text_start);
+    size_t raw_text_len = curly_braces_range.first - last_raw_text_start;
+    if (raw_text_len > 0)
+      logMessageParts.emplace_back(
+          llvm::StringRef(logMessage.c_str() + last_raw_text_start,
+                          raw_text_len),
+          /*is_expr=*/false);
+
+    // Expression between curly braces.
+    assert(curly_braces_range.second > curly_braces_range.first);
+    size_t expr_len = curly_braces_range.second - curly_braces_range.first - 1;
+    logMessageParts.emplace_back(
+        llvm::StringRef(logMessage.c_str() + curly_braces_range.first + 1,
+                        expr_len),
+        /*is_expr=*/true);
+    last_raw_text_start = curly_braces_range.second + 1;
+  }
+  // Trailing raw text after close curly brace.
+  if (logMessage.size() > last_raw_text_start)
+    logMessageParts.emplace_back(
+        llvm::StringRef(logMessage.c_str() + last_raw_text_start,
+                        logMessage.size() - last_raw_text_start),
+        /*is_expr=*/false);
+  bp.SetCallback(BreakpointBase::BreakpointHitCallback, this);
+}
+
+/*static*/
+bool BreakpointBase::BreakpointHitCallback(
+    void *baton, lldb::SBProcess &process, lldb::SBThread &thread,
+    lldb::SBBreakpointLocation &location) {
+  if (!baton)
+    return true;
+
+  BreakpointBase *bp = (BreakpointBase *)baton;
+  lldb::SBFrame frame = thread.GetSelectedFrame();
+
+  std::string output;
+  for (const BreakpointBase::LogMessagePart &messagePart :
+       bp->logMessageParts) {
+    if (messagePart.is_expr) {
+      // Try local frame variables first before fall back to expression
+      // evaluation
+      const char *expr = messagePart.text.str().c_str();
+      lldb::SBValue value =
+          frame.GetValueForVariablePath(expr, lldb::eDynamicDontRunTarget);
+      if (value.GetError().Fail())
+        value = frame.EvaluateExpression(expr);
+      const char *expr_val = value.GetValue();
+      if (expr_val)
+        output += expr_val;
+    } else {
+      output += messagePart.text.str();
+    }
+  }
+  g_vsc.SendOutput(OutputType::Console, output.c_str());
+
+  // Do not stop.
+  return false;
+}
+
 void BreakpointBase::UpdateBreakpoint(const BreakpointBase &request_bp) {
   if (condition != request_bp.condition) {
     condition = request_bp.condition;
     SetCondition();
   }
   if (hitCondition != request_bp.hitCondition) {
     hitCondition = request_bp.hitCondition;
     SetHitCondition();
   }
+  if (logMessage != request_bp.logMessage) {
+    logMessage = request_bp.logMessage;
+    SetLogMessage();
+  }
 }
 
 const char *BreakpointBase::GetBreakpointLabel() {
   // Breakpoints in LLDB can have names added to them which are kind of like
   // labels or categories. All breakpoints that are set through the IDE UI get
   // sent through the various VS code DAP set*Breakpoint packets, and these
   // breakpoints will be labeled with this name so if breakpoint update events
   // come in for breakpoints that the IDE doesn't know about, like if a

lldb/tools/lldb-vscode/FunctionBreakpoint.cpp

void FunctionBreakpoint::SetBreakpoint() {
   bp = g_vsc.target.BreakpointCreateByName(functionName.c_str());
   // See comments in BreakpointBase::GetBreakpointLabel() for details of why
   // we add a label to our breakpoints.
   bp.AddName(GetBreakpointLabel());
   if (!condition.empty())
     SetCondition();
   if (!hitCondition.empty())
     SetHitCondition();
+  if (!logMessage.empty())
+    SetLogMessage();
 }
 
 } // namespace lldb_vscode

lldb/tools/lldb-vscode/SourceBreakpoint.cpp

void SourceBreakpoint::SetBreakpoint(const llvm::StringRef source_path) {
   bp = g_vsc.target.BreakpointCreateByLocation(source_path.str().c_str(), line);
   // See comments in BreakpointBase::GetBreakpointLabel() for details of why
   // we add a label to our breakpoints.
   bp.AddName(GetBreakpointLabel());
   if (!condition.empty())
     SetCondition();
   if (!hitCondition.empty())
     SetHitCondition();
+  if (!logMessage.empty())
+    SetLogMessage();
 }
 
 } // namespace lldb_vscode

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

void request_initialize(const llvm::json::Object &request) {
   // The debug adapter supports the delayed loading of parts of the stack,
   // which requires that both the 'startFrame' and 'levels' arguments and the
   // 'totalFrames' result of the 'StackTrace' request are supported.
   body.try_emplace("supportsDelayedStackTraceLoading", true);
   // The debug adapter supports the 'loadedSources' request.
   body.try_emplace("supportsLoadedSourcesRequest", false);
   // The debug adapter supports sending progress reporting events.
   body.try_emplace("supportsProgressReporting", true);
+  // The debug adapter supports 'logMessage' in breakpoint.
+  body.try_emplace("supportsLogPoints", true);
 
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }
 
 llvm::Error request_runInTerminal(const llvm::json::Object &launch_request) {
   g_vsc.is_attach = true;
   lldb::SBAttachInfo attach_info;
for (const auto &bp : *breakpoints) {
           if (existing_bp != existing_source_bps->second.end()) {
             existing_bp->second.UpdateBreakpoint(src_bp);
             AppendBreakpoint(existing_bp->second.bp, response_breakpoints, path,
                              src_bp.line);
             continue;
           }
         }
         // At this point the breakpoint is new
-        src_bp.SetBreakpoint(path.data());
-        AppendBreakpoint(src_bp.bp, response_breakpoints, path, src_bp.line);
-        g_vsc.source_breakpoints[path][src_bp.line] = std::move(src_bp);
+        g_vsc.source_breakpoints[path][src_bp.line] = src_bp;
+        SourceBreakpoint &new_bp = g_vsc.source_breakpoints[path][src_bp.line];
+        new_bp.SetBreakpoint(path.data());
+        AppendBreakpoint(new_bp.bp, response_breakpoints, path, new_bp.line);
       }
     }
   }
 
   // Delete any breakpoints in this source file that aren't in the
   // request_bps set. There is no call to remove breakpoints other than
   // calling this function with a smaller or empty "breakpoints" list.
   auto old_src_bp_pos = g_vsc.source_breakpoints.find(path);
   if (old_src_bp_pos != g_vsc.source_breakpoints.end()) {
void request_setFunctionBreakpoints(const llvm::json::Object &request) {
   }
   // Remove any breakpoints that are no longer in our list
   for (const auto &name : remove_names)
     g_vsc.function_breakpoints.erase(name);
 
   // Any breakpoints that are left in "request_bps" are breakpoints that
   // need to be set.
   for (auto &pair : request_bps) {
-    pair.second.SetBreakpoint();
     // Add this breakpoint info to the response
-    AppendBreakpoint(pair.second.bp, response_breakpoints);
     g_vsc.function_breakpoints[pair.first()] = std::move(pair.second);
+    FunctionBreakpoint &new_bp = g_vsc.function_breakpoints[pair.first()];
+    new_bp.SetBreakpoint();
+    AppendBreakpoint(new_bp.bp, response_breakpoints);
   }
 
   llvm::json::Object body;
   body.try_emplace("breakpoints", std::move(response_breakpoints));
   response.try_emplace("body", std::move(body));
   g_vsc.SendJSON(llvm::json::Value(std::move(response)));
 }