1 | //===-- ClangExpressionSourceCode.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 "ClangExpressionSourceCode.h" |
10 | |
11 | #include "ClangExpressionUtil.h" |
12 | |
13 | #include "clang/Basic/CharInfo.h" |
14 | #include "clang/Basic/FileManager.h" |
15 | #include "clang/Basic/SourceManager.h" |
16 | #include "clang/Lex/Lexer.h" |
17 | #include "llvm/ADT/ScopeExit.h" |
18 | #include "llvm/ADT/StringRef.h" |
19 | |
20 | #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h" |
21 | #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h" |
22 | #include "lldb/Symbol/Block.h" |
23 | #include "lldb/Symbol/CompileUnit.h" |
24 | #include "lldb/Symbol/DebugMacros.h" |
25 | #include "lldb/Symbol/TypeSystem.h" |
26 | #include "lldb/Symbol/VariableList.h" |
27 | #include "lldb/Target/ExecutionContext.h" |
28 | #include "lldb/Target/Language.h" |
29 | #include "lldb/Target/Platform.h" |
30 | #include "lldb/Target/StackFrame.h" |
31 | #include "lldb/Target/Target.h" |
32 | #include "lldb/Utility/StreamString.h" |
33 | #include "lldb/lldb-forward.h" |
34 | |
35 | using namespace lldb_private; |
36 | |
37 | #define PREFIX_NAME "<lldb wrapper prefix>" |
38 | #define SUFFIX_NAME "<lldb wrapper suffix>" |
39 | |
40 | const llvm::StringRef ClangExpressionSourceCode::g_prefix_file_name = PREFIX_NAME; |
41 | |
42 | const char *ClangExpressionSourceCode::g_expression_prefix = |
43 | "#line 1 \"" PREFIX_NAME R"(" |
44 | #ifndef offsetof |
45 | #define offsetof(t, d) __builtin_offsetof(t, d) |
46 | #endif |
47 | #ifndef NULL |
48 | #define NULL (__null) |
49 | #endif |
50 | #ifndef Nil |
51 | #define Nil (__null) |
52 | #endif |
53 | #ifndef nil |
54 | #define nil (__null) |
55 | #endif |
56 | #ifndef YES |
57 | #define YES ((BOOL)1) |
58 | #endif |
59 | #ifndef NO |
60 | #define NO ((BOOL)0) |
61 | #endif |
62 | typedef __INT8_TYPE__ int8_t; |
63 | typedef __UINT8_TYPE__ uint8_t; |
64 | typedef __INT16_TYPE__ int16_t; |
65 | typedef __UINT16_TYPE__ uint16_t; |
66 | typedef __INT32_TYPE__ int32_t; |
67 | typedef __UINT32_TYPE__ uint32_t; |
68 | typedef __INT64_TYPE__ int64_t; |
69 | typedef __UINT64_TYPE__ uint64_t; |
70 | typedef __INTPTR_TYPE__ intptr_t; |
71 | typedef __UINTPTR_TYPE__ uintptr_t; |
72 | typedef __SIZE_TYPE__ size_t; |
73 | typedef __PTRDIFF_TYPE__ ptrdiff_t; |
74 | typedef unsigned short unichar; |
75 | extern "C" |
76 | { |
77 | int printf(const char * __restrict, ...); |
78 | } |
79 | )" ; |
80 | |
81 | const char *ClangExpressionSourceCode::g_expression_suffix = |
82 | "\n;\n#line 1 \"" SUFFIX_NAME "\"\n" ; |
83 | |
84 | namespace { |
85 | |
86 | class AddMacroState { |
87 | enum State { |
88 | CURRENT_FILE_NOT_YET_PUSHED, |
89 | CURRENT_FILE_PUSHED, |
90 | CURRENT_FILE_POPPED |
91 | }; |
92 | |
93 | public: |
94 | AddMacroState(const FileSpec ¤t_file, const uint32_t current_file_line) |
95 | : m_current_file(current_file), m_current_file_line(current_file_line) {} |
96 | |
97 | void StartFile(const FileSpec &file) { |
98 | m_file_stack.push_back(x: file); |
99 | if (file == m_current_file) |
100 | m_state = CURRENT_FILE_PUSHED; |
101 | } |
102 | |
103 | void EndFile() { |
104 | if (m_file_stack.size() == 0) |
105 | return; |
106 | |
107 | FileSpec old_top = m_file_stack.back(); |
108 | m_file_stack.pop_back(); |
109 | if (old_top == m_current_file) |
110 | m_state = CURRENT_FILE_POPPED; |
111 | } |
112 | |
113 | // An entry is valid if it occurs before the current line in the current |
114 | // file. |
115 | bool IsValidEntry(uint32_t line) { |
116 | switch (m_state) { |
117 | case CURRENT_FILE_NOT_YET_PUSHED: |
118 | return true; |
119 | case CURRENT_FILE_PUSHED: |
120 | // If we are in file included in the current file, the entry should be |
121 | // added. |
122 | if (m_file_stack.back() != m_current_file) |
123 | return true; |
124 | |
125 | return line < m_current_file_line; |
126 | default: |
127 | return false; |
128 | } |
129 | } |
130 | |
131 | private: |
132 | std::vector<FileSpec> m_file_stack; |
133 | State m_state = CURRENT_FILE_NOT_YET_PUSHED; |
134 | FileSpec m_current_file; |
135 | uint32_t m_current_file_line; |
136 | }; |
137 | |
138 | } // anonymous namespace |
139 | |
140 | static void AddMacros(const DebugMacros *dm, CompileUnit *comp_unit, |
141 | AddMacroState &state, StreamString &stream) { |
142 | if (dm == nullptr) |
143 | return; |
144 | |
145 | // The macros directives below can potentially redefine builtin macros of the |
146 | // Clang instance which parses the user expression. The Clang diagnostics |
147 | // caused by this are not useful for the user as the source code here is |
148 | // generated by LLDB. |
149 | stream << "#pragma clang diagnostic push\n" ; |
150 | stream << "#pragma clang diagnostic ignored \"-Wmacro-redefined\"\n" ; |
151 | stream << "#pragma clang diagnostic ignored \"-Wbuiltin-macro-redefined\"\n" ; |
152 | auto pop_warning = llvm::make_scope_exit(F: [&stream](){ |
153 | stream << "#pragma clang diagnostic pop\n" ; |
154 | }); |
155 | |
156 | for (size_t i = 0; i < dm->GetNumMacroEntries(); i++) { |
157 | const DebugMacroEntry &entry = dm->GetMacroEntryAtIndex(index: i); |
158 | uint32_t line; |
159 | |
160 | switch (entry.GetType()) { |
161 | case DebugMacroEntry::DEFINE: |
162 | if (state.IsValidEntry(line: entry.GetLineNumber())) |
163 | stream.Printf(format: "#define %s\n" , entry.GetMacroString().AsCString()); |
164 | else |
165 | return; |
166 | break; |
167 | case DebugMacroEntry::UNDEF: |
168 | if (state.IsValidEntry(line: entry.GetLineNumber())) |
169 | stream.Printf(format: "#undef %s\n" , entry.GetMacroString().AsCString()); |
170 | else |
171 | return; |
172 | break; |
173 | case DebugMacroEntry::START_FILE: |
174 | line = entry.GetLineNumber(); |
175 | if (state.IsValidEntry(line)) |
176 | state.StartFile(file: entry.GetFileSpec(comp_unit)); |
177 | else |
178 | return; |
179 | break; |
180 | case DebugMacroEntry::END_FILE: |
181 | state.EndFile(); |
182 | break; |
183 | case DebugMacroEntry::INDIRECT: |
184 | AddMacros(dm: entry.GetIndirectDebugMacros(), comp_unit, state, stream); |
185 | break; |
186 | default: |
187 | // This is an unknown/invalid entry. Ignore. |
188 | break; |
189 | } |
190 | } |
191 | } |
192 | |
193 | lldb_private::ClangExpressionSourceCode::ClangExpressionSourceCode( |
194 | llvm::StringRef filename, llvm::StringRef name, llvm::StringRef prefix, |
195 | llvm::StringRef body, Wrapping wrap, WrapKind wrap_kind) |
196 | : ExpressionSourceCode(name, prefix, body, wrap), m_wrap_kind(wrap_kind) { |
197 | // Use #line markers to pretend that we have a single-line source file |
198 | // containing only the user expression. This will hide our wrapper code |
199 | // from the user when we render diagnostics with Clang. |
200 | m_start_marker = "#line 1 \"" + filename.str() + "\"\n" ; |
201 | m_end_marker = g_expression_suffix; |
202 | } |
203 | |
204 | namespace { |
205 | /// Allows checking if a token is contained in a given expression. |
206 | class TokenVerifier { |
207 | /// The tokens we found in the expression. |
208 | llvm::StringSet<> m_tokens; |
209 | |
210 | public: |
211 | TokenVerifier(std::string body); |
212 | /// Returns true iff the given expression body contained a token with the |
213 | /// given content. |
214 | bool hasToken(llvm::StringRef token) const { |
215 | return m_tokens.contains(key: token); |
216 | } |
217 | }; |
218 | |
219 | // If we're evaluating from inside a lambda that captures a 'this' pointer, |
220 | // add a "using" declaration to 'stream' for each capture used in the |
221 | // expression (tokenized by 'verifier'). |
222 | // |
223 | // If no 'this' capture exists, generate no using declarations. Instead |
224 | // capture lookups will get resolved by the same mechanism as class member |
225 | // variable lookup. That's because Clang generates an unnamed structure |
226 | // representing the lambda closure whose members are the captured variables. |
227 | void AddLambdaCaptureDecls(StreamString &stream, StackFrame *frame, |
228 | TokenVerifier const &verifier) { |
229 | assert(frame); |
230 | |
231 | if (auto thisValSP = ClangExpressionUtil::GetLambdaValueObject(frame)) { |
232 | uint32_t numChildren = thisValSP->GetNumChildrenIgnoringErrors(); |
233 | for (uint32_t i = 0; i < numChildren; ++i) { |
234 | auto childVal = thisValSP->GetChildAtIndex(idx: i); |
235 | ConstString childName(childVal ? childVal->GetName() : ConstString("" )); |
236 | |
237 | if (!childName.IsEmpty() && verifier.hasToken(token: childName.GetStringRef()) && |
238 | childName != "this" ) { |
239 | stream.Printf(format: "using $__lldb_local_vars::%s;\n" , |
240 | childName.GetCString()); |
241 | } |
242 | } |
243 | } |
244 | } |
245 | |
246 | } // namespace |
247 | |
248 | TokenVerifier::TokenVerifier(std::string body) { |
249 | using namespace clang; |
250 | |
251 | // We only care about tokens and not their original source locations. If we |
252 | // move the whole expression to only be in one line we can simplify the |
253 | // following code that extracts the token contents. |
254 | llvm::replace(Range&: body, OldValue: '\n', NewValue: ' '); |
255 | llvm::replace(Range&: body, OldValue: '\r', NewValue: ' '); |
256 | |
257 | FileSystemOptions file_opts; |
258 | FileManager file_mgr(file_opts, |
259 | FileSystem::Instance().GetVirtualFileSystem()); |
260 | |
261 | // Let's build the actual source code Clang needs and setup some utility |
262 | // objects. |
263 | llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_ids(new DiagnosticIDs()); |
264 | DiagnosticOptions diags_opts; |
265 | DiagnosticsEngine diags(diag_ids, diags_opts); |
266 | clang::SourceManager SM(diags, file_mgr); |
267 | auto buf = llvm::MemoryBuffer::getMemBuffer(InputData: body); |
268 | |
269 | FileID FID = SM.createFileID(Buffer: buf->getMemBufferRef()); |
270 | |
271 | // Let's just enable the latest ObjC and C++ which should get most tokens |
272 | // right. |
273 | LangOptions Opts; |
274 | Opts.ObjC = true; |
275 | Opts.DollarIdents = true; |
276 | Opts.CPlusPlus20 = true; |
277 | Opts.LineComment = true; |
278 | |
279 | Lexer lex(FID, buf->getMemBufferRef(), SM, Opts); |
280 | |
281 | Token token; |
282 | bool exit = false; |
283 | while (!exit) { |
284 | // Returns true if this is the last token we get from the lexer. |
285 | exit = lex.LexFromRawLexer(Result&: token); |
286 | |
287 | // Extract the column number which we need to extract the token content. |
288 | // Our expression is just one line, so we don't need to handle any line |
289 | // numbers here. |
290 | bool invalid = false; |
291 | unsigned start = SM.getSpellingColumnNumber(Loc: token.getLocation(), Invalid: &invalid); |
292 | if (invalid) |
293 | continue; |
294 | // Column numbers start at 1, but indexes in our string start at 0. |
295 | --start; |
296 | |
297 | // Annotations don't have a length, so let's skip them. |
298 | if (token.isAnnotation()) |
299 | continue; |
300 | |
301 | // Extract the token string from our source code and store it. |
302 | std::string token_str = body.substr(pos: start, n: token.getLength()); |
303 | if (token_str.empty()) |
304 | continue; |
305 | m_tokens.insert(key: token_str); |
306 | } |
307 | } |
308 | |
309 | void ClangExpressionSourceCode::AddLocalVariableDecls(StreamString &stream, |
310 | const std::string &expr, |
311 | StackFrame *frame) const { |
312 | assert(frame); |
313 | TokenVerifier tokens(expr); |
314 | |
315 | lldb::VariableListSP var_list_sp = frame->GetInScopeVariableList(get_file_globals: false, must_have_valid_location: true); |
316 | |
317 | for (size_t i = 0; i < var_list_sp->GetSize(); i++) { |
318 | lldb::VariableSP var_sp = var_list_sp->GetVariableAtIndex(idx: i); |
319 | |
320 | ConstString var_name = var_sp->GetName(); |
321 | |
322 | if (var_name == "this" && m_wrap_kind == WrapKind::CppMemberFunction) { |
323 | AddLambdaCaptureDecls(stream, frame, verifier: tokens); |
324 | |
325 | continue; |
326 | } |
327 | |
328 | // We can check for .block_descriptor w/o checking for langauge since this |
329 | // is not a valid identifier in either C or C++. |
330 | if (!var_name || var_name == ".block_descriptor" ) |
331 | continue; |
332 | |
333 | if (!expr.empty() && !tokens.hasToken(token: var_name.GetStringRef())) |
334 | continue; |
335 | |
336 | const bool is_objc = m_wrap_kind == WrapKind::ObjCInstanceMethod || |
337 | m_wrap_kind == WrapKind::ObjCStaticMethod; |
338 | if ((var_name == "self" || var_name == "_cmd" ) && is_objc) |
339 | continue; |
340 | |
341 | stream.Printf(format: "using $__lldb_local_vars::%s;\n" , var_name.AsCString()); |
342 | } |
343 | } |
344 | |
345 | bool ClangExpressionSourceCode::GetText( |
346 | std::string &text, ExecutionContext &exe_ctx, bool add_locals, |
347 | bool force_add_all_locals, llvm::ArrayRef<std::string> modules) const { |
348 | const char *target_specific_defines = "typedef signed char BOOL;\n" ; |
349 | std::string module_macros; |
350 | llvm::raw_string_ostream module_macros_stream(module_macros); |
351 | |
352 | Target *target = exe_ctx.GetTargetPtr(); |
353 | if (target) { |
354 | if (target->GetArchitecture().GetMachine() == llvm::Triple::aarch64 || |
355 | target->GetArchitecture().GetMachine() == llvm::Triple::aarch64_32) { |
356 | target_specific_defines = "typedef bool BOOL;\n" ; |
357 | } |
358 | if (target->GetArchitecture().GetMachine() == llvm::Triple::x86_64) { |
359 | if (lldb::PlatformSP platform_sp = target->GetPlatform()) { |
360 | if (platform_sp->GetPluginName() == "ios-simulator" ) { |
361 | target_specific_defines = "typedef bool BOOL;\n" ; |
362 | } |
363 | } |
364 | } |
365 | |
366 | auto *persistent_vars = llvm::cast<ClangPersistentVariables>( |
367 | Val: target->GetPersistentExpressionStateForLanguage(language: lldb::eLanguageTypeC)); |
368 | std::shared_ptr<ClangModulesDeclVendor> decl_vendor = |
369 | persistent_vars->GetClangModulesDeclVendor(); |
370 | if (decl_vendor) { |
371 | const ClangModulesDeclVendor::ModuleVector &hand_imported_modules = |
372 | persistent_vars->GetHandLoadedClangModules(); |
373 | ClangModulesDeclVendor::ModuleVector modules_for_macros; |
374 | |
375 | for (ClangModulesDeclVendor::ModuleID module : hand_imported_modules) { |
376 | modules_for_macros.push_back(x: module); |
377 | } |
378 | |
379 | if (target->GetEnableAutoImportClangModules()) { |
380 | if (StackFrame *frame = exe_ctx.GetFramePtr()) { |
381 | if (Block *block = frame->GetFrameBlock()) { |
382 | SymbolContext sc; |
383 | |
384 | block->CalculateSymbolContext(sc: &sc); |
385 | |
386 | if (sc.comp_unit) { |
387 | StreamString error_stream; |
388 | |
389 | decl_vendor->AddModulesForCompileUnit( |
390 | cu&: *sc.comp_unit, exported_modules&: modules_for_macros, error_stream); |
391 | } |
392 | } |
393 | } |
394 | } |
395 | |
396 | decl_vendor->ForEachMacro( |
397 | modules: modules_for_macros, |
398 | handler: [&module_macros_stream](llvm::StringRef token, |
399 | llvm::StringRef expansion) -> bool { |
400 | // Check if the macro hasn't already been defined in the |
401 | // g_expression_prefix (which defines a few builtin macros). |
402 | module_macros_stream << "#ifndef " << token << "\n" ; |
403 | module_macros_stream << expansion << "\n" ; |
404 | module_macros_stream << "#endif\n" ; |
405 | return false; |
406 | }); |
407 | } |
408 | } |
409 | |
410 | StreamString debug_macros_stream; |
411 | StreamString lldb_local_var_decls; |
412 | if (StackFrame *frame = exe_ctx.GetFramePtr()) { |
413 | const SymbolContext &sc = frame->GetSymbolContext( |
414 | resolve_scope: lldb::eSymbolContextCompUnit | lldb::eSymbolContextLineEntry); |
415 | |
416 | if (sc.comp_unit && sc.line_entry.IsValid()) { |
417 | DebugMacros *dm = sc.comp_unit->GetDebugMacros(); |
418 | if (dm) { |
419 | AddMacroState state(sc.line_entry.GetFile(), sc.line_entry.line); |
420 | AddMacros(dm, comp_unit: sc.comp_unit, state, stream&: debug_macros_stream); |
421 | } |
422 | } |
423 | |
424 | if (add_locals) |
425 | if (target->GetInjectLocalVariables(exe_ctx: &exe_ctx)) { |
426 | AddLocalVariableDecls(stream&: lldb_local_var_decls, |
427 | expr: force_add_all_locals ? "" : m_body, frame); |
428 | } |
429 | } |
430 | |
431 | if (m_wrap) { |
432 | // Generate a list of @import statements that will import the specified |
433 | // module into our expression. |
434 | std::string module_imports; |
435 | for (const std::string &module : modules) { |
436 | module_imports.append(s: "@import " ); |
437 | module_imports.append(str: module); |
438 | module_imports.append(s: ";\n" ); |
439 | } |
440 | |
441 | StreamString wrap_stream; |
442 | |
443 | wrap_stream.Printf(format: "%s\n%s\n%s\n%s\n%s\n" , g_expression_prefix, |
444 | module_macros.c_str(), debug_macros_stream.GetData(), |
445 | target_specific_defines, m_prefix.c_str()); |
446 | |
447 | // First construct a tagged form of the user expression so we can find it |
448 | // later: |
449 | std::string tagged_body; |
450 | tagged_body.append(str: m_start_marker); |
451 | tagged_body.append(str: m_body); |
452 | tagged_body.append(str: m_end_marker); |
453 | |
454 | switch (m_wrap_kind) { |
455 | case WrapKind::Function: |
456 | wrap_stream.Printf(format: "%s" |
457 | "void \n" |
458 | "%s(void *$__lldb_arg) \n" |
459 | "{ \n" |
460 | " %s; \n" |
461 | "%s" |
462 | "} \n" , |
463 | module_imports.c_str(), m_name.c_str(), |
464 | lldb_local_var_decls.GetData(), tagged_body.c_str()); |
465 | break; |
466 | case WrapKind::CppMemberFunction: |
467 | wrap_stream.Printf(format: "%s" |
468 | "void \n" |
469 | "$__lldb_class::%s(void *$__lldb_arg) \n" |
470 | "{ \n" |
471 | " %s; \n" |
472 | "%s" |
473 | "} \n" , |
474 | module_imports.c_str(), m_name.c_str(), |
475 | lldb_local_var_decls.GetData(), tagged_body.c_str()); |
476 | break; |
477 | case WrapKind::ObjCInstanceMethod: |
478 | wrap_stream.Printf( |
479 | format: "%s" |
480 | "@interface $__lldb_objc_class ($__lldb_category) \n" |
481 | "-(void)%s:(void *)$__lldb_arg; \n" |
482 | "@end \n" |
483 | "@implementation $__lldb_objc_class ($__lldb_category) \n" |
484 | "-(void)%s:(void *)$__lldb_arg \n" |
485 | "{ \n" |
486 | " %s; \n" |
487 | "%s" |
488 | "} \n" |
489 | "@end \n" , |
490 | module_imports.c_str(), m_name.c_str(), m_name.c_str(), |
491 | lldb_local_var_decls.GetData(), tagged_body.c_str()); |
492 | break; |
493 | |
494 | case WrapKind::ObjCStaticMethod: |
495 | wrap_stream.Printf( |
496 | format: "%s" |
497 | "@interface $__lldb_objc_class ($__lldb_category) \n" |
498 | "+(void)%s:(void *)$__lldb_arg; \n" |
499 | "@end \n" |
500 | "@implementation $__lldb_objc_class ($__lldb_category) \n" |
501 | "+(void)%s:(void *)$__lldb_arg \n" |
502 | "{ \n" |
503 | " %s; \n" |
504 | "%s" |
505 | "} \n" |
506 | "@end \n" , |
507 | module_imports.c_str(), m_name.c_str(), m_name.c_str(), |
508 | lldb_local_var_decls.GetData(), tagged_body.c_str()); |
509 | break; |
510 | } |
511 | |
512 | text = std::string(wrap_stream.GetString()); |
513 | } else { |
514 | text.append(str: m_body); |
515 | } |
516 | |
517 | return true; |
518 | } |
519 | |
520 | bool ClangExpressionSourceCode::GetOriginalBodyBounds( |
521 | std::string transformed_text, size_t &start_loc, size_t &end_loc) { |
522 | start_loc = transformed_text.find(str: m_start_marker); |
523 | if (start_loc == std::string::npos) |
524 | return false; |
525 | start_loc += m_start_marker.size(); |
526 | end_loc = transformed_text.find(str: m_end_marker); |
527 | return end_loc != std::string::npos; |
528 | } |
529 | |