Add reverse file remapping for breakpoint set

[tberghammer]

Summary

Add reverse file remapping for breakpoint set

LLDB can remap a source file to a new directory based on the
"target.sorce-map" to handle the usecase when the source code moved
between the compilation and the debugging. Previously the remapping
was only used to display the content of the file. This CL fixes the
scenario when a breakpoint is set based on the new an absolute path
with adding an inverse remapping step before looking up the breakpoint
location.

[jingham]

This looks fine to me.

[jingham]

At some point we should deal with the loss of information when we resolve re-mapped paths. For instance, here I set a breakpoint by the moved source location's full path, and that gets remapped to the build location. That's lovely since it makes the breakpoint take, but then if I do "break list" I'll see something I didn't enter, which is a little surprising. That happens in a few other places, so I don't think you need to deal with it here (and I don't think we want to burden FileSpec with the responsibility of keeping both paths) but just something to keep in the back of our minds...

[tberghammer]

It is a good point. I don't think displaying incorrect path for a breakpoint is a big issue so I don't plan to address it now but we should do it at some point.

lldb/trunk/include/lldb/Target/PathMappingList.h

public:
     ///
     /// @return
     ///     /b true if \a path was successfully located and \a new_path
     ///     is filled in with a new source path, \b false otherwise.
     //------------------------------------------------------------------
     bool
     RemapPath (const char *path, std::string &new_path) const;
 
-    
+    bool
+    ReverseRemapPath (const ConstString &path, ConstString &new_path) const;
     //------------------------------------------------------------------
     /// Finds a source file given a file spec using the path remappings.
     ///
     /// Tries to resolve \a orig_spec by checking the path remappings.
     /// It makes sure the file exists by checking with the file system,
     /// so this call can be expensive if the remappings are on a network
     /// or are even on the local file system, so use this function
     /// sparingly (not in a tight debug info parsing loop).

lldb/trunk/packages/Python/lldbsuite/test/source-manager/TestSourceManager.py

def test_modify_source_file_while_debugging(self):
                 print("new content:", new_content)
                 print("os.path.getmtime() after writing new content:", os.path.getmtime('main.c'))
             # Add teardown hook to restore the file to the original content.
             self.addTearDownHook(restore_file)
 
         # Display the source code again.  We should see the updated line.
         self.expect("source list -f main.c -l %d" % self.line, SOURCE_DISPLAYED_CORRECTLY,
             substrs = ['Hello lldb'])
+
+    def test_set_breakpoint_with_absloute_path(self):
+        self.build()
+        self.runCmd("settings set target.source-map %s %s" % (os.getcwd(), os.path.join(os.getcwd(), "hidden")))
+
+        exe = os.path.join(os.getcwd(), "a.out")
+        main = os.path.join(os.getcwd(), "hidden", "main.c")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        lldbutil.run_break_set_by_file_and_line (self, main, self.line, num_expected_locations=1, loc_exact=False)
+        
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+            substrs = ['stopped',
+                       'main.c:%d' % self.line,
+                       'stop reason = breakpoint'])

lldb/trunk/source/Target/PathMappingList.cpp

for (pos = m_pairs.begin(); pos != end; ++pos)
             new_path.append(path + prefix_len);
             return true;
         }
     }
     return false;
 }
 
 bool
+PathMappingList::ReverseRemapPath (const ConstString &path, ConstString &new_path) const
+{
+    const char *path_cstr = path.GetCString();
+    if (!path_cstr)
+        return false;
+
+    for (const auto& it : m_pairs)
+    {
+        const size_t prefixLen = it.second.GetLength();
+        if (::strncmp (it.second.GetCString(), path_cstr, prefixLen) == 0)
+        {
+            std::string new_path_str (it.first.GetCString());
+            new_path_str.append(path.GetCString() + prefixLen);
+            new_path.SetCString(new_path_str.c_str());
+            return true;
+        }
+    }
+    return false;
+}
+
+bool
 PathMappingList::FindFile (const FileSpec &orig_spec, FileSpec &new_spec) const
 {
     if (!m_pairs.empty())
     {
         char orig_path[PATH_MAX];
         char new_path[PATH_MAX];
         const size_t orig_path_len = orig_spec.GetPath (orig_path, sizeof(orig_path));
         if (orig_path_len > 0)

lldb/trunk/source/Target/Target.cpp

Target::CreateBreakpoint (const FileSpecList *containingModules,
                           const FileSpec &file,
                           uint32_t line_no,
                           LazyBool check_inlines,
                           LazyBool skip_prologue,
                           bool internal,
                           bool hardware,
                           LazyBool move_to_nearest_code)
 {
+    FileSpec remapped_file;
+    ConstString remapped_path;
+    if (GetSourcePathMap().ReverseRemapPath(ConstString(file.GetPath().c_str()), remapped_path))
+        remapped_file.SetFile(remapped_path.AsCString(), true);
+    else
+        remapped_file = file;
+
     if (check_inlines == eLazyBoolCalculate)
     {
         const InlineStrategy inline_strategy = GetInlineStrategy();
         switch (inline_strategy)
         {
             case eInlineBreakpointsNever:
                 check_inlines = eLazyBoolNo;
                 break;
                 
             case eInlineBreakpointsHeaders:
-                if (file.IsSourceImplementationFile())
+                if (remapped_file.IsSourceImplementationFile())
                     check_inlines = eLazyBoolNo;
                 else
                     check_inlines = eLazyBoolYes;
                 break;
 
             case eInlineBreakpointsAlways:
                 check_inlines = eLazyBoolYes;
                 break;
         }
     }
     SearchFilterSP filter_sp;
     if (check_inlines == eLazyBoolNo)
     {
         // Not checking for inlines, we are looking only for matching compile units
         FileSpecList compile_unit_list;
-        compile_unit_list.Append (file);
+        compile_unit_list.Append (remapped_file);
         filter_sp = GetSearchFilterForModuleAndCUList (containingModules, &compile_unit_list);
     }
     else
     {
         filter_sp = GetSearchFilterForModuleList (containingModules);
     }
     if (skip_prologue == eLazyBoolCalculate)
         skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
     if (move_to_nearest_code == eLazyBoolCalculate)
         move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo;
 
     BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine(nullptr,
-                                                                    file,
+                                                                    remapped_file,
                                                                     line_no,
                                                                     check_inlines,
                                                                     skip_prologue,
                                                                     !static_cast<bool>(move_to_nearest_code)));
     return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
 }
 
 BreakpointSP