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