Keep original source path and mapped path in LineEntry

[ted]

Summary

The "file" variable in a LineEntry was mapped using target.source-map, except when stepping through inlined code. This patch adds a new variable to LineEntry, "original_file", that contains the original file from the debug info. "file" will continue to (possibly) be mapped.

Some code has been changed to use "original_file". This is code dealing with symbols. Code dealing with source files will still use "file". Reviewers, please confirm that these particular changes are correct.

Tests run on Ubuntu 12.04 show no regression.

[jingham]

This approach seems right to me.

See the inline comment for BreakpointResolver.

In ThreadPlanStepOverRange at line 235 this instance should also be changed to original_file:

if (sc.line_entry.file != m_addr_context.line_entry.file

Also, there are a couple of places where we test equality of the files in line_entries:

the "struct SourceInfo" operators in CommandObjectSource
LineEntry::GetSameLineContiguousAddressRange () const

I am pretty sure both of those should test original_file, so they don't depend on when/if the line_entries tested got re-mapped.

source/Breakpoint/BreakpointResolver.cpp

89–96

In this case, we probably want to try both. This code is where we set file & line breakpoints. If we're showing the re-mapped file in source listings or anything like that, we should allow people to use it to set breakpoints. But I wouldn't want setting breakpoints by the debug info name to fail as well.

[ted]

Addressed Jim's comments.

Make BreakpointResolver check both original and mapped files.
Changed ThreadPlanStepOverRange line 235 to use original_file.
Changed "struct SourceInfo" operators in CommandobjectSource to use original file.
Changed LineEntry::GetSameLineContiguousAddressRagne to use original file.

[jingham]

Looks good to me.

include/lldb/Symbol/LineEntry.h

struct LineEntry
     /// 
     /// @return
     ///     The contiguous AddressRange for this source line.
     //------------------------------------------------------------------
     AddressRange
     GetSameLineContiguousAddressRange () const;
 
     //------------------------------------------------------------------
+    /// Apply file mappings from target.source-map to the LineEntry's file.
+    ///
+    /// @param[in] target_sp
+    ///     Shared pointer to the target this LineEntry belongs to.
+    //------------------------------------------------------------------
+
+    void
+    ApplyFileMappings(lldb::TargetSP target_sp);
+
+    //------------------------------------------------------------------
     // Member variables.
     //------------------------------------------------------------------
     AddressRange    range;                      ///< The section offset address range for this line entry.
-    FileSpec        file;
+    FileSpec        file;                       ///< The source file, possibly mapped by the target.source-map setting
+    FileSpec        original_file;              ///< The original source file, from debug info.
     uint32_t        line;                       ///< The source line number, or zero if there is no line number information.
     uint16_t        column;                     ///< The column number of the source line, or zero if there is no column information.
     uint16_t        is_start_of_statement:1,    ///< Indicates this entry is the beginning of a statement.
                     is_start_of_basic_block:1,  ///< Indicates this entry is the beginning of a basic block.
                     is_prologue_end:1,          ///< Indicates this entry is one (of possibly many) where execution should be suspended for an entry breakpoint of a function.
                     is_epilogue_begin:1,        ///< Indicates this entry is one (of possibly many) where execution should be suspended for an exit breakpoint of a function.
                     is_terminal_entry:1;        ///< Indicates this entry is that of the first byte after the end of a sequence of target machine instructions.
 };

source/Breakpoint/BreakpointResolver.cpp

