Coverage Report

Created: 2022-07-16 07:03

/Users/buildslave/jenkins/workspace/coverage/llvm-project/clang/include/clang/Interpreter/Interpreter.h
Line
Count
Source
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
92
  llvm::Error ParseAndExecute(llvm::StringRef Code) {
64
92
    auto PTU = Parse(Code);
65
92
    if (!PTU)
66
2
      return PTU.takeError();
67
90
    if (PTU->TheModule)
68
73
      return Execute(*PTU);
69
17
    return llvm::Error::success();
70
90
  }
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