blob: a4ec8ccebbd3bd723bc205190c842731402b2aaa (
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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
//===----------------------------------------------------------------------===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// These classes support the generation of CIR for cleanups, initially based
// on LLVM IR cleanup handling, but ought to change as CIR evolves.
//
//===----------------------------------------------------------------------===//
#ifndef CLANG_LIB_CIR_CODEGEN_CIRGENCLEANUP_H
#define CLANG_LIB_CIR_CODEGEN_CIRGENCLEANUP_H
#include "Address.h"
#include "EHScopeStack.h"
#include "mlir/IR/Value.h"
namespace clang::CIRGen {
/// A protected scope for zero-cost EH handling.
class EHScope {
class CommonBitFields {
friend class EHScope;
unsigned kind : 3;
};
enum { NumCommonBits = 3 };
protected:
class CleanupBitFields {
friend class EHCleanupScope;
unsigned : NumCommonBits;
/// Whether this cleanup needs to be run along normal edges.
unsigned isNormalCleanup : 1;
/// Whether this cleanup needs to be run along exception edges.
unsigned isEHCleanup : 1;
/// Whether this cleanup is currently active.
unsigned isActive : 1;
/// Whether this cleanup is a lifetime marker
unsigned isLifetimeMarker : 1;
/// Whether the normal cleanup should test the activation flag.
unsigned testFlagInNormalCleanup : 1;
/// Whether the EH cleanup should test the activation flag.
unsigned testFlagInEHCleanup : 1;
/// The amount of extra storage needed by the Cleanup.
/// Always a multiple of the scope-stack alignment.
unsigned cleanupSize : 12;
};
union {
CommonBitFields commonBits;
CleanupBitFields cleanupBits;
};
public:
enum Kind { Cleanup, Catch, Terminate, Filter };
EHScope(Kind kind) { commonBits.kind = kind; }
Kind getKind() const { return static_cast<Kind>(commonBits.kind); }
};
/// A cleanup scope which generates the cleanup blocks lazily.
class alignas(EHScopeStack::ScopeStackAlignment) EHCleanupScope
: public EHScope {
public:
/// Gets the size required for a lazy cleanup scope with the given
/// cleanup-data requirements.
static size_t getSizeForCleanupSize(size_t size) {
return sizeof(EHCleanupScope) + size;
}
size_t getAllocatedSize() const {
return sizeof(EHCleanupScope) + cleanupBits.cleanupSize;
}
EHCleanupScope(unsigned cleanupSize) : EHScope(EHScope::Cleanup) {
// TODO(cir): When exception handling is upstreamed, isNormalCleanup and
// isEHCleanup will be arguments to the constructor.
cleanupBits.isNormalCleanup = true;
cleanupBits.isEHCleanup = false;
cleanupBits.isActive = true;
cleanupBits.isLifetimeMarker = false;
cleanupBits.testFlagInNormalCleanup = false;
cleanupBits.testFlagInEHCleanup = false;
cleanupBits.cleanupSize = cleanupSize;
assert(cleanupBits.cleanupSize == cleanupSize && "cleanup size overflow");
}
void destroy() {}
// Objects of EHCleanupScope are not destructed. Use destroy().
~EHCleanupScope() = delete;
bool isNormalCleanup() const { return cleanupBits.isNormalCleanup; }
bool isActive() const { return cleanupBits.isActive; }
size_t getCleanupSize() const { return cleanupBits.cleanupSize; }
void *getCleanupBuffer() { return this + 1; }
EHScopeStack::Cleanup *getCleanup() {
return reinterpret_cast<EHScopeStack::Cleanup *>(getCleanupBuffer());
}
static bool classof(const EHScope *scope) {
return (scope->getKind() == Cleanup);
}
void markEmitted() {}
};
/// A non-stable pointer into the scope stack.
class EHScopeStack::iterator {
char *ptr = nullptr;
friend class EHScopeStack;
explicit iterator(char *ptr) : ptr(ptr) {}
public:
iterator() = default;
EHScope *get() const { return reinterpret_cast<EHScope *>(ptr); }
EHScope &operator*() const { return *get(); }
};
inline EHScopeStack::iterator EHScopeStack::begin() const {
return iterator(startOfData);
}
} // namespace clang::CIRGen
#endif // CLANG_LIB_CIR_CODEGEN_CIRGENCLEANUP_H
|
