1 //===-- ClangUserExpression.cpp ---------------------------------*- C++ -*-===//
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/Host/Config.h"
10 
11 #include <stdio.h>
12 #if HAVE_SYS_TYPES_H
13 #include <sys/types.h>
14 #endif
15 
16 #include <cstdlib>
17 #include <map>
18 #include <string>
19 
20 #include "ClangUserExpression.h"
21 
22 #include "ASTResultSynthesizer.h"
23 #include "ClangDiagnostic.h"
24 #include "ClangExpressionDeclMap.h"
25 #include "ClangExpressionParser.h"
26 #include "ClangModulesDeclVendor.h"
27 #include "ClangPersistentVariables.h"
28 #include "CppModuleConfiguration.h"
29 
30 #include "lldb/Core/Debugger.h"
31 #include "lldb/Core/Module.h"
32 #include "lldb/Core/StreamFile.h"
33 #include "lldb/Core/ValueObjectConstResult.h"
34 #include "lldb/Expression/ExpressionSourceCode.h"
35 #include "lldb/Expression/IRExecutionUnit.h"
36 #include "lldb/Expression/IRInterpreter.h"
37 #include "lldb/Expression/Materializer.h"
38 #include "lldb/Host/HostInfo.h"
39 #include "lldb/Symbol/Block.h"
40 #include "lldb/Symbol/ClangASTContext.h"
41 #include "lldb/Symbol/ClangASTMetadata.h"
42 #include "lldb/Symbol/CompileUnit.h"
43 #include "lldb/Symbol/Function.h"
44 #include "lldb/Symbol/ObjectFile.h"
45 #include "lldb/Symbol/SymbolFile.h"
46 #include "lldb/Symbol/SymbolVendor.h"
47 #include "lldb/Symbol/Type.h"
48 #include "lldb/Symbol/VariableList.h"
49 #include "lldb/Target/ExecutionContext.h"
50 #include "lldb/Target/Process.h"
51 #include "lldb/Target/StackFrame.h"
52 #include "lldb/Target/Target.h"
53 #include "lldb/Target/ThreadPlan.h"
54 #include "lldb/Target/ThreadPlanCallUserExpression.h"
55 #include "lldb/Utility/ConstString.h"
56 #include "lldb/Utility/Log.h"
57 #include "lldb/Utility/StreamString.h"
58 
59 #include "clang/AST/DeclCXX.h"
60 #include "clang/AST/DeclObjC.h"
61 
62 #include "llvm/ADT/ScopeExit.h"
63 
64 using namespace lldb_private;
65 
66 char ClangUserExpression::ID;
67 
ClangUserExpression(ExecutionContextScope & exe_scope,llvm::StringRef expr,llvm::StringRef prefix,lldb::LanguageType language,ResultType desired_type,const EvaluateExpressionOptions & options,ValueObject * ctx_obj)68 ClangUserExpression::ClangUserExpression(
69     ExecutionContextScope &exe_scope, llvm::StringRef expr,
70     llvm::StringRef prefix, lldb::LanguageType language,
71     ResultType desired_type, const EvaluateExpressionOptions &options,
72     ValueObject *ctx_obj)
73     : LLVMUserExpression(exe_scope, expr, prefix, language, desired_type,
74                          options),
75       m_type_system_helper(*m_target_wp.lock(), options.GetExecutionPolicy() ==
76                                                     eExecutionPolicyTopLevel),
77       m_result_delegate(exe_scope.CalculateTarget()), m_ctx_obj(ctx_obj) {
78   switch (m_language) {
79   case lldb::eLanguageTypeC_plus_plus:
80     m_allow_cxx = true;
81     break;
82   case lldb::eLanguageTypeObjC:
83     m_allow_objc = true;
84     break;
85   case lldb::eLanguageTypeObjC_plus_plus:
86   default:
87     m_allow_cxx = true;
88     m_allow_objc = true;
89     break;
90   }
91 }
92 
~ClangUserExpression()93 ClangUserExpression::~ClangUserExpression() {}
94 
ScanContext(ExecutionContext & exe_ctx,Status & err)95 void ClangUserExpression::ScanContext(ExecutionContext &exe_ctx, Status &err) {
96   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
97 
98   LLDB_LOGF(log, "ClangUserExpression::ScanContext()");
99 
100   m_target = exe_ctx.GetTargetPtr();
101 
102   if (!(m_allow_cxx || m_allow_objc)) {
103     LLDB_LOGF(log, "  [CUE::SC] Settings inhibit C++ and Objective-C");
104     return;
105   }
106 
107   StackFrame *frame = exe_ctx.GetFramePtr();
108   if (frame == nullptr) {
109     LLDB_LOGF(log, "  [CUE::SC] Null stack frame");
110     return;
111   }
112 
113   SymbolContext sym_ctx = frame->GetSymbolContext(lldb::eSymbolContextFunction |
114                                                   lldb::eSymbolContextBlock);
115 
116   if (!sym_ctx.function) {
117     LLDB_LOGF(log, "  [CUE::SC] Null function");
118     return;
119   }
120 
121   // Find the block that defines the function represented by "sym_ctx"
122   Block *function_block = sym_ctx.GetFunctionBlock();
123 
124   if (!function_block) {
125     LLDB_LOGF(log, "  [CUE::SC] Null function block");
126     return;
127   }
128 
129   CompilerDeclContext decl_context = function_block->GetDeclContext();
130 
131   if (!decl_context) {
132     LLDB_LOGF(log, "  [CUE::SC] Null decl context");
133     return;
134   }
135 
136   if (m_ctx_obj) {
137     switch (m_ctx_obj->GetObjectRuntimeLanguage()) {
138     case lldb::eLanguageTypeC:
139     case lldb::eLanguageTypeC89:
140     case lldb::eLanguageTypeC99:
141     case lldb::eLanguageTypeC11:
142     case lldb::eLanguageTypeC_plus_plus:
143     case lldb::eLanguageTypeC_plus_plus_03:
144     case lldb::eLanguageTypeC_plus_plus_11:
145     case lldb::eLanguageTypeC_plus_plus_14:
146       m_in_cplusplus_method = true;
147       break;
148     case lldb::eLanguageTypeObjC:
149     case lldb::eLanguageTypeObjC_plus_plus:
150       m_in_objectivec_method = true;
151       break;
152     default:
153       break;
154     }
155     m_needs_object_ptr = true;
156   } else if (clang::CXXMethodDecl *method_decl =
157           ClangASTContext::DeclContextGetAsCXXMethodDecl(decl_context)) {
158     if (m_allow_cxx && method_decl->isInstance()) {
159       if (m_enforce_valid_object) {
160         lldb::VariableListSP variable_list_sp(
161             function_block->GetBlockVariableList(true));
162 
163         const char *thisErrorString = "Stopped in a C++ method, but 'this' "
164                                       "isn't available; pretending we are in a "
165                                       "generic context";
166 
167         if (!variable_list_sp) {
168           err.SetErrorString(thisErrorString);
169           return;
170         }
171 
172         lldb::VariableSP this_var_sp(
173             variable_list_sp->FindVariable(ConstString("this")));
174 
175         if (!this_var_sp || !this_var_sp->IsInScope(frame) ||
176             !this_var_sp->LocationIsValidForFrame(frame)) {
177           err.SetErrorString(thisErrorString);
178           return;
179         }
180       }
181 
182       m_in_cplusplus_method = true;
183       m_needs_object_ptr = true;
184     }
185   } else if (clang::ObjCMethodDecl *method_decl =
186                  ClangASTContext::DeclContextGetAsObjCMethodDecl(
187                      decl_context)) {
188     if (m_allow_objc) {
189       if (m_enforce_valid_object) {
190         lldb::VariableListSP variable_list_sp(
191             function_block->GetBlockVariableList(true));
192 
193         const char *selfErrorString = "Stopped in an Objective-C method, but "
194                                       "'self' isn't available; pretending we "
195                                       "are in a generic context";
196 
197         if (!variable_list_sp) {
198           err.SetErrorString(selfErrorString);
199           return;
200         }
201 
202         lldb::VariableSP self_variable_sp =
203             variable_list_sp->FindVariable(ConstString("self"));
204 
205         if (!self_variable_sp || !self_variable_sp->IsInScope(frame) ||
206             !self_variable_sp->LocationIsValidForFrame(frame)) {
207           err.SetErrorString(selfErrorString);
208           return;
209         }
210       }
211 
212       m_in_objectivec_method = true;
213       m_needs_object_ptr = true;
214 
215       if (!method_decl->isInstanceMethod())
216         m_in_static_method = true;
217     }
218   } else if (clang::FunctionDecl *function_decl =
219                  ClangASTContext::DeclContextGetAsFunctionDecl(decl_context)) {
220     // We might also have a function that said in the debug information that it
221     // captured an object pointer.  The best way to deal with getting to the
222     // ivars at present is by pretending that this is a method of a class in
223     // whatever runtime the debug info says the object pointer belongs to.  Do
224     // that here.
225 
226     ClangASTMetadata *metadata =
227         ClangASTContext::DeclContextGetMetaData(decl_context, function_decl);
228     if (metadata && metadata->HasObjectPtr()) {
229       lldb::LanguageType language = metadata->GetObjectPtrLanguage();
230       if (language == lldb::eLanguageTypeC_plus_plus) {
231         if (m_enforce_valid_object) {
232           lldb::VariableListSP variable_list_sp(
233               function_block->GetBlockVariableList(true));
234 
235           const char *thisErrorString = "Stopped in a context claiming to "
236                                         "capture a C++ object pointer, but "
237                                         "'this' isn't available; pretending we "
238                                         "are in a generic context";
239 
240           if (!variable_list_sp) {
241             err.SetErrorString(thisErrorString);
242             return;
243           }
244 
245           lldb::VariableSP this_var_sp(
246               variable_list_sp->FindVariable(ConstString("this")));
247 
248           if (!this_var_sp || !this_var_sp->IsInScope(frame) ||
249               !this_var_sp->LocationIsValidForFrame(frame)) {
250             err.SetErrorString(thisErrorString);
251             return;
252           }
253         }
254 
255         m_in_cplusplus_method = true;
256         m_needs_object_ptr = true;
257       } else if (language == lldb::eLanguageTypeObjC) {
258         if (m_enforce_valid_object) {
259           lldb::VariableListSP variable_list_sp(
260               function_block->GetBlockVariableList(true));
261 
262           const char *selfErrorString =
263               "Stopped in a context claiming to capture an Objective-C object "
264               "pointer, but 'self' isn't available; pretending we are in a "
265               "generic context";
266 
267           if (!variable_list_sp) {
268             err.SetErrorString(selfErrorString);
269             return;
270           }
271 
272           lldb::VariableSP self_variable_sp =
273               variable_list_sp->FindVariable(ConstString("self"));
274 
275           if (!self_variable_sp || !self_variable_sp->IsInScope(frame) ||
276               !self_variable_sp->LocationIsValidForFrame(frame)) {
277             err.SetErrorString(selfErrorString);
278             return;
279           }
280 
281           Type *self_type = self_variable_sp->GetType();
282 
283           if (!self_type) {
284             err.SetErrorString(selfErrorString);
285             return;
286           }
287 
288           CompilerType self_clang_type = self_type->GetForwardCompilerType();
289 
290           if (!self_clang_type) {
291             err.SetErrorString(selfErrorString);
292             return;
293           }
294 
295           if (ClangASTContext::IsObjCClassType(self_clang_type)) {
296             return;
297           } else if (ClangASTContext::IsObjCObjectPointerType(
298                          self_clang_type)) {
299             m_in_objectivec_method = true;
300             m_needs_object_ptr = true;
301           } else {
302             err.SetErrorString(selfErrorString);
303             return;
304           }
305         } else {
306           m_in_objectivec_method = true;
307           m_needs_object_ptr = true;
308         }
309       }
310     }
311   }
312 }
313 
314 // This is a really nasty hack, meant to fix Objective-C expressions of the
315 // form (int)[myArray count].  Right now, because the type information for
316 // count is not available, [myArray count] returns id, which can't be directly
317 // cast to int without causing a clang error.
ApplyObjcCastHack(std::string & expr)318 static void ApplyObjcCastHack(std::string &expr) {
319   const std::string from = "(int)[";
320   const std::string to = "(int)(long long)[";
321 
322   size_t offset;
323 
324   while ((offset = expr.find(from)) != expr.npos)
325     expr.replace(offset, from.size(), to);
326 }
327 
SetupPersistentState(DiagnosticManager & diagnostic_manager,ExecutionContext & exe_ctx)328 bool ClangUserExpression::SetupPersistentState(DiagnosticManager &diagnostic_manager,
329                                  ExecutionContext &exe_ctx) {
330   if (Target *target = exe_ctx.GetTargetPtr()) {
331     if (PersistentExpressionState *persistent_state =
332             target->GetPersistentExpressionStateForLanguage(
333                 lldb::eLanguageTypeC)) {
334       m_clang_state = llvm::cast<ClangPersistentVariables>(persistent_state);
335       m_result_delegate.RegisterPersistentState(persistent_state);
336     } else {
337       diagnostic_manager.PutString(
338           eDiagnosticSeverityError,
339           "couldn't start parsing (no persistent data)");
340       return false;
341     }
342   } else {
343     diagnostic_manager.PutString(eDiagnosticSeverityError,
344                                  "error: couldn't start parsing (no target)");
345     return false;
346   }
347   return true;
348 }
349 
SetupDeclVendor(ExecutionContext & exe_ctx,Target * target)350 static void SetupDeclVendor(ExecutionContext &exe_ctx, Target *target) {
351   if (ClangModulesDeclVendor *decl_vendor =
352           target->GetClangModulesDeclVendor()) {
353     auto *persistent_state = llvm::cast<ClangPersistentVariables>(
354         target->GetPersistentExpressionStateForLanguage(lldb::eLanguageTypeC));
355     if (!persistent_state)
356       return;
357     const ClangModulesDeclVendor::ModuleVector &hand_imported_modules =
358         persistent_state->GetHandLoadedClangModules();
359     ClangModulesDeclVendor::ModuleVector modules_for_macros;
360 
361     for (ClangModulesDeclVendor::ModuleID module : hand_imported_modules) {
362       modules_for_macros.push_back(module);
363     }
364 
365     if (target->GetEnableAutoImportClangModules()) {
366       if (StackFrame *frame = exe_ctx.GetFramePtr()) {
367         if (Block *block = frame->GetFrameBlock()) {
368           SymbolContext sc;
369 
370           block->CalculateSymbolContext(&sc);
371 
372           if (sc.comp_unit) {
373             StreamString error_stream;
374 
375             decl_vendor->AddModulesForCompileUnit(
376                 *sc.comp_unit, modules_for_macros, error_stream);
377           }
378         }
379       }
380     }
381   }
382 }
383 
UpdateLanguageForExpr()384 void ClangUserExpression::UpdateLanguageForExpr() {
385   m_expr_lang = lldb::LanguageType::eLanguageTypeUnknown;
386   if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel)
387     return;
388   if (m_in_cplusplus_method)
389     m_expr_lang = lldb::eLanguageTypeC_plus_plus;
390   else if (m_in_objectivec_method)
391     m_expr_lang = lldb::eLanguageTypeObjC;
392   else
393     m_expr_lang = lldb::eLanguageTypeC;
394 }
395 
CreateSourceCode(DiagnosticManager & diagnostic_manager,ExecutionContext & exe_ctx,std::vector<std::string> modules_to_import,bool for_completion)396 void ClangUserExpression::CreateSourceCode(
397     DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
398     std::vector<std::string> modules_to_import, bool for_completion) {
399 
400   m_filename = m_clang_state->GetNextExprFileName();
401   std::string prefix = m_expr_prefix;
402 
403   if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
404     m_transformed_text = m_expr_text;
405   } else {
406     m_source_code.reset(ClangExpressionSourceCode::CreateWrapped(
407         m_filename, prefix.c_str(), m_expr_text.c_str()));
408 
409     if (!m_source_code->GetText(m_transformed_text, m_expr_lang,
410                                 m_in_static_method, exe_ctx, !m_ctx_obj,
411                                 for_completion, modules_to_import)) {
412       diagnostic_manager.PutString(eDiagnosticSeverityError,
413                                    "couldn't construct expression body");
414       return;
415     }
416 
417     // Find and store the start position of the original code inside the
418     // transformed code. We need this later for the code completion.
419     std::size_t original_start;
420     std::size_t original_end;
421     bool found_bounds = m_source_code->GetOriginalBodyBounds(
422         m_transformed_text, m_expr_lang, original_start, original_end);
423     if (found_bounds)
424       m_user_expression_start_pos = original_start;
425   }
426 }
427 
SupportsCxxModuleImport(lldb::LanguageType language)428 static bool SupportsCxxModuleImport(lldb::LanguageType language) {
429   switch (language) {
430   case lldb::eLanguageTypeC_plus_plus:
431   case lldb::eLanguageTypeC_plus_plus_03:
432   case lldb::eLanguageTypeC_plus_plus_11:
433   case lldb::eLanguageTypeC_plus_plus_14:
434   case lldb::eLanguageTypeObjC_plus_plus:
435     return true;
436   default:
437     return false;
438   }
439 }
440 
441 /// Utility method that puts a message into the expression log and
442 /// returns an invalid module configuration.
LogConfigError(const std::string & msg)443 static CppModuleConfiguration LogConfigError(const std::string &msg) {
444   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
445   LLDB_LOG(log, "[C++ module config] {0}", msg);
446   return CppModuleConfiguration();
447 }
448 
GetModuleConfig(lldb::LanguageType language,ExecutionContext & exe_ctx)449 CppModuleConfiguration GetModuleConfig(lldb::LanguageType language,
450                                        ExecutionContext &exe_ctx) {
451   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
452 
453   // Don't do anything if this is not a C++ module configuration.
454   if (!SupportsCxxModuleImport(language))
455     return LogConfigError("Language doesn't support C++ modules");
456 
457   Target *target = exe_ctx.GetTargetPtr();
458   if (!target)
459     return LogConfigError("No target");
460 
461   if (!target->GetEnableImportStdModule())
462     return LogConfigError("Importing std module not enabled in settings");
463 
464   StackFrame *frame = exe_ctx.GetFramePtr();
465   if (!frame)
466     return LogConfigError("No frame");
467 
468   Block *block = frame->GetFrameBlock();
469   if (!block)
470     return LogConfigError("No block");
471 
472   SymbolContext sc;
473   block->CalculateSymbolContext(&sc);
474   if (!sc.comp_unit)
475     return LogConfigError("Couldn't calculate symbol context");
476 
477   // Build a list of files we need to analyze to build the configuration.
478   FileSpecList files;
479   for (const FileSpec &f : sc.comp_unit->GetSupportFiles())
480     files.AppendIfUnique(f);
481   // We also need to look at external modules in the case of -gmodules as they
482   // contain the support files for libc++ and the C library.
483   llvm::DenseSet<SymbolFile *> visited_symbol_files;
484   sc.comp_unit->ForEachExternalModule(
485       visited_symbol_files, [&files](Module &module) {
486         for (std::size_t i = 0; i < module.GetNumCompileUnits(); ++i) {
487           const FileSpecList &support_files =
488               module.GetCompileUnitAtIndex(i)->GetSupportFiles();
489           for (const FileSpec &f : support_files) {
490             files.AppendIfUnique(f);
491           }
492         }
493         return false;
494       });
495 
496   LLDB_LOG(log, "[C++ module config] Found {0} support files to analyze",
497            files.GetSize());
498   if (log && log->GetVerbose()) {
499     for (const FileSpec &f : files)
500       LLDB_LOGV(log, "[C++ module config] Analyzing support file: {0}",
501                 f.GetPath());
502   }
503 
504   // Try to create a configuration from the files. If there is no valid
505   // configuration possible with the files, this just returns an invalid
506   // configuration.
507   return CppModuleConfiguration(files);
508 }
509 
PrepareForParsing(DiagnosticManager & diagnostic_manager,ExecutionContext & exe_ctx,bool for_completion)510 bool ClangUserExpression::PrepareForParsing(
511     DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
512     bool for_completion) {
513   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
514 
515   InstallContext(exe_ctx);
516 
517   if (!SetupPersistentState(diagnostic_manager, exe_ctx))
518     return false;
519 
520   Status err;
521   ScanContext(exe_ctx, err);
522 
523   if (!err.Success()) {
524     diagnostic_manager.PutString(eDiagnosticSeverityWarning, err.AsCString());
525   }
526 
527   ////////////////////////////////////
528   // Generate the expression
529   //
530 
531   ApplyObjcCastHack(m_expr_text);
532 
533   SetupDeclVendor(exe_ctx, m_target);
534 
535   CppModuleConfiguration module_config = GetModuleConfig(m_language, exe_ctx);
536   llvm::ArrayRef<std::string> imported_modules =
537       module_config.GetImportedModules();
538   m_imported_cpp_modules = !imported_modules.empty();
539   m_include_directories = module_config.GetIncludeDirs();
540 
541   LLDB_LOG(log, "List of imported modules in expression: {0}",
542            llvm::make_range(imported_modules.begin(), imported_modules.end()));
543   LLDB_LOG(log, "List of include directories gathered for modules: {0}",
544            llvm::make_range(m_include_directories.begin(),
545                             m_include_directories.end()));
546 
547   UpdateLanguageForExpr();
548   CreateSourceCode(diagnostic_manager, exe_ctx, imported_modules,
549                    for_completion);
550   return true;
551 }
552 
Parse(DiagnosticManager & diagnostic_manager,ExecutionContext & exe_ctx,lldb_private::ExecutionPolicy execution_policy,bool keep_result_in_memory,bool generate_debug_info)553 bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
554                                 ExecutionContext &exe_ctx,
555                                 lldb_private::ExecutionPolicy execution_policy,
556                                 bool keep_result_in_memory,
557                                 bool generate_debug_info) {
558   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
559 
560   if (!PrepareForParsing(diagnostic_manager, exe_ctx, /*for_completion*/ false))
561     return false;
562 
563   LLDB_LOGF(log, "Parsing the following code:\n%s", m_transformed_text.c_str());
564 
565   ////////////////////////////////////
566   // Set up the target and compiler
567   //
568 
569   Target *target = exe_ctx.GetTargetPtr();
570 
571   if (!target) {
572     diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid target");
573     return false;
574   }
575 
576   //////////////////////////
577   // Parse the expression
578   //
579 
580   m_materializer_up.reset(new Materializer());
581 
582   ResetDeclMap(exe_ctx, m_result_delegate, keep_result_in_memory);
583 
584   auto on_exit = llvm::make_scope_exit([this]() { ResetDeclMap(); });
585 
586   if (!DeclMap()->WillParse(exe_ctx, GetMaterializer())) {
587     diagnostic_manager.PutString(
588         eDiagnosticSeverityError,
589         "current process state is unsuitable for expression parsing");
590     return false;
591   }
592 
593   if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
594     DeclMap()->SetLookupsEnabled(true);
595   }
596 
597   Process *process = exe_ctx.GetProcessPtr();
598   ExecutionContextScope *exe_scope = process;
599 
600   if (!exe_scope)
601     exe_scope = exe_ctx.GetTargetPtr();
602 
603   // We use a shared pointer here so we can use the original parser - if it
604   // succeeds or the rewrite parser we might make if it fails.  But the
605   // parser_sp will never be empty.
606 
607   ClangExpressionParser parser(exe_scope, *this, generate_debug_info,
608                                m_include_directories, m_filename);
609 
610   unsigned num_errors = parser.Parse(diagnostic_manager);
611 
612   // Check here for FixItHints.  If there are any try to apply the fixits and
613   // set the fixed text in m_fixed_text before returning an error.
614   if (num_errors) {
615     if (diagnostic_manager.HasFixIts()) {
616       if (parser.RewriteExpression(diagnostic_manager)) {
617         size_t fixed_start;
618         size_t fixed_end;
619         const std::string &fixed_expression =
620             diagnostic_manager.GetFixedExpression();
621         // Retrieve the original expression in case we don't have a top level
622         // expression (which has no surrounding source code).
623         if (m_source_code &&
624             m_source_code->GetOriginalBodyBounds(fixed_expression, m_expr_lang,
625                                                  fixed_start, fixed_end))
626           m_fixed_text =
627               fixed_expression.substr(fixed_start, fixed_end - fixed_start);
628       }
629     }
630     return false;
631   }
632 
633   //////////////////////////////////////////////////////////////////////////////
634   // Prepare the output of the parser for execution, evaluating it statically
635   // if possible
636   //
637 
638   {
639     Status jit_error = parser.PrepareForExecution(
640         m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx,
641         m_can_interpret, execution_policy);
642 
643     if (!jit_error.Success()) {
644       const char *error_cstr = jit_error.AsCString();
645       if (error_cstr && error_cstr[0])
646         diagnostic_manager.PutString(eDiagnosticSeverityError, error_cstr);
647       else
648         diagnostic_manager.PutString(eDiagnosticSeverityError,
649                                      "expression can't be interpreted or run");
650       return false;
651     }
652   }
653 
654   if (exe_ctx.GetProcessPtr() && execution_policy == eExecutionPolicyTopLevel) {
655     Status static_init_error =
656         parser.RunStaticInitializers(m_execution_unit_sp, exe_ctx);
657 
658     if (!static_init_error.Success()) {
659       const char *error_cstr = static_init_error.AsCString();
660       if (error_cstr && error_cstr[0])
661         diagnostic_manager.Printf(eDiagnosticSeverityError,
662                                   "couldn't run static initializers: %s\n",
663                                   error_cstr);
664       else
665         diagnostic_manager.PutString(eDiagnosticSeverityError,
666                                      "couldn't run static initializers\n");
667       return false;
668     }
669   }
670 
671   if (m_execution_unit_sp) {
672     bool register_execution_unit = false;
673 
674     if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
675       register_execution_unit = true;
676     }
677 
678     // If there is more than one external function in the execution unit, it
679     // needs to keep living even if it's not top level, because the result
680     // could refer to that function.
681 
682     if (m_execution_unit_sp->GetJittedFunctions().size() > 1) {
683       register_execution_unit = true;
684     }
685 
686     if (register_execution_unit) {
687       if (auto *persistent_state =
688               exe_ctx.GetTargetPtr()->GetPersistentExpressionStateForLanguage(
689                   m_language))
690         persistent_state->RegisterExecutionUnit(m_execution_unit_sp);
691     }
692   }
693 
694   if (generate_debug_info) {
695     lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
696 
697     if (jit_module_sp) {
698       ConstString const_func_name(FunctionName());
699       FileSpec jit_file;
700       jit_file.GetFilename() = const_func_name;
701       jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
702       m_jit_module_wp = jit_module_sp;
703       target->GetImages().Append(jit_module_sp);
704     }
705   }
706 
707   if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS)
708     m_jit_process_wp = lldb::ProcessWP(process->shared_from_this());
709   return true;
710 }
711 
712 /// Converts an absolute position inside a given code string into
713 /// a column/line pair.
714 ///
715 /// \param[in] abs_pos
716 ///     A absolute position in the code string that we want to convert
717 ///     to a column/line pair.
718 ///
719 /// \param[in] code
720 ///     A multi-line string usually representing source code.
721 ///
722 /// \param[out] line
723 ///     The line in the code that contains the given absolute position.
724 ///     The first line in the string is indexed as 1.
725 ///
726 /// \param[out] column
727 ///     The column in the line that contains the absolute position.
728 ///     The first character in a line is indexed as 0.
AbsPosToLineColumnPos(size_t abs_pos,llvm::StringRef code,unsigned & line,unsigned & column)729 static void AbsPosToLineColumnPos(size_t abs_pos, llvm::StringRef code,
730                                   unsigned &line, unsigned &column) {
731   // Reset to code position to beginning of the file.
732   line = 0;
733   column = 0;
734 
735   assert(abs_pos <= code.size() && "Absolute position outside code string?");
736 
737   // We have to walk up to the position and count lines/columns.
738   for (std::size_t i = 0; i < abs_pos; ++i) {
739     // If we hit a line break, we go back to column 0 and enter a new line.
740     // We only handle \n because that's what we internally use to make new
741     // lines for our temporary code strings.
742     if (code[i] == '\n') {
743       ++line;
744       column = 0;
745       continue;
746     }
747     ++column;
748   }
749 }
750 
Complete(ExecutionContext & exe_ctx,CompletionRequest & request,unsigned complete_pos)751 bool ClangUserExpression::Complete(ExecutionContext &exe_ctx,
752                                    CompletionRequest &request,
753                                    unsigned complete_pos) {
754   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
755 
756   // We don't want any visible feedback when completing an expression. Mostly
757   // because the results we get from an incomplete invocation are probably not
758   // correct.
759   DiagnosticManager diagnostic_manager;
760 
761   if (!PrepareForParsing(diagnostic_manager, exe_ctx, /*for_completion*/ true))
762     return false;
763 
764   LLDB_LOGF(log, "Parsing the following code:\n%s", m_transformed_text.c_str());
765 
766   //////////////////////////
767   // Parse the expression
768   //
769 
770   m_materializer_up.reset(new Materializer());
771 
772   ResetDeclMap(exe_ctx, m_result_delegate, /*keep result in memory*/ true);
773 
774   auto on_exit = llvm::make_scope_exit([this]() { ResetDeclMap(); });
775 
776   if (!DeclMap()->WillParse(exe_ctx, GetMaterializer())) {
777     diagnostic_manager.PutString(
778         eDiagnosticSeverityError,
779         "current process state is unsuitable for expression parsing");
780 
781     return false;
782   }
783 
784   if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
785     DeclMap()->SetLookupsEnabled(true);
786   }
787 
788   Process *process = exe_ctx.GetProcessPtr();
789   ExecutionContextScope *exe_scope = process;
790 
791   if (!exe_scope)
792     exe_scope = exe_ctx.GetTargetPtr();
793 
794   ClangExpressionParser parser(exe_scope, *this, false);
795 
796   // We have to find the source code location where the user text is inside
797   // the transformed expression code. When creating the transformed text, we
798   // already stored the absolute position in the m_transformed_text string. The
799   // only thing left to do is to transform it into the line:column format that
800   // Clang expects.
801 
802   // The line and column of the user expression inside the transformed source
803   // code.
804   unsigned user_expr_line, user_expr_column;
805   if (m_user_expression_start_pos.hasValue())
806     AbsPosToLineColumnPos(*m_user_expression_start_pos, m_transformed_text,
807                           user_expr_line, user_expr_column);
808   else
809     return false;
810 
811   // The actual column where we have to complete is the start column of the
812   // user expression + the offset inside the user code that we were given.
813   const unsigned completion_column = user_expr_column + complete_pos;
814   parser.Complete(request, user_expr_line, completion_column, complete_pos);
815 
816   return true;
817 }
818 
AddArguments(ExecutionContext & exe_ctx,std::vector<lldb::addr_t> & args,lldb::addr_t struct_address,DiagnosticManager & diagnostic_manager)819 bool ClangUserExpression::AddArguments(ExecutionContext &exe_ctx,
820                                        std::vector<lldb::addr_t> &args,
821                                        lldb::addr_t struct_address,
822                                        DiagnosticManager &diagnostic_manager) {
823   lldb::addr_t object_ptr = LLDB_INVALID_ADDRESS;
824   lldb::addr_t cmd_ptr = LLDB_INVALID_ADDRESS;
825 
826   if (m_needs_object_ptr) {
827     lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
828     if (!frame_sp)
829       return true;
830 
831     ConstString object_name;
832 
833     if (m_in_cplusplus_method) {
834       object_name.SetCString("this");
835     } else if (m_in_objectivec_method) {
836       object_name.SetCString("self");
837     } else {
838       diagnostic_manager.PutString(
839           eDiagnosticSeverityError,
840           "need object pointer but don't know the language");
841       return false;
842     }
843 
844     Status object_ptr_error;
845 
846     if (m_ctx_obj) {
847       AddressType address_type;
848       object_ptr = m_ctx_obj->GetAddressOf(false, &address_type);
849       if (object_ptr == LLDB_INVALID_ADDRESS ||
850           address_type != eAddressTypeLoad)
851         object_ptr_error.SetErrorString("Can't get context object's "
852                                         "debuggee address");
853     } else
854       object_ptr = GetObjectPointer(frame_sp, object_name, object_ptr_error);
855 
856     if (!object_ptr_error.Success()) {
857       exe_ctx.GetTargetRef().GetDebugger().GetAsyncOutputStream()->Printf(
858           "warning: `%s' is not accessible (substituting 0)\n",
859           object_name.AsCString());
860       object_ptr = 0;
861     }
862 
863     if (m_in_objectivec_method) {
864       ConstString cmd_name("_cmd");
865 
866       cmd_ptr = GetObjectPointer(frame_sp, cmd_name, object_ptr_error);
867 
868       if (!object_ptr_error.Success()) {
869         diagnostic_manager.Printf(
870             eDiagnosticSeverityWarning,
871             "couldn't get cmd pointer (substituting NULL): %s",
872             object_ptr_error.AsCString());
873         cmd_ptr = 0;
874       }
875     }
876 
877     args.push_back(object_ptr);
878 
879     if (m_in_objectivec_method)
880       args.push_back(cmd_ptr);
881 
882     args.push_back(struct_address);
883   } else {
884     args.push_back(struct_address);
885   }
886   return true;
887 }
888 
GetResultAfterDematerialization(ExecutionContextScope * exe_scope)889 lldb::ExpressionVariableSP ClangUserExpression::GetResultAfterDematerialization(
890     ExecutionContextScope *exe_scope) {
891   return m_result_delegate.GetVariable();
892 }
893 
ResetDeclMap(ExecutionContext & exe_ctx,Materializer::PersistentVariableDelegate & delegate,bool keep_result_in_memory,ValueObject * ctx_obj)894 void ClangUserExpression::ClangUserExpressionHelper::ResetDeclMap(
895     ExecutionContext &exe_ctx,
896     Materializer::PersistentVariableDelegate &delegate,
897     bool keep_result_in_memory,
898     ValueObject *ctx_obj) {
899   m_expr_decl_map_up.reset(new ClangExpressionDeclMap(
900       keep_result_in_memory, &delegate, exe_ctx.GetTargetSP(),
901       exe_ctx.GetTargetRef().GetClangASTImporter(), ctx_obj));
902 }
903 
904 clang::ASTConsumer *
ASTTransformer(clang::ASTConsumer * passthrough)905 ClangUserExpression::ClangUserExpressionHelper::ASTTransformer(
906     clang::ASTConsumer *passthrough) {
907   m_result_synthesizer_up.reset(
908       new ASTResultSynthesizer(passthrough, m_top_level, m_target));
909 
910   return m_result_synthesizer_up.get();
911 }
912 
CommitPersistentDecls()913 void ClangUserExpression::ClangUserExpressionHelper::CommitPersistentDecls() {
914   if (m_result_synthesizer_up) {
915     m_result_synthesizer_up->CommitPersistentDecls();
916   }
917 }
918 
GetName()919 ConstString ClangUserExpression::ResultDelegate::GetName() {
920   auto prefix = m_persistent_state->GetPersistentVariablePrefix();
921   return m_persistent_state->GetNextPersistentVariableName(*m_target_sp,
922                                                            prefix);
923 }
924 
DidDematerialize(lldb::ExpressionVariableSP & variable)925 void ClangUserExpression::ResultDelegate::DidDematerialize(
926     lldb::ExpressionVariableSP &variable) {
927   m_variable = variable;
928 }
929 
RegisterPersistentState(PersistentExpressionState * persistent_state)930 void ClangUserExpression::ResultDelegate::RegisterPersistentState(
931     PersistentExpressionState *persistent_state) {
932   m_persistent_state = persistent_state;
933 }
934 
GetVariable()935 lldb::ExpressionVariableSP &ClangUserExpression::ResultDelegate::GetVariable() {
936   return m_variable;
937 }
938