0e16150d33
- Extend verifier to check types of JS and Simplified nodes. - Untyped nodes now contain NULL as types, enforcing hard failure. - Typer immediately installs itself as a decorator; remove explicit decorator installation. - Decorator eagerly types all nodes that have typed inputs (subsumes typing of constant cache, removing its typing side-channel and various spurious dependencies on the typer). - Cut down typer interface to prevent inconsistently typed graphs. - Remove verification from start, since it caused too much trouble with semi-wellformed nodes. - Fix a couple of bugs on the way that got uncovered. To do: verifying machine operators. Also, various conditions in the verifier are currently commented out, because they don't yet hold. BUG= R=jarin@chromium.org,titzer@chromium.org Review URL: https://codereview.chromium.org/658543002 git-svn-id: https://v8.googlecode.com/svn/branches/bleeding_edge@24626 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
393 lines
12 KiB
C++
393 lines
12 KiB
C++
// 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/change-lowering.h"
|
|
#include "src/compiler/control-builders.h"
|
|
#include "src/compiler/generic-node-inl.h"
|
|
#include "src/compiler/js-graph.h"
|
|
#include "src/compiler/node-properties-inl.h"
|
|
#include "src/compiler/pipeline.h"
|
|
#include "src/compiler/simplified-lowering.h"
|
|
#include "src/compiler/verifier.h"
|
|
#include "src/execution.h"
|
|
#include "src/globals.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/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;
|
|
|
|
template <typename ReturnType>
|
|
class ChangesLoweringTester : public GraphBuilderTester<ReturnType> {
|
|
public:
|
|
explicit ChangesLoweringTester(MachineType p0 = kMachNone)
|
|
: GraphBuilderTester<ReturnType>(p0),
|
|
javascript(this->zone()),
|
|
jsgraph(this->graph(), this->common(), &javascript, this->machine()),
|
|
function(Handle<JSFunction>::null()) {}
|
|
|
|
JSOperatorBuilder javascript;
|
|
JSGraph jsgraph;
|
|
Handle<JSFunction> function;
|
|
|
|
Node* start() { return this->graph()->start(); }
|
|
|
|
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.
|
|
if (function.is_null()) {
|
|
function = FunctionTester::ForMachineGraph(this->graph());
|
|
}
|
|
Handle<Object>* args = NULL;
|
|
MaybeHandle<Object> result =
|
|
Execution::Call(this->isolate(), function, factory()->undefined_value(),
|
|
0, args, false);
|
|
return T::cast(*result.ToHandleChecked());
|
|
}
|
|
|
|
void StoreFloat64(Node* node, double* ptr) {
|
|
Node* ptr_node = this->PointerConstant(ptr);
|
|
this->Store(kMachFloat64, ptr_node, node);
|
|
}
|
|
|
|
Node* LoadInt32(int32_t* ptr) {
|
|
Node* ptr_node = this->PointerConstant(ptr);
|
|
return this->Load(kMachInt32, ptr_node);
|
|
}
|
|
|
|
Node* LoadUint32(uint32_t* ptr) {
|
|
Node* ptr_node = this->PointerConstant(ptr);
|
|
return this->Load(kMachUint32, ptr_node);
|
|
}
|
|
|
|
Node* LoadFloat64(double* ptr) {
|
|
Node* ptr_node = this->PointerConstant(ptr);
|
|
return this->Load(kMachFloat64, ptr_node);
|
|
}
|
|
|
|
void CheckNumber(double expected, Object* number) {
|
|
CHECK(this->isolate()->factory()->NewNumber(expected)->SameValue(number));
|
|
}
|
|
|
|
void BuildAndLower(const Operator* op) {
|
|
// We build a graph by hand here, because the raw machine assembler
|
|
// does not add the correct control and effect nodes.
|
|
Node* p0 = this->Parameter(0);
|
|
Node* change = this->graph()->NewNode(op, p0);
|
|
Node* ret = this->graph()->NewNode(this->common()->Return(), change,
|
|
this->start(), this->start());
|
|
Node* end = this->graph()->NewNode(this->common()->End(), ret);
|
|
this->graph()->SetEnd(end);
|
|
LowerChange(change);
|
|
}
|
|
|
|
void BuildStoreAndLower(const Operator* op, const Operator* store_op,
|
|
void* location) {
|
|
// We build a graph by hand here, because the raw machine assembler
|
|
// does not add the correct control and effect nodes.
|
|
Node* p0 = this->Parameter(0);
|
|
Node* change = this->graph()->NewNode(op, p0);
|
|
Node* store = this->graph()->NewNode(
|
|
store_op, this->PointerConstant(location), this->Int32Constant(0),
|
|
change, this->start(), this->start());
|
|
Node* ret = this->graph()->NewNode(
|
|
this->common()->Return(), this->Int32Constant(0), store, this->start());
|
|
Node* end = this->graph()->NewNode(this->common()->End(), ret);
|
|
this->graph()->SetEnd(end);
|
|
LowerChange(change);
|
|
}
|
|
|
|
void BuildLoadAndLower(const Operator* op, const Operator* load_op,
|
|
void* location) {
|
|
// We build a graph by hand here, because the raw machine assembler
|
|
// does not add the correct control and effect nodes.
|
|
Node* load = this->graph()->NewNode(
|
|
load_op, this->PointerConstant(location), this->Int32Constant(0),
|
|
this->start(), this->start());
|
|
Node* change = this->graph()->NewNode(op, load);
|
|
Node* ret = this->graph()->NewNode(this->common()->Return(), change,
|
|
this->start(), this->start());
|
|
Node* end = this->graph()->NewNode(this->common()->End(), ret);
|
|
this->graph()->SetEnd(end);
|
|
LowerChange(change);
|
|
}
|
|
|
|
void LowerChange(Node* change) {
|
|
// Run the graph reducer with changes lowering on a single node.
|
|
CompilationInfo info(this->isolate(), this->zone());
|
|
Linkage linkage(&info);
|
|
ChangeLowering lowering(&jsgraph, &linkage);
|
|
GraphReducer reducer(this->graph());
|
|
reducer.AddReducer(&lowering);
|
|
reducer.ReduceNode(change);
|
|
Verifier::Run(this->graph(), Verifier::UNTYPED);
|
|
}
|
|
|
|
Factory* factory() { return this->isolate()->factory(); }
|
|
Heap* heap() { return this->isolate()->heap(); }
|
|
};
|
|
|
|
|
|
TEST(RunChangeTaggedToInt32) {
|
|
// Build and lower a graph by hand.
|
|
ChangesLoweringTester<int32_t> t(kMachAnyTagged);
|
|
t.BuildAndLower(t.simplified()->ChangeTaggedToInt32());
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
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) {
|
|
// Build and lower a graph by hand.
|
|
ChangesLoweringTester<uint32_t> t(kMachAnyTagged);
|
|
t.BuildAndLower(t.simplified()->ChangeTaggedToUint32());
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
FOR_UINT32_INPUTS(i) {
|
|
uint32_t input = *i;
|
|
|
|
if (Smi::IsValid(input)) {
|
|
uint32_t result = t.Call(Smi::FromInt(input));
|
|
CHECK_EQ(static_cast<int32_t>(input), static_cast<int32_t>(result));
|
|
}
|
|
|
|
{
|
|
Handle<Object> number = t.factory()->NewNumber(input);
|
|
uint32_t result = t.Call(*number);
|
|
CHECK_EQ(static_cast<int32_t>(input), static_cast<int32_t>(result));
|
|
}
|
|
|
|
{
|
|
Handle<HeapNumber> number = t.factory()->NewHeapNumber(input);
|
|
uint32_t result = t.Call(*number);
|
|
CHECK_EQ(static_cast<int32_t>(input), static_cast<int32_t>(result));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(RunChangeTaggedToFloat64) {
|
|
ChangesLoweringTester<int32_t> t(kMachAnyTagged);
|
|
double result;
|
|
|
|
t.BuildStoreAndLower(
|
|
t.simplified()->ChangeTaggedToFloat64(),
|
|
t.machine()->Store(StoreRepresentation(kMachFloat64, kNoWriteBarrier)),
|
|
&result);
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
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));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
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) {
|
|
ChangesLoweringTester<int32_t> t(kMachAnyTagged);
|
|
t.BuildAndLower(t.simplified()->ChangeBoolToBit());
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
Object* true_obj = t.heap()->true_value();
|
|
int32_t result = t.Call(true_obj);
|
|
CHECK_EQ(1, result);
|
|
}
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
Object* false_obj = t.heap()->false_value();
|
|
int32_t result = t.Call(false_obj);
|
|
CHECK_EQ(0, result);
|
|
}
|
|
}
|
|
|
|
|
|
TEST(RunChangeBitToBool) {
|
|
ChangesLoweringTester<Object*> t(kMachInt32);
|
|
t.BuildAndLower(t.simplified()->ChangeBitToBool());
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
Object* result = t.Call(1);
|
|
Object* true_obj = t.heap()->true_value();
|
|
CHECK_EQ(true_obj, result);
|
|
}
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
Object* result = t.Call(0);
|
|
Object* false_obj = t.heap()->false_value();
|
|
CHECK_EQ(false_obj, result);
|
|
}
|
|
}
|
|
|
|
|
|
#if V8_TURBOFAN_BACKEND
|
|
// TODO(titzer): disabled on ARM
|
|
|
|
TEST(RunChangeInt32ToTaggedSmi) {
|
|
ChangesLoweringTester<Object*> t;
|
|
int32_t input;
|
|
t.BuildLoadAndLower(t.simplified()->ChangeInt32ToTagged(),
|
|
t.machine()->Load(kMachInt32), &input);
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
FOR_INT32_INPUTS(i) {
|
|
input = *i;
|
|
if (!Smi::IsValid(input)) continue;
|
|
Object* result = t.Call();
|
|
t.CheckNumber(static_cast<double>(input), result);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(RunChangeUint32ToTaggedSmi) {
|
|
ChangesLoweringTester<Object*> t;
|
|
uint32_t input;
|
|
t.BuildLoadAndLower(t.simplified()->ChangeUint32ToTagged(),
|
|
t.machine()->Load(kMachUint32), &input);
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
FOR_UINT32_INPUTS(i) {
|
|
input = *i;
|
|
if (input > static_cast<uint32_t>(Smi::kMaxValue)) continue;
|
|
Object* result = t.Call();
|
|
double expected = static_cast<double>(input);
|
|
t.CheckNumber(expected, result);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(RunChangeInt32ToTagged) {
|
|
ChangesLoweringTester<Object*> t;
|
|
int32_t input;
|
|
t.BuildLoadAndLower(t.simplified()->ChangeInt32ToTagged(),
|
|
t.machine()->Load(kMachInt32), &input);
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
for (int m = 0; m < 3; m++) { // Try 3 GC modes.
|
|
FOR_INT32_INPUTS(i) {
|
|
if (m == 0) CcTest::heap()->EnableInlineAllocation();
|
|
if (m == 1) CcTest::heap()->DisableInlineAllocation();
|
|
if (m == 2) SimulateFullSpace(CcTest::heap()->new_space());
|
|
|
|
input = *i;
|
|
Object* result = t.CallWithPotentialGC<Object>();
|
|
t.CheckNumber(static_cast<double>(input), result);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(RunChangeUint32ToTagged) {
|
|
ChangesLoweringTester<Object*> t;
|
|
uint32_t input;
|
|
t.BuildLoadAndLower(t.simplified()->ChangeUint32ToTagged(),
|
|
t.machine()->Load(kMachUint32), &input);
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
for (int m = 0; m < 3; m++) { // Try 3 GC modes.
|
|
FOR_UINT32_INPUTS(i) {
|
|
if (m == 0) CcTest::heap()->EnableInlineAllocation();
|
|
if (m == 1) CcTest::heap()->DisableInlineAllocation();
|
|
if (m == 2) SimulateFullSpace(CcTest::heap()->new_space());
|
|
|
|
input = *i;
|
|
Object* result = t.CallWithPotentialGC<Object>();
|
|
double expected = static_cast<double>(input);
|
|
t.CheckNumber(expected, result);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
TEST(RunChangeFloat64ToTagged) {
|
|
ChangesLoweringTester<Object*> t;
|
|
double input;
|
|
t.BuildLoadAndLower(t.simplified()->ChangeFloat64ToTagged(),
|
|
t.machine()->Load(kMachFloat64), &input);
|
|
|
|
if (Pipeline::SupportedTarget()) {
|
|
for (int m = 0; m < 3; m++) { // Try 3 GC modes.
|
|
FOR_FLOAT64_INPUTS(i) {
|
|
if (m == 0) CcTest::heap()->EnableInlineAllocation();
|
|
if (m == 1) CcTest::heap()->DisableInlineAllocation();
|
|
if (m == 2) SimulateFullSpace(CcTest::heap()->new_space());
|
|
|
|
input = *i;
|
|
Object* result = t.CallWithPotentialGC<Object>();
|
|
t.CheckNumber(input, result);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // V8_TURBOFAN_BACKEND
|