Add --move-to-nearest-code / target.move-to-nearest-code options

[ki.stfu]

Summary

This option forces to only set a source line breakpoint when there is an exact-match

This patch includes the following commits:

1. Add the -m/--exact-match option in "breakpoint set" command
   1. Add exact_match arg in BreakpointResolverFileLine ctor
   2. Add m_exact_match field in BreakpointResolverFileLine
   3. Add exact_match arg in BreakpointResolverFileRegex ctor
   4. Add m_exact_match field in BreakpointResolverFileRegex
   5. Add exact_match arg in Target::CreateSourceRegexBreakpoint
   6. Add exact_match arg in Target::CreateBreakpoint
   7. Add -m/--exact-match option in "breakpoint set" command
2. Add target.exact-match option to skip BP if source line doesn't match
   1. Add target.exact-match global option
   2. Add Target::GetExactMatch
   3. Refactor Target::CreateSourceRegexBreakpoint to accept LazyBool exact_match (was bool)
   4. Refactor Target::CreateBreakpoint to accept LazyBool exact_match (was bool)
3. Add target.exact-match test in SettingsCommandTestCase
4. Add BreakpointOptionsTestCase tests to test --skip-prologue/--exact-match options
5. Fix a few typos in lldbutil.check_breakpoint_result func
6. Rename --exact-match/m_exact_match/exact_match/GetExactMatch to --move-to-nearest-code/m_move_to_nearest_code/move_to_nearest_code/GetMoveToNearestCode
7. Add exact_match field in BreakpointResolverFileLine::GetDescription and BreakpointResolverFileRegex::GetDescription, for example:

was:

1: file = '/Users/IliaK/p/llvm/tools/lldb/test/functionalities/breakpoint/breakpoint_command/main.c', line = 12, locations = 1, resolved = 1, hit count = 2
  1.1: where = a.out`main + 20 at main.c:12, address = 0x0000000100000eb4, resolved, hit count = 2

now:

1: file = '/Users/IliaK/p/llvm/tools/lldb/test/functionalities/breakpoint/breakpoint_command/main.c', line = 12, exact_match = 0, locations = 1, resolved = 1, hit count = 2
  1.1: where = a.out`main + 20 at main.c:12, address = 0x0000000100000eb4, resolved, hit count = 2

[ki.stfu]

Fix test/lldbutil.py

[ki.stfu]

Friendly ping.

[jingham]

The implementation seems fine.

"exact-match" would be an okay name for the feature if it was only for file & line breakpoints, but for regex breakpoints it seems confusing - is it an exact match with the regex? Anyway, it doesn't express what the flag really does. What you are really doing is "not moving the breakpoint if the specified line contains no code." We should come up with an option name and help string that makes this clear. Maybe --move-to-nearest-code={true,false}?

For extra credit, "break set" should tell you that it WOULD have set the breakpoint except that --move-to-nearest-code was set to false. Otherwise, I don't know how you'd tell the difference.

[ki.stfu]

In D9273#162667, @jingham wrote:

"exact-match" would be an okay name for the feature if it was only for file & line breakpoints, but for regex breakpoints it seems confusing - is it an exact match with the regex?

Yes, but only for regex that means file:line breakpoints.

Anyway, it doesn't express what the flag really does. What you are really doing is "not moving the breakpoint if the specified line contains no code." We should come up with an option name and help string that makes this clear. Maybe --move-to-nearest-code={true,false}?

It's a long name for option, or not? What I should use as a short option?

For extra credit, "break set" should tell you that it WOULD have set the breakpoint except that --move-to-nearest-code was set to false. Otherwise, I don't know how you'd tell the difference.

How it should tell that? Can you suggest a format to do that?

[jingham]

In D9273#162799, @ki.stfu wrote:

In D9273#162667, @jingham wrote:

"exact-match" would be an okay name for the feature if it was only for file & line breakpoints, but for regex breakpoints it seems confusing - is it an exact match with the regex?

Yes, but only for regex that means file:line breakpoints.

Got that, but it is still confusing.

Anyway, it doesn't express what the flag really does. What you are really doing is "not moving the breakpoint if the specified line contains no code." We should come up with an option name and help string that makes this clear. Maybe --move-to-nearest-code={true,false}?

It's a long name for option, or not? What I should use as a short option?

The long option names can be verbose if that helps make them descriptive, after all lldb does tab completion and shortest unique match on option names, so you wouldn't ever have to type it all if you didn't want to.

I chose --move-to-nearest-code in part because you could still use "-m" as the short option...

For extra credit, "break set" should tell you that it WOULD have set the breakpoint except that --move-to-nearest-code was set to false. Otherwise, I don't know how you'd tell the difference.

How it should tell that? Can you suggest a format to do that?

The breakpoint's GetDescription calls down into the Resolvers description method. So you'd have to remember that you COULD have matched some lines were it not for the exact in the Resolver, and report this in its Description method. That part shouldn't be hard. You're also going to have to get ResolveSymbolContext to tell you how many matches the exact_match ruled out.

You probably should have the resolver's description mention that exact match is turned on, since otherwise there's no way to recover this fact. So the file & line description could say something like:

file = 'foo.c', line = 11, move_to_nearest=true: num_skipped=10

[ki.stfu]

@jingham,

I took a look on this again and I'm confused what should I rename. My solution is based on using the exact=true option in CompileUnit::ResolveSymbolContext. The call stack for this arg looks like the following:

