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