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
22namespace clang {
23namespace interp {
24class Function;
25class InterpState;
26class Pointer;
27
28/// Frame storing local variables.
29class InterpFrame final : public Frame {
30public:
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
123private:
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
145private:
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