1. CompileUnit::ResolveSymbolContext (exact=true) <-- I suppose we are not going to rename it
2. BreakpointResolverFileLine::SearchCallback(exact_match=true) <-- It looks reasonable for me
3. Target::CreateBreakpoint(exact_match=true) <-- It's too
4. CommandObjectBreakpointSet::DoExecute(m_options.m_exact_match=true)  <-- and this
5. breakpoint set ... --exact-match <-- I agree that it's a bit confused for regex but just a bit

Which of them I should rename to MoveToNearestCode (is it a right name?)

The same question for target.exact-match option:

1. Should it be target.move-to-nearest-code?
2. And what about TargetProperties::GetExactMatch()? Should I rename it to TargetProperties::GetMoveToNearestCode()?

All these changes looks ugly for me.

[ki.stfu]

Add MiBreakTestCase.test_lldbmi_break_insert_settings test

[jingham]

In D9273#163830, @ki.stfu wrote:

@jingham,

I took a look on this again and I'm confused what should I rename. My solution is based on using the exact=true option in CompileUnit::ResolveSymbolContext. The call stack for this arg looks like the following:

1. CompileUnit::ResolveSymbolContext (exact=true) <-- I suppose we are not going to rename it
2. BreakpointResolverFileLine::SearchCallback(exact_match=true) <-- It looks reasonable for me

These two seem fine to me, there isn't anything else exact or exact_match could mean.

3. Target::CreateBreakpoint(exact_match=true) <-- It's too
4. CommandObjectBreakpointSet::DoExecute(m_options.m_exact_match=true) <-- and this
5. breakpoint set ... --exact-match <-- I agree that it's a bit confused for regex but just a bit

These three seem confusing since there are a bunch of things exact match could mean.

Which of them I should rename to MoveToNearestCode (is it a right name?)

The same question for target.exact-match option:
# Should it be target.move-to-nearest-code?
# And what about TargetProperties::GetExactMatch()? Should I rename it to TargetProperties::GetMoveToNearestCode()?

Yes, I would change these two.

All these changes looks ugly for me.

Why?

[ki.stfu]

Thanks! I'll rework this according to your comments.

In D9273#164964, @jingham wrote:

All these changes looks ugly for me.

Why?

I thought it is too long name.

[ki.stfu]

Rename --exact-match/m_exact_match/exact_match/GetExactMatch to --move-to-nearest-code/m_move_to_nearest_code/move_to_nearest_code/GetMoveToNearestCode

[ki.stfu]

Friendly ping.

[clayborg]

I will defer to Jim on this one.

[jingham]

I think we talked about coming up with some way to inform users that we didn't get a breakpoint location for the specification but would have if "move-to-nearest-code" was true. I don't see that. It isn't necessary to gate checking this in on that, but it would be good to do as a follow up. One of the common uses for this is "I accidentally put a breakpoint is #if 0-ed. A warning saying the source location contained no code so we didn't set a breakpoint there would help this out.

Another way to do this is to make another flag like "disabled" for locations, something like "not moved" then the regular break list mechanism could be made to show these, but like with disabled breakpoints we would know not to set them.

[ki.stfu]

Add exact_match field in the breakpoint's description

[ki.stfu]

@jingham, take a look again please. Now format looks like:

1: file = '/Users/IliaK/p/llvm/tools/lldb/test/functionalities/breakpoint/breakpoint_command/main.c', line = 12, exact_match = 0, locations = 1, resolved = 1, hit count = 2
  1.1: where = a.out`main + 20 at main.c:12, address = 0x0000000100000eb4, resolved, hit count = 2

3: file = 'main.c', line = 12, exact_match = 0, locations = 1, resolved = 1, hit count = 2
    Breakpoint commands:
      return bktptcmd.function(frame, bp_loc, internal_dict)

  3.1: where = a.out`main + 20 at main.c:12, address = 0x0000000100000eb4, resolved, hit count = 2

[jingham]

That's great. I was thinking something more ambitious, like (this is just a sketch):

3: file = 'main.c', line = 12, exact_match = 1, locations = 1, resolved = 1, hit count = 0

  Breakpoint commands:
    return bktptcmd.function(frame, bp_loc, internal_dict)

3.1: where = a.out`main + 20 at main.c:12, not resolved because exact_match = 1, moved address = 0x0000000100000eb4

Note you have to do it on location, since there could be other locations that do have exact match addresses. But as I said, that's extra credit, it would be fine to check this in and then do this refinement when you have time.

[ki.stfu]

In D9273#172247, @jingham wrote:

3.1: where = a.out`main + 20 at main.c:12, not resolved because exact_match = 1, moved address = 0x0000000100000eb4

How I can determine why it wasn't resolved? (I mean, it wasn't resolved due to exact_match=1, or symbols just not loaded yet?)

[jingham]

You would have to do the exact match check slightly differently in the resolver. Instead of just calling into ResolveSymbolContext with one or the other value of exact match, call with exact_match = false. If you got a result, but the line number didn't match, make a new location anyway but set the not yet existing "not-enabled-because-of-exact-match" flag. Then you'll have to make IsEnabled on the locations check both the enabled flag and the "not-enabled-because-of-exact-match" flags.

Jim

[ki.stfu]

Possible I'll do it later but at the moment I have no time for that. I gonna commit it right now, if you don't mind of course.

[jingham]

I don't mind. I said all along that was "extra-credit".

Jim

[ki.stfu]

Rebase against ToT

[ki.stfu]

Fix MiBreakTestCase.test_lldbmi_break_insert_settings after r236832

[ki.stfu]

@jingham, what you think about hiding of the exact_match field in BP description when it's false? It will fix these errors: http://lab.llvm.org:8011/builders/lldb-x86_64-darwin-13.4/builds/2941

