mirror of https://github.com/lukechilds/node.git
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
167 lines
4.2 KiB
167 lines
4.2 KiB
// Copyright 2014 the V8 project authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#include "src/crankshaft/hydrogen-types.h"
|
|
|
|
#include "test/cctest/cctest.h"
|
|
|
|
using namespace v8::internal;
|
|
|
|
static const HType kTypes[] = {
|
|
#define DECLARE_TYPE(Name, mask) HType::Name(),
|
|
HTYPE_LIST(DECLARE_TYPE)
|
|
#undef DECLARE_TYPE
|
|
};
|
|
|
|
static const int kNumberOfTypes = sizeof(kTypes) / sizeof(kTypes[0]);
|
|
|
|
|
|
TEST(HTypeDistinct) {
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
for (int j = 0; j < kNumberOfTypes; ++j) {
|
|
CHECK(i == j || !kTypes[i].Equals(kTypes[j]));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(HTypeReflexivity) {
|
|
// Reflexivity of =
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
CHECK(kTypes[i].Equals(kTypes[i]));
|
|
}
|
|
|
|
// Reflexivity of <
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
CHECK(kTypes[i].IsSubtypeOf(kTypes[i]));
|
|
}
|
|
}
|
|
|
|
|
|
TEST(HTypeTransitivity) {
|
|
// Transitivity of =
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
for (int j = 0; j < kNumberOfTypes; ++j) {
|
|
for (int k = 0; k < kNumberOfTypes; ++k) {
|
|
HType ti = kTypes[i];
|
|
HType tj = kTypes[j];
|
|
HType tk = kTypes[k];
|
|
CHECK(!ti.Equals(tj) || !tj.Equals(tk) || ti.Equals(tk));
|
|
}
|
|
}
|
|
}
|
|
|
|
// Transitivity of <
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
for (int j = 0; j < kNumberOfTypes; ++j) {
|
|
for (int k = 0; k < kNumberOfTypes; ++k) {
|
|
HType ti = kTypes[i];
|
|
HType tj = kTypes[j];
|
|
HType tk = kTypes[k];
|
|
CHECK(!ti.IsSubtypeOf(tj) || !tj.IsSubtypeOf(tk) || ti.IsSubtypeOf(tk));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(HTypeCombine) {
|
|
// T < T /\ T' and T' < T /\ T' for all T,T'
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
for (int j = 0; j < kNumberOfTypes; ++j) {
|
|
HType ti = kTypes[i];
|
|
HType tj = kTypes[j];
|
|
CHECK(ti.IsSubtypeOf(ti.Combine(tj)));
|
|
CHECK(tj.IsSubtypeOf(ti.Combine(tj)));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(HTypeAny) {
|
|
// T < Any for all T
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
HType ti = kTypes[i];
|
|
CHECK(ti.IsAny());
|
|
}
|
|
|
|
// Any < T implies T = Any for all T
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
HType ti = kTypes[i];
|
|
CHECK(!HType::Any().IsSubtypeOf(ti) || HType::Any().Equals(ti));
|
|
}
|
|
}
|
|
|
|
|
|
TEST(HTypeTagged) {
|
|
// T < Tagged for all T \ {Any}
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
HType ti = kTypes[i];
|
|
CHECK(ti.IsTagged() || HType::Any().Equals(ti));
|
|
}
|
|
|
|
// Tagged < T implies T = Tagged or T = Any
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
HType ti = kTypes[i];
|
|
CHECK(!HType::Tagged().IsSubtypeOf(ti) ||
|
|
HType::Tagged().Equals(ti) ||
|
|
HType::Any().Equals(ti));
|
|
}
|
|
}
|
|
|
|
|
|
TEST(HTypeSmi) {
|
|
// T < Smi implies T = None or T = Smi for all T
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
HType ti = kTypes[i];
|
|
CHECK(!ti.IsSmi() ||
|
|
ti.Equals(HType::Smi()) ||
|
|
ti.Equals(HType::None()));
|
|
}
|
|
}
|
|
|
|
|
|
TEST(HTypeHeapObject) {
|
|
CHECK(!HType::TaggedPrimitive().IsHeapObject());
|
|
CHECK(!HType::TaggedNumber().IsHeapObject());
|
|
CHECK(!HType::Smi().IsHeapObject());
|
|
CHECK(HType::HeapObject().IsHeapObject());
|
|
CHECK(HType::HeapPrimitive().IsHeapObject());
|
|
CHECK(HType::Null().IsHeapObject());
|
|
CHECK(HType::HeapNumber().IsHeapObject());
|
|
CHECK(HType::String().IsHeapObject());
|
|
CHECK(HType::Boolean().IsHeapObject());
|
|
CHECK(HType::Undefined().IsHeapObject());
|
|
CHECK(HType::JSObject().IsHeapObject());
|
|
CHECK(HType::JSArray().IsHeapObject());
|
|
}
|
|
|
|
|
|
TEST(HTypePrimitive) {
|
|
CHECK(HType::TaggedNumber().IsTaggedPrimitive());
|
|
CHECK(HType::Smi().IsTaggedPrimitive());
|
|
CHECK(!HType::HeapObject().IsTaggedPrimitive());
|
|
CHECK(HType::HeapPrimitive().IsTaggedPrimitive());
|
|
CHECK(HType::Null().IsHeapPrimitive());
|
|
CHECK(HType::HeapNumber().IsHeapPrimitive());
|
|
CHECK(HType::String().IsHeapPrimitive());
|
|
CHECK(HType::Boolean().IsHeapPrimitive());
|
|
CHECK(HType::Undefined().IsHeapPrimitive());
|
|
CHECK(!HType::JSObject().IsTaggedPrimitive());
|
|
CHECK(!HType::JSArray().IsTaggedPrimitive());
|
|
}
|
|
|
|
|
|
TEST(HTypeJSObject) {
|
|
CHECK(HType::JSArray().IsJSObject());
|
|
}
|
|
|
|
|
|
TEST(HTypeNone) {
|
|
// None < T for all T
|
|
for (int i = 0; i < kNumberOfTypes; ++i) {
|
|
HType ti = kTypes[i];
|
|
CHECK(HType::None().IsSubtypeOf(ti));
|
|
}
|
|
}
|
|
|