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 172