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