[lldb/API] Expose Target::CreateBreakpoint(..., move_to_nearest_code) overload

[mib]

Summary

This patch exposes the Target::CreateBreakpoint overload with the
boolean argument to move to the neareast code to the SBAPI.

This is useful when creating column breakpoints to restrict lldb's
resolution to the pointed source location, preventing it to go to the next
line.

rdar://72196842

Signed-off-by: Med Ismail Bennani <[e-mail]>

[JDevlieghere]

lldb/include/lldb/API/SBTarget.h

566

It's unfortunate that we have so many overloads, if we had to do it again I would've argued for something like SBBreakpointLocationOptions or something, but I'm not sure if that adds a lot, and dealing with defaults (such as the move_to_nearest_code) is hard because we have no SB counterpart for it. So I guess this is fine.

lldb/source/API/SBTarget.cpp

827–839

There's a lot of code duplication with the method just before it. Can we extract the common code into a private method that both call into? The reproducer instrumentation would remain in the public method.

[mib]

Address @JDevlieghere comments.

[JDevlieghere]

LGTM

lldb/bindings/interface/SBTarget.i

BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line,
                                 lldb::addr_t offset, SBFileSpecList &module_list);
 
     lldb::SBBreakpoint
     BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line,
                                 uint32_t column, lldb::addr_t offset,
                                 SBFileSpecList &module_list);
 
     lldb::SBBreakpoint
+    BreakpointCreateByLocation (const lldb::SBFileSpec &file_spec, uint32_t line,
+                                uint32_t column, lldb::addr_t offset,
+                                SBFileSpecList &module_list,
+                                bool move_to_nearest_code);
+
+    lldb::SBBreakpoint
     BreakpointCreateByName (const char *symbol_name, const char *module_name = NULL);
 
     lldb::SBBreakpoint
     BreakpointCreateByName (const char *symbol_name,
                             uint32_t func_name_type,           // Logical OR one or more FunctionNameType enum bits
                             const SBFileSpecList &module_list,
                             const SBFileSpecList &comp_unit_list);
 

lldb/include/lldb/API/SBTarget.h

 //===-- SBTarget.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_API_SBTARGET_H
 #define LLDB_API_SBTARGET_H
 
+#include "lldb/lldb-private-enumerations.h"
+
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBAttachInfo.h"
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBBroadcaster.h"
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBFileSpec.h"
 #include "lldb/API/SBFileSpecList.h"
 #include "lldb/API/SBLaunchInfo.h"
public:
   BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
                              lldb::addr_t offset, SBFileSpecList &module_list);
 
   lldb::SBBreakpoint
   BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
                              uint32_t column, lldb::addr_t offset,
                              SBFileSpecList &module_list);
 
+  lldb::SBBreakpoint
+  BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
+                             uint32_t column, lldb::addr_t offset,
+                             SBFileSpecList &module_list,
+                             bool move_to_nearest_code);
+
   lldb::SBBreakpoint BreakpointCreateByName(const char *symbol_name,
                                             const char *module_name = nullptr);
 
   // This version uses name_type_mask = eFunctionNameTypeAuto
   lldb::SBBreakpoint
   BreakpointCreateByName(const char *symbol_name,
                          const SBFileSpecList &module_list,
                          const SBFileSpecList &comp_unit_list);
protected:
   // Constructors are private, use static Target::Create function to create an
   // instance of this class.
 
   lldb::TargetSP GetSP() const;
 
   void SetSP(const lldb::TargetSP &target_sp);
 
 private:
+  lldb::SBBreakpoint BreakpointCreateByLocationImpl(
+      const lldb::SBFileSpec &file_spec, uint32_t line, uint32_t column,
+      lldb::addr_t offset, SBFileSpecList &module_list,
+      const lldb_private::LazyBool move_to_nearest_code);
+
   lldb::TargetSP m_opaque_sp;
 };
 
 } // namespace lldb
 
 #endif // LLDB_API_SBTARGET_H

lldb/source/API/SBTarget.cpp

LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
                      (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
                       lldb::SBFileSpecList &),
                      sb_file_spec, line, offset, sb_module_list);
 
   return LLDB_RECORD_RESULT(BreakpointCreateByLocation(sb_file_spec, line, 0,
                                                        offset, sb_module_list));
 }
 
-SBBreakpoint SBTarget::BreakpointCreateByLocation(
-    const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
-    lldb::addr_t offset, SBFileSpecList &sb_module_list) {
-  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
-                     (const lldb::SBFileSpec &, uint32_t, uint32_t,
-                      lldb::addr_t, lldb::SBFileSpecList &),
-                     sb_file_spec, line, column, offset, sb_module_list);
-
+SBBreakpoint SBTarget::BreakpointCreateByLocationImpl(
+    const lldb::SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
+    lldb::addr_t offset, SBFileSpecList &sb_module_list,
+    const LazyBool move_to_nearest_code) {
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp && line != 0) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
     const LazyBool check_inlines = eLazyBoolCalculate;
     const LazyBool skip_prologue = eLazyBoolCalculate;
     const bool internal = false;
     const bool hardware = false;
-    const LazyBool move_to_nearest_code = eLazyBoolCalculate;
     const FileSpecList *module_list = nullptr;
     if (sb_module_list.GetSize() > 0) {
       module_list = sb_module_list.get();
     }
     sb_bp = target_sp->CreateBreakpoint(
         module_list, *sb_file_spec, line, column, offset, check_inlines,
         skip_prologue, internal, hardware, move_to_nearest_code);
   }
 