[jingham]

That seems fine as a "reduce noise by not showing flags when set to their default values."

OTOH we should NOT be writing tests that rely on the exact format of break list output, except as mediated by the breakpoint setting commands in lldbutil.py. I didn't look at the tests that were failing, I'm a bit busy right now. But if people are using the command line to set breakpoints and check breakpoints and not using the run_break_set_by_* functions, they should stop doing that. We should be able to change the output from break list and ONLY have to change this set of functions, not go adjusting test suite code all over the testsuite... So whoever wrote these tests should clean them up.

Jim

include/lldb/Breakpoint/BreakpointResolverFileLine.h

 class BreakpointResolverFileLine :
     public BreakpointResolver
 {
 public:
     BreakpointResolverFileLine (Breakpoint *bkpt,
                                 const FileSpec &resolver,
                                 uint32_t line_no,
                                 bool check_inlines,
-                                bool skip_prologue);
+                                bool skip_prologue,
+                                bool exact_match);
 
     virtual
     ~BreakpointResolverFileLine ();
 
     Searcher::CallbackReturn
     SearchCallback (SearchFilter &filter,
                     SymbolContext &context,
                     Address *addr,
public:
     CopyForBreakpoint (Breakpoint &breakpoint) override;
 
 protected:
     friend class Breakpoint;
     FileSpec m_file_spec; // This is the file spec we are looking for.
     uint32_t m_line_number; // This is the line number that we are looking for.
     bool m_inlines; // This determines whether the resolver looks for inlined functions or not.
     bool m_skip_prologue;
+    bool m_exact_match;
 
 private:
     DISALLOW_COPY_AND_ASSIGN(BreakpointResolverFileLine);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_BreakpointResolverFileLine_h_

include/lldb/Breakpoint/BreakpointResolverFileRegex.h

 /// instances of the file and line specification.
 //----------------------------------------------------------------------
 
 class BreakpointResolverFileRegex :
     public BreakpointResolver
 {
 public:
     BreakpointResolverFileRegex (Breakpoint *bkpt,
-                                RegularExpression &regex);
+                                 RegularExpression &regex,
+                                 bool exact_match);
 
     virtual
     ~BreakpointResolverFileRegex ();
 
     Searcher::CallbackReturn
     SearchCallback (SearchFilter &filter,
                     SymbolContext &context,
                     Address *addr,
public:
     }
 
     lldb::BreakpointResolverSP
     CopyForBreakpoint (Breakpoint &breakpoint) override;
 
 protected:
     friend class Breakpoint;
     RegularExpression m_regex; // This is the line expression that we are looking for.
+    bool m_exact_match;
 
 private:
     DISALLOW_COPY_AND_ASSIGN(BreakpointResolverFileRegex);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_BreakpointResolverFileRegex_h_

include/lldb/Target/Target.h

public:
     ~TargetProperties();
     
     ArchSpec
     GetDefaultArchitecture () const;
     
     void
     SetDefaultArchitecture (const ArchSpec& arch);
 
+    bool
+    GetExactMatch () const;
+
     lldb::DynamicValueType
     GetPreferDynamicValue() const;
     
     bool
     GetDisableASLR () const;
     
     void
     SetDisableASLR (bool b);
public:
     // Use this to create a file and line breakpoint to a given module or all module it is NULL
     lldb::BreakpointSP
     CreateBreakpoint (const FileSpecList *containingModules,
                       const FileSpec &file,
                       uint32_t line_no,
                       LazyBool check_inlines,
                       LazyBool skip_prologue,
                       bool internal,
-                      bool request_hardware);
+                      bool request_hardware,
+                      LazyBool exact_match);
 
     // Use this to create breakpoint that matches regex against the source lines in files given in source_file_list:
     lldb::BreakpointSP
     CreateSourceRegexBreakpoint (const FileSpecList *containingModules,
                                  const FileSpecList *source_file_list,
                                  RegularExpression &source_regex,
                                  bool internal,
-                                 bool request_hardware);
+                                 bool request_hardware,
+                                 LazyBool exact_match);
 
     // Use this to create a breakpoint from a load address
     lldb::BreakpointSP
     CreateBreakpoint (lldb::addr_t load_addr,
                       bool internal,
                       bool request_hardware);
 
     // Use this to create Address breakpoints:

source/API/SBTarget.cpp

