1//===--- Source.h - Source location provider for the VM  --------*- 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// Defines a program which organises and links multiple bytecode functions.
10//
11//===----------------------------------------------------------------------===//
12
13#ifndef LLVM_CLANG_AST_INTERP_SOURCE_H
14#define LLVM_CLANG_AST_INTERP_SOURCE_H
15
16#include "clang/AST/Decl.h"
17#include "clang/AST/Stmt.h"
18#include "llvm/Support/Endian.h"
19
20namespace clang {
21namespace interp {
22class Function;
23
24/// Pointer into the code segment.
25class CodePtr {
26public:
27  CodePtr() : Ptr(nullptr) {}
28
29  CodePtr &operator+=(int32_t Offset) {
30    Ptr += Offset;
31    return *this;
32  }
33
34  int32_t operator-(const CodePtr &RHS) const {
35    assert(Ptr != nullptr && RHS.Ptr != nullptr && "Invalid code pointer");
36    return Ptr - RHS.Ptr;
37  }
38
39  CodePtr operator-(size_t RHS) const {
40    assert(Ptr != nullptr && "Invalid code pointer");
41    return CodePtr(Ptr - RHS);
42  }
43
44  bool operator!=(const CodePtr &RHS) const { return Ptr != RHS.Ptr; }
45
46  /// Reads data and advances the pointer.
47  template <typename T> T read() {
48    T Value = ReadHelper<T>(Ptr);
49    Ptr += sizeof(T);
50    return Value;
51  }
52
53private:
54  /// Constructor used by Function to generate pointers.
55  CodePtr(const char *Ptr) : Ptr(Ptr) {}
56
57  /// Helper to decode a value or a pointer.
58  template <typename T>
59  static typename std::enable_if<!std::is_pointer<T>::value, T>::type
60  ReadHelper(const char *Ptr) {
61    using namespace llvm::support;
62    return endian::read<T, endianness::native, 1>(Ptr);
63  }
64
65  template <typename T>
66  static typename std::enable_if<std::is_pointer<T>::value, T>::type
67  ReadHelper(const char *Ptr) {
68    using namespace llvm::support;
69    auto Punned = endian::read<uintptr_t, endianness::native, 1>(Ptr);
70    return reinterpret_cast<T>(Punned);
71  }
72
73private:
74  friend class Function;
75
76  /// Pointer into the code owned by a function.
77  const char *Ptr;
78};
79
80/// Describes the statement/declaration an opcode was generated from.
81class SourceInfo {
82public:
83  SourceInfo() {}
84  SourceInfo(const Stmt *E) : Source(E) {}
85  SourceInfo(const Decl *D) : Source(D) {}
86
87  SourceLocation getLoc() const;
88
89  const Stmt *asStmt() const { return Source.dyn_cast<const Stmt *>(); }
90  const Decl *asDecl() const { return Source.dyn_cast<const Decl *>(); }
91  const Expr *asExpr() const;
92
93  operator bool() const { return !Source.isNull(); }
94
95private:
96  llvm::PointerUnion<const Decl *, const Stmt *> Source;
97};
98
99using SourceMap = std::vector<std::pair<unsigned, SourceInfo>>;
100
101/// Interface for classes which map locations to sources.
102class SourceMapper {
103public:
104  virtual ~SourceMapper() {}
105
106  /// Returns source information for a given PC in a function.
107  virtual SourceInfo getSource(Function *F, CodePtr PC) const = 0;
108
109  /// Returns the expression if an opcode belongs to one, null otherwise.
110  const Expr *getExpr(Function *F, CodePtr PC) const;
111  /// Returns the location from which an opcode originates.
112  SourceLocation getLocation(Function *F, CodePtr PC) const;
113};
114
115} // namespace interp
116} // namespace clang
117
118#endif
119