forked from phoboslab/JavaScriptCore-iOS
-
Notifications
You must be signed in to change notification settings - Fork 0
Expand file tree
/
Copy pathPredictedType.h
More file actions
259 lines (217 loc) · 9.8 KB
/
PredictedType.h
File metadata and controls
259 lines (217 loc) · 9.8 KB
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
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
/*
* Copyright (C) 2011 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of Apple Computer, Inc. ("Apple") nor the names of
* its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef PredictedType_h
#define PredictedType_h
#include "JSValue.h"
namespace JSC {
class Structure;
typedef uint32_t PredictedType;
static const PredictedType PredictNone = 0x00000000; // We don't know anything yet.
static const PredictedType PredictFinalObject = 0x00000001; // It's definitely a JSFinalObject.
static const PredictedType PredictArray = 0x00000002; // It's definitely a JSArray.
static const PredictedType PredictFunction = 0x00000008; // It's definitely a JSFunction or one of its subclasses.
static const PredictedType PredictInt8Array = 0x00000010; // It's definitely an Int8Array or one of its subclasses.
static const PredictedType PredictInt16Array = 0x00000020; // It's definitely an Int16Array or one of its subclasses.
static const PredictedType PredictInt32Array = 0x00000040; // It's definitely an Int32Array or one of its subclasses.
static const PredictedType PredictUint8Array = 0x00000080; // It's definitely an Uint8Array or one of its subclasses.
static const PredictedType PredictUint8ClampedArray = 0x00000100; // It's definitely an Uint8ClampedArray or one of its subclasses.
static const PredictedType PredictUint16Array = 0x00000200; // It's definitely an Uint16Array or one of its subclasses.
static const PredictedType PredictUint32Array = 0x00000400; // It's definitely an Uint32Array or one of its subclasses.
static const PredictedType PredictFloat32Array = 0x00000800; // It's definitely an Uint16Array or one of its subclasses.
static const PredictedType PredictFloat64Array = 0x00001000; // It's definitely an Uint16Array or one of its subclasses.
static const PredictedType PredictObjectOther = 0x00002000; // It's definitely an object but not JSFinalObject, JSArray, or JSFunction.
static const PredictedType PredictObjectMask = 0x00003fff; // Bitmask used for testing for any kind of object prediction.
static const PredictedType PredictString = 0x00004000; // It's definitely a JSString.
static const PredictedType PredictCellOther = 0x00008000; // It's definitely a JSCell but not a subclass of JSObject and definitely not a JSString.
static const PredictedType PredictCell = 0x0000ffff; // It's definitely a JSCell.
static const PredictedType PredictInt32 = 0x00010000; // It's definitely an Int32.
static const PredictedType PredictDoubleReal = 0x00020000; // It's definitely a non-NaN double.
static const PredictedType PredictDoubleNaN = 0x00040000; // It's definitely a NaN.
static const PredictedType PredictDouble = 0x00060000; // It's either a non-NaN or a NaN double.
static const PredictedType PredictNumber = 0x00070000; // It's either an Int32 or a Double.
static const PredictedType PredictBoolean = 0x00080000; // It's definitely a Boolean.
static const PredictedType PredictOther = 0x08000000; // It's definitely none of the above.
static const PredictedType PredictTop = 0x0fffffff; // It can be any of the above.
static const PredictedType PredictEmpty = 0x10000000; // It's definitely an empty value marker.
static const PredictedType PredictEmptyOrTop = 0x1fffffff; // It can be any of the above.
static const PredictedType FixedIndexedStorageMask = PredictInt8Array | PredictInt16Array | PredictInt32Array | PredictUint8Array | PredictUint8ClampedArray | PredictUint16Array | PredictUint32Array | PredictFloat32Array | PredictFloat64Array;
typedef bool (*PredictionChecker)(PredictedType);
inline bool isCellPrediction(PredictedType value)
{
return !!(value & PredictCell) && !(value & ~PredictCell);
}
inline bool isObjectPrediction(PredictedType value)
{
return !!(value & PredictObjectMask) && !(value & ~PredictObjectMask);
}
inline bool isFinalObjectPrediction(PredictedType value)
{
return value == PredictFinalObject;
}
inline bool isFinalObjectOrOtherPrediction(PredictedType value)
{
return !!(value & (PredictFinalObject | PredictOther)) && !(value & ~(PredictFinalObject | PredictOther));
}
inline bool isFixedIndexedStorageObjectPrediction(PredictedType value)
{
return !!value && (value & FixedIndexedStorageMask) == value;
}
inline bool isStringPrediction(PredictedType value)
{
return value == PredictString;
}
inline bool isArrayPrediction(PredictedType value)
{
return value == PredictArray;
}
inline bool isFunctionPrediction(PredictedType value)
{
return value == PredictFunction;
}
inline bool isInt8ArrayPrediction(PredictedType value)
{
return value == PredictInt8Array;
}
inline bool isInt16ArrayPrediction(PredictedType value)
{
return value == PredictInt16Array;
}
inline bool isInt32ArrayPrediction(PredictedType value)
{
return value == PredictInt32Array;
}
inline bool isUint8ArrayPrediction(PredictedType value)
{
return value == PredictUint8Array;
}
inline bool isUint8ClampedArrayPrediction(PredictedType value)
{
return value == PredictUint8ClampedArray;
}
inline bool isUint16ArrayPrediction(PredictedType value)
{
return value == PredictUint16Array;
}
inline bool isUint32ArrayPrediction(PredictedType value)
{
return value == PredictUint32Array;
}
inline bool isFloat32ArrayPrediction(PredictedType value)
{
return value == PredictFloat32Array;
}
inline bool isFloat64ArrayPrediction(PredictedType value)
{
return value == PredictFloat64Array;
}
inline bool isActionableIntMutableArrayPrediction(PredictedType value)
{
return isInt8ArrayPrediction(value)
|| isInt16ArrayPrediction(value)
|| isInt32ArrayPrediction(value)
|| isUint8ArrayPrediction(value)
|| isUint8ClampedArrayPrediction(value)
|| isUint16ArrayPrediction(value)
|| isUint32ArrayPrediction(value);
}
inline bool isActionableFloatMutableArrayPrediction(PredictedType value)
{
return isFloat32ArrayPrediction(value)
|| isFloat64ArrayPrediction(value);
}
inline bool isActionableTypedMutableArrayPrediction(PredictedType value)
{
return isActionableIntMutableArrayPrediction(value)
|| isActionableFloatMutableArrayPrediction(value);
}
inline bool isActionableMutableArrayPrediction(PredictedType value)
{
return isArrayPrediction(value)
|| isActionableTypedMutableArrayPrediction(value);
}
inline bool isActionableArrayPrediction(PredictedType value)
{
return isStringPrediction(value)
|| isActionableMutableArrayPrediction(value);
}
inline bool isArrayOrOtherPrediction(PredictedType value)
{
return !!(value & (PredictArray | PredictOther)) && !(value & ~(PredictArray | PredictOther));
}
inline bool isInt32Prediction(PredictedType value)
{
return value == PredictInt32;
}
inline bool isDoubleRealPrediction(PredictedType value)
{
return value == PredictDoubleReal;
}
inline bool isDoublePrediction(PredictedType value)
{
return !!value && (value & PredictDouble) == value;
}
inline bool isNumberPrediction(PredictedType value)
{
return !!(value & PredictNumber) && !(value & ~PredictNumber);
}
inline bool isBooleanPrediction(PredictedType value)
{
return value == PredictBoolean;
}
inline bool isOtherPrediction(PredictedType value)
{
return value == PredictOther;
}
inline bool isEmptyPrediction(PredictedType value)
{
return value == PredictEmpty;
}
const char* predictionToString(PredictedType value);
const char* predictionToAbbreviatedString(PredictedType value);
// Merge two predictions. Note that currently this just does left | right. It may
// seem tempting to do so directly, but you would be doing so at your own peril,
// since the merging protocol PredictedType may change at any time (and has already
// changed several times in its history).
inline PredictedType mergePredictions(PredictedType left, PredictedType right)
{
return left | right;
}
template<typename T>
inline bool mergePrediction(T& left, PredictedType right)
{
PredictedType newPrediction = static_cast<T>(mergePredictions(static_cast<PredictedType>(left), right));
bool result = newPrediction != static_cast<PredictedType>(left);
left = newPrediction;
return result;
}
PredictedType predictionFromClassInfo(const ClassInfo*);
PredictedType predictionFromStructure(Structure*);
PredictedType predictionFromCell(JSCell*);
PredictedType predictionFromValue(JSValue);
} // namespace JSC
#endif // PredictedType_h