SBTarget::BreakpointCreateByLocation (const SBFileSpec &sb_file_spec,
     if (target_sp && line != 0)
     {
         Mutex::Locker api_locker (target_sp->GetAPIMutex());
 
         const LazyBool check_inlines = eLazyBoolCalculate;
         const LazyBool skip_prologue = eLazyBoolCalculate;
         const bool internal = false;
         const bool hardware = false;
-        *sb_bp = target_sp->CreateBreakpoint (NULL, *sb_file_spec, line, check_inlines, skip_prologue, internal, hardware);
+        const LazyBool exact_match = eLazyBoolCalculate;
+        *sb_bp = target_sp->CreateBreakpoint (NULL, *sb_file_spec, line, check_inlines, skip_prologue, internal, hardware, exact_match);
     }
 
     if (log)
     {
         SBStream sstr;
         sb_bp.GetDescription (sstr);
         char path[PATH_MAX];
         sb_file_spec->GetPath (path, sizeof(path));
SBTarget::BreakpointCreateBySourceRegex (const char *source_regex,
     SBBreakpoint sb_bp;
     TargetSP target_sp(GetSP());
     if (target_sp && source_regex && source_regex[0])
     {
         Mutex::Locker api_locker (target_sp->GetAPIMutex());
         RegularExpression regexp(source_regex);
         FileSpecList source_file_spec_list;
         const bool hardware = false;
+        const LazyBool exact_match = eLazyBoolCalculate;
         source_file_spec_list.Append (source_file.ref());
 
         if (module_name && module_name[0])
         {
             FileSpecList module_spec_list;
             module_spec_list.Append (FileSpec (module_name, false));
 
-            *sb_bp = target_sp->CreateSourceRegexBreakpoint (&module_spec_list, &source_file_spec_list, regexp, false, hardware);
+            *sb_bp = target_sp->CreateSourceRegexBreakpoint (&module_spec_list, &source_file_spec_list, regexp, false, hardware, exact_match);
         }
         else
         {
-            *sb_bp = target_sp->CreateSourceRegexBreakpoint (NULL, &source_file_spec_list, regexp, false, hardware);
+            *sb_bp = target_sp->CreateSourceRegexBreakpoint (NULL, &source_file_spec_list, regexp, false, hardware, exact_match);
         }
     }
 
     if (log)
     {
         char path[PATH_MAX];
         source_file->GetPath (path, sizeof(path));
         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\", file=\"%s\", module_name=\"%s\") => SBBreakpoint(%p)",
SBTarget::BreakpointCreateBySourceRegex (const char *source_regex,
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API));
 
     SBBreakpoint sb_bp;
     TargetSP target_sp(GetSP());
     if (target_sp && source_regex && source_regex[0])
     {
         Mutex::Locker api_locker (target_sp->GetAPIMutex());
         const bool hardware = false;
+        const LazyBool exact_match = eLazyBoolCalculate;
         RegularExpression regexp(source_regex);
-        *sb_bp = target_sp->CreateSourceRegexBreakpoint (module_list.get(), source_file_list.get(), regexp, false, hardware);
+        *sb_bp = target_sp->CreateSourceRegexBreakpoint (module_list.get(), source_file_list.get(), regexp, false, hardware, exact_match);
     }
 
     if (log)
         log->Printf ("SBTarget(%p)::BreakpointCreateByRegex (source_regex=\"%s\") => SBBreakpoint(%p)",
                      static_cast<void*>(target_sp.get()), source_regex,
                      static_cast<void*>(sb_bp.get()));
 
     return sb_bp;

source/Breakpoint/BreakpointResolverFileLine.cpp

 // BreakpointResolverFileLine:
 //----------------------------------------------------------------------
 BreakpointResolverFileLine::BreakpointResolverFileLine
 (
     Breakpoint *bkpt,
     const FileSpec &file_spec,
     uint32_t line_no,
     bool check_inlines,
-    bool skip_prologue
+    bool skip_prologue,
+    bool exact_match
 ) :
     BreakpointResolver (bkpt, BreakpointResolver::FileLineResolver),
     m_file_spec (file_spec),
     m_line_number (line_no),
     m_inlines (check_inlines),
-    m_skip_prologue(skip_prologue)
+    m_skip_prologue(skip_prologue),
+    m_exact_match(exact_match)
 {
 }
 
 BreakpointResolverFileLine::~BreakpointResolverFileLine ()
 {
 }
 
 Searcher::CallbackReturn
)
     
     const size_t num_comp_units = context.module_sp->GetNumCompileUnits();
     for (size_t i = 0; i < num_comp_units; i++)
     {
         CompUnitSP cu_sp (context.module_sp->GetCompileUnitAtIndex (i));
         if (cu_sp)
         {
             if (filter.CompUnitPasses(*cu_sp))
-                cu_sp->ResolveSymbolContext (m_file_spec, m_line_number, m_inlines, false, eSymbolContextEverything, sc_list);
+                cu_sp->ResolveSymbolContext (m_file_spec, m_line_number, m_inlines, m_exact_match, eSymbolContextEverything, sc_list);
         }
     }
     StreamString s;
     s.Printf ("for %s:%d ",
                         m_file_spec.GetFilename().AsCString("<Unknown>"),
                         m_line_number);
 
     SetSCMatchesByLine (filter, sc_list, m_skip_prologue, s.GetData());

 
 lldb::BreakpointResolverSP
 BreakpointResolverFileLine::CopyForBreakpoint (Breakpoint &breakpoint)
 {
     lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileLine(&breakpoint,
                                                                      m_file_spec,
                                                                      m_line_number,
                                                                      m_inlines,
-                                                                     m_skip_prologue));
+                                                                     m_skip_prologue,
+                                                                     m_exact_match));
 
     return ret_sp;
 }

source/Breakpoint/BreakpointResolverFileRegex.cpp

 using namespace lldb_private;
 
 //----------------------------------------------------------------------
 // BreakpointResolverFileRegex:
 //----------------------------------------------------------------------
 BreakpointResolverFileRegex::BreakpointResolverFileRegex
 (
     Breakpoint *bkpt,
-    RegularExpression &regex
+    RegularExpression &regex,
+    bool exact_match
 ) :
     BreakpointResolver (bkpt, BreakpointResolver::FileLineResolver),
