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
|
//===--- Block.cpp - Allocated blocks for the interpreter -------*- 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 classes describing allocated blocks.
//
//===----------------------------------------------------------------------===//
#include "InterpBlock.h"
#include "Pointer.h"
using namespace clang;
using namespace clang::interp;
void Block::addPointer(Pointer *P) {
assert(P);
if (IsStatic) {
assert(!Pointers);
return;
}
#ifndef NDEBUG
assert(!hasPointer(P));
#endif
if (Pointers)
Pointers->Prev = P;
P->Next = Pointers;
P->Prev = nullptr;
Pointers = P;
}
void Block::removePointer(Pointer *P) {
assert(P);
if (IsStatic) {
assert(!Pointers);
return;
}
#ifndef NDEBUG
assert(hasPointer(P));
#endif
if (Pointers == P)
Pointers = P->Next;
if (P->Prev)
P->Prev->Next = P->Next;
if (P->Next)
P->Next->Prev = P->Prev;
}
void Block::cleanup() {
if (Pointers == nullptr && IsDead)
(reinterpret_cast<DeadBlock *>(this + 1) - 1)->free();
}
void Block::replacePointer(Pointer *Old, Pointer *New) {
assert(Old);
assert(New);
if (IsStatic) {
assert(!Pointers);
return;
}
#ifndef NDEBUG
assert(hasPointer(Old));
#endif
removePointer(Old);
addPointer(New);
Old->PointeeStorage.BS.Pointee = nullptr;
#ifndef NDEBUG
assert(!hasPointer(Old));
assert(hasPointer(New));
#endif
}
#ifndef NDEBUG
bool Block::hasPointer(const Pointer *P) const {
for (const Pointer *C = Pointers; C; C = C->Next) {
if (C == P)
return true;
}
return false;
}
#endif
DeadBlock::DeadBlock(DeadBlock *&Root, Block *Blk)
: Root(Root),
B(~0u, Blk->Desc, Blk->IsStatic, Blk->IsExtern, /*isDead=*/true) {
// Add the block to the chain of dead blocks.
if (Root)
Root->Prev = this;
Next = Root;
Prev = nullptr;
Root = this;
// Transfer pointers.
B.Pointers = Blk->Pointers;
for (Pointer *P = Blk->Pointers; P; P = P->Next)
P->PointeeStorage.BS.Pointee = &B;
Blk->Pointers = nullptr;
}
void DeadBlock::free() {
if (B.IsInitialized)
B.invokeDtor();
if (Prev)
Prev->Next = Next;
if (Next)
Next->Prev = Prev;
if (Root == this)
Root = Next;
std::free(this);
}
|
