lldb/source/Symbol/LineEntry.cpp

   1 //===-- LineEntry.cpp -----------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Symbol/LineEntry.h"
  10 #include "lldb/Symbol/CompileUnit.h"
  11 #include "lldb/Target/Process.h"
  12 #include "lldb/Target/Target.h"
  13
  14 using namespace lldb_private;
  15
  16 LineEntry::LineEntry()
  17     : range(), file_sp(std::make_shared<SupportFile>()),
  18       original_file_sp(std::make_shared<SupportFile>()),
  19       is_start_of_statement(0), is_start_of_basic_block(0), is_prologue_end(0),
  20       is_epilogue_begin(0), is_terminal_entry(0) {}
  21
  22 void LineEntry::Clear() {
  23   range.Clear();
  24   file_sp = std::make_shared<SupportFile>();
  25   original_file_sp = std::make_shared<SupportFile>();
  26   line = LLDB_INVALID_LINE_NUMBER;
  27   column = 0;
  28   is_start_of_statement = 0;
  29   is_start_of_basic_block = 0;
  30   is_prologue_end = 0;
  31   is_epilogue_begin = 0;
  32   is_terminal_entry = 0;
  33 }
  34
  35 bool LineEntry::IsValid() const {
  36   return range.GetBaseAddress().IsValid() && line != LLDB_INVALID_LINE_NUMBER;
  37 }
  38
  39 bool LineEntry::DumpStopContext(Stream *s, bool show_fullpaths) const {
  40   const FileSpec &file = file_sp->GetSpecOnly();
  41   if (file) {
  42     if (show_fullpaths)
  43       file.Dump(s->AsRawOstream());
  44     else
  45       file.GetFilename().Dump(s);
  46
  47     if (line)
  48       s->PutChar(':');
  49   }
  50   if (line) {
  51     s->Printf("%u", line);
  52     if (column) {
  53       s->PutChar(':');
  54       s->Printf("%u", column);
  55     }
  56   }
  57   return file || line;
  58 }
  59
  60 bool LineEntry::Dump(Stream *s, Target *target, bool show_file,
  61                      Address::DumpStyle style,
  62                      Address::DumpStyle fallback_style, bool show_range) const {
  63   if (show_range) {
  64     // Show address range
  65     if (!range.Dump(s, target, style, fallback_style))
  66       return false;
  67   } else {
  68     // Show address only
  69     if (!range.GetBaseAddress().Dump(s, target, style, fallback_style))
  70       return false;
  71   }
  72   if (show_file)
  73     *s << ", file = " << GetFile();
  74   if (line)
  75     s->Printf(", line = %u", line);
  76   if (column)
  77     s->Printf(", column = %u", column);
  78   if (is_start_of_statement)
  79     *s << ", is_start_of_statement = TRUE";
  80
  81   if (is_start_of_basic_block)
  82     *s << ", is_start_of_basic_block = TRUE";
  83
  84   if (is_prologue_end)
  85     *s << ", is_prologue_end = TRUE";
  86
  87   if (is_epilogue_begin)
  88     *s << ", is_epilogue_begin = TRUE";
  89
  90   if (is_terminal_entry)
  91     *s << ", is_terminal_entry = TRUE";
  92   return true;
  93 }
  94
  95 bool LineEntry::GetDescription(Stream *s, lldb::DescriptionLevel level,
  96                                CompileUnit *cu, Target *target,
  97                                bool show_address_only) const {
  98
  99   if (level == lldb::eDescriptionLevelBrief ||
 100       level == lldb::eDescriptionLevelFull) {
 101     if (show_address_only) {
 102       range.GetBaseAddress().Dump(s, target, Address::DumpStyleLoadAddress,
 103                                   Address::DumpStyleFileAddress);
 104     } else {
 105       range.Dump(s, target, Address::DumpStyleLoadAddress,
 106                  Address::DumpStyleFileAddress);
 107     }
 108
 109     *s << ": " << GetFile();
 110
 111     if (line) {
 112       s->Printf(":%u", line);
 113       if (column)
 114         s->Printf(":%u", column);
 115     }
 116
 117     if (level == lldb::eDescriptionLevelFull) {
 118       if (is_start_of_statement)
 119         *s << ", is_start_of_statement = TRUE";
 120
 121       if (is_start_of_basic_block)
 122         *s << ", is_start_of_basic_block = TRUE";
 123
 124       if (is_prologue_end)
 125         *s << ", is_prologue_end = TRUE";
 126
 127       if (is_epilogue_begin)
 128         *s << ", is_epilogue_begin = TRUE";
 129
 130       if (is_terminal_entry)
 131         *s << ", is_terminal_entry = TRUE";
 132     } else {
 133       if (is_terminal_entry)
 134         s->EOL();
 135     }
 136   } else {
 137     return Dump(s, target, true, Address::DumpStyleLoadAddress,
 138                 Address::DumpStyleModuleWithFileAddress, true);
 139   }
 140   return true;
 141 }
 142
 143 bool lldb_private::operator<(const LineEntry &a, const LineEntry &b) {
 144   return LineEntry::Compare(a, b) < 0;
 145 }
 146
 147 int LineEntry::Compare(const LineEntry &a, const LineEntry &b) {
 148   int result = Address::CompareFileAddress(a.range.GetBaseAddress(),
 149                                            b.range.GetBaseAddress());
 150   if (result != 0)
 151     return result;
 152
 153   const lldb::addr_t a_byte_size = a.range.GetByteSize();
 154   const lldb::addr_t b_byte_size = b.range.GetByteSize();
 155
 156   if (a_byte_size < b_byte_size)
 157     return -1;
 158   if (a_byte_size > b_byte_size)
 159     return +1;
 160
 161   // Check for an end sequence entry mismatch after we have determined that the
 162   // address values are equal. If one of the items is an end sequence, we don't
 163   // care about the line, file, or column info.
 164   if (a.is_terminal_entry > b.is_terminal_entry)
 165     return -1;
 166   if (a.is_terminal_entry < b.is_terminal_entry)
 167     return +1;
 168
 169   if (a.line < b.line)
 170     return -1;
 171   if (a.line > b.line)
 172     return +1;
 173
 174   if (a.column < b.column)
 175     return -1;
 176   if (a.column > b.column)
 177     return +1;
 178
 179   return FileSpec::Compare(a.GetFile(), b.GetFile(), true);
 180 }
 181
 182 AddressRange LineEntry::GetSameLineContiguousAddressRange(
 183     bool include_inlined_functions) const {
 184   // Add each LineEntry's range to complete_line_range until we find a
 185   // different file / line number.
 186   AddressRange complete_line_range = range;
 187   auto symbol_context_scope = lldb::eSymbolContextLineEntry;
 188   Declaration start_call_site(original_file_sp->GetSpecOnly(), line);
 189   if (include_inlined_functions)
 190     symbol_context_scope |= lldb::eSymbolContextBlock;
 191
 192   while (true) {
 193     SymbolContext next_line_sc;
 194     Address range_end(complete_line_range.GetBaseAddress());
 195     range_end.Slide(complete_line_range.GetByteSize());
 196     range_end.CalculateSymbolContext(&next_line_sc, symbol_context_scope);
 197
 198     if (!next_line_sc.line_entry.IsValid() ||
 199         next_line_sc.line_entry.range.GetByteSize() == 0)
 200       break;
 201
 202     if (original_file_sp->Equal(*next_line_sc.line_entry.original_file_sp,
 203                                 SupportFile::eEqualFileSpecAndChecksumIfSet) &&
 204         (next_line_sc.line_entry.line == 0 ||
 205          line == next_line_sc.line_entry.line)) {
 206       // Include any line 0 entries - they indicate that this is compiler-
 207       // generated code that does not correspond to user source code.
 208       // next_line_sc is the same file & line as this LineEntry, so extend
 209       // our AddressRange by its size and continue to see if there are more
 210       // LineEntries that we can combine. However, if there was nothing to
 211       // extend we're done.
 212       if (!complete_line_range.Extend(next_line_sc.line_entry.range))
 213         break;
 214       continue;
 215     }
 216
 217     if (include_inlined_functions && next_line_sc.block &&
 218         next_line_sc.block->GetContainingInlinedBlock() != nullptr) {
 219       // The next_line_sc might be in a different file if it's an inlined
 220       // function. If this is the case then we still want to expand our line
 221       // range to include them if the inlined function is at the same call site
 222       // as this line entry. The current block could represent a nested inline
 223       // function call so we need to need to check up the block tree to see if
 224       // we find one.
 225       auto inlined_parent_block =
 226           next_line_sc.block->GetContainingInlinedBlockWithCallSite(
 227               start_call_site);
 228       if (!inlined_parent_block)
 229         // We didn't find any parent inlined block with a call site at this line
 230         // entry so this inlined function is probably at another line.
 231         break;
 232       // Extend our AddressRange by the size of the inlined block, but if there
 233       // was nothing to add then we're done.
 234       if (!complete_line_range.Extend(next_line_sc.line_entry.range))
 235         break;
 236       continue;
 237     }
 238
 239     break;
 240   }
 241   return complete_line_range;
 242 }
 243
 244 void LineEntry::ApplyFileMappings(lldb::TargetSP target_sp) {
 245   if (target_sp) {
 246     // Apply any file remappings to our file.
 247     if (auto new_file_spec = target_sp->GetSourcePathMap().FindFile(
 248             original_file_sp->GetSpecOnly())) {
 249       file_sp = std::make_shared<SupportFile>(*new_file_spec,
 250                                               original_file_sp->GetChecksum());
 251     }
 252   }
 253 }