1 | //===-- BreakpointResolverFileRegex.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/BreakpointResolverFileRegex.h" |
10 | |
11 | #include "lldb/Breakpoint/BreakpointLocation.h" |
12 | #include "lldb/Core/SourceManager.h" |
13 | #include "lldb/Symbol/CompileUnit.h" |
14 | #include "lldb/Target/Target.h" |
15 | #include "lldb/Utility/Log.h" |
16 | #include "lldb/Utility/StreamString.h" |
17 | |
18 | using namespace lldb; |
19 | using namespace lldb_private; |
20 | |
21 | // BreakpointResolverFileRegex: |
22 | BreakpointResolverFileRegex::BreakpointResolverFileRegex( |
23 | const lldb::BreakpointSP &bkpt, RegularExpression regex, |
24 | const std::unordered_set<std::string> &func_names, bool exact_match) |
25 | : BreakpointResolver(bkpt, BreakpointResolver::FileRegexResolver), |
26 | m_regex(std::move(regex)), m_exact_match(exact_match), |
27 | m_function_names(func_names) {} |
28 | |
29 | BreakpointResolverSP BreakpointResolverFileRegex::CreateFromStructuredData( |
30 | const StructuredData::Dictionary &options_dict, Status &error) { |
31 | bool success; |
32 | |
33 | llvm::StringRef regex_string; |
34 | success = options_dict.GetValueForKeyAsString( |
35 | key: GetKey(enum_value: OptionNames::RegexString), result&: regex_string); |
36 | if (!success) { |
37 | error = Status::FromErrorString(str: "BRFR::CFSD: Couldn't find regex entry." ); |
38 | return nullptr; |
39 | } |
40 | RegularExpression regex(regex_string); |
41 | |
42 | bool exact_match; |
43 | success = options_dict.GetValueForKeyAsBoolean( |
44 | key: GetKey(enum_value: OptionNames::ExactMatch), result&: exact_match); |
45 | if (!success) { |
46 | error = |
47 | Status::FromErrorString(str: "BRFL::CFSD: Couldn't find exact match entry." ); |
48 | return nullptr; |
49 | } |
50 | |
51 | // The names array is optional: |
52 | std::unordered_set<std::string> names_set; |
53 | StructuredData::Array *names_array; |
54 | success = options_dict.GetValueForKeyAsArray( |
55 | key: GetKey(enum_value: OptionNames::SymbolNameArray), result&: names_array); |
56 | if (success && names_array) { |
57 | size_t num_names = names_array->GetSize(); |
58 | for (size_t i = 0; i < num_names; i++) { |
59 | std::optional<llvm::StringRef> maybe_name = |
60 | names_array->GetItemAtIndexAsString(idx: i); |
61 | if (!maybe_name) { |
62 | error = Status::FromErrorStringWithFormatv( |
63 | format: "BRFR::CFSD: Malformed element {0} in the names array." , args&: i); |
64 | return nullptr; |
65 | } |
66 | names_set.insert(x: std::string(*maybe_name)); |
67 | } |
68 | } |
69 | |
70 | return std::make_shared<BreakpointResolverFileRegex>( |
71 | args: nullptr, args: std::move(regex), args&: names_set, args&: exact_match); |
72 | } |
73 | |
74 | StructuredData::ObjectSP |
75 | BreakpointResolverFileRegex::SerializeToStructuredData() { |
76 | StructuredData::DictionarySP options_dict_sp( |
77 | new StructuredData::Dictionary()); |
78 | |
79 | options_dict_sp->AddStringItem(key: GetKey(enum_value: OptionNames::RegexString), |
80 | value: m_regex.GetText()); |
81 | options_dict_sp->AddBooleanItem(key: GetKey(enum_value: OptionNames::ExactMatch), |
82 | value: m_exact_match); |
83 | if (!m_function_names.empty()) { |
84 | StructuredData::ArraySP names_array_sp(new StructuredData::Array()); |
85 | for (std::string name : m_function_names) { |
86 | StructuredData::StringSP item(new StructuredData::String(name)); |
87 | names_array_sp->AddItem(item); |
88 | } |
89 | options_dict_sp->AddItem(key: GetKey(enum_value: OptionNames::LineNumber), value_sp: names_array_sp); |
90 | } |
91 | |
92 | return WrapOptionsDict(options_dict_sp); |
93 | } |
94 | |
95 | Searcher::CallbackReturn BreakpointResolverFileRegex::SearchCallback( |
96 | SearchFilter &filter, SymbolContext &context, Address *addr) { |
97 | |
98 | if (!context.target_sp) |
99 | return eCallbackReturnContinue; |
100 | |
101 | CompileUnit *cu = context.comp_unit; |
102 | FileSpec cu_file_spec = cu->GetPrimaryFile(); |
103 | std::vector<uint32_t> line_matches; |
104 | context.target_sp->GetSourceManager().FindLinesMatchingRegex( |
105 | support_file_sp: std::make_shared<SupportFile>(args&: cu_file_spec), regex&: m_regex, start_line: 1, UINT32_MAX, |
106 | match_lines&: line_matches); |
107 | |
108 | uint32_t num_matches = line_matches.size(); |
109 | for (uint32_t i = 0; i < num_matches; i++) { |
110 | SymbolContextList sc_list; |
111 | // TODO: Handle SourceLocationSpec column information |
112 | SourceLocationSpec location_spec(cu_file_spec, line_matches[i], |
113 | /*column=*/std::nullopt, |
114 | /*check_inlines=*/false, m_exact_match); |
115 | cu->ResolveSymbolContext(src_location_spec: location_spec, resolve_scope: eSymbolContextEverything, sc_list); |
116 | // Find all the function names: |
117 | if (!m_function_names.empty()) { |
118 | std::vector<size_t> sc_to_remove; |
119 | for (size_t i = 0; i < sc_list.GetSize(); i++) { |
120 | SymbolContext sc_ctx; |
121 | sc_list.GetContextAtIndex(idx: i, sc&: sc_ctx); |
122 | std::string name( |
123 | sc_ctx |
124 | .GetFunctionName( |
125 | preference: Mangled::NamePreference::ePreferDemangledWithoutArguments) |
126 | .AsCString()); |
127 | if (!m_function_names.count(x: name)) { |
128 | sc_to_remove.push_back(x: i); |
129 | } |
130 | } |
131 | |
132 | if (!sc_to_remove.empty()) { |
133 | std::vector<size_t>::reverse_iterator iter; |
134 | std::vector<size_t>::reverse_iterator rend = sc_to_remove.rend(); |
135 | for (iter = sc_to_remove.rbegin(); iter != rend; iter++) { |
136 | sc_list.RemoveContextAtIndex(idx: *iter); |
137 | } |
138 | } |
139 | } |
140 | |
141 | const bool skip_prologue = true; |
142 | |
143 | BreakpointResolver::SetSCMatchesByLine(filter, sc_list, skip_prologue, |
144 | log_ident: m_regex.GetText()); |
145 | } |
146 | |
147 | return Searcher::eCallbackReturnContinue; |
148 | } |
149 | |
150 | lldb::SearchDepth BreakpointResolverFileRegex::GetDepth() { |
151 | return lldb::eSearchDepthCompUnit; |
152 | } |
153 | |
154 | void BreakpointResolverFileRegex::GetDescription(Stream *s) { |
155 | s->Printf(format: "source regex = \"%s\", exact_match = %d" , |
156 | m_regex.GetText().str().c_str(), m_exact_match); |
157 | } |
158 | |
159 | void BreakpointResolverFileRegex::Dump(Stream *s) const {} |
160 | |
161 | lldb::BreakpointResolverSP |
162 | BreakpointResolverFileRegex::CopyForBreakpoint(BreakpointSP &breakpoint) { |
163 | lldb::BreakpointResolverSP ret_sp(new BreakpointResolverFileRegex( |
164 | breakpoint, m_regex, m_function_names, m_exact_match)); |
165 | return ret_sp; |
166 | } |
167 | |
168 | void BreakpointResolverFileRegex::AddFunctionName(const char *func_name) { |
169 | m_function_names.insert(x: func_name); |
170 | } |
171 | |