Debian Codegraph @

llvm-project/clang/lib/AST/Interp/InterpFrame.h

raw
1 //===--- InterpFrame.h - Call Frame implementation 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 the class storing information about stack frames in the interpreter.
10 //
11 //===----------------------------------------------------------------------===//
12
13 #ifndef LLVM_CLANG_AST_INTERP_INTERPFRAME_H
14 #define LLVM_CLANG_AST_INTERP_INTERPFRAME_H
15
16 #include "Frame.h"
17 #include "Program.h"
18 #include "State.h"
19 #include <cstdint>
20 #include <vector>
21
22 namespace clang {
23 namespace interp {
24 class Function;
25 class InterpState;
26 class Pointer;
27
28 /// Frame storing local variables.
29 class InterpFrame final : public Frame {
30 public:
31 /// The frame of the previous function.
32 InterpFrame *Caller;
33
34 /// Creates a new frame for a method call.
35 InterpFrame(InterpState &S, const Function *Func, InterpFrame *Caller,
36 CodePtr RetPC);
37
38 /// Creates a new frame with the values that make sense.
39 /// I.e., the caller is the current frame of S,
40 /// the This() pointer is the current Pointer on the top of S's stack,
41 /// and the RVO pointer is before that.
42 InterpFrame(InterpState &S, const Function *Func, CodePtr RetPC);
43
44 /// Destroys the frame, killing all live pointers to stack slots.
45 ~InterpFrame();
46
47 /// Invokes the destructors for a scope.
48 void destroy(unsigned Idx);
49
50 /// Pops the arguments off the stack.
51 void popArgs();
52
53 /// Describes the frame with arguments for diagnostic purposes.
54 void describe(llvm::raw_ostream &OS) override;
55
56 /// Returns the parent frame object.
57 Frame *getCaller() const override;
58
59 /// Returns the location of the call to the frame.
60 SourceLocation getCallLocation() const override;
61
62 /// Returns the caller.
63 const FunctionDecl *getCallee() const override;
64
65 /// Returns the current function.
66 const Function *getFunction() const { return Func; }
67
68 /// Returns the offset on the stack at which the frame starts.
69 size_t getFrameOffset() const { return FrameOffset; }
70
71 /// Returns the value of a local variable.
72 template <typename T> const T &getLocal(unsigned Offset) const {
73 return localRef<T>(Offset);
74 }
75
76 /// Mutates a local variable.
77 template <typename T> void setLocal(unsigned Offset, const T &Value) {
78 localRef<T>(Offset) = Value;
79 localInlineDesc(Offset)->IsInitialized = true;
80 }
81
82 /// Returns a pointer to a local variables.
83 Pointer getLocalPointer(unsigned Offset) const;
84
85 /// Returns the value of an argument.
86 template <typename T> const T &getParam(unsigned Offset) const {
87 auto Pt = Params.find(Offset);
88 if (Pt == Params.end()) {
89 return stackRef<T>(Offset);
90 } else {
91 return Pointer(reinterpret_cast<Block *>(Pt->second.get())).deref<T>();
92 }
93 }
94
95 /// Mutates a local copy of a parameter.
96 template <typename T> void setParam(unsigned Offset, const T &Value) {
97 getParamPointer(Offset).deref<T>() = Value;
98 }
99
100 /// Returns a pointer to an argument - lazily creates a block.
101 Pointer getParamPointer(unsigned Offset);
102
103 /// Returns the 'this' pointer.
104 const Pointer &getThis() const { return This; }
105
106 /// Returns the RVO pointer, if the Function has one.
107 const Pointer &getRVOPtr() const { return RVOPtr; }
108
109 /// Checks if the frame is a root frame - return should quit the interpreter.
110 bool isRoot() const { return !Func; }
111
112 /// Returns the PC of the frame's code start.
113 CodePtr getPC() const { return Func->getCodeBegin(); }
114
115 /// Returns the return address of the frame.
116 CodePtr getRetPC() const { return RetPC; }
117
118 /// Map a location to a source.
119 virtual SourceInfo getSource(CodePtr PC) const;
120 const Expr *getExpr(CodePtr PC) const;
121 SourceLocation getLocation(CodePtr PC) const;
122
123 private:
124 /// Returns an original argument from the stack.
125 template <typename T> const T &stackRef(unsigned Offset) const {
126 assert(Args);
127 return *reinterpret_cast<const T *>(Args - ArgSize + Offset);
128 }
129
130 /// Returns an offset to a local.
131 template <typename T> T &localRef(unsigned Offset) const {
132 return getLocalPointer(Offset).deref<T>();
133 }
134
135 /// Returns a pointer to a local's block.
136 void *localBlock(unsigned Offset) const {
137 return Locals.get() + Offset - sizeof(Block);
138 }
139
140 // Returns the inline descriptor of the local.
141 InlineDescriptor *localInlineDesc(unsigned Offset) const {
142 return reinterpret_cast<InlineDescriptor *>(Locals.get() + Offset);
143 }
144
145 private:
146 /// Reference to the interpreter state.
147 InterpState &S;
148 /// Reference to the function being executed.
149 const Function *Func;
150 /// Current object pointer for methods.
151 Pointer This;
152 /// Pointer the non-primitive return value gets constructed in.
153 Pointer RVOPtr;
154 /// Return address.
155 CodePtr RetPC;
156 /// The size of all the arguments.
157 const unsigned ArgSize;
158 /// Pointer to the arguments in the callee's frame.
159 char *Args = nullptr;
160 /// Fixed, initial storage for known local variables.
161 std::unique_ptr<char[]> Locals;
162 /// Offset on the stack at entry.
163 const size_t FrameOffset;
164 /// Mapping from arg offsets to their argument blocks.
165 llvm::DenseMap<unsigned, std::unique_ptr<char[]>> Params;
166 };
167
168 } // namespace interp
169 } // namespace clang
170
171 #endif