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