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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
|
//===--- EnumImpl.h - Enum implementation runtime declarations --*- C++ -*-===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
// Enum implementation details declarations of the Swift runtime.
//
//===----------------------------------------------------------------------===//
#ifndef SWIFT_RUNTIME_ENUMIMPL_H
#define SWIFT_RUNTIME_ENUMIMPL_H
#include "swift/ABI/Enum.h"
#include "swift/Runtime/Enum.h"
namespace swift {
/// Store the given 4-byte unsigned integer value into the variable-
/// length destination buffer. The value will be zero extended or
/// truncated to fit in the buffer.
static inline void storeEnumElement(uint8_t *dst,
uint32_t value,
size_t size) {
// Note: we use fixed size memcpys to encourage the compiler to
// optimize them into unaligned stores.
switch (size) {
case 0:
return;
case 1:
dst[0] = uint8_t(value);
return;
case 2:
#if defined(__BIG_ENDIAN__)
value <<= 16;
#endif
memcpy(dst, &value, 2);
return;
case 3:
#if defined(__BIG_ENDIAN__)
value <<= 8;
#endif
memcpy(dst, &value, 3);
return;
case 4:
memcpy(dst, &value, 4);
return;
}
// Store zero extended value in the destination.
#if defined(__BIG_ENDIAN__)
memset(&dst[0], 0, size - 4);
memcpy(&dst[size - 4], &value, 4);
#else
memcpy(&dst[0], &value, 4);
memset(&dst[4], 0, size - 4);
#endif
}
/// Load a 4-byte unsigned integer value from the variable-length
/// source buffer. The value will be zero-extended or truncated to fit
/// into the returned value.
static inline uint32_t loadEnumElement(const uint8_t *src,
size_t size) {
// Note: we use fixed size memcpys to encourage the compiler to
// optimize them into unaligned loads.
uint32_t result = 0;
switch (size) {
case 0:
return 0;
case 1:
return uint32_t(src[0]);
case 2:
memcpy(&result, src, 2);
#if defined(__BIG_ENDIAN__)
result >>= 16;
#endif
return result;
case 3:
memcpy(&result, src, 3);
#if defined(__BIG_ENDIAN__)
result >>= 8;
#endif
return result;
case 4:
memcpy(&result, src, 4);
return result;
}
// Load value by truncating the source to 4 bytes.
#if defined(__BIG_ENDIAN__)
memcpy(&result, &src[size - 4], 4);
#else
memcpy(&result, &src[0], 4);
#endif
return result;
}
inline unsigned getEnumTagSinglePayloadImpl(
const OpaqueValue *enumAddr, unsigned emptyCases, const Metadata *payload,
size_t payloadSize, unsigned payloadNumExtraInhabitants,
getExtraInhabitantTag_t *getExtraInhabitantTag) {
// If there are extra tag bits, check them.
if (emptyCases > payloadNumExtraInhabitants) {
auto *valueAddr = reinterpret_cast<const uint8_t *>(enumAddr);
auto *extraTagBitAddr = valueAddr + payloadSize;
unsigned numBytes =
getEnumTagCounts(payloadSize,
emptyCases - payloadNumExtraInhabitants,
1 /*payload case*/).numTagBytes;
unsigned extraTagBits = loadEnumElement(extraTagBitAddr, numBytes);
// If the extra tag bits are zero, we have a valid payload or
// extra inhabitant (checked below). If nonzero, form the case index from
// the extra tag value and the value stored in the payload.
if (extraTagBits > 0) {
unsigned caseIndexFromExtraTagBits =
payloadSize >= 4 ? 0 : (extraTagBits - 1U) << (payloadSize * 8U);
unsigned caseIndexFromValue = loadEnumElement(valueAddr, payloadSize);
unsigned noPayloadIndex =
(caseIndexFromExtraTagBits | caseIndexFromValue) +
payloadNumExtraInhabitants;
return noPayloadIndex + 1;
}
}
// If there are extra inhabitants, see whether the payload is valid.
if (payloadNumExtraInhabitants > 0) {
return getExtraInhabitantTag(enumAddr, payloadNumExtraInhabitants, payload);
}
// Otherwise, we have always have a valid payload.
return 0;
}
inline void storeEnumTagSinglePayloadImpl(
OpaqueValue *value, unsigned whichCase, unsigned emptyCases,
const Metadata *payload, size_t payloadSize,
unsigned payloadNumExtraInhabitants,
storeExtraInhabitantTag_t *storeExtraInhabitantTag) {
auto *valueAddr = reinterpret_cast<uint8_t *>(value);
auto *extraTagBitAddr = valueAddr + payloadSize;
unsigned numExtraTagBytes =
emptyCases > payloadNumExtraInhabitants
? getEnumTagCounts(payloadSize,
emptyCases - payloadNumExtraInhabitants,
1 /*payload case*/).numTagBytes
: 0;
// For payload or extra inhabitant cases, zero-initialize the extra tag bits,
// if any.
if (whichCase <= payloadNumExtraInhabitants) {
if (numExtraTagBytes != 0)
storeEnumElement(extraTagBitAddr, 0, numExtraTagBytes);
// If this is the payload case, we're done.
if (whichCase == 0)
return;
// Store the extra inhabitant.
storeExtraInhabitantTag(value, whichCase, payloadNumExtraInhabitants,
payload);
return;
}
// Factor the case index into payload and extra tag parts.
unsigned noPayloadIndex = whichCase - 1;
unsigned caseIndex = noPayloadIndex - payloadNumExtraInhabitants;
unsigned payloadIndex, extraTagIndex;
if (payloadSize >= 4) {
extraTagIndex = 1;
payloadIndex = caseIndex;
} else {
unsigned payloadBits = payloadSize * 8U;
extraTagIndex = 1U + (caseIndex >> payloadBits);
payloadIndex = caseIndex & ((1U << payloadBits) - 1U);
}
// Store into the value.
if (payloadSize)
storeEnumElement(valueAddr, payloadIndex, payloadSize);
if (numExtraTagBytes)
storeEnumElement(extraTagBitAddr, extraTagIndex, numExtraTagBytes);
}
} /* end namespace swift */
#endif /* SWIFT_RUNTIME_ENUMIMPL_H */
|