-    m_regex (regex)
+    m_regex (regex),
+    m_exact_match (exact_match)
 {
 }
 
 BreakpointResolverFileRegex::~BreakpointResolverFileRegex ()
 {
 }
 
 Searcher::CallbackReturn
)
     std::vector<uint32_t> line_matches;
     context.target_sp->GetSourceManager().FindLinesMatchingRegex(cu_file_spec, m_regex, 1, UINT32_MAX, line_matches);
     
     uint32_t num_matches = line_matches.size();
     for (uint32_t i = 0; i < num_matches; i++)
     {
         SymbolContextList sc_list;
         const bool search_inlines = false;
-        const bool exact = false;
         
-        cu->ResolveSymbolContext (cu_file_spec, line_matches[i], search_inlines, exact, eSymbolContextEverything, sc_list);
+        cu->ResolveSymbolContext (cu_file_spec, line_matches[i], search_inlines, m_exact_match, eSymbolContextEverything, sc_list);
         const bool skip_prologue = true;
         
         BreakpointResolver::SetSCMatchesByLine (filter, sc_list, skip_prologue, m_regex.GetText());
     }
     assert (m_breakpoint != NULL);        
 
     return Searcher::eCallbackReturnContinue;
 }

 BreakpointResolverFileRegex::Dump (Stream *s) const
 {
 
 }
 
 lldb::BreakpointResolverSP
 BreakpointResolverFileRegex::CopyForBreakpoint (Breakpoint &breakpoint)
 {
-    lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileRegex(&breakpoint, m_regex));
+    lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileRegex(&breakpoint, m_regex, m_exact_match));
     return ret_sp;
 }
 

source/Commands/CommandObjectBreakpoint.cpp

public:
             m_thread_name(),
             m_queue_name(),
             m_catch_bp (false),
             m_throw_bp (true),
             m_hardware (false),
             m_exception_language (eLanguageTypeUnknown),
             m_skip_prologue (eLazyBoolCalculate),
             m_one_shot (false),
-            m_all_files (false)
+            m_all_files (false),
+            m_exact_match (eLazyBoolCalculate)
         {
         }
 
 
         virtual
         ~CommandOptions () {}
 
         virtual Error
public:
                 case 'l':
                 {
                     bool success;
                     m_line_num = StringConvert::ToUInt32 (option_arg, 0, 0, &success);
                     if (!success)
                         error.SetErrorStringWithFormat ("invalid line number: %s.", option_arg);
                     break;
                 }
+
+                case 'm':
+                    m_exact_match = eLazyBoolYes;
+                    break;
+
                 case 'M':
                     m_func_names.push_back (option_arg);
                     m_func_name_type_mask |= eFunctionNameTypeMethod;
                     break;
 
                 case 'n':
                     m_func_names.push_back (option_arg);
                     m_func_name_type_mask |= eFunctionNameTypeAuto;
public:
             m_hardware = false;
             m_exception_language = eLanguageTypeUnknown;
             m_skip_prologue = eLazyBoolCalculate;
             m_one_shot = false;
             m_use_dummy = false;
             m_breakpoint_names.clear();
             m_all_files = false;
             m_exception_extra_args.Clear();
+            m_exact_match = eLazyBoolCalculate;
         }
     
         const OptionDefinition*
         GetDefinitions ()
         {
             return g_option_table;
         }
 
public:
         bool m_throw_bp;
         bool m_hardware; // Request to use hardware breakpoints
         lldb::LanguageType m_exception_language;
         LazyBool m_skip_prologue;
         bool m_one_shot;
         bool m_use_dummy;
         bool m_all_files;
         Args m_exception_extra_args;
+        LazyBool m_exact_match;
 
     };
 
 protected:
     virtual bool
     DoExecute (Args& command,
               CommandReturnObject &result)
     {
DoExecute (Args& command,
                     LazyBool check_inlines = eLazyBoolCalculate;
                     
                     bp = target->CreateBreakpoint (&(m_options.m_modules),
                                                    file,
                                                    m_options.m_line_num,
                                                    check_inlines,
                                                    m_options.m_skip_prologue,
                                                    internal,
-                                                   m_options.m_hardware).get();
+                                                   m_options.m_hardware,
+                                                   m_options.m_exact_match).get();
                 }
                 break;
 
             case eSetTypeAddress: // Breakpoint by address
                 bp = target->CreateBreakpoint (m_options.m_load_addr,
                                                internal,
                                                m_options.m_hardware).get();
                 break;
DoExecute (Args& command,
                                                      err_str);
                         result.SetStatus (eReturnStatusFailed);
                         return false;
                     }
                     bp = target->CreateSourceRegexBreakpoint (&(m_options.m_modules),
                                                               &(m_options.m_filenames),
                                                               regexp,
                                                               internal,
-                                                              m_options.m_hardware).get();
+                                                              m_options.m_hardware,
+                                                              m_options.m_exact_match).get();
                 }
                 break;
             case eSetTypeException:
                 {
                     Error precond_error;
                     bp = target->CreateExceptionBreakpoint (m_options.m_exception_language,
                                                             m_options.m_catch_bp,
                                                             m_options.m_throw_bp,
private:
     
     CommandOptions m_options;
 };
 // If an additional option set beyond LLDB_OPTION_SET_10 is added, make sure to
 // update the numbers passed to LLDB_OPT_SET_FROM_TO(...) appropriately.
 #define LLDB_OPT_FILE ( LLDB_OPT_SET_FROM_TO(1, 9) & ~LLDB_OPT_SET_2 )
 #define LLDB_OPT_NOT_10 ( LLDB_OPT_SET_FROM_TO(1, 10) & ~LLDB_OPT_SET_10 )
 #define LLDB_OPT_SKIP_PROLOGUE ( LLDB_OPT_SET_1 | LLDB_OPT_SET_FROM_TO(3,8) )
+#define LLDB_OPT_EXACT_MATCH ( LLDB_OPT_SET_1 | LLDB_OPT_SET_9 )
 
 OptionDefinition
 CommandObjectBreakpointSet::CommandOptions::g_option_table[] =
 {
     { LLDB_OPT_NOT_10, false, "shlib", 's', OptionParser::eRequiredArgument, NULL, NULL, CommandCompletions::eModuleCompletion, eArgTypeShlibName,
         "Set the breakpoint only in this shared library.  "
         "Can repeat this option multiple times to specify multiple shared libraries."},
 
//        "The breakpoint will only stop if an exception Object of this type is thrown.  Can be repeated multiple times to stop for multiple object types" },
         "sKip the prologue if the breakpoint is at the beginning of a function.  If not set the target.skip-prologue setting is used." },
 
     { LLDB_OPT_SET_ALL, false, "dummy-breakpoints", 'D', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone,
         "Sets Dummy breakpoints - i.e. breakpoints set before a file is provided, which prime new targets."},
 
     { LLDB_OPT_SET_ALL, false, "breakpoint-name", 'N', OptionParser::eRequiredArgument, NULL, NULL, 0, eArgTypeBreakpointName,
         "Adds this to the list of names for this breakopint."},
 
+    { LLDB_OPT_EXACT_MATCH, false, "exact-match", 'm', OptionParser::eNoArgument, NULL, NULL, 0, eArgTypeNone,
+        "Don't set the breakpoint if the line number doesn't Match." },
+
     { 0, false, NULL, 0, 0, NULL, NULL, 0, eArgTypeNone, NULL }
 };
 
 //-------------------------------------------------------------------------
 // CommandObjectBreakpointModify
 //-------------------------------------------------------------------------
 #pragma mark Modify
 

