// -----------------------------------------------------------------------------
// TypeImpl
-template <class Config>
+template<class Config>
typename TypeImpl<Config>::bitset TypeImpl<Config>::BitsetType::SignedSmall() {
return i::SmiValuesAre31Bits() ? kSigned31 : kSigned32;
}
-template <class Config>
+template<class Config>
typename TypeImpl<Config>::bitset
TypeImpl<Config>::BitsetType::UnsignedSmall() {
return i::SmiValuesAre31Bits() ? kUnsigned30 : kUnsigned31;
}
+#define CONSTRUCT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) \
+template<class Config> \
+typename TypeImpl<Config>::TypeHandle TypeImpl<Config>::Name( \
+ Isolate* isolate, Region* region) { \
+ return Class(i::handle(isolate->heap()->name##_map()), region); \
+}
+SIMD128_TYPES(CONSTRUCT_SIMD_TYPE)
+#undef CONSTRUCT_SIMD_TYPE
+
+
template<class Config>
TypeImpl<Config>* TypeImpl<Config>::cast(typename Config::Base* object) {
TypeImpl* t = static_cast<TypeImpl*>(object);
V(Symbol, 1u << 12 | REPRESENTATION(kTaggedPointer)) \
V(InternalizedString, 1u << 13 | REPRESENTATION(kTaggedPointer)) \
V(OtherString, 1u << 14 | REPRESENTATION(kTaggedPointer)) \
- V(Undetectable, 1u << 15 | REPRESENTATION(kTaggedPointer)) \
- /* Unused semantic bit 1u << 16 in case you are looking for a bit. */ \
+ V(Simd, 1u << 15 | REPRESENTATION(kTaggedPointer)) \
+ V(Undetectable, 1u << 16 | REPRESENTATION(kTaggedPointer)) \
V(OtherObject, 1u << 17 | REPRESENTATION(kTaggedPointer)) \
V(Proxy, 1u << 18 | REPRESENTATION(kTaggedPointer)) \
V(Internal, 1u << 19 | REPRESENTATION(kTagged | kUntagged)) \
V(NumberOrString, kNumber | kString) \
V(NumberOrUndefined, kNumber | kUndefined) \
V(PlainPrimitive, kNumberOrString | kBoolean | kNullOrUndefined) \
- V(Primitive, kSymbol | kPlainPrimitive) \
+ V(Primitive, kSymbol | kSimd | kPlainPrimitive) \
V(DetectableReceiver, kOtherObject | kProxy) \
V(Detectable, kDetectableReceiver | kNumber | kName) \
V(Object, kOtherObject | kUndetectable) \
// typedef Range;
// typedef Region;
// template<class> struct Handle { typedef type; } // No template typedefs...
+//
// template<class T> static Handle<T>::type null_handle();
// template<class T> static Handle<T>::type handle(T* t); // !is_bitset(t)
// template<class T> static Handle<T>::type cast(Handle<Type>::type);
return function;
}
+#define CONSTRUCT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) \
+ static TypeHandle Name(Isolate* isolate, Region* region);
+ SIMD128_TYPES(CONSTRUCT_SIMD_TYPE)
+#undef CONSTRUCT_SIMD_TYPE
+
static TypeHandle Union(TypeHandle type1, TypeHandle type2, Region* reg);
static TypeHandle Intersect(TypeHandle type1, TypeHandle type2, Region* reg);
static TypeImpl* Union(TypeImpl* type1, TypeImpl* type2) {
class Types {
public:
Types(Region* region, Isolate* isolate, v8::base::RandomNumberGenerator* rng)
- : region_(region), rng_(rng) {
+ : region_(region), isolate_(isolate), rng_(rng) {
#define DECLARE_TYPE(name, value) \
name = Type::name(region); \
types.push_back(name);
}
return type;
}
+ case 8: { // simd
+ static const int num_simd_types =
+ #define COUNT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) +1
+ SIMD128_TYPES(COUNT_SIMD_TYPE)
+ #undef COUNT_SIMD_TYPE
+ ;
+ TypeHandle (*simd_constructors[num_simd_types])(Isolate*, Region*) = {
+ #define COUNT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) \
+ &Type::Name,
+ SIMD128_TYPES(COUNT_SIMD_TYPE)
+ #undef COUNT_SIMD_TYPE
+ };
+ return simd_constructors[rng_->NextInt(num_simd_types)](
+ isolate_, region_);
+ }
default: { // union
int n = rng_->NextInt(10);
TypeHandle type = None;
private:
Region* region_;
+ Isolate* isolate_;
v8::base::RandomNumberGenerator* rng_;
};