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