Index: test/cctest/compiler/compiler/test-simplified-lowering.cc |
diff --git a/test/cctest/compiler/compiler/test-simplified-lowering.cc b/test/cctest/compiler/compiler/test-simplified-lowering.cc |
deleted file mode 100644 |
index f1d95707635d67ce96b8bab777056d0b9074b9e0..0000000000000000000000000000000000000000 |
--- a/test/cctest/compiler/compiler/test-simplified-lowering.cc |
+++ /dev/null |
@@ -1,614 +0,0 @@ |
-// 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 <limits> |
- |
-#include "src/compiler/control-builders.h" |
-#include "src/compiler/node-properties-inl.h" |
-#include "src/compiler/pipeline.h" |
-#include "src/compiler/simplified-lowering.h" |
-#include "src/compiler/simplified-node-factory.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 "test/cctest/cctest.h" |
-#include "test/cctest/compiler/codegen-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; |
- |
-template <typename ReturnType> |
-class SimplifiedGraphBuilderTester : public GraphBuilderTester<ReturnType> { |
- public: |
- SimplifiedGraphBuilderTester(MachineRepresentation p0 = kMachineLast, |
- MachineRepresentation p1 = kMachineLast, |
- MachineRepresentation p2 = kMachineLast, |
- MachineRepresentation p3 = kMachineLast, |
- MachineRepresentation p4 = kMachineLast) |
- : GraphBuilderTester<ReturnType>(p0, p1, p2, p3, p4) {} |
- |
- // Close graph and lower one node. |
- void Lower(Node* node) { |
- this->End(); |
- Typer typer(this->zone()); |
- CommonOperatorBuilder common(this->zone()); |
- SourcePositionTable source_positions(this->graph()); |
- JSGraph jsgraph(this->graph(), &common, &typer); |
- SimplifiedLowering lowering(&jsgraph, &source_positions); |
- if (node == NULL) { |
- lowering.LowerAllNodes(); |
- } else { |
- lowering.Lower(node); |
- } |
- } |
- |
- // Close graph and lower all nodes. |
- void LowerAllNodes() { Lower(NULL); } |
- |
- void StoreFloat64(Node* node, double* ptr) { |
- Node* ptr_node = this->PointerConstant(ptr); |
- this->Store(kMachineFloat64, ptr_node, node); |
- } |
- |
- Node* LoadInt32(int32_t* ptr) { |
- Node* ptr_node = this->PointerConstant(ptr); |
- return this->Load(kMachineWord32, ptr_node); |
- } |
- |
- Node* LoadUint32(uint32_t* ptr) { |
- Node* ptr_node = this->PointerConstant(ptr); |
- return this->Load(kMachineWord32, ptr_node); |
- } |
- |
- Node* LoadFloat64(double* ptr) { |
- Node* ptr_node = this->PointerConstant(ptr); |
- return this->Load(kMachineFloat64, ptr_node); |
- } |
- |
- Factory* factory() { return this->isolate()->factory(); } |
- Heap* heap() { return this->isolate()->heap(); } |
-}; |
- |
- |
-class SimplifiedGraphBuilderJSTester |
- : public SimplifiedGraphBuilderTester<Object*> { |
- public: |
- SimplifiedGraphBuilderJSTester() |
- : SimplifiedGraphBuilderTester<Object*>(), |
- f_(v8::Utils::OpenHandle(*v8::Handle<v8::Function>::Cast(CompileRun( |
- "(function() { 'use strict'; return 2.7123; })")))), |
- swapped_(false) { |
- set_current_context(HeapConstant(handle(f_->context()))); |
- } |
- |
- template <typename T> |
- T* CallJS() { |
- if (!swapped_) { |
- Compile(); |
- } |
- Handle<Object>* args = NULL; |
- MaybeHandle<Object> result = Execution::Call( |
- isolate(), f_, factory()->undefined_value(), 0, args, false); |
- return T::cast(*result.ToHandleChecked()); |
- } |
- |
- private: |
- void Compile() { |
- CompilationInfoWithZone info(f_); |
- CHECK(Parser::Parse(&info)); |
- StrictMode strict_mode = info.function()->strict_mode(); |
- info.SetStrictMode(strict_mode); |
- info.SetOptimizing(BailoutId::None(), Handle<Code>(f_->code())); |
- CHECK(Rewriter::Rewrite(&info)); |
- CHECK(Scope::Analyze(&info)); |
- CHECK_NE(NULL, info.scope()); |
- Pipeline pipeline(&info); |
- Linkage linkage(&info); |
- Handle<Code> code = pipeline.GenerateCodeForMachineGraph(&linkage, graph()); |
- CHECK(!code.is_null()); |
- f_->ReplaceCode(*code); |
- swapped_ = true; |
- } |
- |
- Handle<JSFunction> f_; |
- bool swapped_; |
-}; |
- |
- |
-TEST(RunChangeTaggedToInt32) { |
- SimplifiedGraphBuilderTester<int32_t> t(kMachineTagged); |
- Node* x = t.ChangeTaggedToInt32(t.Parameter(0)); |
- t.Return(x); |
- |
- t.Lower(x); |
- |
- // TODO(titzer): remove me. |
- return; |
- |
- FOR_INT32_INPUTS(i) { |
- int32_t input = *i; |
- |
- if (Smi::IsValid(input)) { |
- int32_t result = t.Call(Smi::FromInt(input)); |
- CHECK_EQ(input, result); |
- } |
- |
- { |
- Handle<Object> number = t.factory()->NewNumber(input); |
- int32_t result = t.Call(*number); |
- CHECK_EQ(input, result); |
- } |
- |
- { |
- Handle<HeapNumber> number = t.factory()->NewHeapNumber(input); |
- int32_t result = t.Call(*number); |
- CHECK_EQ(input, result); |
- } |
- } |
-} |
- |
- |
-TEST(RunChangeTaggedToUint32) { |
- SimplifiedGraphBuilderTester<int32_t> t(kMachineTagged); |
- Node* x = t.ChangeTaggedToUint32(t.Parameter(0)); |
- t.Return(x); |
- |
- t.Lower(x); |
- |
- // TODO(titzer): remove me. |
- return; |
- |
- FOR_UINT32_INPUTS(i) { |
- uint32_t input = *i; |
- |
- if (Smi::IsValid(input)) { |
- int32_t result = t.Call(Smi::FromInt(input)); |
- CHECK_EQ(static_cast<int32_t>(input), result); |
- } |
- |
- { |
- Handle<Object> number = t.factory()->NewNumber(input); |
- int32_t result = t.Call(*number); |
- CHECK_EQ(static_cast<int32_t>(input), result); |
- } |
- |
- { |
- Handle<HeapNumber> number = t.factory()->NewHeapNumber(input); |
- int32_t result = t.Call(*number); |
- CHECK_EQ(static_cast<int32_t>(input), result); |
- } |
- } |
-} |
- |
- |
-TEST(RunChangeTaggedToFloat64) { |
- SimplifiedGraphBuilderTester<int32_t> t(kMachineTagged); |
- double result; |
- Node* x = t.ChangeTaggedToFloat64(t.Parameter(0)); |
- t.StoreFloat64(x, &result); |
- t.Return(t.Int32Constant(0)); |
- |
- t.Lower(x); |
- |
- // TODO(titzer): remove me. |
- return; |
- |
- { |
- FOR_INT32_INPUTS(i) { |
- int32_t input = *i; |
- |
- if (Smi::IsValid(input)) { |
- t.Call(Smi::FromInt(input)); |
- CHECK_EQ(input, static_cast<int32_t>(result)); |
- } |
- |
- { |
- Handle<Object> number = t.factory()->NewNumber(input); |
- t.Call(*number); |
- CHECK_EQ(input, static_cast<int32_t>(result)); |
- } |
- |
- { |
- Handle<HeapNumber> number = t.factory()->NewHeapNumber(input); |
- t.Call(*number); |
- CHECK_EQ(input, static_cast<int32_t>(result)); |
- } |
- } |
- } |
- |
- { |
- FOR_FLOAT64_INPUTS(i) { |
- double input = *i; |
- { |
- Handle<Object> number = t.factory()->NewNumber(input); |
- t.Call(*number); |
- CHECK_EQ(input, result); |
- } |
- |
- { |
- Handle<HeapNumber> number = t.factory()->NewHeapNumber(input); |
- t.Call(*number); |
- CHECK_EQ(input, result); |
- } |
- } |
- } |
-} |
- |
- |
-TEST(RunChangeBoolToBit) { |
- SimplifiedGraphBuilderTester<int32_t> t(kMachineTagged); |
- Node* x = t.ChangeBoolToBit(t.Parameter(0)); |
- t.Return(x); |
- |
- t.Lower(x); |
- |
- if (!Pipeline::SupportedTarget()) return; |
- |
- { |
- Object* true_obj = t.heap()->true_value(); |
- int32_t result = t.Call(true_obj); |
- CHECK_EQ(1, result); |
- } |
- |
- { |
- Object* false_obj = t.heap()->false_value(); |
- int32_t result = t.Call(false_obj); |
- CHECK_EQ(0, result); |
- } |
-} |
- |
- |
-TEST(RunChangeBitToBool) { |
- SimplifiedGraphBuilderTester<Object*> t(kMachineTagged); |
- Node* x = t.ChangeBitToBool(t.Parameter(0)); |
- t.Return(x); |
- |
- t.Lower(x); |
- |
- // TODO(titzer): remove me. |
- return; |
- |
- { |
- Object* result = t.Call(1); |
- Object* true_obj = t.heap()->true_value(); |
- CHECK_EQ(true_obj, result); |
- } |
- |
- { |
- Object* result = t.Call(0); |
- Object* false_obj = t.heap()->false_value(); |
- CHECK_EQ(false_obj, result); |
- } |
-} |
- |
- |
-TEST(RunChangeInt32ToTagged) { |
- SimplifiedGraphBuilderJSTester t; |
- int32_t input; |
- Node* load = t.LoadInt32(&input); |
- Node* x = t.ChangeInt32ToTagged(load); |
- t.Return(x); |
- |
- t.Lower(x); |
- |
- // TODO(titzer): remove me. |
- return; |
- |
- |
- { |
- FOR_INT32_INPUTS(i) { |
- input = *i; |
- HeapNumber* result = t.CallJS<HeapNumber>(); |
- CHECK_EQ(static_cast<double>(input), result->value()); |
- } |
- } |
- |
- { |
- FOR_INT32_INPUTS(i) { |
- input = *i; |
- SimulateFullSpace(CcTest::heap()->new_space()); |
- HeapNumber* result = t.CallJS<HeapNumber>(); |
- CHECK_EQ(static_cast<double>(input), result->value()); |
- } |
- } |
-} |
- |
- |
-TEST(RunChangeUint32ToTagged) { |
- SimplifiedGraphBuilderJSTester t; |
- uint32_t input; |
- Node* load = t.LoadUint32(&input); |
- Node* x = t.ChangeUint32ToTagged(load); |
- t.Return(x); |
- |
- t.Lower(x); |
- |
- // TODO(titzer): remove me. |
- return; |
- |
- { |
- FOR_UINT32_INPUTS(i) { |
- input = *i; |
- HeapNumber* result = t.CallJS<HeapNumber>(); |
- double expected = static_cast<double>(input); |
- CHECK_EQ(expected, result->value()); |
- } |
- } |
- |
- { |
- FOR_UINT32_INPUTS(i) { |
- input = *i; |
- SimulateFullSpace(CcTest::heap()->new_space()); |
- HeapNumber* result = t.CallJS<HeapNumber>(); |
- double expected = static_cast<double>(static_cast<uint32_t>(input)); |
- CHECK_EQ(expected, result->value()); |
- } |
- } |
-} |
- |
- |
-TEST(RunChangeFloat64ToTagged) { |
- SimplifiedGraphBuilderJSTester t; |
- double input; |
- Node* load = t.LoadFloat64(&input); |
- Node* x = t.ChangeFloat64ToTagged(load); |
- t.Return(x); |
- |
- t.Lower(x); |
- |
- // TODO(titzer): remove me. |
- return; |
- |
- { |
- FOR_FLOAT64_INPUTS(i) { |
- input = *i; |
- HeapNumber* result = t.CallJS<HeapNumber>(); |
- CHECK_EQ(input, result->value()); |
- } |
- } |
- { |
- FOR_FLOAT64_INPUTS(i) { |
- input = *i; |
- SimulateFullSpace(CcTest::heap()->new_space()); |
- HeapNumber* result = t.CallJS<HeapNumber>(); |
- CHECK_EQ(input, result->value()); |
- } |
- } |
-} |
- |
- |
-// TODO(dcarney): find a home for these functions. |
-namespace { |
- |
-FieldAccess ForJSObjectMap() { |
- FieldAccess access = {JSObject::kMapOffset, Handle<Name>(), Type::Any(), |
- kMachineTagged}; |
- return access; |
-} |
- |
- |
-FieldAccess ForJSObjectProperties() { |
- FieldAccess access = {JSObject::kPropertiesOffset, Handle<Name>(), |
- Type::Any(), kMachineTagged}; |
- return access; |
-} |
- |
- |
-FieldAccess ForArrayBufferBackingStore() { |
- FieldAccess access = { |
- JSArrayBuffer::kBackingStoreOffset, Handle<Name>(), Type::UntaggedPtr(), |
- MachineOperatorBuilder::pointer_rep(), |
- }; |
- return access; |
-} |
- |
- |
-ElementAccess ForFixedArrayElement() { |
- ElementAccess access = {FixedArray::kHeaderSize, Type::Any(), kMachineTagged}; |
- return access; |
-} |
- |
- |
-ElementAccess ForBackingStoreElement(MachineRepresentation rep) { |
- ElementAccess access = {kNonHeapObjectHeaderSize, Type::Any(), rep}; |
- return access; |
-} |
-} |
- |
- |
-// Create a simple JSObject with a unique map. |
-static Handle<JSObject> TestObject() { |
- static int index = 0; |
- char buffer[50]; |
- v8::base::OS::SNPrintF(buffer, 50, "({'a_%d':1})", index++); |
- return Handle<JSObject>::cast(v8::Utils::OpenHandle(*CompileRun(buffer))); |
-} |
- |
- |
-TEST(RunLoadMap) { |
- SimplifiedGraphBuilderTester<Object*> t(kMachineTagged); |
- FieldAccess access = ForJSObjectMap(); |
- Node* load = t.LoadField(access, t.Parameter(0)); |
- t.Return(load); |
- |
- t.LowerAllNodes(); |
- |
- if (!Pipeline::SupportedTarget()) return; |
- |
- Handle<JSObject> src = TestObject(); |
- Handle<Map> src_map(src->map()); |
- Object* result = t.Call(*src); |
- CHECK_EQ(*src_map, result); |
-} |
- |
- |
-TEST(RunStoreMap) { |
- SimplifiedGraphBuilderTester<int32_t> t(kMachineTagged, kMachineTagged); |
- FieldAccess access = ForJSObjectMap(); |
- t.StoreField(access, t.Parameter(1), t.Parameter(0)); |
- t.Return(t.Int32Constant(0)); |
- |
- t.LowerAllNodes(); |
- |
- if (!Pipeline::SupportedTarget()) return; |
- |
- Handle<JSObject> src = TestObject(); |
- Handle<Map> src_map(src->map()); |
- Handle<JSObject> dst = TestObject(); |
- CHECK(src->map() != dst->map()); |
- t.Call(*src_map, *dst); |
- CHECK(*src_map == dst->map()); |
-} |
- |
- |
-TEST(RunLoadProperties) { |
- SimplifiedGraphBuilderTester<Object*> t(kMachineTagged); |
- FieldAccess access = ForJSObjectProperties(); |
- Node* load = t.LoadField(access, t.Parameter(0)); |
- t.Return(load); |
- |
- t.LowerAllNodes(); |
- |
- if (!Pipeline::SupportedTarget()) return; |
- |
- Handle<JSObject> src = TestObject(); |
- Handle<FixedArray> src_props(src->properties()); |
- Object* result = t.Call(*src); |
- CHECK_EQ(*src_props, result); |
-} |
- |
- |
-TEST(RunLoadStoreMap) { |
- SimplifiedGraphBuilderTester<Object*> t(kMachineTagged, kMachineTagged); |
- FieldAccess access = ForJSObjectMap(); |
- Node* load = t.LoadField(access, t.Parameter(0)); |
- t.StoreField(access, t.Parameter(1), load); |
- t.Return(load); |
- |
- t.LowerAllNodes(); |
- |
- if (!Pipeline::SupportedTarget()) return; |
- |
- Handle<JSObject> src = TestObject(); |
- Handle<Map> src_map(src->map()); |
- Handle<JSObject> dst = TestObject(); |
- CHECK(src->map() != dst->map()); |
- Object* result = t.Call(*src, *dst); |
- CHECK(result->IsMap()); |
- CHECK_EQ(*src_map, result); |
- CHECK(*src_map == dst->map()); |
-} |
- |
- |
-TEST(RunLoadStoreFixedArrayIndex) { |
- SimplifiedGraphBuilderTester<Object*> t(kMachineTagged); |
- ElementAccess access = 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(); |
- |
- if (!Pipeline::SupportedTarget()) return; |
- |
- Handle<FixedArray> array = t.factory()->NewFixedArray(2); |
- Handle<JSObject> src = TestObject(); |
- Handle<JSObject> dst = TestObject(); |
- array->set(0, *src); |
- array->set(1, *dst); |
- Object* result = t.Call(*array); |
- CHECK_EQ(*src, result); |
- CHECK_EQ(*src, array->get(0)); |
- CHECK_EQ(*src, array->get(1)); |
-} |
- |
- |
-TEST(RunLoadStoreArrayBuffer) { |
- SimplifiedGraphBuilderTester<int32_t> t(kMachineTagged); |
- const int index = 12; |
- FieldAccess access = ForArrayBufferBackingStore(); |
- Node* backing_store = t.LoadField(access, t.Parameter(0)); |
- ElementAccess buffer_access = ForBackingStoreElement(kMachineWord8); |
- Node* load = |
- t.LoadElement(buffer_access, backing_store, t.Int32Constant(index)); |
- t.StoreElement(buffer_access, backing_store, t.Int32Constant(index + 1), |
- load); |
- t.Return(load); |
- |
- t.LowerAllNodes(); |
- |
- if (!Pipeline::SupportedTarget()) return; |
- |
- Handle<JSArrayBuffer> array = t.factory()->NewJSArrayBuffer(); |
- const int array_length = 2 * index; |
- Runtime::SetupArrayBufferAllocatingData(t.isolate(), array, array_length); |
- uint8_t* data = reinterpret_cast<uint8_t*>(array->backing_store()); |
- for (int i = 0; i < array_length; i++) { |
- data[i] = i; |
- } |
- int32_t result = t.Call(*array); |
- CHECK_EQ(index, result); |
- for (int i = 0; i < array_length; i++) { |
- uint8_t expected = i; |
- if (i == (index + 1)) expected = result; |
- CHECK_EQ(data[i], expected); |
- } |
-} |
- |
- |
-TEST(RunCopyFixedArray) { |
- SimplifiedGraphBuilderTester<int32_t> t(kMachineTagged, kMachineTagged); |
- |
- const int kArraySize = 15; |
- Node* one = t.Int32Constant(1); |
- Node* index = t.Int32Constant(0); |
- Node* limit = t.Int32Constant(kArraySize); |
- t.environment()->Push(index); |
- { |
- LoopBuilder loop(&t); |
- loop.BeginLoop(); |
- // Loop exit condition. |
- index = t.environment()->Top(); |
- Node* condition = t.Int32LessThan(index, limit); |
- loop.BreakUnless(condition); |
- // src[index] = dst[index]. |
- index = t.environment()->Pop(); |
- ElementAccess access = ForFixedArrayElement(); |
- Node* src = t.Parameter(0); |
- Node* load = t.LoadElement(access, src, index); |
- Node* dst = t.Parameter(1); |
- t.StoreElement(access, dst, index, load); |
- // index++ |
- index = t.Int32Add(index, one); |
- t.environment()->Push(index); |
- // continue. |
- loop.EndBody(); |
- loop.EndLoop(); |
- } |
- index = t.environment()->Pop(); |
- t.Return(index); |
- |
- t.LowerAllNodes(); |
- |
- if (!Pipeline::SupportedTarget()) return; |
- |
- Handle<FixedArray> src = t.factory()->NewFixedArray(kArraySize); |
- Handle<FixedArray> src_copy = t.factory()->NewFixedArray(kArraySize); |
- Handle<FixedArray> dst = t.factory()->NewFixedArray(kArraySize); |
- for (int i = 0; i < kArraySize; i++) { |
- src->set(i, *TestObject()); |
- src_copy->set(i, src->get(i)); |
- dst->set(i, *TestObject()); |
- CHECK_NE(src_copy->get(i), dst->get(i)); |
- } |
- CHECK_EQ(kArraySize, t.Call(*src, *dst)); |
- for (int i = 0; i < kArraySize; i++) { |
- CHECK_EQ(src_copy->get(i), dst->get(i)); |
- } |
-} |