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 | |
21 | using namespace lldb; |
22 | using namespace lldb_private; |
23 | |
24 | // BreakpointResolverFileLine: |
25 | BreakpointResolverFileLine::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 | |
33 | BreakpointResolverSP 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 | |
96 | StructuredData::ObjectSP |
97 | BreakpointResolverFileLine::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. |
125 | void 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 | |
193 | void 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 | |
269 | Searcher::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 | |
317 | lldb::SearchDepth BreakpointResolverFileLine::GetDepth() { |
318 | return lldb::eSearchDepthModule; |
319 | } |
320 | |
321 | void 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 | |
331 | void BreakpointResolverFileLine::Dump(Stream *s) const {} |
332 | |
333 | lldb::BreakpointResolverSP |
334 | BreakpointResolverFileLine::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 | |