Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. //===--- Interpreter.h - Incremental Compilation and Execution---*- C++ -*-===//
  2. //
  3. // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
  4. // See https://llvm.org/LICENSE.txt for license information.
  5. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
  6. //
  7. //===----------------------------------------------------------------------===//
  8. //
  9. // This file defines the component which performs incremental code
  10. // compilation and execution.
  11. //
  12. //===----------------------------------------------------------------------===//
  13.  
  14. #ifndef LLVM_CLANG_INTERPRETER_INTERPRETER_H
  15. #define LLVM_CLANG_INTERPRETER_INTERPRETER_H
  16.  
  17. #include "clang/Interpreter/PartialTranslationUnit.h"
  18.  
  19. #include "clang/AST/GlobalDecl.h"
  20.  
  21. #include "llvm/ExecutionEngine/JITSymbol.h"
  22. #include "llvm/Support/Error.h"
  23.  
  24. #include <memory>
  25. #include <vector>
  26.  
  27. namespace llvm {
  28. namespace orc {
  29. class LLJIT;
  30. class ThreadSafeContext;
  31. }
  32. } // namespace llvm
  33.  
  34. namespace clang {
  35.  
  36. class CompilerInstance;
  37. class IncrementalExecutor;
  38. class IncrementalParser;
  39.  
  40. /// Create a pre-configured \c CompilerInstance for incremental processing.
  41. class IncrementalCompilerBuilder {
  42. public:
  43.   static llvm::Expected<std::unique_ptr<CompilerInstance>>
  44.   create(std::vector<const char *> &ClangArgv);
  45. };
  46.  
  47. /// Provides top-level interfaces for incremental compilation and execution.
  48. class Interpreter {
  49.   std::unique_ptr<llvm::orc::ThreadSafeContext> TSCtx;
  50.   std::unique_ptr<IncrementalParser> IncrParser;
  51.   std::unique_ptr<IncrementalExecutor> IncrExecutor;
  52.  
  53.   Interpreter(std::unique_ptr<CompilerInstance> CI, llvm::Error &Err);
  54.  
  55. public:
  56.   ~Interpreter();
  57.   static llvm::Expected<std::unique_ptr<Interpreter>>
  58.   create(std::unique_ptr<CompilerInstance> CI);
  59.   const CompilerInstance *getCompilerInstance() const;
  60.   const llvm::orc::LLJIT *getExecutionEngine() const;
  61.   llvm::Expected<PartialTranslationUnit &> Parse(llvm::StringRef Code);
  62.   llvm::Error Execute(PartialTranslationUnit &T);
  63.   llvm::Error ParseAndExecute(llvm::StringRef Code) {
  64.     auto PTU = Parse(Code);
  65.     if (!PTU)
  66.       return PTU.takeError();
  67.     if (PTU->TheModule)
  68.       return Execute(*PTU);
  69.     return llvm::Error::success();
  70.   }
  71.  
  72.   /// Undo N previous incremental inputs.
  73.   llvm::Error Undo(unsigned N = 1);
  74.  
  75.   /// \returns the \c JITTargetAddress of a \c GlobalDecl. This interface uses
  76.   /// the CodeGenModule's internal mangling cache to avoid recomputing the
  77.   /// mangled name.
  78.   llvm::Expected<llvm::JITTargetAddress> getSymbolAddress(GlobalDecl GD) const;
  79.  
  80.   /// \returns the \c JITTargetAddress of a given name as written in the IR.
  81.   llvm::Expected<llvm::JITTargetAddress>
  82.   getSymbolAddress(llvm::StringRef IRName) const;
  83.  
  84.   /// \returns the \c JITTargetAddress of a given name as written in the object
  85.   /// file.
  86.   llvm::Expected<llvm::JITTargetAddress>
  87.   getSymbolAddressFromLinkerName(llvm::StringRef LinkerName) const;
  88. };
  89. } // namespace clang
  90.  
  91. #endif // LLVM_CLANG_INTERPRETER_INTERPRETER_H
  92.