Source/JavaScriptCore/bytecode/PredictedType.h

   1 /*
   2  * Copyright (C) 2011 Apple Inc. All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  *
   8  * 1.  Redistributions of source code must retain the above copyright
   9  *     notice, this list of conditions and the following disclaimer.
  10  * 2.  Redistributions in binary form must reproduce the above copyright
  11  *     notice, this list of conditions and the following disclaimer in the
  12  *     documentation and/or other materials provided with the distribution.
  13  * 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
  14  *     its contributors may be used to endorse or promote products derived
  15  *     from this software without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  19  * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  20  * DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
  21  * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  22  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  23  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  24  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  26  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27  */
  28
  29 #ifndef PredictedType_h
  30 #define PredictedType_h
  31
  32 #include "JSValue.h"
  33
  34 namespace JSC {
  35
  36 class Structure;
  37
  38 typedef uint32_t PredictedType;
  39 static const PredictedType PredictNone          = 0x00000000; // We don't know anything yet.
  40 static const PredictedType PredictFinalObject   = 0x00000001; // It's definitely a JSFinalObject.
  41 static const PredictedType PredictArray         = 0x00000002; // It's definitely a JSArray.
  42 static const PredictedType PredictByteArray     = 0x00000004; // It's definitely a JSByteArray or one of its subclasses.
  43 static const PredictedType PredictFunction      = 0x00000008; // It's definitely a JSFunction or one of its subclasses.
  44 static const PredictedType PredictInt8Array     = 0x00000010; // It's definitely an Int8Array or one of its subclasses.
  45 static const PredictedType PredictInt16Array    = 0x00000020; // It's definitely an Int16Array or one of its subclasses.
  46 static const PredictedType PredictInt32Array    = 0x00000040; // It's definitely an Int32Array or one of its subclasses.
  47 static const PredictedType PredictUint8Array    = 0x00000080; // It's definitely an Uint8Array or one of its subclasses.
  48 static const PredictedType PredictUint16Array   = 0x00000100; // It's definitely an Uint16Array or one of its subclasses.
  49 static const PredictedType PredictUint32Array   = 0x00000200; // It's definitely an Uint32Array or one of its subclasses.
  50 static const PredictedType PredictFloat32Array  = 0x00000400; // It's definitely an Uint16Array or one of its subclasses.
  51 static const PredictedType PredictFloat64Array  = 0x00000800; // It's definitely an Uint16Array or one of its subclasses.
  52 static const PredictedType PredictObjectOther   = 0x00001000; // It's definitely an object but not JSFinalObject, JSArray, JSByteArray, or JSFunction.
  53 static const PredictedType PredictObjectMask    = 0x00001fff; // Bitmask used for testing for any kind of object prediction.
  54 static const PredictedType PredictString        = 0x00002000; // It's definitely a JSString.
  55 static const PredictedType PredictCellOther     = 0x00004000; // It's definitely a JSCell but not a subclass of JSObject and definitely not a JSString.
  56 static const PredictedType PredictCell          = 0x00007fff; // It's definitely a JSCell.
  57 static const PredictedType PredictInt32         = 0x00008000; // It's definitely an Int32.
  58 static const PredictedType PredictDoubleReal    = 0x00010000; // It's definitely a non-NaN double.
  59 static const PredictedType PredictDoubleNaN     = 0x00020000; // It's definitely a NaN.
  60 static const PredictedType PredictDouble        = 0x00030000; // It's either a non-NaN or a NaN double.
  61 static const PredictedType PredictNumber        = 0x00038000; // It's either an Int32 or a Double.
  62 static const PredictedType PredictBoolean       = 0x00040000; // It's definitely a Boolean.
  63 static const PredictedType PredictOther         = 0x40000000; // It's definitely none of the above.
  64 static const PredictedType PredictTop           = 0x7fffffff; // It can be any of the above.
  65 static const PredictedType FixedIndexedStorageMask = PredictByteArray | PredictInt8Array | PredictInt16Array | PredictInt32Array | PredictUint8Array | PredictUint16Array | PredictUint32Array | PredictFloat32Array | PredictFloat64Array;
  66
  67 typedef bool (*PredictionChecker)(PredictedType);
  68
  69 inline bool isCellPrediction(PredictedType value)
  70 {
  71     return !!(value & PredictCell) && !(value & ~PredictCell);
  72 }
  73
  74 inline bool isObjectPrediction(PredictedType value)
  75 {
  76     return !!(value & PredictObjectMask) && !(value & ~PredictObjectMask);
  77 }
  78
  79 inline bool isFinalObjectPrediction(PredictedType value)
  80 {
  81     return value == PredictFinalObject;
  82 }
  83
  84 inline bool isFinalObjectOrOtherPrediction(PredictedType value)
  85 {
  86     return !!(value & (PredictFinalObject | PredictOther)) && !(value & ~(PredictFinalObject | PredictOther));
  87 }
  88
  89 inline bool isFixedIndexedStorageObjectPrediction(PredictedType value)
  90 {
  91     return (value & FixedIndexedStorageMask) == value;
  92 }
  93
  94 inline bool isStringPrediction(PredictedType value)
  95 {
  96     return value == PredictString;
  97 }
  98
  99 inline bool isArrayPrediction(PredictedType value)
 100 {
 101     return value == PredictArray;
 102 }
 103
 104 inline bool isFunctionPrediction(PredictedType value)
 105 {
 106     return value == PredictFunction;
 107 }
 108
 109 inline bool isByteArrayPrediction(PredictedType value)
 110 {
 111     return value == PredictByteArray;
 112 }
 113
 114 inline bool isInt8ArrayPrediction(PredictedType value)
 115 {
 116     return value == PredictInt8Array;
 117 }
 118
 119 inline bool isInt16ArrayPrediction(PredictedType value)
 120 {
 121     return value == PredictInt16Array;
 122 }
 123
 124 inline bool isInt32ArrayPrediction(PredictedType value)
 125 {
 126     return value == PredictInt32Array;
 127 }
 128
 129 inline bool isUint8ArrayPrediction(PredictedType value)
 130 {
 131     return value == PredictUint8Array;
 132 }
 133
 134 inline bool isUint16ArrayPrediction(PredictedType value)
 135 {
 136     return value == PredictUint16Array;
 137 }
 138
 139 inline bool isUint32ArrayPrediction(PredictedType value)
 140 {
 141     return value == PredictUint32Array;
 142 }
 143
 144 inline bool isFloat32ArrayPrediction(PredictedType value)
 145 {
 146     return value == PredictFloat32Array;
 147 }
 148
 149 inline bool isFloat64ArrayPrediction(PredictedType value)
 150 {
 151     return value == PredictFloat64Array;
 152 }
 153
 154 inline bool isActionableMutableArrayPrediction(PredictedType value)
 155 {
 156     return isArrayPrediction(value)
 157         || isByteArrayPrediction(value)
 158         || isInt8ArrayPrediction(value)
 159         || isInt16ArrayPrediction(value)
 160         || isInt32ArrayPrediction(value)
 161         || isUint8ArrayPrediction(value)
 162         || isUint16ArrayPrediction(value)
 163         || isUint32ArrayPrediction(value)
 164 #if CPU(X86) || CPU(X86_64)
 165         || isFloat32ArrayPrediction(value)
 166 #endif
 167         || isFloat64ArrayPrediction(value);
 168 }
 169
 170 inline bool isActionableArrayPrediction(PredictedType value)
 171 {
 172     return isStringPrediction(value)
 173         || isActionableMutableArrayPrediction(value);
 174 }
 175
 176 inline bool isArrayOrOtherPrediction(PredictedType value)
 177 {
 178     return !!(value & (PredictArray | PredictOther)) && !(value & ~(PredictArray | PredictOther));
 179 }
 180
 181 inline bool isInt32Prediction(PredictedType value)
 182 {
 183     return value == PredictInt32;
 184 }
 185
 186 inline bool isDoubleRealPrediction(PredictedType value)
 187 {
 188     return value == PredictDoubleReal;
 189 }
 190
 191 inline bool isDoublePrediction(PredictedType value)
 192 {
 193     return (value & PredictDouble) == value;
 194 }
 195
 196 inline bool isNumberPrediction(PredictedType value)
 197 {
 198     return !!(value & PredictNumber) && !(value & ~PredictNumber);
 199 }
 200
 201 inline bool isBooleanPrediction(PredictedType value)
 202 {
 203     return value == PredictBoolean;
 204 }
 205
 206 inline bool isOtherPrediction(PredictedType value)
 207 {
 208     return value == PredictOther;
 209 }
 210
 211 #ifndef NDEBUG
 212 const char* predictionToString(PredictedType value);
 213 #endif
 214
 215 // Merge two predictions. Note that currently this just does left | right. It may
 216 // seem tempting to do so directly, but you would be doing so at your own peril,
 217 // since the merging protocol PredictedType may change at any time (and has already
 218 // changed several times in its history).
 219 inline PredictedType mergePredictions(PredictedType left, PredictedType right)
 220 {
 221     return left | right;
 222 }
 223
 224 template<typename T>
 225 inline bool mergePrediction(T& left, PredictedType right)
 226 {
 227     PredictedType newPrediction = static_cast<T>(mergePredictions(static_cast<PredictedType>(left), right));
 228     bool result = newPrediction != static_cast<PredictedType>(left);
 229     left = newPrediction;
 230     return result;
 231 }
 232
 233 PredictedType predictionFromClassInfo(const ClassInfo*);
 234 PredictedType predictionFromStructure(Structure*);
 235 PredictedType predictionFromCell(JSCell*);
 236 PredictedType predictionFromValue(JSValue);
 237
 238 } // namespace JSC
 239
 240 #endif // PredictedType_h