BreakpointResolver::SetSCMatchesByLine (SearchFilter &filter, SymbolContextList &sc_list, bool skip_prologue, const char *log_ident)
     while (sc_list.GetSize() > 0)
     {
         SymbolContextList tmp_sc_list;
         unsigned current_idx = 0;
         SymbolContext sc;
         bool first_entry = true;
         
         FileSpec match_file_spec;
+        FileSpec match_original_file_spec;
         uint32_t closest_line_number = UINT32_MAX;
 
         // Pull out the first entry, and all the others that match its file spec, and stuff them in the tmp list.
         while (current_idx < sc_list.GetSize())
         {
             bool matches;
             
             sc_list.GetContextAtIndex (current_idx, sc);
             if (first_entry)
             {
                 match_file_spec = sc.line_entry.file;
+                match_original_file_spec = sc.line_entry.original_file;
                 matches = true;
                 first_entry = false;
             }
             else
-                matches = (sc.line_entry.file == match_file_spec);
+                matches = ((sc.line_entry.file == match_file_spec) ||
+                           (sc.line_entry.original_file == match_original_file_spec));
             
             if (matches)
             {
                 tmp_sc_list.Append (sc);
                 sc_list.RemoveContextAtIndex(current_idx);
                 
                 // ResolveSymbolContext will always return a number that is >= the line number you pass in.
                 // So the smaller line number is always better.

source/Commands/CommandObjectSource.cpp

struct SourceInfo
         {
             return (bool)function && line_entry.IsValid();
         }
         
         bool
         operator == (const SourceInfo &rhs) const
         {
             return function == rhs.function &&
-            line_entry.file == rhs.line_entry.file &&
+            line_entry.original_file == rhs.line_entry.original_file &&
             line_entry.line == rhs.line_entry.line;
         }
         
         bool
         operator != (const SourceInfo &rhs) const
         {
             return function != rhs.function ||
-            line_entry.file != rhs.line_entry.file ||
+            line_entry.original_file != rhs.line_entry.original_file ||
             line_entry.line != rhs.line_entry.line;
         }
         
         bool
         operator < (const SourceInfo &rhs) const
         {
             if (function.GetCString() < rhs.function.GetCString())
                 return true;

source/Symbol/LineEntry.cpp

(
     bool _is_start_of_statement,
     bool _is_start_of_basic_block,
     bool _is_prologue_end,
     bool _is_epilogue_begin,
     bool _is_terminal_entry
 ) :
     range(section_sp, section_offset, byte_size),
     file(_file),
+    original_file(_file),
     line(_line),
     column(_column),
     is_start_of_statement(_is_start_of_statement),
     is_start_of_basic_block(_is_start_of_basic_block),
     is_prologue_end(_is_prologue_end),
     is_epilogue_begin(_is_epilogue_begin),
     is_terminal_entry(_is_terminal_entry)
 {
 }
 
 void
 LineEntry::Clear()
 {
     range.Clear();
     file.Clear();
+    original_file.Clear();
     line = LLDB_INVALID_LINE_NUMBER;
     column = 0;
     is_start_of_statement = 0;
     is_start_of_basic_block = 0;
     is_prologue_end = 0;
     is_epilogue_begin = 0;
     is_terminal_entry = 0;
 }
LineEntry::GetSameLineContiguousAddressRange () const
     {
         SymbolContext next_line_sc;
         Address range_end (complete_line_range.GetBaseAddress());
         range_end.Slide (complete_line_range.GetByteSize());
         range_end.CalculateSymbolContext (&next_line_sc, lldb::eSymbolContextLineEntry);
 
         if (next_line_sc.line_entry.IsValid() 
             && next_line_sc.line_entry.range.GetByteSize() > 0
-            && file == next_line_sc.line_entry.file)
+            && original_file == next_line_sc.line_entry.original_file)
         {
             // Include any line 0 entries - they indicate that this is compiler-generated code 
             // that does not correspond to user source code.
             if (next_line_sc.line_entry.line == 0)
             {
                 complete_line_range.SetByteSize (complete_line_range.GetByteSize() + next_line_sc.line_entry.range.GetByteSize());
                 continue;
             }
 
             if (line == next_line_sc.line_entry.line)
             {
                 // next_line_sc is the same file & line as this LineEntry, so extend our
                 // AddressRange by its size and continue to see if there are more LineEntries
                 // that we can combine.
                 complete_line_range.SetByteSize (complete_line_range.GetByteSize() + next_line_sc.line_entry.range.GetByteSize());
                 continue;
             }
         }
         break;
     }
     return complete_line_range;
 }
+
+void
+LineEntry::ApplyFileMappings(lldb::TargetSP target_sp)
+{
+    if (target_sp)
+    {
+        // Apply any file remappings to our file
+        FileSpec new_file_spec;
+        if (target_sp->GetSourcePathMap().FindFile(original_file, new_file_spec))
+            file = new_file_spec;
+    }
+}

source/Symbol/LineTable.cpp

if (idx < m_entries.size())
         if (module_sp && module_sp->ResolveFileAddress(entry.file_addr, line_entry.range.GetBaseAddress()))
         {
             if (!entry.is_terminal_entry && idx + 1 < m_entries.size())
                 line_entry.range.SetByteSize(m_entries[idx+1].file_addr - entry.file_addr);
             else
                 line_entry.range.SetByteSize(0);
 
             line_entry.file = m_comp_unit->GetSupportFiles().GetFileSpecAtIndex (entry.file_idx);
+            line_entry.original_file = m_comp_unit->GetSupportFiles().GetFileSpecAtIndex(entry.file_idx);
             line_entry.line = entry.line;
             line_entry.column = entry.column;
             line_entry.is_start_of_statement = entry.is_start_of_statement;
             line_entry.is_start_of_basic_block = entry.is_start_of_basic_block;
             line_entry.is_prologue_end = entry.is_prologue_end;
             line_entry.is_epilogue_begin = entry.is_epilogue_begin;
             line_entry.is_terminal_entry = entry.is_terminal_entry;
             return true;

 LineTable::Dump (Stream *s, Target *target, Address::DumpStyle style, Address::DumpStyle fallback_style, bool show_line_ranges)
 {
     const size_t count = m_entries.size();
     LineEntry line_entry;
     FileSpec prev_file;
     for (size_t idx = 0; idx < count; ++idx)
     {
         ConvertEntryAtIndexToLineEntry (idx, line_entry);
-        line_entry.Dump (s, target, prev_file != line_entry.file, style, fallback_style, show_line_ranges);
+        line_entry.Dump (s, target, prev_file != line_entry.original_file, style, fallback_style, show_line_ranges);
         s->EOL();
-        prev_file = line_entry.file;
+        prev_file = line_entry.original_file;
     }
 }
 
 
 void
 LineTable::GetDescription (Stream *s, Target *target, DescriptionLevel level)
 {
     const size_t count = m_entries.size();

source/Symbol/SymbolContext.cpp

if (block)
             if (curr_inlined_block->GetRangeContainingAddress (curr_frame_pc, range))
             {
                 // To see there this new frame block it, we need to look at the
                 // call site information from 
                 const InlineFunctionInfo* curr_inlined_block_inlined_info = curr_inlined_block->GetInlinedFunctionInfo();
                 next_frame_pc = range.GetBaseAddress();
                 next_frame_sc.line_entry.range.GetBaseAddress() = next_frame_pc;
                 next_frame_sc.line_entry.file = curr_inlined_block_inlined_info->GetCallSite().GetFile();
+                next_frame_sc.line_entry.original_file = curr_inlined_block_inlined_info->GetCallSite().GetFile();
                 next_frame_sc.line_entry.line = curr_inlined_block_inlined_info->GetCallSite().GetLine();
                 next_frame_sc.line_entry.column = curr_inlined_block_inlined_info->GetCallSite().GetColumn();
                 return true;
             }
             else
             {
                 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_SYMBOLS));
 

source/Target/StackFrame.cpp

if ((m_flags.Get() & resolve_scope) != resolve_scope)
                     m_sc.function = sc.function;
                 if ((resolved & eSymbolContextBlock)     && m_sc.block == nullptr)  
                     m_sc.block = sc.block;
                 if ((resolved & eSymbolContextSymbol)    && m_sc.symbol == nullptr)  
                     m_sc.symbol = sc.symbol;
                 if ((resolved & eSymbolContextLineEntry) && !m_sc.line_entry.IsValid())
                 {
                     m_sc.line_entry = sc.line_entry;
-                    if (m_sc.target_sp)
-                    {
-                        // Be sure to apply and file remappings to our file and line
-                        // entries when handing out a line entry
-                        FileSpec new_file_spec;
-                        if (m_sc.target_sp->GetSourcePathMap().FindFile (m_sc.line_entry.file, new_file_spec))
-                            m_sc.line_entry.file = new_file_spec;
-                    }
+                    m_sc.line_entry.ApplyFileMappings(m_sc.target_sp);
                 }
             }
         }
         else
         {
             // If we don't have a module, then we can't have the compile unit,
             // function, block, line entry or symbol, so we can safely call
             // ResolveSymbolContextForAddress with our symbol context member m_sc.

source/Target/StackFrameList.cpp

#endif
             }
             
             assert(unwind_frame_sp);
             SymbolContext unwind_sc = unwind_frame_sp->GetSymbolContext (eSymbolContextBlock | eSymbolContextFunction);
             Block *unwind_block = unwind_sc.block;
             if (unwind_block)
             {
                 Address curr_frame_address (unwind_frame_sp->GetFrameCodeAddress());
+                TargetSP target_sp = m_thread.CalculateTarget();
                 // Be sure to adjust the frame address to match the address
                 // that was used to lookup the symbol context above. If we are
                 // in the first concrete frame, then we lookup using the current
                 // address, else we decrement the address by one to get the correct
                 // location.
                 if (idx > 0)
                 {
                     if (curr_frame_address.GetOffset() == 0)
                     {
                         // If curr_frame_address points to the first address in a section then after
                         // adjustment it will point to an other section. In that case resolve the
                         // address again to the correct section plus offset form.
-                        TargetSP target = m_thread.CalculateTarget();
-                        addr_t load_addr = curr_frame_address.GetOpcodeLoadAddress(target.get(), eAddressClassCode);
-                        curr_frame_address.SetOpcodeLoadAddress(load_addr - 1, target.get(), eAddressClassCode);
+                        addr_t load_addr = curr_frame_address.GetOpcodeLoadAddress(target_sp.get(), eAddressClassCode);
+                        curr_frame_address.SetOpcodeLoadAddress(load_addr - 1, target_sp.get(), eAddressClassCode);
                     }
                     else
                     {
                         curr_frame_address.Slide(-1);
                     }
                 }
                     
                 SymbolContext next_frame_sc;
                 Address next_frame_address;
                 
                 while (unwind_sc.GetParentOfInlinedScope(curr_frame_address, next_frame_sc, next_frame_address))
                 {
-                        StackFrameSP frame_sp(new StackFrame (m_thread.shared_from_this(),
-                                                              m_frames.size(),
-                                                              idx,
-                                                              unwind_frame_sp->GetRegisterContextSP (),
-                                                              cfa,
-                                                              next_frame_address,
-                                                              &next_frame_sc));  
-                                                    
-                        m_frames.push_back (frame_sp);
-                        unwind_sc = next_frame_sc;
-                        curr_frame_address = next_frame_address;
+                    next_frame_sc.line_entry.ApplyFileMappings(target_sp);
+                    StackFrameSP frame_sp(new StackFrame(m_thread.shared_from_this(),
                 }
             }
         } while (m_frames.size() - 1 < end_idx);
 
         // Don't try to merge till you've calculated all the frames in this stack.
         if (GetAllFramesFetched() && m_prev_frames_sp)
         {
             StackFrameList *prev_frames = m_prev_frames_sp.get();

source/Target/ThreadPlanStepOverRange.cpp

else
 
             if (m_addr_context.line_entry.IsValid())
             {
                 SymbolContext sc;
                 StackFrameSP frame_sp = m_thread.GetStackFrameAtIndex(0);
                 sc = frame_sp->GetSymbolContext (eSymbolContextEverything);
                 if (sc.line_entry.IsValid())
                 {
-                    if (sc.line_entry.file != m_addr_context.line_entry.file
+                    if (sc.line_entry.original_file != m_addr_context.line_entry.original_file
                          && sc.comp_unit == m_addr_context.comp_unit
                          && sc.function == m_addr_context.function)
                     {
                         // Okay, find the next occurrence of this file in the line table:
                         LineTable *line_table = m_addr_context.comp_unit->GetLineTable();
                         if (line_table)
                         {
                             Address cur_address = frame_sp->GetFrameCodeAddress();
                             uint32_t entry_idx;
                             LineEntry line_entry;
                             if (line_table->FindLineEntryByAddress (cur_address, line_entry, &entry_idx))
                             {
                                 LineEntry next_line_entry;
                                 bool step_past_remaining_inline = false;
                                 if (entry_idx > 0)
                                 {
                                     // We require the previous line entry and the current line entry come
                                     // from the same file.
                                     // The other requirement is that the previous line table entry be part of an
                                     // inlined block, we don't want to step past cases where people have inlined
                                     // some code fragment by using #include <source-fragment.c> directly.
                                     LineEntry prev_line_entry;
                                     if (line_table->GetLineEntryAtIndex(entry_idx - 1, prev_line_entry)
-                                        && prev_line_entry.file == line_entry.file)
+                                        && prev_line_entry.original_file == line_entry.original_file)
                                     {
                                         SymbolContext prev_sc;
                                         Address prev_address = prev_line_entry.range.GetBaseAddress();
                                         prev_address.CalculateSymbolContext(&prev_sc);
                                         if (prev_sc.block)
                                         {
                                             Block *inlined_block = prev_sc.block->GetContainingInlinedBlock();
                                             if (inlined_block)
else
                                     while (line_table->GetLineEntryAtIndex(entry_idx + look_ahead_step, next_line_entry))
                                     {
                                         // Make sure we haven't wandered out of the function we started from...
                                         Address next_line_address = next_line_entry.range.GetBaseAddress();
                                         Function *next_line_function = next_line_address.CalculateSymbolContextFunction();
                                         if (next_line_function != m_addr_context.function)
                                             break;
                                         
-                                        if (next_line_entry.file == m_addr_context.line_entry.file)
+                                        if (next_line_entry.original_file == m_addr_context.line_entry.original_file)
                                         {
                                             const bool abort_other_plans = false;
                                             const RunMode stop_other_threads = RunMode::eAllThreads;
                                             lldb::addr_t cur_pc = m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
                                             AddressRange step_range(cur_pc, next_line_address.GetLoadAddress(&GetTarget()) - cur_pc);
                                             
                                             new_plan_sp = m_thread.QueueThreadPlanForStepOverRange (abort_other_plans,
                                                                                                     step_range,

source/Target/ThreadPlanStepRange.cpp

ThreadPlanStepRange::InRange ()
     if (!ret_value && !m_given_ranges_only)
     {
         // See if we've just stepped to another part of the same line number...
         StackFrame *frame = m_thread.GetStackFrameAtIndex(0).get();
         
         SymbolContext new_context(frame->GetSymbolContext(eSymbolContextEverything));
         if (m_addr_context.line_entry.IsValid() && new_context.line_entry.IsValid())
         {
-            if (m_addr_context.line_entry.file == new_context.line_entry.file)
+            if (m_addr_context.line_entry.original_file == new_context.line_entry.original_file)
             {
                 if (m_addr_context.line_entry.line == new_context.line_entry.line)
                 {
                     m_addr_context = new_context;
                     AddRange(m_addr_context.line_entry.GetSameLineContiguousAddressRange());
                     ret_value = true;
                     if (log)
                     {