-  return LLDB_RECORD_RESULT(sb_bp);
+  return sb_bp;
+}
+
+SBBreakpoint SBTarget::BreakpointCreateByLocation(
+    const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
+    lldb::addr_t offset, SBFileSpecList &sb_module_list) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+                     (const lldb::SBFileSpec &, uint32_t, uint32_t,
+                      lldb::addr_t, lldb::SBFileSpecList &),
+                     sb_file_spec, line, column, offset, sb_module_list);
+
+  return LLDB_RECORD_RESULT(BreakpointCreateByLocationImpl(
+      sb_file_spec, line, column, offset, sb_module_list, eLazyBoolCalculate));
+}
+
+SBBreakpoint SBTarget::BreakpointCreateByLocation(
+    const SBFileSpec &sb_file_spec, uint32_t line, uint32_t column,
+    lldb::addr_t offset, SBFileSpecList &sb_module_list,
+    bool move_to_nearest_code) {
+  LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+                     (const lldb::SBFileSpec &, uint32_t, uint32_t,
+                      lldb::addr_t, lldb::SBFileSpecList &, bool),
+                     sb_file_spec, line, column, offset, sb_module_list,
+                     move_to_nearest_code);
+
+  return LLDB_RECORD_RESULT(BreakpointCreateByLocationImpl(
+      sb_file_spec, line, column, offset, sb_module_list,
+      move_to_nearest_code ? eLazyBoolYes : eLazyBoolNo));
 }
 
 SBBreakpoint SBTarget::BreakpointCreateByName(const char *symbol_name,
                                               const char *module_name) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
                      (const char *, const char *), symbol_name, module_name);
 
   SBBreakpoint sb_bp;
   TargetSP target_sp(GetSP());
   if (target_sp.get()) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
 
     const bool internal = false;
     const bool hardware = false;
     const LazyBool skip_prologue = eLazyBoolCalculate;
     const lldb::addr_t offset = 0;
     if (module_name && module_name[0]) {
       FileSpecList module_spec_list;
       module_spec_list.Append(FileSpec(module_name));
       sb_bp = target_sp->CreateBreakpoint(
           &module_spec_list, nullptr, symbol_name, eFunctionNameTypeAuto,
           eLanguageTypeUnknown, offset, skip_prologue, internal, hardware);
     } else {
       sb_bp = target_sp->CreateBreakpoint(
           nullptr, nullptr, symbol_name, eFunctionNameTypeAuto,
           eLanguageTypeUnknown, offset, skip_prologue, internal, hardware);
     }
   }
 
   return LLDB_RECORD_RESULT(sb_bp);
 }
 
 lldb::SBBreakpoint
 SBTarget::BreakpointCreateByName(const char *symbol_name,
                                  const SBFileSpecList &module_list,
                                  const SBFileSpecList &comp_unit_list) {
   LLDB_RECORD_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
                      (const char *, const lldb::SBFileSpecList &,
void RegisterMethods<SBTarget>(Registry &R) {
   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
                        BreakpointCreateByLocation,
                        (const lldb::SBFileSpec &, uint32_t, lldb::addr_t,
                         lldb::SBFileSpecList &));
   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget,
                        BreakpointCreateByLocation,
                        (const lldb::SBFileSpec &, uint32_t, uint32_t,
                         lldb::addr_t, lldb::SBFileSpecList &));
+  LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByLocation,
+                       (const lldb::SBFileSpec &, uint32_t, uint32_t,
+                        lldb::addr_t, lldb::SBFileSpecList &, bool));
   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
                        (const char *, const char *));
   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
                        (const char *, const lldb::SBFileSpecList &,
                         const lldb::SBFileSpecList &));
   LLDB_REGISTER_METHOD(lldb::SBBreakpoint, SBTarget, BreakpointCreateByName,
                        (const char *, uint32_t, const lldb::SBFileSpecList &,
                         const lldb::SBFileSpecList &));

lldb/test/API/functionalities/breakpoint/breakpoint_by_line_and_column/TestBreakpointByLineAndColumn.py

def testBreakpointByLine(self):
         _, _, _, breakpoint = lldbutil.run_to_line_breakpoint(self, main_c, 11)
         self.expect("fr v did_call", substrs=['0'])
         in_condition = False
         for i in range(breakpoint.GetNumLocations()):
             b_loc = breakpoint.GetLocationAtIndex(i).GetAddress().GetLineEntry()
             self.assertEqual(b_loc.GetLine(), 11)
             in_condition |= b_loc.GetColumn() < 30
         self.assertTrue(in_condition)
+
+    ## Skip gcc version less 7.1 since it doesn't support -gcolumn-info
+    @skipIf(compiler="gcc", compiler_version=['<', '7.1'])
+    def testBreakpointByLineAndColumnNearestCode(self):
+        self.build()
+        exe = self.getBuildArtifact("a.out")
+
+        main_c = lldb.SBFileSpec("main.c")
+        line = line_number("main.c", "// Line 20.")
+        column = len("// Line 20") # should stop at the period.
+        indent = 2
+        module_list = lldb.SBFileSpecList()
+
+        # Create a target from the debugger.
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target, VALID_TARGET)
+
+        valid_bpt = target.BreakpointCreateByLocation(main_c, line, column,
+                                                      indent, module_list, True)
+        self.assertTrue(valid_bpt, VALID_BREAKPOINT)
+        self.assertEqual(valid_bpt.GetNumLocations(), 1)
+
+        invalid_bpt = target.BreakpointCreateByLocation(main_c, line, column,
+                                                      indent, module_list, False)
+        self.assertTrue(invalid_bpt, VALID_BREAKPOINT)
+        self.assertEqual(invalid_bpt.GetNumLocations(), 0)
+