Upgrade V8 to version 4.9.385.28
https://chromium.googlesource.com/v8/v8/+/4.9.385.28
FPIIM-449
Change-Id: I4b2e74289d4bf3667f2f3dc8aa2e541f63e26eb4
diff --git a/test/cctest/compiler/test-simplified-lowering.cc b/test/cctest/compiler/test-simplified-lowering.cc
index 147aa32..1b752ed 100644
--- a/test/cctest/compiler/test-simplified-lowering.cc
+++ b/test/cctest/compiler/test-simplified-lowering.cc
@@ -4,46 +4,49 @@
#include <limits>
+#include "src/ast/scopes.h"
#include "src/compiler/access-builder.h"
#include "src/compiler/change-lowering.h"
#include "src/compiler/control-builders.h"
#include "src/compiler/graph-reducer.h"
#include "src/compiler/graph-visualizer.h"
-#include "src/compiler/node-properties-inl.h"
+#include "src/compiler/node-properties.h"
#include "src/compiler/pipeline.h"
#include "src/compiler/representation-change.h"
#include "src/compiler/simplified-lowering.h"
+#include "src/compiler/source-position.h"
#include "src/compiler/typer.h"
#include "src/compiler/verifier.h"
#include "src/execution.h"
-#include "src/parser.h"
-#include "src/rewriter.h"
-#include "src/scopes.h"
+#include "src/parsing/parser.h"
+#include "src/parsing/rewriter.h"
#include "test/cctest/cctest.h"
#include "test/cctest/compiler/codegen-tester.h"
+#include "test/cctest/compiler/function-tester.h"
#include "test/cctest/compiler/graph-builder-tester.h"
#include "test/cctest/compiler/value-helper.h"
-using namespace v8::internal;
-using namespace v8::internal::compiler;
+namespace v8 {
+namespace internal {
+namespace compiler {
template <typename ReturnType>
class SimplifiedLoweringTester : public GraphBuilderTester<ReturnType> {
public:
- SimplifiedLoweringTester(MachineType p0 = kMachNone,
- MachineType p1 = kMachNone,
- MachineType p2 = kMachNone,
- MachineType p3 = kMachNone,
- MachineType p4 = kMachNone)
- : GraphBuilderTester<ReturnType>(p0, p1, p2, p3, p4),
- typer(this->graph(), MaybeHandle<Context>()),
+ SimplifiedLoweringTester(MachineType p0 = MachineType::None(),
+ MachineType p1 = MachineType::None())
+ : GraphBuilderTester<ReturnType>(p0, p1),
+ typer(this->isolate(), this->graph()),
javascript(this->zone()),
- jsgraph(this->graph(), this->common(), &javascript, this->machine()),
- lowering(&jsgraph, this->zone()) {}
+ jsgraph(this->isolate(), this->graph(), this->common(), &javascript,
+ this->simplified(), this->machine()),
+ source_positions(jsgraph.graph()),
+ lowering(&jsgraph, this->zone(), &source_positions) {}
Typer typer;
JSOperatorBuilder javascript;
JSGraph jsgraph;
+ SourcePositionTable source_positions;
SimplifiedLowering lowering;
void LowerAllNodes() {
@@ -57,12 +60,8 @@
typer.Run();
lowering.LowerAllNodes();
- Zone* zone = this->zone();
- CompilationInfo info(zone->isolate(), zone);
- Linkage linkage(
- zone, Linkage::GetSimplifiedCDescriptor(zone, this->machine_sig_));
- ChangeLowering lowering(&jsgraph, &linkage);
- GraphReducer reducer(this->graph(), this->zone());
+ ChangeLowering lowering(&jsgraph);
+ GraphReducer reducer(this->zone(), this->graph());
reducer.AddReducer(&lowering);
reducer.ReduceGraph();
Verifier::Run(this->graph());
@@ -77,6 +76,17 @@
CHECK(factory()->NewNumber(expected)->SameValue(result));
}
+ template <typename T>
+ T* CallWithPotentialGC() {
+ // TODO(titzer): we wrap the code in a JSFunction here to reuse the
+ // JSEntryStub; that could be done with a special prologue or other stub.
+ Handle<JSFunction> fun = FunctionTester::ForMachineGraph(this->graph(), 0);
+ Handle<Object>* args = NULL;
+ MaybeHandle<Object> result = Execution::Call(
+ this->isolate(), fun, factory()->undefined_value(), 0, args);
+ return T::cast(*result.ToHandleChecked());
+ }
+
Factory* factory() { return this->isolate()->factory(); }
Heap* heap() { return this->isolate()->heap(); }
};
@@ -90,25 +100,23 @@
int32_t result;
SimplifiedLoweringTester<Object*> t;
FieldAccess load = {kUntaggedBase, 0, Handle<Name>(), Type::Number(),
- kMachFloat64};
+ MachineType::Float64()};
Node* loaded = t.LoadField(load, t.PointerConstant(&input));
- NodeProperties::SetBounds(loaded, Bounds(Type::Number()));
+ NodeProperties::SetType(loaded, Type::Number());
Node* convert = t.NumberToInt32(loaded);
FieldAccess store = {kUntaggedBase, 0, Handle<Name>(), Type::Signed32(),
- kMachInt32};
+ MachineType::Int32()};
t.StoreField(store, t.PointerConstant(&result), convert);
t.Return(t.jsgraph.TrueConstant());
- t.LowerAllNodes();
+ t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
FOR_FLOAT64_INPUTS(i) {
input = *i;
int32_t expected = DoubleToInt32(*i);
t.Call();
CHECK_EQ(expected, result);
}
- }
}
@@ -119,18 +127,17 @@
uint32_t result;
SimplifiedLoweringTester<Object*> t;
FieldAccess load = {kUntaggedBase, 0, Handle<Name>(), Type::Number(),
- kMachFloat64};
+ MachineType::Float64()};
Node* loaded = t.LoadField(load, t.PointerConstant(&input));
- NodeProperties::SetBounds(loaded, Bounds(Type::Number()));
+ NodeProperties::SetType(loaded, Type::Number());
Node* convert = t.NumberToUint32(loaded);
FieldAccess store = {kUntaggedBase, 0, Handle<Name>(), Type::Unsigned32(),
- kMachUint32};
+ MachineType::Uint32()};
t.StoreField(store, t.PointerConstant(&result), convert);
t.Return(t.jsgraph.TrueConstant());
- t.LowerAllNodes();
+ t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
FOR_FLOAT64_INPUTS(i) {
input = *i;
uint32_t expected = DoubleToUint32(*i);
@@ -138,7 +145,6 @@
CHECK_EQ(static_cast<int32_t>(expected), static_cast<int32_t>(result));
}
}
-}
// Create a simple JSObject with a unique map.
@@ -151,33 +157,31 @@
TEST(RunLoadMap) {
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
FieldAccess access = AccessBuilder::ForMap();
Node* load = t.LoadField(access, t.Parameter(0));
t.Return(load);
- t.LowerAllNodes();
+ t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
- Handle<JSObject> src = TestObject();
- Handle<Map> src_map(src->map());
- Object* result = t.Call(*src); // TODO(titzer): raw pointers in call
- CHECK_EQ(*src_map, result);
- }
+ Handle<JSObject> src = TestObject();
+ Handle<Map> src_map(src->map());
+ Object* result = t.Call(*src); // TODO(titzer): raw pointers in call
+ CHECK_EQ(*src_map, result);
}
TEST(RunStoreMap) {
- SimplifiedLoweringTester<int32_t> t(kMachAnyTagged, kMachAnyTagged);
+ SimplifiedLoweringTester<int32_t> t(MachineType::AnyTagged(),
+ MachineType::AnyTagged());
FieldAccess access = AccessBuilder::ForMap();
t.StoreField(access, t.Parameter(1), t.Parameter(0));
t.Return(t.jsgraph.TrueConstant());
- t.LowerAllNodes();
+ t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
Handle<JSObject> src = TestObject();
Handle<Map> src_map(src->map());
Handle<JSObject> dst = TestObject();
@@ -185,38 +189,35 @@
t.Call(*src_map, *dst); // TODO(titzer): raw pointers in call
CHECK(*src_map == dst->map());
}
-}
TEST(RunLoadProperties) {
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
FieldAccess access = AccessBuilder::ForJSObjectProperties();
Node* load = t.LoadField(access, t.Parameter(0));
t.Return(load);
- t.LowerAllNodes();
+ t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
Handle<JSObject> src = TestObject();
Handle<FixedArray> src_props(src->properties());
Object* result = t.Call(*src); // TODO(titzer): raw pointers in call
CHECK_EQ(*src_props, result);
- }
}
TEST(RunLoadStoreMap) {
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged, kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged(),
+ MachineType::AnyTagged());
FieldAccess access = AccessBuilder::ForMap();
Node* load = t.LoadField(access, t.Parameter(0));
t.StoreField(access, t.Parameter(1), load);
t.Return(load);
- t.LowerAllNodes();
+ t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
Handle<JSObject> src = TestObject();
Handle<Map> src_map(src->map());
Handle<JSObject> dst = TestObject();
@@ -225,21 +226,19 @@
CHECK(result->IsMap());
CHECK_EQ(*src_map, result);
CHECK(*src_map == dst->map());
- }
}
TEST(RunLoadStoreFixedArrayIndex) {
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
ElementAccess access = AccessBuilder::ForFixedArrayElement();
Node* load = t.LoadElement(access, t.Parameter(0), t.Int32Constant(0));
t.StoreElement(access, t.Parameter(0), t.Int32Constant(1), load);
t.Return(load);
- t.LowerAllNodes();
+ t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
Handle<FixedArray> array = t.factory()->NewFixedArray(2);
Handle<JSObject> src = TestObject();
Handle<JSObject> dst = TestObject();
@@ -249,16 +248,15 @@
CHECK_EQ(*src, result);
CHECK_EQ(*src, array->get(0));
CHECK_EQ(*src, array->get(1));
- }
}
TEST(RunLoadStoreArrayBuffer) {
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
const int index = 12;
const int array_length = 2 * index;
ElementAccess buffer_access =
- AccessBuilder::ForTypedArrayElement(v8::kExternalInt8Array, true);
+ AccessBuilder::ForTypedArrayElement(kExternalInt8Array, true);
Node* backing_store = t.LoadField(
AccessBuilder::ForJSArrayBufferBackingStore(), t.Parameter(0));
Node* load =
@@ -267,12 +265,11 @@
load);
t.Return(t.jsgraph.TrueConstant());
- t.LowerAllNodes();
+ t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
Handle<JSArrayBuffer> array = t.factory()->NewJSArrayBuffer();
- Runtime::SetupArrayBufferAllocatingData(t.isolate(), array, array_length);
+ JSArrayBuffer::SetupAllocatingData(array, t.isolate(), array_length);
uint8_t* data = reinterpret_cast<uint8_t*>(array->backing_store());
for (int i = 0; i < array_length; i++) {
data[i] = i;
@@ -287,7 +284,6 @@
CHECK_EQ(data[i], expected);
}
}
-}
TEST(RunLoadFieldFromUntaggedBase) {
@@ -296,14 +292,12 @@
for (size_t i = 0; i < arraysize(smis); i++) {
int offset = static_cast<int>(i * sizeof(Smi*));
FieldAccess access = {kUntaggedBase, offset, Handle<Name>(),
- Type::Integral32(), kMachAnyTagged};
+ Type::Integral32(), MachineType::AnyTagged()};
SimplifiedLoweringTester<Object*> t;
Node* load = t.LoadField(access, t.PointerConstant(smis));
t.Return(load);
- t.LowerAllNodes();
-
- if (!Pipeline::SupportedTarget()) continue;
+ t.LowerAllNodesAndLowerChanges();
for (int j = -5; j <= 5; j++) {
Smi* expected = Smi::FromInt(j);
@@ -320,15 +314,13 @@
for (size_t i = 0; i < arraysize(smis); i++) {
int offset = static_cast<int>(i * sizeof(Smi*));
FieldAccess access = {kUntaggedBase, offset, Handle<Name>(),
- Type::Integral32(), kMachAnyTagged};
+ Type::Integral32(), MachineType::AnyTagged()};
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* p0 = t.Parameter(0);
t.StoreField(access, t.PointerConstant(smis), p0);
t.Return(p0);
- t.LowerAllNodes();
-
- if (!Pipeline::SupportedTarget()) continue;
+ t.LowerAllNodesAndLowerChanges();
for (int j = -5; j <= 5; j++) {
Smi* expected = Smi::FromInt(j);
@@ -348,15 +340,13 @@
for (size_t j = 0; (i + j) < arraysize(smis); j++) { // for element index
int offset = static_cast<int>(i * sizeof(Smi*));
ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
- kMachAnyTagged};
+ MachineType::AnyTagged()};
SimplifiedLoweringTester<Object*> t;
Node* load = t.LoadElement(access, t.PointerConstant(smis),
t.Int32Constant(static_cast<int>(j)));
t.Return(load);
- t.LowerAllNodes();
-
- if (!Pipeline::SupportedTarget()) continue;
+ t.LowerAllNodesAndLowerChanges();
for (int k = -5; k <= 5; k++) {
Smi* expected = Smi::FromInt(k);
@@ -376,16 +366,14 @@
for (size_t j = 0; (i + j) < arraysize(smis); j++) { // for element index
int offset = static_cast<int>(i * sizeof(Smi*));
ElementAccess access = {kUntaggedBase, offset, Type::Integral32(),
- kMachAnyTagged};
+ MachineType::AnyTagged()};
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* p0 = t.Parameter(0);
t.StoreElement(access, t.PointerConstant(smis),
t.Int32Constant(static_cast<int>(j)), p0);
t.Return(p0);
- t.LowerAllNodes();
-
- if (!Pipeline::SupportedTarget()) continue;
+ t.LowerAllNodesAndLowerChanges();
for (int k = -5; k <= 5; k++) {
Smi* expected = Smi::FromInt(k);
@@ -450,13 +438,11 @@
Node* load = t.LoadElement(access, ptr, t.Int32Constant(from_index));
t.StoreElement(access, ptr, t.Int32Constant(to_index), load);
t.Return(t.jsgraph.TrueConstant());
- t.LowerAllNodes();
+ t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
Object* result = t.Call();
CHECK_EQ(t.isolate()->heap()->true_value(), result);
- }
}
// Create and run code that copies the field in either {untagged_array}
@@ -472,13 +458,11 @@
Node* load = t.LoadField(from_access, ptr);
t.StoreField(to_access, ptr, load);
t.Return(t.jsgraph.TrueConstant());
- t.LowerAllNodes();
+ t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
Object* result = t.Call();
CHECK_EQ(t.isolate()->heap()->true_value(), result);
- }
}
// Create and run code that copies the elements from {this} to {that}.
@@ -516,18 +500,15 @@
t.LowerAllNodes();
t.GenerateCode();
- if (Pipeline::SupportedTarget()) {
Object* result = t.Call();
CHECK_EQ(t.isolate()->heap()->true_value(), result);
- }
#endif
}
E GetElement(int index) {
BoundsCheck(index);
if (tagged) {
- E* raw = reinterpret_cast<E*>(tagged_array->GetDataStartAddress());
- return raw[index];
+ return GetTaggedElement(index);
} else {
return untagged_array[index];
}
@@ -560,8 +541,19 @@
CHECK_LT(index, static_cast<int>(num_elements));
CHECK_EQ(static_cast<int>(ByteSize()), tagged_array->length());
}
+
+ E GetTaggedElement(int index) {
+ E* raw = reinterpret_cast<E*>(tagged_array->GetDataStartAddress());
+ return raw[index];
+ }
};
+template <>
+double AccessTester<double>::GetTaggedElement(int index) {
+ return ReadDoubleValue(tagged_array->GetDataStartAddress() +
+ index * sizeof(double));
+}
+
template <typename E>
static void RunAccessTest(MachineType rep, E* original_elements, size_t num) {
@@ -577,13 +569,11 @@
} else {
a.RunCopyElement(i, i + 1); // Test element read/write.
}
- if (Pipeline::SupportedTarget()) { // verify.
for (int j = 0; j < num_elements; j++) {
E expect =
j == (i + 1) ? original_elements[i] : original_elements[j];
CHECK_EQ(expect, a.GetElement(j));
}
- }
}
}
}
@@ -593,10 +583,8 @@
AccessTester<E> a(tf == 1, rep, original_elements, num);
AccessTester<E> b(tt == 1, rep, original_elements, num);
a.RunCopyElements(&b);
- if (Pipeline::SupportedTarget()) { // verify.
for (int i = 0; i < num_elements; i++) {
CHECK_EQ(a.GetElement(i), b.GetElement(i));
- }
}
}
}
@@ -606,19 +594,19 @@
TEST(RunAccessTests_uint8) {
uint8_t data[] = {0x07, 0x16, 0x25, 0x34, 0x43, 0x99,
0xab, 0x78, 0x89, 0x19, 0x2b, 0x38};
- RunAccessTest<uint8_t>(kMachInt8, data, arraysize(data));
+ RunAccessTest<uint8_t>(MachineType::Int8(), data, arraysize(data));
}
TEST(RunAccessTests_uint16) {
uint16_t data[] = {0x071a, 0x162b, 0x253c, 0x344d, 0x435e, 0x7777};
- RunAccessTest<uint16_t>(kMachInt16, data, arraysize(data));
+ RunAccessTest<uint16_t>(MachineType::Int16(), data, arraysize(data));
}
TEST(RunAccessTests_int32) {
int32_t data[] = {-211, 211, 628347, 2000000000, -2000000000, -1, -100000034};
- RunAccessTest<int32_t>(kMachInt32, data, arraysize(data));
+ RunAccessTest<int32_t>(MachineType::Int32(), data, arraysize(data));
}
@@ -632,13 +620,13 @@
V8_2PART_INT64(0x30313233, 34353637),
V8_2PART_INT64(0xa0a1a2a3, a4a5a6a7),
V8_2PART_INT64(0xf0f1f2f3, f4f5f6f7)};
- RunAccessTest<int64_t>(kMachInt64, data, arraysize(data));
+ RunAccessTest<int64_t>(MachineType::Int64(), data, arraysize(data));
}
TEST(RunAccessTests_float64) {
double data[] = {1.25, -1.25, 2.75, 11.0, 11100.8};
- RunAccessTest<double>(kMachFloat64, data, arraysize(data));
+ RunAccessTest<double>(MachineType::Float64(), data, arraysize(data));
}
@@ -646,7 +634,30 @@
Smi* data[] = {Smi::FromInt(-1), Smi::FromInt(-9),
Smi::FromInt(0), Smi::FromInt(666),
Smi::FromInt(77777), Smi::FromInt(Smi::kMaxValue)};
- RunAccessTest<Smi*>(kMachAnyTagged, data, arraysize(data));
+ RunAccessTest<Smi*>(MachineType::AnyTagged(), data, arraysize(data));
+}
+
+
+TEST(RunAllocate) {
+ PretenureFlag flag[] = {NOT_TENURED, TENURED};
+
+ for (size_t i = 0; i < arraysize(flag); i++) {
+ SimplifiedLoweringTester<HeapObject*> t;
+ FieldAccess access = AccessBuilder::ForMap();
+ Node* size = t.jsgraph.Constant(HeapNumber::kSize);
+ Node* alloc = t.NewNode(t.simplified()->Allocate(flag[i]), size);
+ Node* map = t.jsgraph.Constant(t.factory()->heap_number_map());
+ t.StoreField(access, alloc, map);
+ t.Return(alloc);
+
+ t.LowerAllNodesAndLowerChanges();
+ t.GenerateCode();
+
+ HeapObject* result = t.CallWithPotentialGC<HeapObject>();
+ CHECK(t.heap()->new_space()->Contains(result) || flag[i] == TENURED);
+ CHECK(t.heap()->old_space()->Contains(result) || flag[i] == NOT_TENURED);
+ CHECK(result->IsHeapNumber());
+ }
}
@@ -666,22 +677,23 @@
explicit TestingGraph(Type* p0_type, Type* p1_type = Type::None(),
Type* p2_type = Type::None())
: GraphAndBuilders(main_zone()),
- typer(graph(), MaybeHandle<Context>()),
+ typer(main_isolate(), graph()),
javascript(main_zone()),
- jsgraph(graph(), common(), &javascript, machine()) {
- start = graph()->NewNode(common()->Start(2));
+ jsgraph(main_isolate(), graph(), common(), &javascript, simplified(),
+ machine()) {
+ start = graph()->NewNode(common()->Start(4));
graph()->SetStart(start);
ret =
graph()->NewNode(common()->Return(), jsgraph.Constant(0), start, start);
- end = graph()->NewNode(common()->End(), ret);
+ end = graph()->NewNode(common()->End(1), ret);
graph()->SetEnd(end);
p0 = graph()->NewNode(common()->Parameter(0), start);
p1 = graph()->NewNode(common()->Parameter(1), start);
p2 = graph()->NewNode(common()->Parameter(2), start);
typer.Run();
- NodeProperties::SetBounds(p0, Bounds(p0_type));
- NodeProperties::SetBounds(p1, Bounds(p1_type));
- NodeProperties::SetBounds(p2, Bounds(p2_type));
+ NodeProperties::SetType(p0, p0_type);
+ NodeProperties::SetType(p1, p1_type);
+ NodeProperties::SetType(p2, p2_type);
}
void CheckLoweringBinop(IrOpcode::Value expected, const Operator* op) {
@@ -690,6 +702,13 @@
CHECK_EQ(expected, node->opcode());
}
+ void CheckLoweringStringBinop(IrOpcode::Value expected, const Operator* op) {
+ Node* node = Return(
+ graph()->NewNode(op, p0, p1, graph()->start(), graph()->start()));
+ Lower();
+ CHECK_EQ(expected, node->opcode());
+ }
+
void CheckLoweringTruncatedBinop(IrOpcode::Value expected, const Operator* op,
const Operator* trunc) {
Node* node = graph()->NewNode(op, p0, p1);
@@ -698,7 +717,21 @@
CHECK_EQ(expected, node->opcode());
}
- void Lower() { SimplifiedLowering(&jsgraph, jsgraph.zone()).LowerAllNodes(); }
+ void Lower() {
+ SourcePositionTable table(jsgraph.graph());
+ SimplifiedLowering(&jsgraph, jsgraph.zone(), &table).LowerAllNodes();
+ }
+
+ void LowerAllNodesAndLowerChanges() {
+ SourcePositionTable table(jsgraph.graph());
+ SimplifiedLowering(&jsgraph, jsgraph.zone(), &table).LowerAllNodes();
+
+ ChangeLowering lowering(&jsgraph);
+ GraphReducer reducer(this->zone(), this->graph());
+ reducer.AddReducer(&lowering);
+ reducer.ReduceGraph();
+ Verifier::Run(this->graph());
+ }
// Inserts the node as the return value of the graph.
Node* Return(Node* node) {
@@ -710,55 +743,43 @@
void Effect(Node* node) { ret->ReplaceInput(1, node); }
Node* ExampleWithOutput(MachineType type) {
- // TODO(titzer): use parameters with guaranteed representations.
- if (type & kTypeInt32) {
+ if (type.semantic() == MachineSemantic::kInt32) {
return graph()->NewNode(machine()->Int32Add(), jsgraph.Int32Constant(1),
jsgraph.Int32Constant(1));
- } else if (type & kTypeUint32) {
+ } else if (type.semantic() == MachineSemantic::kUint32) {
return graph()->NewNode(machine()->Word32Shr(), jsgraph.Int32Constant(1),
jsgraph.Int32Constant(1));
- } else if (type & kRepFloat64) {
+ } else if (type.representation() == MachineRepresentation::kFloat64) {
return graph()->NewNode(machine()->Float64Add(),
jsgraph.Float64Constant(1),
jsgraph.Float64Constant(1));
- } else if (type & kRepBit) {
+ } else if (type.representation() == MachineRepresentation::kBit) {
return graph()->NewNode(machine()->Word32Equal(),
jsgraph.Int32Constant(1),
jsgraph.Int32Constant(1));
- } else if (type & kRepWord64) {
+ } else if (type.representation() == MachineRepresentation::kWord64) {
return graph()->NewNode(machine()->Int64Add(), Int64Constant(1),
Int64Constant(1));
} else {
- CHECK(type & kRepTagged);
+ CHECK(type.representation() == MachineRepresentation::kTagged);
return p0;
}
}
- Node* ExampleWithTypeAndRep(Type* type, MachineType mach_type) {
- FieldAccess access = {kUntaggedBase, 0, Handle<Name>::null(), type,
- mach_type};
- // TODO(titzer): using loads here just to force the representation is ugly.
- Node* node = graph()->NewNode(simplified()->LoadField(access),
- jsgraph.IntPtrConstant(0), graph()->start(),
- graph()->start());
- NodeProperties::SetBounds(node, Bounds(type));
- return node;
- }
-
Node* Use(Node* node, MachineType type) {
- if (type & kTypeInt32) {
+ if (type.semantic() == MachineSemantic::kInt32) {
return graph()->NewNode(machine()->Int32LessThan(), node,
jsgraph.Int32Constant(1));
- } else if (type & kTypeUint32) {
+ } else if (type.semantic() == MachineSemantic::kUint32) {
return graph()->NewNode(machine()->Uint32LessThan(), node,
jsgraph.Int32Constant(1));
- } else if (type & kRepFloat64) {
+ } else if (type.representation() == MachineRepresentation::kFloat64) {
return graph()->NewNode(machine()->Float64Add(), node,
jsgraph.Float64Constant(1));
- } else if (type & kRepWord64) {
+ } else if (type.representation() == MachineRepresentation::kWord64) {
return graph()->NewNode(machine()->Int64LessThan(), node,
Int64Constant(1));
- } else if (type & kRepWord32) {
+ } else if (type.representation() == MachineRepresentation::kWord32) {
return graph()->NewNode(machine()->Word32Equal(), node,
jsgraph.Int32Constant(1));
} else {
@@ -787,54 +808,10 @@
};
-TEST(LowerAnyToBoolean_bit_bit) {
- // AnyToBoolean(x: kRepBit) used as kRepBit
- HandleAndZoneScope scope;
- Factory* f = scope.main_zone()->isolate()->factory();
- Handle<Object> zero = f->NewNumber(0);
- Handle<Object> one = f->NewNumber(1);
- Type* singleton_zero = Type::Constant(zero, scope.main_zone());
- Type* singleton_one = Type::Constant(one, scope.main_zone());
- Type* zero_one_range = Type::Range(zero, one, scope.main_zone());
- static Type* kTypes[] = {
- singleton_zero, singleton_one, zero_one_range, Type::Boolean(),
- Type::Union(Type::Boolean(), singleton_zero, scope.main_zone()),
- Type::Union(Type::Boolean(), singleton_one, scope.main_zone()),
- Type::Union(Type::Boolean(), zero_one_range, scope.main_zone())};
- for (Type* type : kTypes) {
- TestingGraph t(type);
- Node* x = t.ExampleWithTypeAndRep(type, kRepBit);
- Node* cnv = t.graph()->NewNode(t.simplified()->AnyToBoolean(), x);
- Node* use = t.Branch(cnv);
- t.Lower();
- CHECK_EQ(x, use->InputAt(0));
- }
-}
-
-
-#if V8_TURBOFAN_TARGET
-
-TEST(LowerAnyToBoolean_tagged_tagged) {
- // AnyToBoolean(x: kRepTagged) used as kRepTagged
- TestingGraph t(Type::Any());
- Node* x = t.p0;
- Node* cnv = t.graph()->NewNode(t.simplified()->AnyToBoolean(), x);
- Node* use = t.Use(cnv, kRepTagged);
- t.Return(use);
- t.Lower();
- CHECK_EQ(IrOpcode::kCall, cnv->opcode());
- CHECK_EQ(IrOpcode::kHeapConstant, cnv->InputAt(0)->opcode());
- CHECK_EQ(x, cnv->InputAt(1));
- CHECK_EQ(t.jsgraph.NoContextConstant(), cnv->InputAt(2));
-}
-
-#endif
-
-
TEST(LowerBooleanNot_bit_bit) {
// BooleanNot(x: kRepBit) used as kRepBit
TestingGraph t(Type::Boolean());
- Node* b = t.ExampleWithOutput(kRepBit);
+ Node* b = t.ExampleWithOutput(MachineType::Bool());
Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
Node* use = t.Branch(inv);
t.Lower();
@@ -849,9 +826,9 @@
TEST(LowerBooleanNot_bit_tagged) {
// BooleanNot(x: kRepBit) used as kRepTagged
TestingGraph t(Type::Boolean());
- Node* b = t.ExampleWithOutput(kRepBit);
+ Node* b = t.ExampleWithOutput(MachineType::Bool());
Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
- Node* use = t.Use(inv, kRepTagged);
+ Node* use = t.Use(inv, MachineType::AnyTagged());
t.Return(use);
t.Lower();
CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
@@ -883,7 +860,7 @@
TestingGraph t(Type::Boolean());
Node* b = t.p0;
Node* inv = t.graph()->NewNode(t.simplified()->BooleanNot(), b);
- Node* use = t.Use(inv, kRepTagged);
+ Node* use = t.Use(inv, MachineType::AnyTagged());
t.Return(use);
t.Lower();
CHECK_EQ(IrOpcode::kChangeBitToBool, use->InputAt(0)->opcode());
@@ -896,11 +873,11 @@
TEST(LowerBooleanToNumber_bit_int32) {
- // BooleanToNumber(x: kRepBit) used as kMachInt32
+ // BooleanToNumber(x: kRepBit) used as MachineType::Int32()
TestingGraph t(Type::Boolean());
- Node* b = t.ExampleWithOutput(kRepBit);
+ Node* b = t.ExampleWithOutput(MachineType::Bool());
Node* cnv = t.graph()->NewNode(t.simplified()->BooleanToNumber(), b);
- Node* use = t.Use(cnv, kMachInt32);
+ Node* use = t.Use(cnv, MachineType::Int32());
t.Return(use);
t.Lower();
CHECK_EQ(b, use->InputAt(0));
@@ -908,11 +885,11 @@
TEST(LowerBooleanToNumber_tagged_int32) {
- // BooleanToNumber(x: kRepTagged) used as kMachInt32
+ // BooleanToNumber(x: kRepTagged) used as MachineType::Int32()
TestingGraph t(Type::Boolean());
Node* b = t.p0;
Node* cnv = t.graph()->NewNode(t.simplified()->BooleanToNumber(), b);
- Node* use = t.Use(cnv, kMachInt32);
+ Node* use = t.Use(cnv, MachineType::Int32());
t.Return(use);
t.Lower();
CHECK_EQ(t.machine()->WordEqual()->opcode(), cnv->opcode());
@@ -923,28 +900,28 @@
TEST(LowerBooleanToNumber_bit_tagged) {
- // BooleanToNumber(x: kRepBit) used as kMachAnyTagged
+ // BooleanToNumber(x: kRepBit) used as MachineType::AnyTagged()
TestingGraph t(Type::Boolean());
- Node* b = t.ExampleWithOutput(kRepBit);
+ Node* b = t.ExampleWithOutput(MachineType::Bool());
Node* cnv = t.graph()->NewNode(t.simplified()->BooleanToNumber(), b);
- Node* use = t.Use(cnv, kMachAnyTagged);
+ Node* use = t.Use(cnv, MachineType::AnyTagged());
t.Return(use);
t.Lower();
CHECK_EQ(b, use->InputAt(0)->InputAt(0));
- CHECK_EQ(IrOpcode::kChangeInt32ToTagged, use->InputAt(0)->opcode());
+ CHECK_EQ(IrOpcode::kChangeUint32ToTagged, use->InputAt(0)->opcode());
}
TEST(LowerBooleanToNumber_tagged_tagged) {
- // BooleanToNumber(x: kRepTagged) used as kMachAnyTagged
+ // BooleanToNumber(x: kRepTagged) used as MachineType::AnyTagged()
TestingGraph t(Type::Boolean());
Node* b = t.p0;
Node* cnv = t.graph()->NewNode(t.simplified()->BooleanToNumber(), b);
- Node* use = t.Use(cnv, kMachAnyTagged);
+ Node* use = t.Use(cnv, MachineType::AnyTagged());
t.Return(use);
t.Lower();
CHECK_EQ(cnv, use->InputAt(0)->InputAt(0));
- CHECK_EQ(IrOpcode::kChangeInt32ToTagged, use->InputAt(0)->opcode());
+ CHECK_EQ(IrOpcode::kChangeUint32ToTagged, use->InputAt(0)->opcode());
CHECK_EQ(t.machine()->WordEqual()->opcode(), cnv->opcode());
CHECK(b == cnv->InputAt(0) || b == cnv->InputAt(1));
Node* c = t.jsgraph.TrueConstant();
@@ -996,11 +973,8 @@
TEST(LowerNumberAddSub_to_int32) {
HandleAndZoneScope scope;
- Factory* f = scope.main_zone()->isolate()->factory();
- Type* small_range =
- Type::Range(f->NewNumber(1), f->NewNumber(10), scope.main_zone());
- Type* large_range =
- Type::Range(f->NewNumber(-1e+13), f->NewNumber(1e+14), scope.main_zone());
+ Type* small_range = Type::Range(1, 10, scope.main_zone());
+ Type* large_range = Type::Range(-1e+13, 1e+14, scope.main_zone());
static Type* types[] = {Type::Signed32(), Type::Integral32(), small_range,
large_range};
@@ -1020,11 +994,8 @@
TEST(LowerNumberAddSub_to_uint32) {
HandleAndZoneScope scope;
- Factory* f = scope.main_zone()->isolate()->factory();
- Type* small_range =
- Type::Range(f->NewNumber(1), f->NewNumber(10), scope.main_zone());
- Type* large_range =
- Type::Range(f->NewNumber(-1e+13), f->NewNumber(1e+14), scope.main_zone());
+ Type* small_range = Type::Range(1, 10, scope.main_zone());
+ Type* large_range = Type::Range(-1e+13, 1e+14, scope.main_zone());
static Type* types[] = {Type::Signed32(), Type::Integral32(), small_range,
large_range};
@@ -1072,33 +1043,11 @@
}
-TEST(LowerNumberToInt32_to_nop) {
- // NumberToInt32(x: kRepTagged | kTypeInt32) used as kRepTagged
- TestingGraph t(Type::Signed32());
- Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
- Node* use = t.Use(trunc, kRepTagged);
- t.Return(use);
- t.Lower();
- CHECK_EQ(t.p0, use->InputAt(0));
-}
-
-
-TEST(LowerNumberToInt32_to_ChangeTaggedToFloat64) {
- // NumberToInt32(x: kRepTagged | kTypeInt32) used as kRepFloat64
- TestingGraph t(Type::Signed32());
- Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
- Node* use = t.Use(trunc, kRepFloat64);
- t.Return(use);
- t.Lower();
- CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p0, use->InputAt(0));
-}
-
-
TEST(LowerNumberToInt32_to_ChangeTaggedToInt32) {
// NumberToInt32(x: kRepTagged | kTypeInt32) used as kRepWord32
TestingGraph t(Type::Signed32());
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
- Node* use = t.Use(trunc, kTypeInt32);
+ Node* use = t.Use(trunc, MachineType::Int32());
t.Return(use);
t.Lower();
CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p0, use->InputAt(0));
@@ -1106,11 +1055,11 @@
TEST(LowerNumberToInt32_to_TruncateFloat64ToInt32) {
- // NumberToInt32(x: kRepFloat64) used as kMachInt32
+ // NumberToInt32(x: kRepFloat64) used as MachineType::Int32()
TestingGraph t(Type::Number());
- Node* p0 = t.ExampleWithTypeAndRep(Type::Number(), kMachFloat64);
+ Node* p0 = t.ExampleWithOutput(MachineType::Float64());
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), p0);
- Node* use = t.Use(trunc, kMachInt32);
+ Node* use = t.Use(trunc, MachineType::Int32());
t.Return(use);
t.Lower();
CheckChangeOf(IrOpcode::kTruncateFloat64ToInt32, p0, use->InputAt(0));
@@ -1118,10 +1067,10 @@
TEST(LowerNumberToInt32_to_TruncateFloat64ToInt32_with_change) {
- // NumberToInt32(x: kTypeNumber | kRepTagged) used as kMachInt32
+ // NumberToInt32(x: kTypeNumber | kRepTagged) used as MachineType::Int32()
TestingGraph t(Type::Number());
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), t.p0);
- Node* use = t.Use(trunc, kMachInt32);
+ Node* use = t.Use(trunc, MachineType::Int32());
t.Return(use);
t.Lower();
Node* node = use->InputAt(0);
@@ -1132,33 +1081,11 @@
}
-TEST(LowerNumberToUint32_to_nop) {
- // NumberToUint32(x: kRepTagged | kTypeUint32) used as kRepTagged
- TestingGraph t(Type::Unsigned32());
- Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
- Node* use = t.Use(trunc, kRepTagged);
- t.Return(use);
- t.Lower();
- CHECK_EQ(t.p0, use->InputAt(0));
-}
-
-
-TEST(LowerNumberToUint32_to_ChangeTaggedToFloat64) {
- // NumberToUint32(x: kRepTagged | kTypeUint32) used as kRepWord32
- TestingGraph t(Type::Unsigned32());
- Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
- Node* use = t.Use(trunc, kRepFloat64);
- t.Return(use);
- t.Lower();
- CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p0, use->InputAt(0));
-}
-
-
TEST(LowerNumberToUint32_to_ChangeTaggedToUint32) {
// NumberToUint32(x: kRepTagged | kTypeUint32) used as kRepWord32
TestingGraph t(Type::Unsigned32());
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
- Node* use = t.Use(trunc, kTypeUint32);
+ Node* use = t.Use(trunc, MachineType::Uint32());
t.Return(use);
t.Lower();
CheckChangeOf(IrOpcode::kChangeTaggedToUint32, t.p0, use->InputAt(0));
@@ -1166,13 +1093,13 @@
TEST(LowerNumberToUint32_to_TruncateFloat64ToInt32) {
- // NumberToUint32(x: kRepFloat64) used as kMachUint32
+ // NumberToUint32(x: kRepFloat64) used as MachineType::Uint32()
TestingGraph t(Type::Number());
- Node* p0 = t.ExampleWithOutput(kMachFloat64);
+ Node* p0 = t.ExampleWithOutput(MachineType::Float64());
// TODO(titzer): run the typer here, or attach machine type to param.
- NodeProperties::SetBounds(p0, Bounds(Type::Number()));
+ NodeProperties::SetType(p0, Type::Number());
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), p0);
- Node* use = t.Use(trunc, kMachUint32);
+ Node* use = t.Use(trunc, MachineType::Uint32());
t.Return(use);
t.Lower();
CheckChangeOf(IrOpcode::kTruncateFloat64ToInt32, p0, use->InputAt(0));
@@ -1180,10 +1107,10 @@
TEST(LowerNumberToUint32_to_TruncateFloat64ToInt32_with_change) {
- // NumberToInt32(x: kTypeNumber | kRepTagged) used as kMachUint32
+ // NumberToInt32(x: kTypeNumber | kRepTagged) used as MachineType::Uint32()
TestingGraph t(Type::Number());
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), t.p0);
- Node* use = t.Use(trunc, kMachUint32);
+ Node* use = t.Use(trunc, MachineType::Uint32());
t.Return(use);
t.Lower();
Node* node = use->InputAt(0);
@@ -1197,67 +1124,15 @@
TEST(LowerNumberToUint32_to_TruncateFloat64ToInt32_uint32) {
// NumberToUint32(x: kRepFloat64) used as kRepWord32
TestingGraph t(Type::Unsigned32());
- Node* input = t.ExampleWithTypeAndRep(Type::Number(), kMachFloat64);
+ Node* input = t.ExampleWithOutput(MachineType::Float64());
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), input);
- Node* use = t.Use(trunc, kRepWord32);
+ Node* use = t.Use(trunc, MachineType::RepWord32());
t.Return(use);
t.Lower();
CheckChangeOf(IrOpcode::kTruncateFloat64ToInt32, input, use->InputAt(0));
}
-TEST(LowerNumberToUI32_of_Float64_used_as_word32) {
- // NumberTo(Int,Uint)32(x: kRepFloat64 | kType(Int,Uint)32) used as
- // kType(Int,Uint)32 | kRepWord32
- Type* types[] = {Type::Signed32(), Type::Unsigned32()};
- MachineType mach[] = {kTypeInt32, kTypeUint32, kMachNone};
-
- for (int i = 0; i < 2; i++) {
- for (int u = 0; u < 3; u++) {
- TestingGraph t(types[i]);
- Node* input = t.ExampleWithTypeAndRep(
- types[i], static_cast<MachineType>(kRepFloat64 | mach[i]));
- const Operator* op = i == 0 ? t.simplified()->NumberToInt32()
- : t.simplified()->NumberToUint32();
- Node* trunc = t.graph()->NewNode(op, input);
- Node* use = t.Use(trunc, static_cast<MachineType>(kRepWord32 | mach[u]));
- t.Return(use);
- t.Lower();
- IrOpcode::Value opcode = i == 0 ? IrOpcode::kChangeFloat64ToInt32
- : IrOpcode::kChangeFloat64ToUint32;
- CheckChangeOf(opcode, input, use->InputAt(0));
- }
- }
-}
-
-
-TEST(LowerNumberToUI32_of_Float64_used_as_tagged) {
- // NumberTo(Int,Uint)32(x: kRepFloat64 | kType(Int,Uint)32) used as
- // kType(Int,Uint)32 | kRepTagged
- Type* types[] = {Type::Signed32(), Type::Unsigned32(), Type::Any()};
- MachineType mach[] = {kTypeInt32, kTypeUint32, kMachNone};
-
- for (int i = 0; i < 2; i++) {
- for (int u = 0; u < 3; u++) {
- TestingGraph t(types[i]);
- Node* input = t.ExampleWithTypeAndRep(
- types[i], static_cast<MachineType>(kRepFloat64 | mach[i]));
- const Operator* op = i == 0 ? t.simplified()->NumberToInt32()
- : t.simplified()->NumberToUint32();
- Node* trunc = t.graph()->NewNode(op, input);
- // TODO(titzer): we use the store here to force the representation.
- FieldAccess access = {kTaggedBase, 0, Handle<Name>(), types[u],
- static_cast<MachineType>(mach[u] | kRepTagged)};
- Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
- trunc, t.start, t.start);
- t.Effect(store);
- t.Lower();
- CheckChangeOf(IrOpcode::kChangeFloat64ToTagged, input, store->InputAt(2));
- }
- }
-}
-
-
TEST(LowerReferenceEqual_to_wordeq) {
TestingGraph t(Type::Any(), Type::Any());
IrOpcode::Value opcode =
@@ -1267,7 +1142,6 @@
TEST(LowerStringOps_to_call_and_compare) {
- if (Pipeline::SupportedTarget()) {
// These tests need linkage for the calls.
TestingGraph t(Type::String(), Type::String());
IrOpcode::Value compare_eq =
@@ -1276,18 +1150,18 @@
static_cast<IrOpcode::Value>(t.machine()->IntLessThan()->opcode());
IrOpcode::Value compare_le = static_cast<IrOpcode::Value>(
t.machine()->IntLessThanOrEqual()->opcode());
- t.CheckLoweringBinop(compare_eq, t.simplified()->StringEqual());
- t.CheckLoweringBinop(compare_lt, t.simplified()->StringLessThan());
- t.CheckLoweringBinop(compare_le, t.simplified()->StringLessThanOrEqual());
- t.CheckLoweringBinop(IrOpcode::kCall, t.simplified()->StringAdd());
+ t.CheckLoweringStringBinop(compare_eq, t.simplified()->StringEqual());
+ t.CheckLoweringStringBinop(compare_lt, t.simplified()->StringLessThan());
+ t.CheckLoweringStringBinop(compare_le,
+ t.simplified()->StringLessThanOrEqual());
}
-}
-void CheckChangeInsertion(IrOpcode::Value expected, MachineType from,
- MachineType to) {
+ void CheckChangeInsertion(IrOpcode::Value expected, MachineType from,
+ MachineType to, Type* type = Type::Any()) {
TestingGraph t(Type::Any());
Node* in = t.ExampleWithOutput(from);
+ NodeProperties::SetType(in, type);
Node* use = t.Use(in, to);
t.Return(use);
t.Lower();
@@ -1297,34 +1171,43 @@
TEST(InsertBasicChanges) {
- CheckChangeInsertion(IrOpcode::kChangeFloat64ToInt32, kRepFloat64,
- kTypeInt32);
- CheckChangeInsertion(IrOpcode::kChangeFloat64ToUint32, kRepFloat64,
- kTypeUint32);
- CheckChangeInsertion(IrOpcode::kChangeTaggedToInt32, kRepTagged, kTypeInt32);
- CheckChangeInsertion(IrOpcode::kChangeTaggedToUint32, kRepTagged,
- kTypeUint32);
+ CheckChangeInsertion(IrOpcode::kChangeFloat64ToInt32, MachineType::Float64(),
+ MachineType::Int32(), Type::Signed32());
+ CheckChangeInsertion(IrOpcode::kChangeFloat64ToUint32, MachineType::Float64(),
+ MachineType::Uint32(), Type::Unsigned32());
+ CheckChangeInsertion(IrOpcode::kTruncateFloat64ToInt32,
+ MachineType::Float64(), MachineType::Uint32(),
+ Type::Integral32());
+ CheckChangeInsertion(IrOpcode::kChangeTaggedToInt32, MachineType::AnyTagged(),
+ MachineType::Int32(), Type::Signed32());
+ CheckChangeInsertion(IrOpcode::kChangeTaggedToUint32,
+ MachineType::AnyTagged(), MachineType::Uint32(),
+ Type::Unsigned32());
- CheckChangeInsertion(IrOpcode::kChangeFloat64ToTagged, kRepFloat64,
- kRepTagged);
- CheckChangeInsertion(IrOpcode::kChangeTaggedToFloat64, kRepTagged,
- kRepFloat64);
+ CheckChangeInsertion(IrOpcode::kChangeFloat64ToTagged, MachineType::Float64(),
+ MachineType::AnyTagged());
+ CheckChangeInsertion(IrOpcode::kChangeTaggedToFloat64,
+ MachineType::AnyTagged(), MachineType::Float64());
- CheckChangeInsertion(IrOpcode::kChangeInt32ToFloat64, kTypeInt32,
- kRepFloat64);
- CheckChangeInsertion(IrOpcode::kChangeInt32ToTagged, kTypeInt32, kRepTagged);
+ CheckChangeInsertion(IrOpcode::kChangeInt32ToFloat64, MachineType::Int32(),
+ MachineType::Float64());
+ CheckChangeInsertion(IrOpcode::kChangeInt32ToTagged, MachineType::Int32(),
+ MachineType::AnyTagged());
- CheckChangeInsertion(IrOpcode::kChangeUint32ToFloat64, kTypeUint32,
- kRepFloat64);
- CheckChangeInsertion(IrOpcode::kChangeUint32ToTagged, kTypeUint32,
- kRepTagged);
+ CheckChangeInsertion(IrOpcode::kChangeUint32ToFloat64, MachineType::Uint32(),
+ MachineType::Float64());
+ CheckChangeInsertion(IrOpcode::kChangeUint32ToTagged, MachineType::Uint32(),
+ MachineType::AnyTagged());
}
static void CheckChangesAroundBinop(TestingGraph* t, const Operator* op,
IrOpcode::Value input_change,
IrOpcode::Value output_change) {
- Node* binop = t->graph()->NewNode(op, t->p0, t->p1);
+ Node* binop =
+ op->ControlInputCount() == 0
+ ? t->graph()->NewNode(op, t->p0, t->p1)
+ : t->graph()->NewNode(op, t->p0, t->p1, t->graph()->start());
t->Return(binop);
t->Lower();
CHECK_EQ(input_change, binop->InputAt(0)->opcode());
@@ -1427,7 +1310,8 @@
CHECK_EQ(IrOpcode::kInt32Add, mindex.node()->opcode());
CHECK(mindex.right().Is(access.header_size - access.tag()));
- const int element_size_shift = ElementSizeLog2Of(access.machine_type);
+ const int element_size_shift =
+ ElementSizeLog2Of(access.machine_type.representation());
if (element_size_shift) {
Int32BinopMatcher shl(mindex.left().node());
CHECK_EQ(IrOpcode::kWord32Shl, shl.node()->opcode());
@@ -1439,9 +1323,10 @@
}
-const MachineType kMachineReps[] = {kRepBit, kMachInt8, kMachInt16,
- kMachInt32, kMachInt64, kMachFloat64,
- kMachAnyTagged};
+const MachineType kMachineReps[] = {
+ MachineType::Int8(), MachineType::Int16(), MachineType::Int32(),
+ MachineType::Uint32(), MachineType::Int64(), MachineType::Float64(),
+ MachineType::AnyTagged()};
} // namespace
@@ -1453,43 +1338,62 @@
FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
Handle<Name>::null(), Type::Any(), kMachineReps[i]};
- Node* load =
- t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
+ Node* load = t.graph()->NewNode(t.simplified()->LoadField(access), t.p0,
+ t.start, t.start);
Node* use = t.Use(load, kMachineReps[i]);
t.Return(use);
- t.Lower();
+ t.LowerAllNodesAndLowerChanges();
CHECK_EQ(IrOpcode::kLoad, load->opcode());
CHECK_EQ(t.p0, load->InputAt(0));
CheckFieldAccessArithmetic(access, load);
- MachineType rep = OpParameter<MachineType>(load);
+ MachineType rep = LoadRepresentationOf(load->op());
CHECK_EQ(kMachineReps[i], rep);
}
}
TEST(LowerStoreField_to_store) {
- TestingGraph t(Type::Any(), Type::Signed32());
+ {
+ TestingGraph t(Type::Any(), Type::Signed32());
- for (size_t i = 0; i < arraysize(kMachineReps); i++) {
- FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(), kMachineReps[i]};
+ for (size_t i = 0; i < arraysize(kMachineReps); i++) {
+ FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
+ Handle<Name>::null(), Type::Any(), kMachineReps[i]};
- Node* val = t.ExampleWithOutput(kMachineReps[i]);
- Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
- val, t.start, t.start);
- t.Effect(store);
- t.Lower();
- CHECK_EQ(IrOpcode::kStore, store->opcode());
- CHECK_EQ(val, store->InputAt(2));
- CheckFieldAccessArithmetic(access, store);
+ Node* val = t.ExampleWithOutput(kMachineReps[i]);
+ Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
+ val, t.start, t.start);
+ t.Effect(store);
+ t.LowerAllNodesAndLowerChanges();
+ CHECK_EQ(IrOpcode::kStore, store->opcode());
+ CHECK_EQ(val, store->InputAt(2));
+ CheckFieldAccessArithmetic(access, store);
- StoreRepresentation rep = OpParameter<StoreRepresentation>(store);
- if (kMachineReps[i] & kRepTagged) {
- CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());
+ StoreRepresentation rep = StoreRepresentationOf(store->op());
+ if (kMachineReps[i].representation() == MachineRepresentation::kTagged) {
+ CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());
+ }
+ CHECK_EQ(kMachineReps[i].representation(), rep.representation());
}
- CHECK_EQ(kMachineReps[i], rep.machine_type());
+ }
+ {
+ HandleAndZoneScope scope;
+ Zone* z = scope.main_zone();
+ TestingGraph t(Type::Any(), Type::Intersect(Type::SignedSmall(),
+ Type::TaggedSigned(), z));
+ FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
+ Handle<Name>::null(), Type::Any(),
+ MachineType::AnyTagged()};
+ Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
+ t.p1, t.start, t.start);
+ t.Effect(store);
+ t.LowerAllNodesAndLowerChanges();
+ CHECK_EQ(IrOpcode::kStore, store->opcode());
+ CHECK_EQ(t.p1, store->InputAt(2));
+ StoreRepresentation rep = StoreRepresentationOf(store->op());
+ CHECK_EQ(kNoWriteBarrier, rep.write_barrier_kind());
}
}
@@ -1505,38 +1409,57 @@
t.p1, t.start, t.start);
Node* use = t.Use(load, kMachineReps[i]);
t.Return(use);
- t.Lower();
+ t.LowerAllNodesAndLowerChanges();
CHECK_EQ(IrOpcode::kLoad, load->opcode());
CHECK_EQ(t.p0, load->InputAt(0));
CheckElementAccessArithmetic(access, load);
- MachineType rep = OpParameter<MachineType>(load);
+ MachineType rep = LoadRepresentationOf(load->op());
CHECK_EQ(kMachineReps[i], rep);
}
}
TEST(LowerStoreElement_to_store) {
- TestingGraph t(Type::Any(), Type::Signed32());
+ {
+ TestingGraph t(Type::Any(), Type::Signed32());
- for (size_t i = 0; i < arraysize(kMachineReps); i++) {
- ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Type::Any(), kMachineReps[i]};
+ for (size_t i = 0; i < arraysize(kMachineReps); i++) {
+ ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
+ Type::Any(), kMachineReps[i]};
- Node* val = t.ExampleWithOutput(kMachineReps[i]);
- Node* store = t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
- t.p1, val, t.start, t.start);
- t.Effect(store);
- t.Lower();
- CHECK_EQ(IrOpcode::kStore, store->opcode());
- CHECK_EQ(val, store->InputAt(2));
- CheckElementAccessArithmetic(access, store);
+ Node* val = t.ExampleWithOutput(kMachineReps[i]);
+ Node* store = t.graph()->NewNode(t.simplified()->StoreElement(access),
+ t.p0, t.p1, val, t.start, t.start);
+ t.Effect(store);
+ t.LowerAllNodesAndLowerChanges();
+ CHECK_EQ(IrOpcode::kStore, store->opcode());
+ CHECK_EQ(val, store->InputAt(2));
+ CheckElementAccessArithmetic(access, store);
- StoreRepresentation rep = OpParameter<StoreRepresentation>(store);
- if (kMachineReps[i] & kRepTagged) {
- CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());
+ StoreRepresentation rep = StoreRepresentationOf(store->op());
+ if (kMachineReps[i].representation() == MachineRepresentation::kTagged) {
+ CHECK_EQ(kFullWriteBarrier, rep.write_barrier_kind());
+ }
+ CHECK_EQ(kMachineReps[i].representation(), rep.representation());
}
- CHECK_EQ(kMachineReps[i], rep.machine_type());
+ }
+ {
+ HandleAndZoneScope scope;
+ Zone* z = scope.main_zone();
+ TestingGraph t(
+ Type::Any(), Type::Signed32(),
+ Type::Intersect(Type::SignedSmall(), Type::TaggedSigned(), z));
+ ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
+ Type::Any(), MachineType::AnyTagged()};
+ Node* store = t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
+ t.p1, t.p2, t.start, t.start);
+ t.Effect(store);
+ t.LowerAllNodesAndLowerChanges();
+ CHECK_EQ(IrOpcode::kStore, store->opcode());
+ CHECK_EQ(t.p2, store->InputAt(2));
+ StoreRepresentation rep = StoreRepresentationOf(store->op());
+ CHECK_EQ(kNoWriteBarrier, rep.write_barrier_kind());
}
}
@@ -1546,17 +1469,15 @@
// Load(obj, Int32Add(Int32Mul(ChangeTaggedToInt32(index), #k), #k))
TestingGraph t(Type::Any(), Type::Signed32());
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
- kMachAnyTagged};
+ MachineType::AnyTagged()};
Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
t.p1, t.start, t.start);
t.Return(load);
t.Lower();
- CHECK_EQ(IrOpcode::kLoad, load->opcode());
+ CHECK_EQ(IrOpcode::kLoadElement, load->opcode());
CHECK_EQ(t.p0, load->InputAt(0));
-
- Node* index = CheckElementAccessArithmetic(access, load);
- CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p1, index);
+ CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p1, load->InputAt(1));
}
@@ -1565,18 +1486,16 @@
// Store(obj, Int32Add(Int32Mul(ChangeTaggedToInt32(index), #k), #k), val)
TestingGraph t(Type::Any(), Type::Signed32());
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
- kMachAnyTagged};
+ MachineType::AnyTagged()};
Node* store =
t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0, t.p1,
t.jsgraph.TrueConstant(), t.start, t.start);
t.Effect(store);
t.Lower();
- CHECK_EQ(IrOpcode::kStore, store->opcode());
+ CHECK_EQ(IrOpcode::kStoreElement, store->opcode());
CHECK_EQ(t.p0, store->InputAt(0));
-
- Node* index = CheckElementAccessArithmetic(access, store);
- CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p1, index);
+ CheckChangeOf(IrOpcode::kChangeTaggedToInt32, t.p1, store->InputAt(1));
}
@@ -1584,13 +1503,13 @@
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32(), Type::Any());
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
- kMachFloat64};
+ MachineType::Float64()};
Node* load = t.graph()->NewNode(t.simplified()->LoadElement(access), t.p0,
t.p1, t.start, t.start);
t.Return(load);
t.Lower();
- CHECK_EQ(IrOpcode::kLoad, load->opcode());
+ CHECK_EQ(IrOpcode::kLoadElement, load->opcode());
CHECK_EQ(t.p0, load->InputAt(0));
CheckChangeOf(IrOpcode::kChangeFloat64ToTagged, load, t.ret->InputAt(0));
}
@@ -1600,13 +1519,14 @@
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32());
FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(), kMachFloat64};
+ Handle<Name>::null(), Type::Any(),
+ MachineType::Float64()};
- Node* load =
- t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
+ Node* load = t.graph()->NewNode(t.simplified()->LoadField(access), t.p0,
+ t.start, t.start);
t.Return(load);
t.Lower();
- CHECK_EQ(IrOpcode::kLoad, load->opcode());
+ CHECK_EQ(IrOpcode::kLoadField, load->opcode());
CHECK_EQ(t.p0, load->InputAt(0));
CheckChangeOf(IrOpcode::kChangeFloat64ToTagged, load, t.ret->InputAt(0));
}
@@ -1616,7 +1536,7 @@
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32());
ElementAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize, Type::Any(),
- kMachFloat64};
+ MachineType::Float64()};
Node* store =
t.graph()->NewNode(t.simplified()->StoreElement(access), t.p0,
@@ -1624,7 +1544,7 @@
t.Effect(store);
t.Lower();
- CHECK_EQ(IrOpcode::kStore, store->opcode());
+ CHECK_EQ(IrOpcode::kStoreElement, store->opcode());
CHECK_EQ(t.p0, store->InputAt(0));
CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(2));
}
@@ -1634,76 +1554,59 @@
// TODO(titzer): test all load/store representation change insertions.
TestingGraph t(Type::Any(), Type::Signed32());
FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
- Handle<Name>::null(), Type::Any(), kMachFloat64};
+ Handle<Name>::null(), Type::Any(),
+ MachineType::Float64()};
Node* store = t.graph()->NewNode(t.simplified()->StoreField(access), t.p0,
t.p1, t.start, t.start);
t.Effect(store);
t.Lower();
- CHECK_EQ(IrOpcode::kStore, store->opcode());
+ CHECK_EQ(IrOpcode::kStoreField, store->opcode());
CHECK_EQ(t.p0, store->InputAt(0));
- CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(2));
+ CheckChangeOf(IrOpcode::kChangeTaggedToFloat64, t.p1, store->InputAt(1));
}
TEST(UpdatePhi) {
TestingGraph t(Type::Any(), Type::Signed32());
- static const MachineType kMachineTypes[] = {kMachInt32, kMachUint32,
- kMachFloat64};
+ static const MachineType kMachineTypes[] = {
+ MachineType::Int32(), MachineType::Uint32(), MachineType::Float64()};
Type* kTypes[] = {Type::Signed32(), Type::Unsigned32(), Type::Number()};
for (size_t i = 0; i < arraysize(kMachineTypes); i++) {
FieldAccess access = {kTaggedBase, FixedArrayBase::kHeaderSize,
Handle<Name>::null(), kTypes[i], kMachineTypes[i]};
- Node* load0 =
- t.graph()->NewNode(t.simplified()->LoadField(access), t.p0, t.start);
- Node* load1 =
- t.graph()->NewNode(t.simplified()->LoadField(access), t.p1, t.start);
- Node* phi = t.graph()->NewNode(t.common()->Phi(kMachAnyTagged, 2), load0,
- load1, t.start);
+ Node* load0 = t.graph()->NewNode(t.simplified()->LoadField(access), t.p0,
+ t.start, t.start);
+ Node* load1 = t.graph()->NewNode(t.simplified()->LoadField(access), t.p1,
+ t.start, t.start);
+ Node* phi =
+ t.graph()->NewNode(t.common()->Phi(MachineRepresentation::kTagged, 2),
+ load0, load1, t.start);
t.Return(t.Use(phi, kMachineTypes[i]));
t.Lower();
CHECK_EQ(IrOpcode::kPhi, phi->opcode());
- CHECK_EQ(RepresentationOf(kMachineTypes[i]),
- RepresentationOf(OpParameter<MachineType>(phi)));
+ CHECK_EQ(kMachineTypes[i].representation(), PhiRepresentationOf(phi->op()));
}
}
TEST(RunNumberDivide_minus_1_TruncatingToInt32) {
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* num = t.NumberToInt32(t.Parameter(0));
Node* div = t.NumberDivide(num, t.jsgraph.Constant(-1));
Node* trunc = t.NumberToInt32(div);
t.Return(trunc);
- if (Pipeline::SupportedTarget()) {
- t.LowerAllNodesAndLowerChanges();
- t.GenerateCode();
+ t.LowerAllNodesAndLowerChanges();
+ t.GenerateCode();
- FOR_INT32_INPUTS(i) {
- int32_t x = 0 - *i;
- t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
- }
- }
-}
-
-
-TEST(NumberMultiply_TruncatingToInt32) {
- int32_t constants[] = {-100, -10, -1, 0, 1, 100, 1000};
-
- for (size_t i = 0; i < arraysize(constants); i++) {
- TestingGraph t(Type::Signed32());
- Node* k = t.jsgraph.Constant(constants[i]);
- Node* mul = t.graph()->NewNode(t.simplified()->NumberMultiply(), t.p0, k);
- Node* trunc = t.graph()->NewNode(t.simplified()->NumberToInt32(), mul);
- t.Return(trunc);
- t.Lower();
-
- CHECK_EQ(IrOpcode::kInt32Mul, mul->opcode());
+ FOR_INT32_INPUTS(i) {
+ int32_t x = 0 - *i;
+ t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
}
}
@@ -1713,13 +1616,12 @@
for (size_t i = 0; i < arraysize(constants); i++) {
double k = static_cast<double>(constants[i]);
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* num = t.NumberToInt32(t.Parameter(0));
Node* mul = t.NumberMultiply(num, t.jsgraph.Constant(k));
Node* trunc = t.NumberToInt32(mul);
t.Return(trunc);
- if (Pipeline::SupportedTarget()) {
t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
@@ -1728,7 +1630,6 @@
t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
}
}
- }
}
@@ -1737,33 +1638,30 @@
for (size_t i = 0; i < arraysize(constants); i++) {
double k = static_cast<double>(constants[i]);
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* num = t.NumberToUint32(t.Parameter(0));
Node* mul = t.NumberMultiply(num, t.jsgraph.Constant(k));
Node* trunc = t.NumberToUint32(mul);
t.Return(trunc);
- if (Pipeline::SupportedTarget()) {
t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
FOR_UINT32_INPUTS(i) {
uint32_t x = DoubleToUint32(static_cast<double>(*i) * k);
t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
- }
}
}
}
TEST(RunNumberDivide_2_TruncatingToUint32) {
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* num = t.NumberToUint32(t.Parameter(0));
Node* div = t.NumberDivide(num, t.jsgraph.Constant(2));
Node* trunc = t.NumberToUint32(div);
t.Return(trunc);
- if (Pipeline::SupportedTarget()) {
t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
@@ -1771,7 +1669,6 @@
uint32_t x = DoubleToUint32(static_cast<double>(*i / 2.0));
t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
}
- }
}
@@ -1805,7 +1702,7 @@
TestingGraph t(Type::Signed32());
Node* k = t.jsgraph.Constant(constants[i]);
Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
- Node* use = t.Use(div, kMachInt32);
+ Node* use = t.Use(div, MachineType::Int32());
t.Return(use);
t.Lower();
@@ -1819,13 +1716,12 @@
for (size_t i = 0; i < arraysize(constants); i++) {
int32_t k = constants[i];
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* num = t.NumberToInt32(t.Parameter(0));
Node* div = t.NumberDivide(num, t.jsgraph.Constant(k));
Node* trunc = t.NumberToInt32(div);
t.Return(trunc);
- if (Pipeline::SupportedTarget()) {
t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
@@ -1833,7 +1729,6 @@
if (*i == INT_MAX) continue; // exclude max int.
int32_t x = DoubleToInt32(static_cast<double>(*i) / k);
t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
- }
}
}
}
@@ -1846,7 +1741,7 @@
TestingGraph t(Type::Unsigned32());
Node* k = t.jsgraph.Constant(constants[i]);
Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
- Node* use = t.Use(div, kMachUint32);
+ Node* use = t.Use(div, MachineType::Uint32());
t.Return(use);
t.Lower();
@@ -1860,20 +1755,18 @@
for (size_t i = 0; i < arraysize(constants); i++) {
uint32_t k = constants[i];
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* num = t.NumberToUint32(t.Parameter(0));
Node* div = t.NumberDivide(num, t.jsgraph.Constant(static_cast<double>(k)));
Node* trunc = t.NumberToUint32(div);
t.Return(trunc);
- if (Pipeline::SupportedTarget()) {
t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
FOR_UINT32_INPUTS(i) {
uint32_t x = *i / k;
t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
- }
}
}
}
@@ -1884,7 +1777,7 @@
TestingGraph t(Type::Signed32());
Node* k = t.jsgraph.Constant(-1);
Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
- Node* use = t.Use(div, kMachInt32);
+ Node* use = t.Use(div, MachineType::Int32());
t.Return(use);
t.Lower();
@@ -1895,7 +1788,7 @@
TestingGraph t(Type::Signed32());
Node* k = t.jsgraph.Constant(0);
Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
- Node* use = t.Use(div, kMachInt32);
+ Node* use = t.Use(div, MachineType::Int32());
t.Return(use);
t.Lower();
@@ -1907,7 +1800,7 @@
TestingGraph t(Type::Unsigned32());
Node* k = t.jsgraph.Constant(0);
Node* div = t.graph()->NewNode(t.simplified()->NumberDivide(), t.p0, k);
- Node* use = t.Use(div, kMachUint32);
+ Node* use = t.Use(div, MachineType::Uint32());
t.Return(use);
t.Lower();
@@ -1924,7 +1817,7 @@
TestingGraph t(Type::Signed32());
Node* k = t.jsgraph.Constant(constants[i]);
Node* mod = t.graph()->NewNode(t.simplified()->NumberModulus(), t.p0, k);
- Node* use = t.Use(mod, kMachInt32);
+ Node* use = t.Use(mod, MachineType::Int32());
t.Return(use);
t.Lower();
@@ -1938,13 +1831,12 @@
for (size_t i = 0; i < arraysize(constants); i++) {
int32_t k = constants[i];
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* num = t.NumberToInt32(t.Parameter(0));
Node* mod = t.NumberModulus(num, t.jsgraph.Constant(k));
Node* trunc = t.NumberToInt32(mod);
t.Return(trunc);
- if (Pipeline::SupportedTarget()) {
t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
@@ -1952,7 +1844,6 @@
if (*i == INT_MAX) continue; // exclude max int.
int32_t x = DoubleToInt32(std::fmod(static_cast<double>(*i), k));
t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
- }
}
}
}
@@ -1966,10 +1857,10 @@
Node* k = t.jsgraph.Constant(constants[i]);
Node* mod = t.graph()->NewNode(t.simplified()->NumberModulus(), t.p0, k);
Node* trunc = t.graph()->NewNode(t.simplified()->NumberToUint32(), mod);
- Node* ret = t.Return(trunc);
+ t.Return(trunc);
t.Lower();
- CHECK_EQ(IrOpcode::kUint32Mod, ret->InputAt(0)->opcode());
+ CHECK_EQ(IrOpcode::kUint32Mod, t.ret->InputAt(0)->InputAt(0)->opcode());
}
}
@@ -1979,21 +1870,19 @@
for (size_t i = 0; i < arraysize(constants); i++) {
uint32_t k = constants[i];
- SimplifiedLoweringTester<Object*> t(kMachAnyTagged);
+ SimplifiedLoweringTester<Object*> t(MachineType::AnyTagged());
Node* num = t.NumberToUint32(t.Parameter(0));
Node* mod =
t.NumberModulus(num, t.jsgraph.Constant(static_cast<double>(k)));
Node* trunc = t.NumberToUint32(mod);
t.Return(trunc);
- if (Pipeline::SupportedTarget()) {
t.LowerAllNodesAndLowerChanges();
t.GenerateCode();
FOR_UINT32_INPUTS(i) {
uint32_t x = *i % k;
t.CheckNumberCall(static_cast<double>(x), static_cast<double>(*i));
- }
}
}
}
@@ -2016,7 +1905,7 @@
TEST(NumberModulus_Uint32) {
const double kConstants[] = {2, 100, 1000, 1024, 2048};
- const MachineType kTypes[] = {kMachInt32, kMachUint32};
+ const MachineType kTypes[] = {MachineType::Int32(), MachineType::Uint32()};
for (auto const type : kTypes) {
for (auto const c : kConstants) {
@@ -2041,18 +1930,20 @@
Type* arg1;
Type* arg2;
MachineType use;
- MachineTypeUnion expected;
+ MachineRepresentation expected;
};
TestData test_data[] = {
- {Type::Signed32(), Type::Unsigned32(), kMachInt32,
- kRepWord32 | kTypeNumber},
- {Type::Signed32(), Type::Unsigned32(), kMachUint32,
- kRepWord32 | kTypeNumber},
- {Type::Signed32(), Type::Signed32(), kMachInt32, kMachInt32},
- {Type::Unsigned32(), Type::Unsigned32(), kMachInt32, kMachUint32},
- {Type::Number(), Type::Signed32(), kMachInt32, kMachFloat64},
- {Type::Signed32(), Type::String(), kMachInt32, kMachAnyTagged}};
+ {Type::Signed32(), Type::Unsigned32(), MachineType::Int32(),
+ MachineRepresentation::kWord32},
+ {Type::Signed32(), Type::Unsigned32(), MachineType::Uint32(),
+ MachineRepresentation::kWord32},
+ {Type::Signed32(), Type::Signed32(), MachineType::Int32(),
+ MachineRepresentation::kWord32},
+ {Type::Unsigned32(), Type::Unsigned32(), MachineType::Int32(),
+ MachineRepresentation::kWord32},
+ {Type::Number(), Type::Signed32(), MachineType::Int32(),
+ MachineRepresentation::kWord32}};
for (auto const d : test_data) {
TestingGraph t(d.arg1, d.arg2, Type::Boolean());
@@ -2062,16 +1953,20 @@
Node* fb = t.graph()->NewNode(t.common()->IfFalse(), br);
Node* m = t.graph()->NewNode(t.common()->Merge(2), tb, fb);
- Node* phi =
- t.graph()->NewNode(t.common()->Phi(kMachAnyTagged, 2), t.p0, t.p1, m);
+ Node* phi = t.graph()->NewNode(
+ t.common()->Phi(MachineRepresentation::kTagged, 2), t.p0, t.p1, m);
- Bounds phi_bounds = Bounds::Either(Bounds(d.arg1), Bounds(d.arg2), z);
- NodeProperties::SetBounds(phi, phi_bounds);
+ Type* phi_type = Type::Union(d.arg1, d.arg2, z);
+ NodeProperties::SetType(phi, phi_type);
Node* use = t.Use(phi, d.use);
t.Return(use);
t.Lower();
- CHECK_EQ(d.expected, OpParameter<MachineType>(phi));
+ CHECK_EQ(d.expected, PhiRepresentationOf(phi->op()));
}
}
+
+} // namespace compiler
+} // namespace internal
+} // namespace v8