Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(591)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: test/cctest/ast-types-fuzz.h

Issue 2302283002: Forking the type system between Crankshaft & Turbofan. (Closed)
Patch Set: Nits. Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « src/v8.gyp ('k') | test/cctest/cctest.gyp » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: test/cctest/ast-types-fuzz.h
diff --git a/test/cctest/types-fuzz.h b/test/cctest/ast-types-fuzz.h
similarity index 52%
copy from test/cctest/types-fuzz.h
copy to test/cctest/ast-types-fuzz.h
index 3d6eddaed8841c9a3cda341a7bdc1ceca048d9dd..81d53da43b89099fe889664e6644c7ed6168f1c7 100644
--- a/test/cctest/types-fuzz.h
+++ b/test/cctest/ast-types-fuzz.h
@@ -36,37 +36,35 @@
namespace v8 {
namespace internal {
-
class Types {
public:
Types(Zone* zone, Isolate* isolate, v8::base::RandomNumberGenerator* rng)
: zone_(zone), isolate_(isolate), rng_(rng) {
#define DECLARE_TYPE(name, value) \
- name = Type::name(); \
+ name = AstType::name(); \
types.push_back(name);
- PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
- #undef DECLARE_TYPE
-
- SignedSmall = Type::SignedSmall();
- UnsignedSmall = Type::UnsignedSmall();
-
- object_map = isolate->factory()->NewMap(
- JS_OBJECT_TYPE, JSObject::kHeaderSize);
- array_map = isolate->factory()->NewMap(
- JS_ARRAY_TYPE, JSArray::kSize);
- number_map = isolate->factory()->NewMap(
- HEAP_NUMBER_TYPE, HeapNumber::kSize);
+ AST_PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
+#undef DECLARE_TYPE
+
+ SignedSmall = AstType::SignedSmall();
+ UnsignedSmall = AstType::UnsignedSmall();
+
+ object_map =
+ isolate->factory()->NewMap(JS_OBJECT_TYPE, JSObject::kHeaderSize);
+ array_map = isolate->factory()->NewMap(JS_ARRAY_TYPE, JSArray::kSize);
+ number_map =
+ isolate->factory()->NewMap(HEAP_NUMBER_TYPE, HeapNumber::kSize);
uninitialized_map = isolate->factory()->uninitialized_map();
- ObjectClass = Type::Class(object_map, zone);
- ArrayClass = Type::Class(array_map, zone);
- NumberClass = Type::Class(number_map, zone);
- UninitializedClass = Type::Class(uninitialized_map, zone);
+ ObjectClass = AstType::Class(object_map, zone);
+ ArrayClass = AstType::Class(array_map, zone);
+ NumberClass = AstType::Class(number_map, zone);
+ UninitializedClass = AstType::Class(uninitialized_map, zone);
maps.push_back(object_map);
maps.push_back(array_map);
maps.push_back(uninitialized_map);
for (MapVector::iterator it = maps.begin(); it != maps.end(); ++it) {
- types.push_back(Type::Class(*it, zone));
+ types.push_back(AstType::Class(*it, zone));
}
smi = handle(Smi::FromInt(666), isolate);
@@ -75,13 +73,13 @@ class Types {
object2 = isolate->factory()->NewJSObjectFromMap(object_map);
array = isolate->factory()->NewJSArray(20);
uninitialized = isolate->factory()->uninitialized_value();
- SmiConstant = Type::Constant(smi, zone);
- Signed32Constant = Type::Constant(signed32, zone);
+ SmiConstant = AstType::Constant(smi, zone);
+ Signed32Constant = AstType::Constant(signed32, zone);
- ObjectConstant1 = Type::Constant(object1, zone);
- ObjectConstant2 = Type::Constant(object2, zone);
- ArrayConstant = Type::Constant(array, zone);
- UninitializedConstant = Type::Constant(uninitialized, zone);
+ ObjectConstant1 = AstType::Constant(object1, zone);
+ ObjectConstant2 = AstType::Constant(object2, zone);
+ ArrayConstant = AstType::Constant(array, zone);
+ UninitializedConstant = AstType::Constant(uninitialized, zone);
values.push_back(smi);
values.push_back(signed32);
@@ -90,7 +88,7 @@ class Types {
values.push_back(array);
values.push_back(uninitialized);
for (ValueVector::iterator it = values.begin(); it != values.end(); ++it) {
- types.push_back(Type::Constant(*it, zone));
+ types.push_back(AstType::Constant(*it, zone));
}
integers.push_back(isolate->factory()->NewNumber(-V8_INFINITY));
@@ -104,16 +102,16 @@ class Types {
if (!IsMinusZero(x)) integers.push_back(isolate->factory()->NewNumber(x));
}
- Integer = Type::Range(-V8_INFINITY, +V8_INFINITY, zone);
+ Integer = AstType::Range(-V8_INFINITY, +V8_INFINITY, zone);
- NumberArray = Type::Array(Number, zone);
- StringArray = Type::Array(String, zone);
- AnyArray = Type::Array(Any, zone);
+ NumberArray = AstType::Array(Number, zone);
+ StringArray = AstType::Array(String, zone);
+ AnyArray = AstType::Array(Any, zone);
- SignedFunction1 = Type::Function(SignedSmall, SignedSmall, zone);
- NumberFunction1 = Type::Function(Number, Number, zone);
- NumberFunction2 = Type::Function(Number, Number, Number, zone);
- MethodFunction = Type::Function(String, Object, 0, zone);
+ SignedFunction1 = AstType::Function(SignedSmall, SignedSmall, zone);
+ NumberFunction1 = AstType::Function(Number, Number, zone);
+ NumberFunction2 = AstType::Function(Number, Number, Number, zone);
+ MethodFunction = AstType::Function(String, Object, 0, zone);
for (int i = 0; i < 30; ++i) {
types.push_back(Fuzz());
@@ -132,40 +130,40 @@ class Types {
Handle<i::JSArray> array;
Handle<i::Oddball> uninitialized;
-#define DECLARE_TYPE(name, value) Type* name;
- PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
- #undef DECLARE_TYPE
+#define DECLARE_TYPE(name, value) AstType* name;
+ AST_PROPER_BITSET_TYPE_LIST(DECLARE_TYPE)
+#undef DECLARE_TYPE
-#define DECLARE_TYPE(name, value) Type* Mask##name##ForTesting;
- MASK_BITSET_TYPE_LIST(DECLARE_TYPE)
+#define DECLARE_TYPE(name, value) AstType* Mask##name##ForTesting;
+ AST_MASK_BITSET_TYPE_LIST(DECLARE_TYPE)
#undef DECLARE_TYPE
- Type* SignedSmall;
- Type* UnsignedSmall;
+ AstType* SignedSmall;
+ AstType* UnsignedSmall;
- Type* ObjectClass;
- Type* ArrayClass;
- Type* NumberClass;
- Type* UninitializedClass;
+ AstType* ObjectClass;
+ AstType* ArrayClass;
+ AstType* NumberClass;
+ AstType* UninitializedClass;
- Type* SmiConstant;
- Type* Signed32Constant;
- Type* ObjectConstant1;
- Type* ObjectConstant2;
- Type* ArrayConstant;
- Type* UninitializedConstant;
+ AstType* SmiConstant;
+ AstType* Signed32Constant;
+ AstType* ObjectConstant1;
+ AstType* ObjectConstant2;
+ AstType* ArrayConstant;
+ AstType* UninitializedConstant;
- Type* Integer;
+ AstType* Integer;
- Type* NumberArray;
- Type* StringArray;
- Type* AnyArray;
+ AstType* NumberArray;
+ AstType* StringArray;
+ AstType* AnyArray;
- Type* SignedFunction1;
- Type* NumberFunction1;
- Type* NumberFunction2;
- Type* MethodFunction;
+ AstType* SignedFunction1;
+ AstType* NumberFunction1;
+ AstType* NumberFunction2;
+ AstType* MethodFunction;
- typedef std::vector<Type*> TypeVector;
+ typedef std::vector<AstType*> TypeVector;
typedef std::vector<Handle<i::Map> > MapVector;
typedef std::vector<Handle<i::Object> > ValueVector;
@@ -174,80 +172,90 @@ class Types {
ValueVector values;
ValueVector integers; // "Integer" values used for range limits.
- Type* Of(Handle<i::Object> value) { return Type::Of(value, zone_); }
+ AstType* Of(Handle<i::Object> value) { return AstType::Of(value, zone_); }
- Type* NowOf(Handle<i::Object> value) { return Type::NowOf(value, zone_); }
+ AstType* NowOf(Handle<i::Object> value) {
+ return AstType::NowOf(value, zone_);
+ }
- Type* Class(Handle<i::Map> map) { return Type::Class(map, zone_); }
+ AstType* Class(Handle<i::Map> map) { return AstType::Class(map, zone_); }
- Type* Constant(Handle<i::Object> value) {
- return Type::Constant(value, zone_);
+ AstType* Constant(Handle<i::Object> value) {
+ return AstType::Constant(value, zone_);
}
- Type* Range(double min, double max) { return Type::Range(min, max, zone_); }
+ AstType* Range(double min, double max) {
+ return AstType::Range(min, max, zone_);
+ }
- Type* Context(Type* outer) { return Type::Context(outer, zone_); }
+ AstType* Context(AstType* outer) { return AstType::Context(outer, zone_); }
- Type* Array1(Type* element) { return Type::Array(element, zone_); }
+ AstType* Array1(AstType* element) { return AstType::Array(element, zone_); }
- Type* Function0(Type* result, Type* receiver) {
- return Type::Function(result, receiver, 0, zone_);
+ AstType* Function0(AstType* result, AstType* receiver) {
+ return AstType::Function(result, receiver, 0, zone_);
}
- Type* Function1(Type* result, Type* receiver, Type* arg) {
- Type* type = Type::Function(result, receiver, 1, zone_);
+ AstType* Function1(AstType* result, AstType* receiver, AstType* arg) {
+ AstType* type = AstType::Function(result, receiver, 1, zone_);
type->AsFunction()->InitParameter(0, arg);
return type;
}
- Type* Function2(Type* result, Type* arg1, Type* arg2) {
- return Type::Function(result, arg1, arg2, zone_);
+ AstType* Function2(AstType* result, AstType* arg1, AstType* arg2) {
+ return AstType::Function(result, arg1, arg2, zone_);
}
- Type* Union(Type* t1, Type* t2) { return Type::Union(t1, t2, zone_); }
+ AstType* Union(AstType* t1, AstType* t2) {
+ return AstType::Union(t1, t2, zone_);
+ }
- Type* Intersect(Type* t1, Type* t2) { return Type::Intersect(t1, t2, zone_); }
+ AstType* Intersect(AstType* t1, AstType* t2) {
+ return AstType::Intersect(t1, t2, zone_);
+ }
- Type* Representation(Type* t) { return Type::Representation(t, zone_); }
+ AstType* Representation(AstType* t) {
+ return AstType::Representation(t, zone_);
+ }
- Type* Semantic(Type* t) { return Type::Semantic(t, zone_); }
+ AstType* Semantic(AstType* t) { return AstType::Semantic(t, zone_); }
- Type* Random() {
+ AstType* Random() {
return types[rng_->NextInt(static_cast<int>(types.size()))];
}
- Type* Fuzz(int depth = 4) {
+ AstType* Fuzz(int depth = 4) {
switch (rng_->NextInt(depth == 0 ? 3 : 20)) {
case 0: { // bitset
- #define COUNT_BITSET_TYPES(type, value) + 1
- int n = 0 PROPER_BITSET_TYPE_LIST(COUNT_BITSET_TYPES);
- #undef COUNT_BITSET_TYPES
+#define COUNT_BITSET_TYPES(type, value) +1
+ int n = 0 AST_PROPER_BITSET_TYPE_LIST(COUNT_BITSET_TYPES);
+#undef COUNT_BITSET_TYPES
// Pick a bunch of named bitsets and return their intersection.
- Type* result = Type::Any();
+ AstType* result = AstType::Any();
for (int i = 0, m = 1 + rng_->NextInt(3); i < m; ++i) {
int j = rng_->NextInt(n);
-#define PICK_BITSET_TYPE(type, value) \
- if (j-- == 0) { \
- Type* tmp = Type::Intersect(result, Type::type(), zone_); \
- if (tmp->Is(Type::None()) && i != 0) { \
- break; \
- } else { \
- result = tmp; \
- continue; \
- } \
+#define PICK_BITSET_TYPE(type, value) \
+ if (j-- == 0) { \
+ AstType* tmp = AstType::Intersect(result, AstType::type(), zone_); \
+ if (tmp->Is(AstType::None()) && i != 0) { \
+ break; \
+ } else { \
+ result = tmp; \
+ continue; \
+ } \
}
- PROPER_BITSET_TYPE_LIST(PICK_BITSET_TYPE)
- #undef PICK_BITSET_TYPE
+ AST_PROPER_BITSET_TYPE_LIST(PICK_BITSET_TYPE)
+#undef PICK_BITSET_TYPE
}
return result;
}
case 1: { // class
int i = rng_->NextInt(static_cast<int>(maps.size()));
- return Type::Class(maps[i], zone_);
+ return AstType::Class(maps[i], zone_);
}
case 2: { // constant
int i = rng_->NextInt(static_cast<int>(values.size()));
- return Type::Constant(values[i], zone_);
+ return AstType::Constant(values[i], zone_);
}
case 3: { // range
int i = rng_->NextInt(static_cast<int>(integers.size()));
@@ -255,50 +263,49 @@ class Types {
double min = integers[i]->Number();
double max = integers[j]->Number();
if (min > max) std::swap(min, max);
- return Type::Range(min, max, zone_);
+ return AstType::Range(min, max, zone_);
}
case 4: { // context
int depth = rng_->NextInt(3);
- Type* type = Type::Internal();
- for (int i = 0; i < depth; ++i) type = Type::Context(type, zone_);
+ AstType* type = AstType::Internal();
+ for (int i = 0; i < depth; ++i) type = AstType::Context(type, zone_);
return type;
}
case 5: { // array
- Type* element = Fuzz(depth / 2);
- return Type::Array(element, zone_);
+ AstType* element = Fuzz(depth / 2);
+ return AstType::Array(element, zone_);
}
case 6:
case 7: { // function
- Type* result = Fuzz(depth / 2);
- Type* receiver = Fuzz(depth / 2);
+ AstType* result = Fuzz(depth / 2);
+ AstType* receiver = Fuzz(depth / 2);
int arity = rng_->NextInt(3);
- Type* type = Type::Function(result, receiver, arity, zone_);
+ AstType* type = AstType::Function(result, receiver, arity, zone_);
for (int i = 0; i < type->AsFunction()->Arity(); ++i) {
- Type* parameter = Fuzz(depth / 2);
+ AstType* parameter = Fuzz(depth / 2);
type->AsFunction()->InitParameter(i, parameter);
}
return type;
}
case 8: { // simd
static const int num_simd_types =
- #define COUNT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) +1
+#define COUNT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) +1
SIMD128_TYPES(COUNT_SIMD_TYPE);
- #undef COUNT_SIMD_TYPE
- Type* (*simd_constructors[num_simd_types])(Isolate*, Zone*) = {
- #define COUNT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) \
- &Type::Name,
+#undef COUNT_SIMD_TYPE
+ AstType* (*simd_constructors[num_simd_types])(Isolate*, Zone*) = {
+#define COUNT_SIMD_TYPE(NAME, Name, name, lane_count, lane_type) &AstType::Name,
SIMD128_TYPES(COUNT_SIMD_TYPE)
- #undef COUNT_SIMD_TYPE
+#undef COUNT_SIMD_TYPE
};
return simd_constructors[rng_->NextInt(num_simd_types)](isolate_,
zone_);
}
default: { // union
int n = rng_->NextInt(10);
- Type* type = None;
+ AstType* type = None;
for (int i = 0; i < n; ++i) {
- Type* operand = Fuzz(depth - 1);
- type = Type::Union(type, operand, zone_);
+ AstType* operand = Fuzz(depth - 1);
+ type = AstType::Union(type, operand, zone_);
}
return type;
}
@@ -314,7 +321,6 @@ class Types {
v8::base::RandomNumberGenerator* rng_;
};
-
} // namespace internal
} // namespace v8
« no previous file with comments | « src/v8.gyp ('k') | test/cctest/cctest.gyp » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698