blob: 992546560eec45d39a43611942534c5162a1e8f3 (
plain)
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
|
//===--- InterpStack.cpp - Stack 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
//
//===----------------------------------------------------------------------===//
#include "InterpStack.h"
#include "Boolean.h"
#include "FixedPoint.h"
#include "Floating.h"
#include "Integral.h"
#include "MemberPointer.h"
#include "Pointer.h"
#include <cassert>
#include <cstdlib>
using namespace clang;
using namespace clang::interp;
InterpStack::~InterpStack() {
if (Chunk && Chunk->Next)
std::free(Chunk->Next);
if (Chunk)
std::free(Chunk);
}
// We keep the last chunk around to reuse.
void InterpStack::clear() {
for (PrimType Item : llvm::reverse(ItemTypes)) {
TYPE_SWITCH(Item, { this->discard<T>(); });
}
assert(ItemTypes.empty());
assert(empty());
}
void InterpStack::clearTo(size_t NewSize) {
if (NewSize == 0)
return clear();
if (NewSize == size())
return;
assert(NewSize <= size());
for (PrimType Item : llvm::reverse(ItemTypes)) {
TYPE_SWITCH(Item, { this->discard<T>(); });
if (size() == NewSize)
break;
}
// Note: discard() above already removed the types from ItemTypes.
assert(size() == NewSize);
}
void *InterpStack::peekData(size_t Size) const {
assert(Chunk && "Stack is empty!");
if (LLVM_LIKELY(Size <= Chunk->size()))
return reinterpret_cast<void *>(Chunk->start() + Chunk->Size - Size);
StackChunk *Ptr = Chunk;
while (Size > Ptr->size()) {
Size -= Ptr->size();
Ptr = Ptr->Prev;
assert(Ptr && "Offset too large");
}
return reinterpret_cast<void *>(Ptr->start() + Ptr->Size - Size);
}
void InterpStack::shrink(size_t Size) {
assert(Chunk && "Chunk is empty!");
// Likely case is that we simply remove something from the current chunk.
if (LLVM_LIKELY(Size <= Chunk->size())) {
Chunk->Size -= Size;
StackSize -= Size;
return;
}
while (Size > Chunk->size()) {
Size -= Chunk->size();
if (Chunk->Next) {
std::free(Chunk->Next);
Chunk->Next = nullptr;
}
Chunk->Size = 0;
Chunk = Chunk->Prev;
assert(Chunk && "Offset too large");
}
Chunk->Size -= Size;
StackSize -= Size;
}
void InterpStack::dump() const {
llvm::errs() << "Items: " << ItemTypes.size() << ". Size: " << size() << '\n';
if (ItemTypes.empty())
return;
size_t Index = 0;
size_t Offset = 0;
// The type of the item on the top of the stack is inserted to the back
// of the vector, so the iteration has to happen backwards.
for (PrimType Item : llvm::reverse(ItemTypes)) {
Offset += align(primSize(Item));
llvm::errs() << Index << '/' << Offset << ": ";
TYPE_SWITCH(Item, {
const T &V = peek<T>(Offset);
llvm::errs() << V;
});
llvm::errs() << '\n';
++Index;
}
}
|