source/Core/IOHandler.cpp

WindowDelegateHandleChar (Window &window, int c) override
                     if (exe_ctx.HasProcessScope() && exe_ctx.GetProcessRef().IsAlive())
                     {
                         BreakpointSP bp_sp = exe_ctx.GetTargetRef().CreateBreakpoint (NULL,                      // Don't limit the breakpoint to certain modules
                                                                                       m_file_sp->GetFileSpec(),  // Source file
                                                                                       m_selected_line + 1,       // Source line number (m_selected_line is zero based)
                                                                                       eLazyBoolCalculate,        // Check inlines using global setting
                                                                                       eLazyBoolCalculate,        // Skip prologue using global setting,
                                                                                       false,                     // internal
-                                                                                      false);                    // request_hardware
+                                                                                      false,                     // request_hardware
+                                                                                      eLazyBoolCalculate);       // exact_match
                         // Make breakpoint one shot
                         bp_sp->GetOptions()->SetOneShot(true);
                         exe_ctx.GetProcessRef().Resume();
                     }
                 }
                 else if (m_selected_line < GetNumDisassemblyLines())
                 {
                     const Instruction *inst = m_disassembly_sp->GetInstructionList().GetInstructionAtIndex(m_selected_line).get();
WindowDelegateHandleChar (Window &window, int c) override
                     if (exe_ctx.HasTargetScope())
                     {
                         BreakpointSP bp_sp = exe_ctx.GetTargetRef().CreateBreakpoint (NULL,                      // Don't limit the breakpoint to certain modules
                                                                                       m_file_sp->GetFileSpec(),  // Source file
                                                                                       m_selected_line + 1,       // Source line number (m_selected_line is zero based)
                                                                                       eLazyBoolCalculate,        // Check inlines using global setting
                                                                                       eLazyBoolCalculate,        // Skip prologue using global setting,
                                                                                       false,                     // internal
-                                                                                      false);                    // request_hardware
+                                                                                      false,                     // request_hardware
+                                                                                      eLazyBoolCalculate);       // exact_match
                     }
                 }
                 else if (m_selected_line < GetNumDisassemblyLines())
                 {
                     const Instruction *inst = m_disassembly_sp->GetInstructionList().GetInstructionAtIndex(m_selected_line).get();
                     ExecutionContext exe_ctx = m_debugger.GetCommandInterpreter().GetExecutionContext();
                     if (exe_ctx.HasTargetScope())
                     {

source/Target/Target.cpp

Target::GetBreakpointByID (break_id_t break_id)
     return bp_sp;
 }
 
 BreakpointSP
 Target::CreateSourceRegexBreakpoint (const FileSpecList *containingModules,
                                      const FileSpecList *source_file_spec_list,
                                      RegularExpression &source_regex,
                                      bool internal,
-                                     bool hardware)
+                                     bool hardware,
+                                     LazyBool exact_match)
 {
     SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, source_file_spec_list));
