clang/lib/AST/ByteCode/InterpFrame.h

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