You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
262 lines
8.5 KiB
262 lines
8.5 KiB
//===-- LineEntry.cpp -----------------------------------------------------===//
|
|
//
|
|
// 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
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Symbol/LineEntry.h"
|
|
#include "lldb/Symbol/CompileUnit.h"
|
|
#include "lldb/Target/Process.h"
|
|
#include "lldb/Target/Target.h"
|
|
|
|
using namespace lldb_private;
|
|
|
|
LineEntry::LineEntry()
|
|
: range(), file(), 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::LineEntry(const lldb::SectionSP §ion_sp,
|
|
lldb::addr_t section_offset, lldb::addr_t byte_size,
|
|
const FileSpec &_file, uint32_t _line, uint16_t _column,
|
|
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;
|
|
}
|
|
|
|
bool LineEntry::IsValid() const {
|
|
return range.GetBaseAddress().IsValid() && line != LLDB_INVALID_LINE_NUMBER;
|
|
}
|
|
|
|
bool LineEntry::DumpStopContext(Stream *s, bool show_fullpaths) const {
|
|
if (file) {
|
|
if (show_fullpaths)
|
|
file.Dump(s->AsRawOstream());
|
|
else
|
|
file.GetFilename().Dump(s);
|
|
|
|
if (line)
|
|
s->PutChar(':');
|
|
}
|
|
if (line) {
|
|
s->Printf("%u", line);
|
|
if (column) {
|
|
s->PutChar(':');
|
|
s->Printf("%u", column);
|
|
}
|
|
}
|
|
return file || line;
|
|
}
|
|
|
|
bool LineEntry::Dump(Stream *s, Target *target, bool show_file,
|
|
Address::DumpStyle style,
|
|
Address::DumpStyle fallback_style, bool show_range) const {
|
|
if (show_range) {
|
|
// Show address range
|
|
if (!range.Dump(s, target, style, fallback_style))
|
|
return false;
|
|
} else {
|
|
// Show address only
|
|
if (!range.GetBaseAddress().Dump(s, target, style, fallback_style))
|
|
return false;
|
|
}
|
|
if (show_file)
|
|
*s << ", file = " << file;
|
|
if (line)
|
|
s->Printf(", line = %u", line);
|
|
if (column)
|
|
s->Printf(", column = %u", column);
|
|
if (is_start_of_statement)
|
|
*s << ", is_start_of_statement = TRUE";
|
|
|
|
if (is_start_of_basic_block)
|
|
*s << ", is_start_of_basic_block = TRUE";
|
|
|
|
if (is_prologue_end)
|
|
*s << ", is_prologue_end = TRUE";
|
|
|
|
if (is_epilogue_begin)
|
|
*s << ", is_epilogue_begin = TRUE";
|
|
|
|
if (is_terminal_entry)
|
|
*s << ", is_terminal_entry = TRUE";
|
|
return true;
|
|
}
|
|
|
|
bool LineEntry::GetDescription(Stream *s, lldb::DescriptionLevel level,
|
|
CompileUnit *cu, Target *target,
|
|
bool show_address_only) const {
|
|
|
|
if (level == lldb::eDescriptionLevelBrief ||
|
|
level == lldb::eDescriptionLevelFull) {
|
|
if (show_address_only) {
|
|
range.GetBaseAddress().Dump(s, target, Address::DumpStyleLoadAddress,
|
|
Address::DumpStyleFileAddress);
|
|
} else {
|
|
range.Dump(s, target, Address::DumpStyleLoadAddress,
|
|
Address::DumpStyleFileAddress);
|
|
}
|
|
|
|
*s << ": " << file;
|
|
|
|
if (line) {
|
|
s->Printf(":%u", line);
|
|
if (column)
|
|
s->Printf(":%u", column);
|
|
}
|
|
|
|
if (level == lldb::eDescriptionLevelFull) {
|
|
if (is_start_of_statement)
|
|
*s << ", is_start_of_statement = TRUE";
|
|
|
|
if (is_start_of_basic_block)
|
|
*s << ", is_start_of_basic_block = TRUE";
|
|
|
|
if (is_prologue_end)
|
|
*s << ", is_prologue_end = TRUE";
|
|
|
|
if (is_epilogue_begin)
|
|
*s << ", is_epilogue_begin = TRUE";
|
|
|
|
if (is_terminal_entry)
|
|
*s << ", is_terminal_entry = TRUE";
|
|
} else {
|
|
if (is_terminal_entry)
|
|
s->EOL();
|
|
}
|
|
} else {
|
|
return Dump(s, target, true, Address::DumpStyleLoadAddress,
|
|
Address::DumpStyleModuleWithFileAddress, true);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool lldb_private::operator<(const LineEntry &a, const LineEntry &b) {
|
|
return LineEntry::Compare(a, b) < 0;
|
|
}
|
|
|
|
int LineEntry::Compare(const LineEntry &a, const LineEntry &b) {
|
|
int result = Address::CompareFileAddress(a.range.GetBaseAddress(),
|
|
b.range.GetBaseAddress());
|
|
if (result != 0)
|
|
return result;
|
|
|
|
const lldb::addr_t a_byte_size = a.range.GetByteSize();
|
|
const lldb::addr_t b_byte_size = b.range.GetByteSize();
|
|
|
|
if (a_byte_size < b_byte_size)
|
|
return -1;
|
|
if (a_byte_size > b_byte_size)
|
|
return +1;
|
|
|
|
// Check for an end sequence entry mismatch after we have determined that the
|
|
// address values are equal. If one of the items is an end sequence, we don't
|
|
// care about the line, file, or column info.
|
|
if (a.is_terminal_entry > b.is_terminal_entry)
|
|
return -1;
|
|
if (a.is_terminal_entry < b.is_terminal_entry)
|
|
return +1;
|
|
|
|
if (a.line < b.line)
|
|
return -1;
|
|
if (a.line > b.line)
|
|
return +1;
|
|
|
|
if (a.column < b.column)
|
|
return -1;
|
|
if (a.column > b.column)
|
|
return +1;
|
|
|
|
return FileSpec::Compare(a.file, b.file, true);
|
|
}
|
|
|
|
AddressRange LineEntry::GetSameLineContiguousAddressRange(
|
|
bool include_inlined_functions) const {
|
|
// Add each LineEntry's range to complete_line_range until we find a
|
|
// different file / line number.
|
|
AddressRange complete_line_range = range;
|
|
auto symbol_context_scope = lldb::eSymbolContextLineEntry;
|
|
Declaration start_call_site(original_file, line);
|
|
if (include_inlined_functions)
|
|
symbol_context_scope |= lldb::eSymbolContextBlock;
|
|
|
|
while (true) {
|
|
SymbolContext next_line_sc;
|
|
Address range_end(complete_line_range.GetBaseAddress());
|
|
range_end.Slide(complete_line_range.GetByteSize());
|
|
range_end.CalculateSymbolContext(&next_line_sc, symbol_context_scope);
|
|
|
|
if (!next_line_sc.line_entry.IsValid() ||
|
|
next_line_sc.line_entry.range.GetByteSize() == 0)
|
|
break;
|
|
|
|
if (original_file == next_line_sc.line_entry.original_file &&
|
|
(next_line_sc.line_entry.line == 0 ||
|
|
line == next_line_sc.line_entry.line)) {
|
|
// Include any line 0 entries - they indicate that this is compiler-
|
|
// generated code that does not correspond to user source code.
|
|
// 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. However, if there was nothing to
|
|
// extend we're done.
|
|
if (!complete_line_range.Extend(next_line_sc.line_entry.range))
|
|
break;
|
|
continue;
|
|
}
|
|
|
|
if (include_inlined_functions && next_line_sc.block &&
|
|
next_line_sc.block->GetContainingInlinedBlock() != nullptr) {
|
|
// The next_line_sc might be in a different file if it's an inlined
|
|
// function. If this is the case then we still want to expand our line
|
|
// range to include them if the inlined function is at the same call site
|
|
// as this line entry. The current block could represent a nested inline
|
|
// function call so we need to need to check up the block tree to see if
|
|
// we find one.
|
|
auto inlined_parent_block =
|
|
next_line_sc.block->GetContainingInlinedBlockWithCallSite(
|
|
start_call_site);
|
|
if (!inlined_parent_block)
|
|
// We didn't find any parent inlined block with a call site at this line
|
|
// entry so this inlined function is probably at another line.
|
|
break;
|
|
// Extend our AddressRange by the size of the inlined block, but if there
|
|
// was nothing to add then we're done.
|
|
if (!complete_line_range.Extend(next_line_sc.line_entry.range))
|
|
break;
|
|
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;
|
|
}
|
|
}
|