-    BreakpointResolverSP resolver_sp(new BreakpointResolverFileRegex (NULL, source_regex));
+    if (exact_match == eLazyBoolCalculate)
+        exact_match = GetExactMatch() ? eLazyBoolYes : eLazyBoolNo;
+    BreakpointResolverSP resolver_sp(new BreakpointResolverFileRegex (NULL, source_regex, static_cast<bool>(exact_match)));
     return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
 }
 
 
 BreakpointSP
 Target::CreateBreakpoint (const FileSpecList *containingModules,
                           const FileSpec &file,
                           uint32_t line_no,
                           LazyBool check_inlines,
                           LazyBool skip_prologue,
                           bool internal,
-                          bool hardware)
+                          bool hardware,
+                          LazyBool exact_match)
 {
     if (check_inlines == eLazyBoolCalculate)
     {
         const InlineStrategy inline_strategy = GetInlineStrategy();
         switch (inline_strategy)
         {
             case eInlineBreakpointsNever:
                 check_inlines = eLazyBoolNo;
if (check_inlines == eLazyBoolNo)
         filter_sp = GetSearchFilterForModuleAndCUList (containingModules, &compile_unit_list);
     }
     else
     {
         filter_sp = GetSearchFilterForModuleList (containingModules);
     }
     if (skip_prologue == eLazyBoolCalculate)
         skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
+    if (exact_match == eLazyBoolCalculate)
+        exact_match = GetExactMatch() ? eLazyBoolYes : eLazyBoolNo;
 
     BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine (NULL,
                                                                      file,
                                                                      line_no,
                                                                      check_inlines,
-                                                                     skip_prologue));
+                                                                     skip_prologue,
+                                                                     static_cast<bool>(exact_match)));
     return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
 }
 
 
 BreakpointSP
 Target::CreateBreakpoint (lldb::addr_t addr, bool internal, bool hardware)
 {
     Address so_addr;
g_memory_module_load_level_values[] =
     { eMemoryModuleLoadLevelComplete, "complete", "Load complete information when loading modules from memory. Currently this setting loads sections and all symbols."},
     { 0, NULL, NULL }
 };
 
 static PropertyDefinition
 g_properties[] =
 {
     { "default-arch"                       , OptionValue::eTypeArch      , true , 0                         , NULL, NULL, "Default architecture to choose, when there's a choice." },
+    { "exact-match"                        , OptionValue::eTypeBoolean   , false, false                     , NULL, NULL, "Don't set the breakpoint when the resolved line number doesn't match to the original." },
     { "expr-prefix"                        , OptionValue::eTypeFileSpec  , false, 0                         , NULL, NULL, "Path to a file containing expressions to be prepended to all expressions." },
     { "prefer-dynamic-value"               , OptionValue::eTypeEnum      , false, eDynamicDontRunTarget     , NULL, g_dynamic_value_types, "Should printed values be shown as their dynamic value." },
     { "enable-synthetic-value"             , OptionValue::eTypeBoolean   , false, true                      , NULL, NULL, "Should synthetic values be used by default whenever available." },
     { "skip-prologue"                      , OptionValue::eTypeBoolean   , false, true                      , NULL, NULL, "Skip function prologues when setting breakpoints by name." },
     { "source-map"                         , OptionValue::eTypePathMap   , false, 0                         , NULL, NULL, "Source path remappings used to track the change of location between a source file when built, and "
       "where it exists on the current system.  It consists of an array of duples, the first element of each duple is "
       "some part (starting at the root) of the path to the file when it was built, "
       "and the second is where the remainder of the original build hierarchy is rooted on the local system.  "
g_properties[] =
     { "trap-handler-names"                 , OptionValue::eTypeArray     , true,  OptionValue::eTypeString,   NULL, NULL, "A list of trap handler function names, e.g. a common Unix user process one is _sigtramp." },
     { "display-runtime-support-values"     , OptionValue::eTypeBoolean   , false, false,                      NULL, NULL, "If true, LLDB will show variables that are meant to support the operation of a language's runtime support." },
     { NULL                                 , OptionValue::eTypeInvalid   , false, 0                         , NULL, NULL, NULL }
 };
 
 enum
 {
     ePropertyDefaultArch,
+    ePropertyExactMatch,
     ePropertyExprPrefix,
     ePropertyPreferDynamic,
     ePropertyEnableSynthetic,
     ePropertySkipPrologue,
     ePropertySourceMap,
     ePropertyExecutableSearchPaths,
     ePropertyDebugFileSearchPaths,
     ePropertyClangModuleSearchPaths,

 void
 TargetProperties::SetDefaultArchitecture (const ArchSpec& arch)
 {
     OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch (NULL, ePropertyDefaultArch);
     if (value)
         return value->SetCurrentValue(arch, true);
 }
 
+bool
+TargetProperties::GetExactMatch() const
+{
+    const uint32_t idx = ePropertyExactMatch;
+    return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
+}
+
 lldb::DynamicValueType
 TargetProperties::GetPreferDynamicValue() const
 {
     const uint32_t idx = ePropertyPreferDynamic;
     return (lldb::DynamicValueType)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value);
 }
 
 bool

test/functionalities/breakpoint/breakpoint_options/Makefile

+LEVEL = ../../../make
+
+C_SOURCES := main.c
+
+include $(LEVEL)/Makefile.rules

test/functionalities/breakpoint/breakpoint_options/TestBreakpointOptions.py

+"""
+Test breakpoint command for different options.
+"""
+
+import os
+import unittest2
+import lldb
+from lldbtest import *
+import lldbutil
+
+class BreakpointOptionsTestCase(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @skipUnlessDarwin
+    @dsym_test
+    def test_with_dsym(self):
+        """Test breakpoint command for different options."""
+        self.buildDsym()
+        self.breakpoint_options_test()
+
+    @dwarf_test
+    def test_with_dwarf(self):
+        """Test breakpoint command for different options."""
+        self.buildDwarf()
+        self.breakpoint_options_test()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break inside main().
+        self.line = line_number('main.c', '// Set break point at this line.')
+
+    def breakpoint_options_test(self):
+        """Test breakpoint command for different options."""
+        exe = os.path.join(os.getcwd(), "a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        # This should create a breakpoint with 1 locations.
+        lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-K 1", num_expected_locations = 1)
+        lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-K 0", num_expected_locations = 1)
+
+        # This should create a breakpoint 0 locations.
+        lldbutil.run_break_set_by_file_and_line (self, "main.c", self.line, extra_options = "-m", num_expected_locations = 0)
+
+        # Run the program.
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # Stopped once.
+        self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ["stop reason = breakpoint 2."])
+
+        # Continue the program, there should be another stop.
+        self.runCmd("process continue")
+
+        # Stopped again.
+        self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ["stop reason = breakpoint 1."])
+
+        # Continue the program, we should exit.
+        self.runCmd("process continue")
+
+        # We should exit.
+        self.expect("process status", "Process exited successfully",
+            patterns = ["^Process [0-9]+ exited with status = 0"])
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

test/functionalities/breakpoint/breakpoint_options/main.c

+// Set break point at this line.
+
+int
+main (int argc, char **argv)
+{ 
+  return 0;
+}

test/lldbutil.py

def check_breakpoint_result (test, break_results, file_name=None, line_number=-1, symbol_name=None, symbol_match_exact=True, module_name=None, offset=-1, num_locations=-1):
 
     if file_name:
         out_file_name = ""
         if 'file' in break_results:
             out_file_name = break_results['file']
         test.assertTrue (file_name == out_file_name, "Breakpoint file name '%s' doesn't match resultant name '%s'."%(file_name, out_file_name))
 
     if line_number != -1:
-        out_file_line = -1
+        out_line_number = -1
         if 'line_no' in break_results:
             out_line_number = break_results['line_no']
 
         test.assertTrue (line_number == out_line_number, "Breakpoint line number %s doesn't match resultant line %s."%(line_number, out_line_number))
 
     if symbol_name:
         out_symbol_name = ""
         # Look first for the inlined symbol name, otherwise use the symbol name:
         if 'inline_symbol' in break_results and break_results['inline_symbol']:
             out_symbol_name = break_results['inline_symbol']
         elif 'symbol' in break_results:
             out_symbol_name = break_results['symbol']
 
         if symbol_match_exact:
             test.assertTrue(symbol_name == out_symbol_name, "Symbol name '%s' doesn't match resultant symbol '%s'."%(symbol_name, out_symbol_name))
         else:
             test.assertTrue(out_symbol_name.find(symbol_name) != -1, "Symbol name '%s' isn't in resultant symbol '%s'."%(symbol_name, out_symbol_name))
 
     if module_name:
-        out_nodule_name = None
+        out_module_name = None
         if 'module' in break_results:
             out_module_name = break_results['module']
         
         test.assertTrue (module_name.find(out_module_name) != -1, "Symbol module name '%s' isn't in expected module name '%s'."%(out_module_name, module_name))
 
 # ==================================================
 # Utility functions related to Threads and Processes
 # ==================================================

test/settings/TestSettings.py

def test_all_settings_exist (self):
                                  "stop-disassembly-count",
                                  "stop-disassembly-display",
                                  "stop-line-count-after",
                                  "stop-line-count-before",
                                  "term-width",
                                  "thread-format",
                                  "use-external-editor",
                                  "target.default-arch",
+                                 "target.exact-match",
                                  "target.expr-prefix",
                                  "target.prefer-dynamic-value",
                                  "target.enable-synthetic-value",
                                  "target.skip-prologue",
                                  "target.source-map",
                                  "target.exec-search-paths",
                                  "target.max-children-count",
                                  "target.max-string-summary-length",

test/tools/lldb-mi/breakpoint/TestMiBreak.py

def test_lldbmi_break_insert_file_line_absolute_path(self):
         line = line_number('main.cpp', '// BP_return')
         self.runCmd("-break-insert %s:%d" % (path, line))
         self.expect("\^done,bkpt={number=\"2\"")
 
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
+    def test_lldbmi_break_insert_settings(self):
+        """Test that 'lldb-mi --interpreter' can set breakpoints accoridng to global options."""
+
+        self.spawnLldbMi(args = None)
+
+        # Load executable
+        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+        self.expect("\^done")
+
+        # Set target.exact-match=on and try to set BP #1 that shouldn't be hit
+        self.runCmd("-interpreter-exec console \"settings set target.exact-match on\"")
+        self.expect("\^done")
+        line = line_number('main.cpp', '// BP_before_main')
+        self.runCmd("-break-insert main.cpp:%d" % line)
+        self.expect("\^done,bkpt={number=\"1\"")
+
+        # Set target.exact-match=off and target.skip-prologue=on and set BP #2
+        self.runCmd("-interpreter-exec console \"settings set target.exact-match off\"")
+        self.runCmd("-interpreter-exec console \"settings set target.skip-prologue on\"")
+        self.expect("\^done")
+        self.runCmd("-break-insert main.cpp:%d" % line)
+        self.expect("\^done,bkpt={number=\"2\"")
+
+        # Set target.skip-prologue=off and set BP #3
+        self.runCmd("-interpreter-exec console \"settings set target.skip-prologue off\"")
+        self.expect("\^done")
+        self.runCmd("-break-insert main.cpp:%d" % line)
+        self.expect("\^done,bkpt={number=\"3\"")
+
+        # Test that BP #3 is located before BP #2
+        self.runCmd("-exec-run")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"breakpoint-hit\",disp=\"del\",bkptno=\"3\"")
+
+        # Test that BP #2 is hit
+        self.runCmd("-exec-continue")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"breakpoint-hit\",disp=\"del\",bkptno=\"2\"")
+
+        # Test that BP #1 wasn't set
+        self.runCmd("-exec-continue")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"exited-normally\"")
+
 if __name__ == '__main__':
     unittest2.main()

test/tools/lldb-mi/breakpoint/main.cpp

 //===-- main.cpp ------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <cstdio>
 
+// BP_before_main
+
 int
 main(int argc, char const *argv[])
 {
     printf("Print a formatted string so that GCC does not optimize this printf call: %s\n", argv[0]);
     return 0; // BP_return
 }