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

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