1 //===-- ClangExpressionParser.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 "clang/AST/ASTContext.h"
10 #include "clang/AST/ASTDiagnostic.h"
11 #include "clang/AST/ExternalASTSource.h"
12 #include "clang/AST/PrettyPrinter.h"
13 #include "clang/Basic/Builtins.h"
14 #include "clang/Basic/DiagnosticIDs.h"
15 #include "clang/Basic/SourceLocation.h"
16 #include "clang/Basic/TargetInfo.h"
17 #include "clang/Basic/Version.h"
18 #include "clang/CodeGen/CodeGenAction.h"
19 #include "clang/CodeGen/ModuleBuilder.h"
20 #include "clang/Edit/Commit.h"
21 #include "clang/Edit/EditedSource.h"
22 #include "clang/Edit/EditsReceiver.h"
23 #include "clang/Frontend/CompilerInstance.h"
24 #include "clang/Frontend/CompilerInvocation.h"
25 #include "clang/Frontend/FrontendActions.h"
26 #include "clang/Frontend/FrontendDiagnostic.h"
27 #include "clang/Frontend/FrontendPluginRegistry.h"
28 #include "clang/Frontend/TextDiagnosticBuffer.h"
29 #include "clang/Frontend/TextDiagnosticPrinter.h"
30 #include "clang/Lex/Preprocessor.h"
31 #include "clang/Parse/ParseAST.h"
32 #include "clang/Rewrite/Core/Rewriter.h"
33 #include "clang/Rewrite/Frontend/FrontendActions.h"
34 #include "clang/Sema/CodeCompleteConsumer.h"
35 #include "clang/Sema/Sema.h"
36 #include "clang/Sema/SemaConsumer.h"
37
38 #include "llvm/ADT/StringRef.h"
39 #include "llvm/ExecutionEngine/ExecutionEngine.h"
40 #include "llvm/Support/CrashRecoveryContext.h"
41 #include "llvm/Support/Debug.h"
42 #include "llvm/Support/FileSystem.h"
43 #include "llvm/Support/TargetSelect.h"
44
45 #include "llvm/IR/LLVMContext.h"
46 #include "llvm/IR/Module.h"
47 #include "llvm/Support/DynamicLibrary.h"
48 #include "llvm/Support/ErrorHandling.h"
49 #include "llvm/Support/Host.h"
50 #include "llvm/Support/MemoryBuffer.h"
51 #include "llvm/Support/Signals.h"
52
53 #include "ClangDiagnostic.h"
54 #include "ClangExpressionParser.h"
55 #include "ClangUserExpression.h"
56
57 #include "ASTUtils.h"
58 #include "ClangASTSource.h"
59 #include "ClangDiagnostic.h"
60 #include "ClangExpressionDeclMap.h"
61 #include "ClangExpressionHelper.h"
62 #include "ClangExpressionParser.h"
63 #include "ClangHost.h"
64 #include "ClangModulesDeclVendor.h"
65 #include "ClangPersistentVariables.h"
66 #include "IRDynamicChecks.h"
67 #include "IRForTarget.h"
68 #include "ModuleDependencyCollector.h"
69
70 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
71 #include "lldb/Core/Debugger.h"
72 #include "lldb/Core/Disassembler.h"
73 #include "lldb/Core/Module.h"
74 #include "lldb/Core/StreamFile.h"
75 #include "lldb/Expression/IRExecutionUnit.h"
76 #include "lldb/Expression/IRInterpreter.h"
77 #include "lldb/Host/File.h"
78 #include "lldb/Host/HostInfo.h"
79 #include "lldb/Symbol/SymbolVendor.h"
80 #include "lldb/Target/ExecutionContext.h"
81 #include "lldb/Target/Language.h"
82 #include "lldb/Target/Process.h"
83 #include "lldb/Target/Target.h"
84 #include "lldb/Target/ThreadPlanCallFunction.h"
85 #include "lldb/Utility/DataBufferHeap.h"
86 #include "lldb/Utility/LLDBAssert.h"
87 #include "lldb/Utility/Log.h"
88 #include "lldb/Utility/ReproducerProvider.h"
89 #include "lldb/Utility/Stream.h"
90 #include "lldb/Utility/StreamString.h"
91 #include "lldb/Utility/StringList.h"
92
93 #include "Plugins/LanguageRuntime/ObjC/ObjCLanguageRuntime.h"
94 #include "Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.h"
95
96 #include <cctype>
97 #include <memory>
98
99 using namespace clang;
100 using namespace llvm;
101 using namespace lldb_private;
102
103 //===----------------------------------------------------------------------===//
104 // Utility Methods for Clang
105 //===----------------------------------------------------------------------===//
106
107 class ClangExpressionParser::LLDBPreprocessorCallbacks : public PPCallbacks {
108 ClangModulesDeclVendor &m_decl_vendor;
109 ClangPersistentVariables &m_persistent_vars;
110 clang::SourceManager &m_source_mgr;
111 StreamString m_error_stream;
112 bool m_has_errors = false;
113
114 public:
LLDBPreprocessorCallbacks(ClangModulesDeclVendor & decl_vendor,ClangPersistentVariables & persistent_vars,clang::SourceManager & source_mgr)115 LLDBPreprocessorCallbacks(ClangModulesDeclVendor &decl_vendor,
116 ClangPersistentVariables &persistent_vars,
117 clang::SourceManager &source_mgr)
118 : m_decl_vendor(decl_vendor), m_persistent_vars(persistent_vars),
119 m_source_mgr(source_mgr) {}
120
moduleImport(SourceLocation import_location,clang::ModuleIdPath path,const clang::Module *)121 void moduleImport(SourceLocation import_location, clang::ModuleIdPath path,
122 const clang::Module * /*null*/) override {
123 // Ignore modules that are imported in the wrapper code as these are not
124 // loaded by the user.
125 llvm::StringRef filename =
126 m_source_mgr.getPresumedLoc(import_location).getFilename();
127 if (filename == ClangExpressionSourceCode::g_prefix_file_name)
128 return;
129
130 SourceModule module;
131
132 for (const std::pair<IdentifierInfo *, SourceLocation> &component : path)
133 module.path.push_back(ConstString(component.first->getName()));
134
135 StreamString error_stream;
136
137 ClangModulesDeclVendor::ModuleVector exported_modules;
138 if (!m_decl_vendor.AddModule(module, &exported_modules, m_error_stream))
139 m_has_errors = true;
140
141 for (ClangModulesDeclVendor::ModuleID module : exported_modules)
142 m_persistent_vars.AddHandLoadedClangModule(module);
143 }
144
hasErrors()145 bool hasErrors() { return m_has_errors; }
146
getErrorString()147 llvm::StringRef getErrorString() { return m_error_stream.GetString(); }
148 };
149
AddAllFixIts(ClangDiagnostic * diag,const clang::Diagnostic & Info)150 static void AddAllFixIts(ClangDiagnostic *diag, const clang::Diagnostic &Info) {
151 for (auto &fix_it : Info.getFixItHints()) {
152 if (fix_it.isNull())
153 continue;
154 diag->AddFixitHint(fix_it);
155 }
156 }
157
158 class ClangDiagnosticManagerAdapter : public clang::DiagnosticConsumer {
159 public:
ClangDiagnosticManagerAdapter(DiagnosticOptions & opts)160 ClangDiagnosticManagerAdapter(DiagnosticOptions &opts) {
161 DiagnosticOptions *options = new DiagnosticOptions(opts);
162 options->ShowPresumedLoc = true;
163 options->ShowLevel = false;
164 m_os = std::make_shared<llvm::raw_string_ostream>(m_output);
165 m_passthrough =
166 std::make_shared<clang::TextDiagnosticPrinter>(*m_os, options);
167 }
168
ResetManager(DiagnosticManager * manager=nullptr)169 void ResetManager(DiagnosticManager *manager = nullptr) {
170 m_manager = manager;
171 }
172
173 /// Returns the last ClangDiagnostic message that the DiagnosticManager
174 /// received or a nullptr if the DiagnosticMangager hasn't seen any
175 /// Clang diagnostics yet.
MaybeGetLastClangDiag() const176 ClangDiagnostic *MaybeGetLastClangDiag() const {
177 if (m_manager->Diagnostics().empty())
178 return nullptr;
179 lldb_private::Diagnostic *diag = m_manager->Diagnostics().back().get();
180 ClangDiagnostic *clang_diag = dyn_cast<ClangDiagnostic>(diag);
181 return clang_diag;
182 }
183
HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,const clang::Diagnostic & Info)184 void HandleDiagnostic(DiagnosticsEngine::Level DiagLevel,
185 const clang::Diagnostic &Info) override {
186 if (!m_manager) {
187 // We have no DiagnosticManager before/after parsing but we still could
188 // receive diagnostics (e.g., by the ASTImporter failing to copy decls
189 // when we move the expression result ot the ScratchASTContext). Let's at
190 // least log these diagnostics until we find a way to properly render
191 // them and display them to the user.
192 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
193 if (log) {
194 llvm::SmallVector<char, 32> diag_str;
195 Info.FormatDiagnostic(diag_str);
196 diag_str.push_back('\0');
197 const char *plain_diag = diag_str.data();
198 LLDB_LOG(log, "Received diagnostic outside parsing: {0}", plain_diag);
199 }
200 return;
201 }
202
203 // Update error/warning counters.
204 DiagnosticConsumer::HandleDiagnostic(DiagLevel, Info);
205
206 // Render diagnostic message to m_output.
207 m_output.clear();
208 m_passthrough->HandleDiagnostic(DiagLevel, Info);
209 m_os->flush();
210
211 lldb_private::DiagnosticSeverity severity;
212 bool make_new_diagnostic = true;
213
214 switch (DiagLevel) {
215 case DiagnosticsEngine::Level::Fatal:
216 case DiagnosticsEngine::Level::Error:
217 severity = eDiagnosticSeverityError;
218 break;
219 case DiagnosticsEngine::Level::Warning:
220 severity = eDiagnosticSeverityWarning;
221 break;
222 case DiagnosticsEngine::Level::Remark:
223 case DiagnosticsEngine::Level::Ignored:
224 severity = eDiagnosticSeverityRemark;
225 break;
226 case DiagnosticsEngine::Level::Note:
227 m_manager->AppendMessageToDiagnostic(m_output);
228 make_new_diagnostic = false;
229
230 // 'note:' diagnostics for errors and warnings can also contain Fix-Its.
231 // We add these Fix-Its to the last error diagnostic to make sure
232 // that we later have all Fix-Its related to an 'error' diagnostic when
233 // we apply them to the user expression.
234 auto *clang_diag = MaybeGetLastClangDiag();
235 // If we don't have a previous diagnostic there is nothing to do.
236 // If the previous diagnostic already has its own Fix-Its, assume that
237 // the 'note:' Fix-It is just an alternative way to solve the issue and
238 // ignore these Fix-Its.
239 if (!clang_diag || clang_diag->HasFixIts())
240 break;
241 // Ignore all Fix-Its that are not associated with an error.
242 if (clang_diag->GetSeverity() != eDiagnosticSeverityError)
243 break;
244 AddAllFixIts(clang_diag, Info);
245 break;
246 }
247 if (make_new_diagnostic) {
248 // ClangDiagnostic messages are expected to have no whitespace/newlines
249 // around them.
250 std::string stripped_output =
251 std::string(llvm::StringRef(m_output).trim());
252
253 auto new_diagnostic = std::make_unique<ClangDiagnostic>(
254 stripped_output, severity, Info.getID());
255
256 // Don't store away warning fixits, since the compiler doesn't have
257 // enough context in an expression for the warning to be useful.
258 // FIXME: Should we try to filter out FixIts that apply to our generated
259 // code, and not the user's expression?
260 if (severity == eDiagnosticSeverityError)
261 AddAllFixIts(new_diagnostic.get(), Info);
262
263 m_manager->AddDiagnostic(std::move(new_diagnostic));
264 }
265 }
266
BeginSourceFile(const LangOptions & LO,const Preprocessor * PP)267 void BeginSourceFile(const LangOptions &LO, const Preprocessor *PP) override {
268 m_passthrough->BeginSourceFile(LO, PP);
269 }
270
EndSourceFile()271 void EndSourceFile() override { m_passthrough->EndSourceFile(); }
272
273 private:
274 DiagnosticManager *m_manager = nullptr;
275 std::shared_ptr<clang::TextDiagnosticPrinter> m_passthrough;
276 /// Output stream of m_passthrough.
277 std::shared_ptr<llvm::raw_string_ostream> m_os;
278 /// Output string filled by m_os.
279 std::string m_output;
280 };
281
SetupModuleHeaderPaths(CompilerInstance * compiler,std::vector<std::string> include_directories,lldb::TargetSP target_sp)282 static void SetupModuleHeaderPaths(CompilerInstance *compiler,
283 std::vector<std::string> include_directories,
284 lldb::TargetSP target_sp) {
285 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
286
287 HeaderSearchOptions &search_opts = compiler->getHeaderSearchOpts();
288
289 for (const std::string &dir : include_directories) {
290 search_opts.AddPath(dir, frontend::System, false, true);
291 LLDB_LOG(log, "Added user include dir: {0}", dir);
292 }
293
294 llvm::SmallString<128> module_cache;
295 const auto &props = ModuleList::GetGlobalModuleListProperties();
296 props.GetClangModulesCachePath().GetPath(module_cache);
297 search_opts.ModuleCachePath = std::string(module_cache.str());
298 LLDB_LOG(log, "Using module cache path: {0}", module_cache.c_str());
299
300 search_opts.ResourceDir = GetClangResourceDir().GetPath();
301
302 search_opts.ImplicitModuleMaps = true;
303 }
304
305 /// Iff the given identifier is a C++ keyword, remove it from the
306 /// identifier table (i.e., make the token a normal identifier).
RemoveCppKeyword(IdentifierTable & idents,llvm::StringRef token)307 static void RemoveCppKeyword(IdentifierTable &idents, llvm::StringRef token) {
308 // FIXME: 'using' is used by LLDB for local variables, so we can't remove
309 // this keyword without breaking this functionality.
310 if (token == "using")
311 return;
312 // GCC's '__null' is used by LLDB to define NULL/Nil/nil.
313 if (token == "__null")
314 return;
315
316 LangOptions cpp_lang_opts;
317 cpp_lang_opts.CPlusPlus = true;
318 cpp_lang_opts.CPlusPlus11 = true;
319 cpp_lang_opts.CPlusPlus20 = true;
320
321 clang::IdentifierInfo &ii = idents.get(token);
322 // The identifier has to be a C++-exclusive keyword. if not, then there is
323 // nothing to do.
324 if (!ii.isCPlusPlusKeyword(cpp_lang_opts))
325 return;
326 // If the token is already an identifier, then there is nothing to do.
327 if (ii.getTokenID() == clang::tok::identifier)
328 return;
329 // Otherwise the token is a C++ keyword, so turn it back into a normal
330 // identifier.
331 ii.revertTokenIDToIdentifier();
332 }
333
334 /// Remove all C++ keywords from the given identifier table.
RemoveAllCppKeywords(IdentifierTable & idents)335 static void RemoveAllCppKeywords(IdentifierTable &idents) {
336 #define KEYWORD(NAME, FLAGS) RemoveCppKeyword(idents, llvm::StringRef(#NAME));
337 #include "clang/Basic/TokenKinds.def"
338 }
339
340 //===----------------------------------------------------------------------===//
341 // Implementation of ClangExpressionParser
342 //===----------------------------------------------------------------------===//
343
ClangExpressionParser(ExecutionContextScope * exe_scope,Expression & expr,bool generate_debug_info,std::vector<std::string> include_directories,std::string filename)344 ClangExpressionParser::ClangExpressionParser(
345 ExecutionContextScope *exe_scope, Expression &expr,
346 bool generate_debug_info, std::vector<std::string> include_directories,
347 std::string filename)
348 : ExpressionParser(exe_scope, expr, generate_debug_info), m_compiler(),
349 m_pp_callbacks(nullptr),
350 m_include_directories(std::move(include_directories)),
351 m_filename(std::move(filename)) {
352 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
353
354 // We can't compile expressions without a target. So if the exe_scope is
355 // null or doesn't have a target, then we just need to get out of here. I'll
356 // lldbassert and not make any of the compiler objects since
357 // I can't return errors directly from the constructor. Further calls will
358 // check if the compiler was made and
359 // bag out if it wasn't.
360
361 if (!exe_scope) {
362 lldbassert(exe_scope &&
363 "Can't make an expression parser with a null scope.");
364 return;
365 }
366
367 lldb::TargetSP target_sp;
368 target_sp = exe_scope->CalculateTarget();
369 if (!target_sp) {
370 lldbassert(target_sp.get() &&
371 "Can't make an expression parser with a null target.");
372 return;
373 }
374
375 // 1. Create a new compiler instance.
376 m_compiler = std::make_unique<CompilerInstance>();
377
378 // When capturing a reproducer, hook up the file collector with clang to
379 // collector modules and headers.
380 if (repro::Generator *g = repro::Reproducer::Instance().GetGenerator()) {
381 repro::FileProvider &fp = g->GetOrCreate<repro::FileProvider>();
382 m_compiler->setModuleDepCollector(
383 std::make_shared<ModuleDependencyCollectorAdaptor>(
384 fp.GetFileCollector()));
385 DependencyOutputOptions &opts = m_compiler->getDependencyOutputOpts();
386 opts.IncludeSystemHeaders = true;
387 opts.IncludeModuleFiles = true;
388 }
389
390 // Make sure clang uses the same VFS as LLDB.
391 m_compiler->createFileManager(FileSystem::Instance().GetVirtualFileSystem());
392
393 lldb::LanguageType frame_lang =
394 expr.Language(); // defaults to lldb::eLanguageTypeUnknown
395 bool overridden_target_opts = false;
396 lldb_private::LanguageRuntime *lang_rt = nullptr;
397
398 std::string abi;
399 ArchSpec target_arch;
400 target_arch = target_sp->GetArchitecture();
401
402 const auto target_machine = target_arch.GetMachine();
403
404 // If the expression is being evaluated in the context of an existing stack
405 // frame, we introspect to see if the language runtime is available.
406
407 lldb::StackFrameSP frame_sp = exe_scope->CalculateStackFrame();
408 lldb::ProcessSP process_sp = exe_scope->CalculateProcess();
409
410 // Make sure the user hasn't provided a preferred execution language with
411 // `expression --language X -- ...`
412 if (frame_sp && frame_lang == lldb::eLanguageTypeUnknown)
413 frame_lang = frame_sp->GetLanguage();
414
415 if (process_sp && frame_lang != lldb::eLanguageTypeUnknown) {
416 lang_rt = process_sp->GetLanguageRuntime(frame_lang);
417 LLDB_LOGF(log, "Frame has language of type %s",
418 Language::GetNameForLanguageType(frame_lang));
419 }
420
421 // 2. Configure the compiler with a set of default options that are
422 // appropriate for most situations.
423 if (target_arch.IsValid()) {
424 std::string triple = target_arch.GetTriple().str();
425 m_compiler->getTargetOpts().Triple = triple;
426 LLDB_LOGF(log, "Using %s as the target triple",
427 m_compiler->getTargetOpts().Triple.c_str());
428 } else {
429 // If we get here we don't have a valid target and just have to guess.
430 // Sometimes this will be ok to just use the host target triple (when we
431 // evaluate say "2+3", but other expressions like breakpoint conditions and
432 // other things that _are_ target specific really shouldn't just be using
433 // the host triple. In such a case the language runtime should expose an
434 // overridden options set (3), below.
435 m_compiler->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
436 LLDB_LOGF(log, "Using default target triple of %s",
437 m_compiler->getTargetOpts().Triple.c_str());
438 }
439 // Now add some special fixes for known architectures: Any arm32 iOS
440 // environment, but not on arm64
441 if (m_compiler->getTargetOpts().Triple.find("arm64") == std::string::npos &&
442 m_compiler->getTargetOpts().Triple.find("arm") != std::string::npos &&
443 m_compiler->getTargetOpts().Triple.find("ios") != std::string::npos) {
444 m_compiler->getTargetOpts().ABI = "apcs-gnu";
445 }
446 // Supported subsets of x86
447 if (target_machine == llvm::Triple::x86 ||
448 target_machine == llvm::Triple::x86_64) {
449 m_compiler->getTargetOpts().Features.push_back("+sse");
450 m_compiler->getTargetOpts().Features.push_back("+sse2");
451 }
452
453 // Set the target CPU to generate code for. This will be empty for any CPU
454 // that doesn't really need to make a special
455 // CPU string.
456 m_compiler->getTargetOpts().CPU = target_arch.GetClangTargetCPU();
457
458 // Set the target ABI
459 abi = GetClangTargetABI(target_arch);
460 if (!abi.empty())
461 m_compiler->getTargetOpts().ABI = abi;
462
463 // 3. Now allow the runtime to provide custom configuration options for the
464 // target. In this case, a specialized language runtime is available and we
465 // can query it for extra options. For 99% of use cases, this will not be
466 // needed and should be provided when basic platform detection is not enough.
467 // FIXME: Generalize this. Only RenderScriptRuntime currently supports this
468 // currently. Hardcoding this isn't ideal but it's better than LanguageRuntime
469 // having knowledge of clang::TargetOpts.
470 if (auto *renderscript_rt =
471 llvm::dyn_cast_or_null<RenderScriptRuntime>(lang_rt))
472 overridden_target_opts =
473 renderscript_rt->GetOverrideExprOptions(m_compiler->getTargetOpts());
474
475 if (overridden_target_opts)
476 if (log && log->GetVerbose()) {
477 LLDB_LOGV(
478 log, "Using overridden target options for the expression evaluation");
479
480 auto opts = m_compiler->getTargetOpts();
481 LLDB_LOGV(log, "Triple: '{0}'", opts.Triple);
482 LLDB_LOGV(log, "CPU: '{0}'", opts.CPU);
483 LLDB_LOGV(log, "FPMath: '{0}'", opts.FPMath);
484 LLDB_LOGV(log, "ABI: '{0}'", opts.ABI);
485 LLDB_LOGV(log, "LinkerVersion: '{0}'", opts.LinkerVersion);
486 StringList::LogDump(log, opts.FeaturesAsWritten, "FeaturesAsWritten");
487 StringList::LogDump(log, opts.Features, "Features");
488 }
489
490 // 4. Create and install the target on the compiler.
491 m_compiler->createDiagnostics();
492 // Limit the number of error diagnostics we emit.
493 // A value of 0 means no limit for both LLDB and Clang.
494 m_compiler->getDiagnostics().setErrorLimit(target_sp->GetExprErrorLimit());
495
496 auto target_info = TargetInfo::CreateTargetInfo(
497 m_compiler->getDiagnostics(), m_compiler->getInvocation().TargetOpts);
498 if (log) {
499 LLDB_LOGF(log, "Using SIMD alignment: %d",
500 target_info->getSimdDefaultAlign());
501 LLDB_LOGF(log, "Target datalayout string: '%s'",
502 target_info->getDataLayout().getStringRepresentation().c_str());
503 LLDB_LOGF(log, "Target ABI: '%s'", target_info->getABI().str().c_str());
504 LLDB_LOGF(log, "Target vector alignment: %d",
505 target_info->getMaxVectorAlign());
506 }
507 m_compiler->setTarget(target_info);
508
509 assert(m_compiler->hasTarget());
510
511 // 5. Set language options.
512 lldb::LanguageType language = expr.Language();
513 LangOptions &lang_opts = m_compiler->getLangOpts();
514
515 switch (language) {
516 case lldb::eLanguageTypeC:
517 case lldb::eLanguageTypeC89:
518 case lldb::eLanguageTypeC99:
519 case lldb::eLanguageTypeC11:
520 // FIXME: the following language option is a temporary workaround,
521 // to "ask for C, get C++."
522 // For now, the expression parser must use C++ anytime the language is a C
523 // family language, because the expression parser uses features of C++ to
524 // capture values.
525 lang_opts.CPlusPlus = true;
526 break;
527 case lldb::eLanguageTypeObjC:
528 lang_opts.ObjC = true;
529 // FIXME: the following language option is a temporary workaround,
530 // to "ask for ObjC, get ObjC++" (see comment above).
531 lang_opts.CPlusPlus = true;
532
533 // Clang now sets as default C++14 as the default standard (with
534 // GNU extensions), so we do the same here to avoid mismatches that
535 // cause compiler error when evaluating expressions (e.g. nullptr not found
536 // as it's a C++11 feature). Currently lldb evaluates C++14 as C++11 (see
537 // two lines below) so we decide to be consistent with that, but this could
538 // be re-evaluated in the future.
539 lang_opts.CPlusPlus11 = true;
540 break;
541 case lldb::eLanguageTypeC_plus_plus:
542 case lldb::eLanguageTypeC_plus_plus_11:
543 case lldb::eLanguageTypeC_plus_plus_14:
544 lang_opts.CPlusPlus11 = true;
545 m_compiler->getHeaderSearchOpts().UseLibcxx = true;
546 LLVM_FALLTHROUGH;
547 case lldb::eLanguageTypeC_plus_plus_03:
548 lang_opts.CPlusPlus = true;
549 if (process_sp)
550 lang_opts.ObjC =
551 process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC) != nullptr;
552 break;
553 case lldb::eLanguageTypeObjC_plus_plus:
554 case lldb::eLanguageTypeUnknown:
555 default:
556 lang_opts.ObjC = true;
557 lang_opts.CPlusPlus = true;
558 lang_opts.CPlusPlus11 = true;
559 m_compiler->getHeaderSearchOpts().UseLibcxx = true;
560 break;
561 }
562
563 lang_opts.Bool = true;
564 lang_opts.WChar = true;
565 lang_opts.Blocks = true;
566 lang_opts.DebuggerSupport =
567 true; // Features specifically for debugger clients
568 if (expr.DesiredResultType() == Expression::eResultTypeId)
569 lang_opts.DebuggerCastResultToId = true;
570
571 lang_opts.CharIsSigned = ArchSpec(m_compiler->getTargetOpts().Triple.c_str())
572 .CharIsSignedByDefault();
573
574 // Spell checking is a nice feature, but it ends up completing a lot of types
575 // that we didn't strictly speaking need to complete. As a result, we spend a
576 // long time parsing and importing debug information.
577 lang_opts.SpellChecking = false;
578
579 auto *clang_expr = dyn_cast<ClangUserExpression>(&m_expr);
580 if (clang_expr && clang_expr->DidImportCxxModules()) {
581 LLDB_LOG(log, "Adding lang options for importing C++ modules");
582
583 lang_opts.Modules = true;
584 // We want to implicitly build modules.
585 lang_opts.ImplicitModules = true;
586 // To automatically import all submodules when we import 'std'.
587 lang_opts.ModulesLocalVisibility = false;
588
589 // We use the @import statements, so we need this:
590 // FIXME: We could use the modules-ts, but that currently doesn't work.
591 lang_opts.ObjC = true;
592
593 // Options we need to parse libc++ code successfully.
594 // FIXME: We should ask the driver for the appropriate default flags.
595 lang_opts.GNUMode = true;
596 lang_opts.GNUKeywords = true;
597 lang_opts.DoubleSquareBracketAttributes = true;
598 lang_opts.CPlusPlus11 = true;
599
600 // The Darwin libc expects this macro to be set.
601 lang_opts.GNUCVersion = 40201;
602
603 SetupModuleHeaderPaths(m_compiler.get(), m_include_directories,
604 target_sp);
605 }
606
607 if (process_sp && lang_opts.ObjC) {
608 if (auto *runtime = ObjCLanguageRuntime::Get(*process_sp)) {
609 if (runtime->GetRuntimeVersion() ==
610 ObjCLanguageRuntime::ObjCRuntimeVersions::eAppleObjC_V2)
611 lang_opts.ObjCRuntime.set(ObjCRuntime::MacOSX, VersionTuple(10, 7));
612 else
613 lang_opts.ObjCRuntime.set(ObjCRuntime::FragileMacOSX,
614 VersionTuple(10, 7));
615
616 if (runtime->HasNewLiteralsAndIndexing())
617 lang_opts.DebuggerObjCLiteral = true;
618 }
619 }
620
621 lang_opts.ThreadsafeStatics = false;
622 lang_opts.AccessControl = false; // Debuggers get universal access
623 lang_opts.DollarIdents = true; // $ indicates a persistent variable name
624 // We enable all builtin functions beside the builtins from libc/libm (e.g.
625 // 'fopen'). Those libc functions are already correctly handled by LLDB, and
626 // additionally enabling them as expandable builtins is breaking Clang.
627 lang_opts.NoBuiltin = true;
628
629 // Set CodeGen options
630 m_compiler->getCodeGenOpts().EmitDeclMetadata = true;
631 m_compiler->getCodeGenOpts().InstrumentFunctions = false;
632 m_compiler->getCodeGenOpts().setFramePointer(
633 CodeGenOptions::FramePointerKind::All);
634 if (generate_debug_info)
635 m_compiler->getCodeGenOpts().setDebugInfo(codegenoptions::FullDebugInfo);
636 else
637 m_compiler->getCodeGenOpts().setDebugInfo(codegenoptions::NoDebugInfo);
638
639 // Disable some warnings.
640 m_compiler->getDiagnostics().setSeverityForGroup(
641 clang::diag::Flavor::WarningOrError, "unused-value",
642 clang::diag::Severity::Ignored, SourceLocation());
643 m_compiler->getDiagnostics().setSeverityForGroup(
644 clang::diag::Flavor::WarningOrError, "odr",
645 clang::diag::Severity::Ignored, SourceLocation());
646
647 // Inform the target of the language options
648 //
649 // FIXME: We shouldn't need to do this, the target should be immutable once
650 // created. This complexity should be lifted elsewhere.
651 m_compiler->getTarget().adjust(m_compiler->getLangOpts());
652
653 // 6. Set up the diagnostic buffer for reporting errors
654
655 auto diag_mgr = new ClangDiagnosticManagerAdapter(
656 m_compiler->getDiagnostics().getDiagnosticOptions());
657 m_compiler->getDiagnostics().setClient(diag_mgr);
658
659 // 7. Set up the source management objects inside the compiler
660 m_compiler->createFileManager();
661 if (!m_compiler->hasSourceManager())
662 m_compiler->createSourceManager(m_compiler->getFileManager());
663 m_compiler->createPreprocessor(TU_Complete);
664
665 switch (language) {
666 case lldb::eLanguageTypeC:
667 case lldb::eLanguageTypeC89:
668 case lldb::eLanguageTypeC99:
669 case lldb::eLanguageTypeC11:
670 case lldb::eLanguageTypeObjC:
671 // This is not a C++ expression but we enabled C++ as explained above.
672 // Remove all C++ keywords from the PP so that the user can still use
673 // variables that have C++ keywords as names (e.g. 'int template;').
674 RemoveAllCppKeywords(m_compiler->getPreprocessor().getIdentifierTable());
675 break;
676 default:
677 break;
678 }
679
680 if (ClangModulesDeclVendor *decl_vendor =
681 target_sp->GetClangModulesDeclVendor()) {
682 if (auto *clang_persistent_vars = llvm::cast<ClangPersistentVariables>(
683 target_sp->GetPersistentExpressionStateForLanguage(
684 lldb::eLanguageTypeC))) {
685 std::unique_ptr<PPCallbacks> pp_callbacks(
686 new LLDBPreprocessorCallbacks(*decl_vendor, *clang_persistent_vars,
687 m_compiler->getSourceManager()));
688 m_pp_callbacks =
689 static_cast<LLDBPreprocessorCallbacks *>(pp_callbacks.get());
690 m_compiler->getPreprocessor().addPPCallbacks(std::move(pp_callbacks));
691 }
692 }
693
694 // 8. Most of this we get from the CompilerInstance, but we also want to give
695 // the context an ExternalASTSource.
696
697 auto &PP = m_compiler->getPreprocessor();
698 auto &builtin_context = PP.getBuiltinInfo();
699 builtin_context.initializeBuiltins(PP.getIdentifierTable(),
700 m_compiler->getLangOpts());
701
702 m_compiler->createASTContext();
703 clang::ASTContext &ast_context = m_compiler->getASTContext();
704
705 m_ast_context = std::make_unique<TypeSystemClang>(
706 "Expression ASTContext for '" + m_filename + "'", ast_context);
707
708 std::string module_name("$__lldb_module");
709
710 m_llvm_context = std::make_unique<LLVMContext>();
711 m_code_generator.reset(CreateLLVMCodeGen(
712 m_compiler->getDiagnostics(), module_name,
713 m_compiler->getHeaderSearchOpts(), m_compiler->getPreprocessorOpts(),
714 m_compiler->getCodeGenOpts(), *m_llvm_context));
715 }
716
~ClangExpressionParser()717 ClangExpressionParser::~ClangExpressionParser() {}
718
719 namespace {
720
721 /// \class CodeComplete
722 ///
723 /// A code completion consumer for the clang Sema that is responsible for
724 /// creating the completion suggestions when a user requests completion
725 /// of an incomplete `expr` invocation.
726 class CodeComplete : public CodeCompleteConsumer {
727 CodeCompletionTUInfo m_info;
728
729 std::string m_expr;
730 unsigned m_position = 0;
731 /// The printing policy we use when printing declarations for our completion
732 /// descriptions.
733 clang::PrintingPolicy m_desc_policy;
734
735 struct CompletionWithPriority {
736 CompletionResult::Completion completion;
737 /// See CodeCompletionResult::Priority;
738 unsigned Priority;
739
740 /// Establishes a deterministic order in a list of CompletionWithPriority.
741 /// The order returned here is the order in which the completions are
742 /// displayed to the user.
operator <__anon57ee7a770111::CodeComplete::CompletionWithPriority743 bool operator<(const CompletionWithPriority &o) const {
744 // High priority results should come first.
745 if (Priority != o.Priority)
746 return Priority > o.Priority;
747
748 // Identical priority, so just make sure it's a deterministic order.
749 return completion.GetUniqueKey() < o.completion.GetUniqueKey();
750 }
751 };
752
753 /// The stored completions.
754 /// Warning: These are in a non-deterministic order until they are sorted
755 /// and returned back to the caller.
756 std::vector<CompletionWithPriority> m_completions;
757
758 /// Returns true if the given character can be used in an identifier.
759 /// This also returns true for numbers because for completion we usually
760 /// just iterate backwards over iterators.
761 ///
762 /// Note: lldb uses '$' in its internal identifiers, so we also allow this.
IsIdChar(char c)763 static bool IsIdChar(char c) {
764 return c == '_' || std::isalnum(c) || c == '$';
765 }
766
767 /// Returns true if the given character is used to separate arguments
768 /// in the command line of lldb.
IsTokenSeparator(char c)769 static bool IsTokenSeparator(char c) { return c == ' ' || c == '\t'; }
770
771 /// Drops all tokens in front of the expression that are unrelated for
772 /// the completion of the cmd line. 'unrelated' means here that the token
773 /// is not interested for the lldb completion API result.
dropUnrelatedFrontTokens(StringRef cmd) const774 StringRef dropUnrelatedFrontTokens(StringRef cmd) const {
775 if (cmd.empty())
776 return cmd;
777
778 // If we are at the start of a word, then all tokens are unrelated to
779 // the current completion logic.
780 if (IsTokenSeparator(cmd.back()))
781 return StringRef();
782
783 // Remove all previous tokens from the string as they are unrelated
784 // to completing the current token.
785 StringRef to_remove = cmd;
786 while (!to_remove.empty() && !IsTokenSeparator(to_remove.back())) {
787 to_remove = to_remove.drop_back();
788 }
789 cmd = cmd.drop_front(to_remove.size());
790
791 return cmd;
792 }
793
794 /// Removes the last identifier token from the given cmd line.
removeLastToken(StringRef cmd) const795 StringRef removeLastToken(StringRef cmd) const {
796 while (!cmd.empty() && IsIdChar(cmd.back())) {
797 cmd = cmd.drop_back();
798 }
799 return cmd;
800 }
801
802 /// Attempts to merge the given completion from the given position into the
803 /// existing command. Returns the completion string that can be returned to
804 /// the lldb completion API.
mergeCompletion(StringRef existing,unsigned pos,StringRef completion) const805 std::string mergeCompletion(StringRef existing, unsigned pos,
806 StringRef completion) const {
807 StringRef existing_command = existing.substr(0, pos);
808 // We rewrite the last token with the completion, so let's drop that
809 // token from the command.
810 existing_command = removeLastToken(existing_command);
811 // We also should remove all previous tokens from the command as they
812 // would otherwise be added to the completion that already has the
813 // completion.
814 existing_command = dropUnrelatedFrontTokens(existing_command);
815 return existing_command.str() + completion.str();
816 }
817
818 public:
819 /// Constructs a CodeComplete consumer that can be attached to a Sema.
820 ///
821 /// \param[out] expr
822 /// The whole expression string that we are currently parsing. This
823 /// string needs to be equal to the input the user typed, and NOT the
824 /// final code that Clang is parsing.
825 /// \param[out] position
826 /// The character position of the user cursor in the `expr` parameter.
827 ///
CodeComplete(clang::LangOptions ops,std::string expr,unsigned position)828 CodeComplete(clang::LangOptions ops, std::string expr, unsigned position)
829 : CodeCompleteConsumer(CodeCompleteOptions()),
830 m_info(std::make_shared<GlobalCodeCompletionAllocator>()), m_expr(expr),
831 m_position(position), m_desc_policy(ops) {
832
833 // Ensure that the printing policy is producing a description that is as
834 // short as possible.
835 m_desc_policy.SuppressScope = true;
836 m_desc_policy.SuppressTagKeyword = true;
837 m_desc_policy.FullyQualifiedName = false;
838 m_desc_policy.TerseOutput = true;
839 m_desc_policy.IncludeNewlines = false;
840 m_desc_policy.UseVoidForZeroParams = false;
841 m_desc_policy.Bool = true;
842 }
843
844 /// \name Code-completion filtering
845 /// Check if the result should be filtered out.
isResultFilteredOut(StringRef Filter,CodeCompletionResult Result)846 bool isResultFilteredOut(StringRef Filter,
847 CodeCompletionResult Result) override {
848 // This code is mostly copied from CodeCompleteConsumer.
849 switch (Result.Kind) {
850 case CodeCompletionResult::RK_Declaration:
851 return !(
852 Result.Declaration->getIdentifier() &&
853 Result.Declaration->getIdentifier()->getName().startswith(Filter));
854 case CodeCompletionResult::RK_Keyword:
855 return !StringRef(Result.Keyword).startswith(Filter);
856 case CodeCompletionResult::RK_Macro:
857 return !Result.Macro->getName().startswith(Filter);
858 case CodeCompletionResult::RK_Pattern:
859 return !StringRef(Result.Pattern->getAsString()).startswith(Filter);
860 }
861 // If we trigger this assert or the above switch yields a warning, then
862 // CodeCompletionResult has been enhanced with more kinds of completion
863 // results. Expand the switch above in this case.
864 assert(false && "Unknown completion result type?");
865 // If we reach this, then we should just ignore whatever kind of unknown
866 // result we got back. We probably can't turn it into any kind of useful
867 // completion suggestion with the existing code.
868 return true;
869 }
870
871 private:
872 /// Generate the completion strings for the given CodeCompletionResult.
873 /// Note that this function has to process results that could come in
874 /// non-deterministic order, so this function should have no side effects.
875 /// To make this easier to enforce, this function and all its parameters
876 /// should always be const-qualified.
877 /// \return Returns llvm::None if no completion should be provided for the
878 /// given CodeCompletionResult.
879 llvm::Optional<CompletionWithPriority>
getCompletionForResult(const CodeCompletionResult & R) const880 getCompletionForResult(const CodeCompletionResult &R) const {
881 std::string ToInsert;
882 std::string Description;
883 // Handle the different completion kinds that come from the Sema.
884 switch (R.Kind) {
885 case CodeCompletionResult::RK_Declaration: {
886 const NamedDecl *D = R.Declaration;
887 ToInsert = R.Declaration->getNameAsString();
888 // If we have a function decl that has no arguments we want to
889 // complete the empty parantheses for the user. If the function has
890 // arguments, we at least complete the opening bracket.
891 if (const FunctionDecl *F = dyn_cast<FunctionDecl>(D)) {
892 if (F->getNumParams() == 0)
893 ToInsert += "()";
894 else
895 ToInsert += "(";
896 raw_string_ostream OS(Description);
897 F->print(OS, m_desc_policy, false);
898 OS.flush();
899 } else if (const VarDecl *V = dyn_cast<VarDecl>(D)) {
900 Description = V->getType().getAsString(m_desc_policy);
901 } else if (const FieldDecl *F = dyn_cast<FieldDecl>(D)) {
902 Description = F->getType().getAsString(m_desc_policy);
903 } else if (const NamespaceDecl *N = dyn_cast<NamespaceDecl>(D)) {
904 // If we try to complete a namespace, then we can directly append
905 // the '::'.
906 if (!N->isAnonymousNamespace())
907 ToInsert += "::";
908 }
909 break;
910 }
911 case CodeCompletionResult::RK_Keyword:
912 ToInsert = R.Keyword;
913 break;
914 case CodeCompletionResult::RK_Macro:
915 ToInsert = R.Macro->getName().str();
916 break;
917 case CodeCompletionResult::RK_Pattern:
918 ToInsert = R.Pattern->getTypedText();
919 break;
920 }
921 // We also filter some internal lldb identifiers here. The user
922 // shouldn't see these.
923 if (llvm::StringRef(ToInsert).startswith("$__lldb_"))
924 return llvm::None;
925 if (ToInsert.empty())
926 return llvm::None;
927 // Merge the suggested Token into the existing command line to comply
928 // with the kind of result the lldb API expects.
929 std::string CompletionSuggestion =
930 mergeCompletion(m_expr, m_position, ToInsert);
931
932 CompletionResult::Completion completion(CompletionSuggestion, Description,
933 CompletionMode::Normal);
934 return {{completion, R.Priority}};
935 }
936
937 public:
938 /// Adds the completions to the given CompletionRequest.
GetCompletions(CompletionRequest & request)939 void GetCompletions(CompletionRequest &request) {
940 // Bring m_completions into a deterministic order and pass it on to the
941 // CompletionRequest.
942 llvm::sort(m_completions);
943
944 for (const CompletionWithPriority &C : m_completions)
945 request.AddCompletion(C.completion.GetCompletion(),
946 C.completion.GetDescription(),
947 C.completion.GetMode());
948 }
949
950 /// \name Code-completion callbacks
951 /// Process the finalized code-completion results.
ProcessCodeCompleteResults(Sema & SemaRef,CodeCompletionContext Context,CodeCompletionResult * Results,unsigned NumResults)952 void ProcessCodeCompleteResults(Sema &SemaRef, CodeCompletionContext Context,
953 CodeCompletionResult *Results,
954 unsigned NumResults) override {
955
956 // The Sema put the incomplete token we try to complete in here during
957 // lexing, so we need to retrieve it here to know what we are completing.
958 StringRef Filter = SemaRef.getPreprocessor().getCodeCompletionFilter();
959
960 // Iterate over all the results. Filter out results we don't want and
961 // process the rest.
962 for (unsigned I = 0; I != NumResults; ++I) {
963 // Filter the results with the information from the Sema.
964 if (!Filter.empty() && isResultFilteredOut(Filter, Results[I]))
965 continue;
966
967 CodeCompletionResult &R = Results[I];
968 llvm::Optional<CompletionWithPriority> CompletionAndPriority =
969 getCompletionForResult(R);
970 if (!CompletionAndPriority)
971 continue;
972 m_completions.push_back(*CompletionAndPriority);
973 }
974 }
975
976 /// \param S the semantic-analyzer object for which code-completion is being
977 /// done.
978 ///
979 /// \param CurrentArg the index of the current argument.
980 ///
981 /// \param Candidates an array of overload candidates.
982 ///
983 /// \param NumCandidates the number of overload candidates
ProcessOverloadCandidates(Sema & S,unsigned CurrentArg,OverloadCandidate * Candidates,unsigned NumCandidates,SourceLocation OpenParLoc)984 void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
985 OverloadCandidate *Candidates,
986 unsigned NumCandidates,
987 SourceLocation OpenParLoc) override {
988 // At the moment we don't filter out any overloaded candidates.
989 }
990
getAllocator()991 CodeCompletionAllocator &getAllocator() override {
992 return m_info.getAllocator();
993 }
994
getCodeCompletionTUInfo()995 CodeCompletionTUInfo &getCodeCompletionTUInfo() override { return m_info; }
996 };
997 } // namespace
998
Complete(CompletionRequest & request,unsigned line,unsigned pos,unsigned typed_pos)999 bool ClangExpressionParser::Complete(CompletionRequest &request, unsigned line,
1000 unsigned pos, unsigned typed_pos) {
1001 DiagnosticManager mgr;
1002 // We need the raw user expression here because that's what the CodeComplete
1003 // class uses to provide completion suggestions.
1004 // However, the `Text` method only gives us the transformed expression here.
1005 // To actually get the raw user input here, we have to cast our expression to
1006 // the LLVMUserExpression which exposes the right API. This should never fail
1007 // as we always have a ClangUserExpression whenever we call this.
1008 ClangUserExpression *llvm_expr = cast<ClangUserExpression>(&m_expr);
1009 CodeComplete CC(m_compiler->getLangOpts(), llvm_expr->GetUserText(),
1010 typed_pos);
1011 // We don't need a code generator for parsing.
1012 m_code_generator.reset();
1013 // Start parsing the expression with our custom code completion consumer.
1014 ParseInternal(mgr, &CC, line, pos);
1015 CC.GetCompletions(request);
1016 return true;
1017 }
1018
Parse(DiagnosticManager & diagnostic_manager)1019 unsigned ClangExpressionParser::Parse(DiagnosticManager &diagnostic_manager) {
1020 return ParseInternal(diagnostic_manager);
1021 }
1022
1023 unsigned
ParseInternal(DiagnosticManager & diagnostic_manager,CodeCompleteConsumer * completion_consumer,unsigned completion_line,unsigned completion_column)1024 ClangExpressionParser::ParseInternal(DiagnosticManager &diagnostic_manager,
1025 CodeCompleteConsumer *completion_consumer,
1026 unsigned completion_line,
1027 unsigned completion_column) {
1028 ClangDiagnosticManagerAdapter *adapter =
1029 static_cast<ClangDiagnosticManagerAdapter *>(
1030 m_compiler->getDiagnostics().getClient());
1031
1032 adapter->ResetManager(&diagnostic_manager);
1033
1034 const char *expr_text = m_expr.Text();
1035
1036 clang::SourceManager &source_mgr = m_compiler->getSourceManager();
1037 bool created_main_file = false;
1038
1039 // Clang wants to do completion on a real file known by Clang's file manager,
1040 // so we have to create one to make this work.
1041 // TODO: We probably could also simulate to Clang's file manager that there
1042 // is a real file that contains our code.
1043 bool should_create_file = completion_consumer != nullptr;
1044
1045 // We also want a real file on disk if we generate full debug info.
1046 should_create_file |= m_compiler->getCodeGenOpts().getDebugInfo() ==
1047 codegenoptions::FullDebugInfo;
1048
1049 if (should_create_file) {
1050 int temp_fd = -1;
1051 llvm::SmallString<128> result_path;
1052 if (FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir()) {
1053 tmpdir_file_spec.AppendPathComponent("lldb-%%%%%%.expr");
1054 std::string temp_source_path = tmpdir_file_spec.GetPath();
1055 llvm::sys::fs::createUniqueFile(temp_source_path, temp_fd, result_path);
1056 } else {
1057 llvm::sys::fs::createTemporaryFile("lldb", "expr", temp_fd, result_path);
1058 }
1059
1060 if (temp_fd != -1) {
1061 lldb_private::NativeFile file(temp_fd, File::eOpenOptionWrite, true);
1062 const size_t expr_text_len = strlen(expr_text);
1063 size_t bytes_written = expr_text_len;
1064 if (file.Write(expr_text, bytes_written).Success()) {
1065 if (bytes_written == expr_text_len) {
1066 file.Close();
1067 if (auto fileEntry =
1068 m_compiler->getFileManager().getFile(result_path)) {
1069 source_mgr.setMainFileID(source_mgr.createFileID(
1070 *fileEntry,
1071 SourceLocation(), SrcMgr::C_User));
1072 created_main_file = true;
1073 }
1074 }
1075 }
1076 }
1077 }
1078
1079 if (!created_main_file) {
1080 std::unique_ptr<MemoryBuffer> memory_buffer =
1081 MemoryBuffer::getMemBufferCopy(expr_text, m_filename);
1082 source_mgr.setMainFileID(source_mgr.createFileID(std::move(memory_buffer)));
1083 }
1084
1085 adapter->BeginSourceFile(m_compiler->getLangOpts(),
1086 &m_compiler->getPreprocessor());
1087
1088 ClangExpressionHelper *type_system_helper =
1089 dyn_cast<ClangExpressionHelper>(m_expr.GetTypeSystemHelper());
1090
1091 // If we want to parse for code completion, we need to attach our code
1092 // completion consumer to the Sema and specify a completion position.
1093 // While parsing the Sema will call this consumer with the provided
1094 // completion suggestions.
1095 if (completion_consumer) {
1096 auto main_file = source_mgr.getFileEntryForID(source_mgr.getMainFileID());
1097 auto &PP = m_compiler->getPreprocessor();
1098 // Lines and columns start at 1 in Clang, but code completion positions are
1099 // indexed from 0, so we need to add 1 to the line and column here.
1100 ++completion_line;
1101 ++completion_column;
1102 PP.SetCodeCompletionPoint(main_file, completion_line, completion_column);
1103 }
1104
1105 ASTConsumer *ast_transformer =
1106 type_system_helper->ASTTransformer(m_code_generator.get());
1107
1108 std::unique_ptr<clang::ASTConsumer> Consumer;
1109 if (ast_transformer) {
1110 Consumer = std::make_unique<ASTConsumerForwarder>(ast_transformer);
1111 } else if (m_code_generator) {
1112 Consumer = std::make_unique<ASTConsumerForwarder>(m_code_generator.get());
1113 } else {
1114 Consumer = std::make_unique<ASTConsumer>();
1115 }
1116
1117 clang::ASTContext &ast_context = m_compiler->getASTContext();
1118
1119 m_compiler->setSema(new Sema(m_compiler->getPreprocessor(), ast_context,
1120 *Consumer, TU_Complete, completion_consumer));
1121 m_compiler->setASTConsumer(std::move(Consumer));
1122
1123 if (ast_context.getLangOpts().Modules) {
1124 m_compiler->createASTReader();
1125 m_ast_context->setSema(&m_compiler->getSema());
1126 }
1127
1128 ClangExpressionDeclMap *decl_map = type_system_helper->DeclMap();
1129 if (decl_map) {
1130 decl_map->InstallCodeGenerator(&m_compiler->getASTConsumer());
1131 decl_map->InstallDiagnosticManager(diagnostic_manager);
1132
1133 clang::ExternalASTSource *ast_source = decl_map->CreateProxy();
1134
1135 if (ast_context.getExternalSource()) {
1136 auto module_wrapper =
1137 new ExternalASTSourceWrapper(ast_context.getExternalSource());
1138
1139 auto ast_source_wrapper = new ExternalASTSourceWrapper(ast_source);
1140
1141 auto multiplexer =
1142 new SemaSourceWithPriorities(*module_wrapper, *ast_source_wrapper);
1143 IntrusiveRefCntPtr<ExternalASTSource> Source(multiplexer);
1144 ast_context.setExternalSource(Source);
1145 } else {
1146 ast_context.setExternalSource(ast_source);
1147 }
1148 decl_map->InstallASTContext(*m_ast_context);
1149 }
1150
1151 // Check that the ASTReader is properly attached to ASTContext and Sema.
1152 if (ast_context.getLangOpts().Modules) {
1153 assert(m_compiler->getASTContext().getExternalSource() &&
1154 "ASTContext doesn't know about the ASTReader?");
1155 assert(m_compiler->getSema().getExternalSource() &&
1156 "Sema doesn't know about the ASTReader?");
1157 }
1158
1159 {
1160 llvm::CrashRecoveryContextCleanupRegistrar<Sema> CleanupSema(
1161 &m_compiler->getSema());
1162 ParseAST(m_compiler->getSema(), false, false);
1163 }
1164
1165 // Make sure we have no pointer to the Sema we are about to destroy.
1166 if (ast_context.getLangOpts().Modules)
1167 m_ast_context->setSema(nullptr);
1168 // Destroy the Sema. This is necessary because we want to emulate the
1169 // original behavior of ParseAST (which also destroys the Sema after parsing).
1170 m_compiler->setSema(nullptr);
1171
1172 adapter->EndSourceFile();
1173
1174 unsigned num_errors = adapter->getNumErrors();
1175
1176 if (m_pp_callbacks && m_pp_callbacks->hasErrors()) {
1177 num_errors++;
1178 diagnostic_manager.PutString(eDiagnosticSeverityError,
1179 "while importing modules:");
1180 diagnostic_manager.AppendMessageToDiagnostic(
1181 m_pp_callbacks->getErrorString());
1182 }
1183
1184 if (!num_errors) {
1185 type_system_helper->CommitPersistentDecls();
1186 }
1187
1188 adapter->ResetManager();
1189
1190 return num_errors;
1191 }
1192
1193 std::string
GetClangTargetABI(const ArchSpec & target_arch)1194 ClangExpressionParser::GetClangTargetABI(const ArchSpec &target_arch) {
1195 std::string abi;
1196
1197 if (target_arch.IsMIPS()) {
1198 switch (target_arch.GetFlags() & ArchSpec::eMIPSABI_mask) {
1199 case ArchSpec::eMIPSABI_N64:
1200 abi = "n64";
1201 break;
1202 case ArchSpec::eMIPSABI_N32:
1203 abi = "n32";
1204 break;
1205 case ArchSpec::eMIPSABI_O32:
1206 abi = "o32";
1207 break;
1208 default:
1209 break;
1210 }
1211 }
1212 return abi;
1213 }
1214
1215 /// Applies the given Fix-It hint to the given commit.
ApplyFixIt(const FixItHint & fixit,clang::edit::Commit & commit)1216 static void ApplyFixIt(const FixItHint &fixit, clang::edit::Commit &commit) {
1217 // This is cobbed from clang::Rewrite::FixItRewriter.
1218 if (fixit.CodeToInsert.empty()) {
1219 if (fixit.InsertFromRange.isValid()) {
1220 commit.insertFromRange(fixit.RemoveRange.getBegin(),
1221 fixit.InsertFromRange, /*afterToken=*/false,
1222 fixit.BeforePreviousInsertions);
1223 return;
1224 }
1225 commit.remove(fixit.RemoveRange);
1226 return;
1227 }
1228 if (fixit.RemoveRange.isTokenRange() ||
1229 fixit.RemoveRange.getBegin() != fixit.RemoveRange.getEnd()) {
1230 commit.replace(fixit.RemoveRange, fixit.CodeToInsert);
1231 return;
1232 }
1233 commit.insert(fixit.RemoveRange.getBegin(), fixit.CodeToInsert,
1234 /*afterToken=*/false, fixit.BeforePreviousInsertions);
1235 }
1236
RewriteExpression(DiagnosticManager & diagnostic_manager)1237 bool ClangExpressionParser::RewriteExpression(
1238 DiagnosticManager &diagnostic_manager) {
1239 clang::SourceManager &source_manager = m_compiler->getSourceManager();
1240 clang::edit::EditedSource editor(source_manager, m_compiler->getLangOpts(),
1241 nullptr);
1242 clang::edit::Commit commit(editor);
1243 clang::Rewriter rewriter(source_manager, m_compiler->getLangOpts());
1244
1245 class RewritesReceiver : public edit::EditsReceiver {
1246 Rewriter &rewrite;
1247
1248 public:
1249 RewritesReceiver(Rewriter &in_rewrite) : rewrite(in_rewrite) {}
1250
1251 void insert(SourceLocation loc, StringRef text) override {
1252 rewrite.InsertText(loc, text);
1253 }
1254 void replace(CharSourceRange range, StringRef text) override {
1255 rewrite.ReplaceText(range.getBegin(), rewrite.getRangeSize(range), text);
1256 }
1257 };
1258
1259 RewritesReceiver rewrites_receiver(rewriter);
1260
1261 const DiagnosticList &diagnostics = diagnostic_manager.Diagnostics();
1262 size_t num_diags = diagnostics.size();
1263 if (num_diags == 0)
1264 return false;
1265
1266 for (const auto &diag : diagnostic_manager.Diagnostics()) {
1267 const auto *diagnostic = llvm::dyn_cast<ClangDiagnostic>(diag.get());
1268 if (!diagnostic)
1269 continue;
1270 if (!diagnostic->HasFixIts())
1271 continue;
1272 for (const FixItHint &fixit : diagnostic->FixIts())
1273 ApplyFixIt(fixit, commit);
1274 }
1275
1276 // FIXME - do we want to try to propagate specific errors here?
1277 if (!commit.isCommitable())
1278 return false;
1279 else if (!editor.commit(commit))
1280 return false;
1281
1282 // Now play all the edits, and stash the result in the diagnostic manager.
1283 editor.applyRewrites(rewrites_receiver);
1284 RewriteBuffer &main_file_buffer =
1285 rewriter.getEditBuffer(source_manager.getMainFileID());
1286
1287 std::string fixed_expression;
1288 llvm::raw_string_ostream out_stream(fixed_expression);
1289
1290 main_file_buffer.write(out_stream);
1291 out_stream.flush();
1292 diagnostic_manager.SetFixedExpression(fixed_expression);
1293
1294 return true;
1295 }
1296
FindFunctionInModule(ConstString & mangled_name,llvm::Module * module,const char * orig_name)1297 static bool FindFunctionInModule(ConstString &mangled_name,
1298 llvm::Module *module, const char *orig_name) {
1299 for (const auto &func : module->getFunctionList()) {
1300 const StringRef &name = func.getName();
1301 if (name.find(orig_name) != StringRef::npos) {
1302 mangled_name.SetString(name);
1303 return true;
1304 }
1305 }
1306
1307 return false;
1308 }
1309
PrepareForExecution(lldb::addr_t & func_addr,lldb::addr_t & func_end,lldb::IRExecutionUnitSP & execution_unit_sp,ExecutionContext & exe_ctx,bool & can_interpret,ExecutionPolicy execution_policy)1310 lldb_private::Status ClangExpressionParser::PrepareForExecution(
1311 lldb::addr_t &func_addr, lldb::addr_t &func_end,
1312 lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx,
1313 bool &can_interpret, ExecutionPolicy execution_policy) {
1314 func_addr = LLDB_INVALID_ADDRESS;
1315 func_end = LLDB_INVALID_ADDRESS;
1316 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
1317
1318 lldb_private::Status err;
1319
1320 std::unique_ptr<llvm::Module> llvm_module_up(
1321 m_code_generator->ReleaseModule());
1322
1323 if (!llvm_module_up) {
1324 err.SetErrorToGenericError();
1325 err.SetErrorString("IR doesn't contain a module");
1326 return err;
1327 }
1328
1329 ConstString function_name;
1330
1331 if (execution_policy != eExecutionPolicyTopLevel) {
1332 // Find the actual name of the function (it's often mangled somehow)
1333
1334 if (!FindFunctionInModule(function_name, llvm_module_up.get(),
1335 m_expr.FunctionName())) {
1336 err.SetErrorToGenericError();
1337 err.SetErrorStringWithFormat("Couldn't find %s() in the module",
1338 m_expr.FunctionName());
1339 return err;
1340 } else {
1341 LLDB_LOGF(log, "Found function %s for %s", function_name.AsCString(),
1342 m_expr.FunctionName());
1343 }
1344 }
1345
1346 SymbolContext sc;
1347
1348 if (lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP()) {
1349 sc = frame_sp->GetSymbolContext(lldb::eSymbolContextEverything);
1350 } else if (lldb::TargetSP target_sp = exe_ctx.GetTargetSP()) {
1351 sc.target_sp = target_sp;
1352 }
1353
1354 LLVMUserExpression::IRPasses custom_passes;
1355 {
1356 auto lang = m_expr.Language();
1357 LLDB_LOGF(log, "%s - Current expression language is %s\n", __FUNCTION__,
1358 Language::GetNameForLanguageType(lang));
1359 lldb::ProcessSP process_sp = exe_ctx.GetProcessSP();
1360 if (process_sp && lang != lldb::eLanguageTypeUnknown) {
1361 auto runtime = process_sp->GetLanguageRuntime(lang);
1362 if (runtime)
1363 runtime->GetIRPasses(custom_passes);
1364 }
1365 }
1366
1367 if (custom_passes.EarlyPasses) {
1368 LLDB_LOGF(log,
1369 "%s - Running Early IR Passes from LanguageRuntime on "
1370 "expression module '%s'",
1371 __FUNCTION__, m_expr.FunctionName());
1372
1373 custom_passes.EarlyPasses->run(*llvm_module_up);
1374 }
1375
1376 execution_unit_sp = std::make_shared<IRExecutionUnit>(
1377 m_llvm_context, // handed off here
1378 llvm_module_up, // handed off here
1379 function_name, exe_ctx.GetTargetSP(), sc,
1380 m_compiler->getTargetOpts().Features);
1381
1382 ClangExpressionHelper *type_system_helper =
1383 dyn_cast<ClangExpressionHelper>(m_expr.GetTypeSystemHelper());
1384 ClangExpressionDeclMap *decl_map =
1385 type_system_helper->DeclMap(); // result can be NULL
1386
1387 if (decl_map) {
1388 StreamString error_stream;
1389 IRForTarget ir_for_target(decl_map, m_expr.NeedsVariableResolution(),
1390 *execution_unit_sp, error_stream,
1391 function_name.AsCString());
1392
1393 if (!ir_for_target.runOnModule(*execution_unit_sp->GetModule())) {
1394 err.SetErrorString(error_stream.GetString());
1395 return err;
1396 }
1397
1398 Process *process = exe_ctx.GetProcessPtr();
1399
1400 if (execution_policy != eExecutionPolicyAlways &&
1401 execution_policy != eExecutionPolicyTopLevel) {
1402 lldb_private::Status interpret_error;
1403
1404 bool interpret_function_calls =
1405 !process ? false : process->CanInterpretFunctionCalls();
1406 can_interpret = IRInterpreter::CanInterpret(
1407 *execution_unit_sp->GetModule(), *execution_unit_sp->GetFunction(),
1408 interpret_error, interpret_function_calls);
1409
1410 if (!can_interpret && execution_policy == eExecutionPolicyNever) {
1411 err.SetErrorStringWithFormat(
1412 "Can't evaluate the expression without a running target due to: %s",
1413 interpret_error.AsCString());
1414 return err;
1415 }
1416 }
1417
1418 if (!process && execution_policy == eExecutionPolicyAlways) {
1419 err.SetErrorString("Expression needed to run in the target, but the "
1420 "target can't be run");
1421 return err;
1422 }
1423
1424 if (!process && execution_policy == eExecutionPolicyTopLevel) {
1425 err.SetErrorString("Top-level code needs to be inserted into a runnable "
1426 "target, but the target can't be run");
1427 return err;
1428 }
1429
1430 if (execution_policy == eExecutionPolicyAlways ||
1431 (execution_policy != eExecutionPolicyTopLevel && !can_interpret)) {
1432 if (m_expr.NeedsValidation() && process) {
1433 if (!process->GetDynamicCheckers()) {
1434 ClangDynamicCheckerFunctions *dynamic_checkers =
1435 new ClangDynamicCheckerFunctions();
1436
1437 DiagnosticManager install_diagnostics;
1438
1439 if (!dynamic_checkers->Install(install_diagnostics, exe_ctx)) {
1440 if (install_diagnostics.Diagnostics().size())
1441 err.SetErrorString(install_diagnostics.GetString().c_str());
1442 else
1443 err.SetErrorString("couldn't install checkers, unknown error");
1444
1445 return err;
1446 }
1447
1448 process->SetDynamicCheckers(dynamic_checkers);
1449
1450 LLDB_LOGF(log, "== [ClangExpressionParser::PrepareForExecution] "
1451 "Finished installing dynamic checkers ==");
1452 }
1453
1454 if (auto *checker_funcs = llvm::dyn_cast<ClangDynamicCheckerFunctions>(
1455 process->GetDynamicCheckers())) {
1456 IRDynamicChecks ir_dynamic_checks(*checker_funcs,
1457 function_name.AsCString());
1458
1459 llvm::Module *module = execution_unit_sp->GetModule();
1460 if (!module || !ir_dynamic_checks.runOnModule(*module)) {
1461 err.SetErrorToGenericError();
1462 err.SetErrorString("Couldn't add dynamic checks to the expression");
1463 return err;
1464 }
1465
1466 if (custom_passes.LatePasses) {
1467 LLDB_LOGF(log,
1468 "%s - Running Late IR Passes from LanguageRuntime on "
1469 "expression module '%s'",
1470 __FUNCTION__, m_expr.FunctionName());
1471
1472 custom_passes.LatePasses->run(*module);
1473 }
1474 }
1475 }
1476 }
1477
1478 if (execution_policy == eExecutionPolicyAlways ||
1479 execution_policy == eExecutionPolicyTopLevel || !can_interpret) {
1480 execution_unit_sp->GetRunnableInfo(err, func_addr, func_end);
1481 }
1482 } else {
1483 execution_unit_sp->GetRunnableInfo(err, func_addr, func_end);
1484 }
1485
1486 return err;
1487 }
1488
RunStaticInitializers(lldb::IRExecutionUnitSP & execution_unit_sp,ExecutionContext & exe_ctx)1489 lldb_private::Status ClangExpressionParser::RunStaticInitializers(
1490 lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx) {
1491 lldb_private::Status err;
1492
1493 lldbassert(execution_unit_sp.get());
1494 lldbassert(exe_ctx.HasThreadScope());
1495
1496 if (!execution_unit_sp.get()) {
1497 err.SetErrorString(
1498 "can't run static initializers for a NULL execution unit");
1499 return err;
1500 }
1501
1502 if (!exe_ctx.HasThreadScope()) {
1503 err.SetErrorString("can't run static initializers without a thread");
1504 return err;
1505 }
1506
1507 std::vector<lldb::addr_t> static_initializers;
1508
1509 execution_unit_sp->GetStaticInitializers(static_initializers);
1510
1511 for (lldb::addr_t static_initializer : static_initializers) {
1512 EvaluateExpressionOptions options;
1513
1514 lldb::ThreadPlanSP call_static_initializer(new ThreadPlanCallFunction(
1515 exe_ctx.GetThreadRef(), Address(static_initializer), CompilerType(),
1516 llvm::ArrayRef<lldb::addr_t>(), options));
1517
1518 DiagnosticManager execution_errors;
1519 lldb::ExpressionResults results =
1520 exe_ctx.GetThreadRef().GetProcess()->RunThreadPlan(
1521 exe_ctx, call_static_initializer, options, execution_errors);
1522
1523 if (results != lldb::eExpressionCompleted) {
1524 err.SetErrorStringWithFormat("couldn't run static initializer: %s",
1525 execution_errors.GetString().c_str());
1526 return err;
1527 }
1528 }
1529
1530 return err;
1531 }
1532