1//===-- BreakpointResolverFileLine.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/Breakpoint/BreakpointResolverFileLine.h"
10
11#include "lldb/Breakpoint/BreakpointLocation.h"
12#include "lldb/Core/Module.h"
13#include "lldb/Symbol/CompileUnit.h"
14#include "lldb/Symbol/Function.h"
15#include "lldb/Target/Target.h"
16#include "lldb/Utility/LLDBLog.h"
17#include "lldb/Utility/Log.h"
18#include "lldb/Utility/RealpathPrefixes.h"
19#include "lldb/Utility/StreamString.h"
20#include <optional>
21
22using namespace lldb;
23using namespace lldb_private;
24
25// BreakpointResolverFileLine:
26BreakpointResolverFileLine::BreakpointResolverFileLine(
27 const BreakpointSP &bkpt, lldb::addr_t offset, bool skip_prologue,
28 const SourceLocationSpec &location_spec,
29 std::optional<llvm::StringRef> removed_prefix_opt)
30 : BreakpointResolver(bkpt, BreakpointResolver::FileLineResolver, offset),
31 m_location_spec(location_spec), m_skip_prologue(skip_prologue),
32 m_removed_prefix_opt(removed_prefix_opt) {}
33
34BreakpointResolverSP BreakpointResolverFileLine::CreateFromStructuredData(
35 const StructuredData::Dictionary &options_dict, Status &error) {
36 llvm::StringRef filename;
37 uint32_t line;
38 uint16_t column;
39 bool check_inlines;
40 bool skip_prologue;
41 bool exact_match;
42 bool success;
43
44 lldb::addr_t offset = 0;
45
46 success = options_dict.GetValueForKeyAsString(key: GetKey(enum_value: OptionNames::FileName),
47 result&: filename);
48 if (!success) {
49 error =
50 Status::FromErrorString(str: "BRFL::CFSD: Couldn't find filename entry.");
51 return nullptr;
52 }
53
54 success = options_dict.GetValueForKeyAsInteger(
55 key: GetKey(enum_value: OptionNames::LineNumber), result&: line);
56 if (!success) {
57 error =
58 Status::FromErrorString(str: "BRFL::CFSD: Couldn't find line number entry.");
59 return nullptr;
60 }
61
62 success =
63 options_dict.GetValueForKeyAsInteger(key: GetKey(enum_value: OptionNames::Column), result&: column);
64 if (!success) {
65 // Backwards compatibility.
66 column = 0;
67 }
68
69 success = options_dict.GetValueForKeyAsBoolean(key: GetKey(enum_value: OptionNames::Inlines),
70 result&: check_inlines);
71 if (!success) {
72 error = Status::FromErrorString(
73 str: "BRFL::CFSD: Couldn't find check inlines entry.");
74 return nullptr;
75 }
76
77 success = options_dict.GetValueForKeyAsBoolean(
78 key: GetKey(enum_value: OptionNames::SkipPrologue), result&: skip_prologue);
79 if (!success) {
80 error = Status::FromErrorString(
81 str: "BRFL::CFSD: Couldn't find skip prologue entry.");
82 return nullptr;
83 }
84
85 success = options_dict.GetValueForKeyAsBoolean(
86 key: GetKey(enum_value: OptionNames::ExactMatch), result&: exact_match);
87 if (!success) {
88 error =
89 Status::FromErrorString(str: "BRFL::CFSD: Couldn't find exact match entry.");
90 return nullptr;
91 }
92
93 SourceLocationSpec location_spec(FileSpec(filename), line, column,
94 check_inlines, exact_match);
95 if (!location_spec)
96 return nullptr;
97
98 return std::make_shared<BreakpointResolverFileLine>(
99 args: nullptr, args&: offset, args&: skip_prologue, args&: location_spec);
100}
101
102StructuredData::ObjectSP
103BreakpointResolverFileLine::SerializeToStructuredData() {
104 StructuredData::DictionarySP options_dict_sp(
105 new StructuredData::Dictionary());
106
107 options_dict_sp->AddBooleanItem(key: GetKey(enum_value: OptionNames::SkipPrologue),
108 value: m_skip_prologue);
109 options_dict_sp->AddStringItem(key: GetKey(enum_value: OptionNames::FileName),
110 value: m_location_spec.GetFileSpec().GetPath());
111 options_dict_sp->AddIntegerItem(key: GetKey(enum_value: OptionNames::LineNumber),
112 value: m_location_spec.GetLine().value_or(u: 0));
113 options_dict_sp->AddIntegerItem(
114 key: GetKey(enum_value: OptionNames::Column),
115 value: m_location_spec.GetColumn().value_or(LLDB_INVALID_COLUMN_NUMBER));
116 options_dict_sp->AddBooleanItem(key: GetKey(enum_value: OptionNames::Inlines),
117 value: m_location_spec.GetCheckInlines());
118 options_dict_sp->AddBooleanItem(key: GetKey(enum_value: OptionNames::ExactMatch),
119 value: m_location_spec.GetExactMatch());
120
121 return WrapOptionsDict(options_dict_sp);
122}
123
124// Filter the symbol context list to remove contexts where the line number was
125// moved into a new function. We do this conservatively, so if e.g. we cannot
126// resolve the function in the context (which can happen in case of line-table-
127// only debug info), we leave the context as is. The trickiest part here is
128// handling inlined functions -- in this case we need to make sure we look at
129// the declaration line of the inlined function, NOT the function it was
130// inlined into.
131void BreakpointResolverFileLine::FilterContexts(SymbolContextList &sc_list) {
132 if (m_location_spec.GetExactMatch())
133 return; // Nothing to do. Contexts are precise.
134
135 Log *log = GetLog(mask: LLDBLog::Breakpoints);
136 for(uint32_t i = 0; i < sc_list.GetSize(); ++i) {
137 SymbolContext sc;
138 sc_list.GetContextAtIndex(idx: i, sc);
139 if (!sc.block)
140 continue;
141
142 SupportFileSP file_sp;
143 uint32_t line;
144 const Block *inline_block = sc.block->GetContainingInlinedBlock();
145 if (inline_block) {
146 const Declaration &inline_declaration = inline_block->GetInlinedFunctionInfo()->GetDeclaration();
147 if (!inline_declaration.IsValid())
148 continue;
149 file_sp = std::make_shared<SupportFile>(args: inline_declaration.GetFile());
150 line = inline_declaration.GetLine();
151 } else if (sc.function)
152 sc.function->GetStartLineSourceInfo(source_file_sp&: file_sp, line_no&: line);
153 else
154 continue;
155
156 if (!file_sp ||
157 !file_sp->Equal(other: *sc.line_entry.file_sp,
158 equality: SupportFile::eEqualFileSpecAndChecksumIfSet)) {
159 LLDB_LOG(log, "unexpected symbol context file {0}",
160 sc.line_entry.GetFile());
161 continue;
162 }
163
164 // Compare the requested line number with the line of the function
165 // declaration. In case of a function declared as:
166 //
167 // int
168 // foo()
169 // {
170 // ...
171 //
172 // the compiler will set the declaration line to the "foo" line, which is
173 // the reason why we have -1 here. This can fail in case of two inline
174 // functions defined back-to-back:
175 //
176 // inline int foo1() { ... }
177 // inline int foo2() { ... }
178 //
179 // but that's the best we can do for now.
180 // One complication, if the line number returned from GetStartLineSourceInfo
181 // is 0, then we can't do this calculation. That can happen if
182 // GetStartLineSourceInfo gets an error, or if the first line number in
183 // the function really is 0 - which happens for some languages.
184
185 // But only do this calculation if the line number we found in the SC
186 // was different from the one requested in the source file. If we actually
187 // found an exact match it must be valid.
188
189 if (m_location_spec.GetLine() == sc.line_entry.line)
190 continue;
191
192 const int decl_line_is_too_late_fudge = 1;
193 if (line &&
194 m_location_spec.GetLine() < line - decl_line_is_too_late_fudge) {
195 LLDB_LOG(log, "removing symbol context at {0}:{1}",
196 file_sp->GetSpecOnly(), line);
197 sc_list.RemoveContextAtIndex(idx: i);
198 --i;
199 }
200 }
201}
202
203void BreakpointResolverFileLine::DeduceSourceMapping(
204 const SymbolContextList &sc_list) {
205 Target &target = GetBreakpoint()->GetTarget();
206 if (!target.GetAutoSourceMapRelative())
207 return;
208
209 Log *log = GetLog(mask: LLDBLog::Breakpoints);
210 // Check if "b" is a suffix of "a".
211 // And return std::nullopt if not or the new path
212 // of "a" after consuming "b" from the back.
213 auto check_suffix =
214 [](llvm::StringRef a, llvm::StringRef b,
215 bool case_sensitive) -> std::optional<llvm::StringRef> {
216 if (case_sensitive ? a.consume_back(Suffix: b) : a.consume_back_insensitive(Suffix: b)) {
217 // Note sc_file_dir and request_file_dir below are normalized
218 // and always contain the path separator '/'.
219 if (a.empty() || a.ends_with(Suffix: "/")) {
220 return a;
221 }
222 }
223 return std::nullopt;
224 };
225
226 FileSpec request_file = m_location_spec.GetFileSpec();
227
228 // Only auto deduce source map if breakpoint is full path.
229 // Note: an existing source map reverse mapping (m_removed_prefix_opt has
230 // value) may make request_file relative.
231 if (!m_removed_prefix_opt.has_value() && request_file.IsRelative())
232 return;
233
234 const bool case_sensitive = request_file.IsCaseSensitive();
235 for (const SymbolContext &sc : sc_list) {
236 FileSpec sc_file = sc.line_entry.GetFile();
237
238 if (FileSpec::Equal(a: sc_file, b: request_file, /*full*/ true))
239 continue;
240
241 llvm::StringRef sc_file_dir = sc_file.GetDirectory().GetStringRef();
242 llvm::StringRef request_file_dir =
243 request_file.GetDirectory().GetStringRef();
244
245 llvm::StringRef new_mapping_from;
246 llvm::SmallString<256> new_mapping_to;
247
248 // Adding back any potentially reverse mapping stripped prefix.
249 // for new_mapping_to.
250 if (m_removed_prefix_opt.has_value())
251 llvm::sys::path::append(path&: new_mapping_to, a: *m_removed_prefix_opt);
252
253 std::optional<llvm::StringRef> new_mapping_from_opt =
254 check_suffix(sc_file_dir, request_file_dir, case_sensitive);
255 if (new_mapping_from_opt) {
256 new_mapping_from = *new_mapping_from_opt;
257 if (new_mapping_to.empty())
258 new_mapping_to = ".";
259 } else {
260 std::optional<llvm::StringRef> new_mapping_to_opt =
261 check_suffix(request_file_dir, sc_file_dir, case_sensitive);
262 if (new_mapping_to_opt) {
263 new_mapping_from = ".";
264 llvm::sys::path::append(path&: new_mapping_to, a: *new_mapping_to_opt);
265 }
266 }
267
268 if (!new_mapping_from.empty() && !new_mapping_to.empty()) {
269 LLDB_LOG(log, "generating auto source map from {0} to {1}",
270 new_mapping_from, new_mapping_to);
271 if (target.GetSourcePathMap().AppendUnique(path: new_mapping_from,
272 replacement: new_mapping_to,
273 /*notify*/ true))
274 target.GetStatistics().IncreaseSourceMapDeduceCount();
275 }
276 }
277}
278
279Searcher::CallbackReturn BreakpointResolverFileLine::SearchCallback(
280 SearchFilter &filter, SymbolContext &context, Address *addr) {
281 SymbolContextList sc_list;
282
283 // There is a tricky bit here. You can have two compilation units that
284 // #include the same file, and in one of them the function at m_line_number
285 // is used (and so code and a line entry for it is generated) but in the
286 // other it isn't. If we considered the CU's independently, then in the
287 // second inclusion, we'd move the breakpoint to the next function that
288 // actually generated code in the header file. That would end up being
289 // confusing. So instead, we do the CU iterations by hand here, then scan
290 // through the complete list of matches, and figure out the closest line
291 // number match, and only set breakpoints on that match.
292
293 // Note also that if file_spec only had a file name and not a directory,
294 // there may be many different file spec's in the resultant list. The
295 // closest line match for one will not be right for some totally different
296 // file. So we go through the match list and pull out the sets that have the
297 // same file spec in their line_entry and treat each set separately.
298
299 const uint32_t line = m_location_spec.GetLine().value_or(u: 0);
300 const std::optional<uint16_t> column = m_location_spec.GetColumn();
301
302 Target &target = GetBreakpoint()->GetTarget();
303 RealpathPrefixes realpath_prefixes = target.GetSourceRealpathPrefixes();
304
305 const size_t num_comp_units = context.module_sp->GetNumCompileUnits();
306 for (size_t i = 0; i < num_comp_units; i++) {
307 CompUnitSP cu_sp(context.module_sp->GetCompileUnitAtIndex(idx: i));
308 if (cu_sp) {
309 if (filter.CompUnitPasses(compUnit&: *cu_sp))
310 cu_sp->ResolveSymbolContext(src_location_spec: m_location_spec, resolve_scope: eSymbolContextEverything,
311 sc_list, realpath_prefixes: &realpath_prefixes);
312 }
313 }
314
315 // Gather stats into the Target
316 target.GetStatistics().IncreaseSourceRealpathAttemptCount(
317 count: realpath_prefixes.GetSourceRealpathAttemptCount());
318 target.GetStatistics().IncreaseSourceRealpathCompatibleCount(
319 count: realpath_prefixes.GetSourceRealpathCompatibleCount());
320
321 FilterContexts(sc_list);
322
323 DeduceSourceMapping(sc_list);
324
325 StreamString s;
326 s.Printf(format: "for %s:%d ",
327 m_location_spec.GetFileSpec().GetFilename().AsCString(value_if_empty: "<Unknown>"),
328 line);
329
330 SetSCMatchesByLine(filter, sc_list, skip_prologue: m_skip_prologue, log_ident: s.GetString(), line,
331 column);
332
333 return Searcher::eCallbackReturnContinue;
334}
335
336lldb::SearchDepth BreakpointResolverFileLine::GetDepth() {
337 return lldb::eSearchDepthModule;
338}
339
340void BreakpointResolverFileLine::GetDescription(Stream *s) {
341 s->Printf(format: "file = '%s', line = %u, ",
342 m_location_spec.GetFileSpec().GetPath().c_str(),
343 m_location_spec.GetLine().value_or(u: 0));
344 auto column = m_location_spec.GetColumn();
345 if (column)
346 s->Printf(format: "column = %u, ", *column);
347 s->Printf(format: "exact_match = %d", m_location_spec.GetExactMatch());
348}
349
350void BreakpointResolverFileLine::Dump(Stream *s) const {}
351
352lldb::BreakpointResolverSP
353BreakpointResolverFileLine::CopyForBreakpoint(BreakpointSP &breakpoint) {
354 lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileLine(
355 breakpoint, GetOffset(), m_skip_prologue, m_location_spec));
356
357 return ret_sp;
358}
359

source code of lldb/source/Breakpoint/BreakpointResolverFileLine.cpp