Reduction ChangeLowering::Reduce(Node* node) {
Node* control = graph()->start();
- Node* effect = control;
switch (node->opcode()) {
case IrOpcode::kChangeBitToBool:
return ChangeBitToBool(node->InputAt(0), control);
case IrOpcode::kChangeBoolToBit:
return ChangeBoolToBit(node->InputAt(0));
+ case IrOpcode::kChangeFloat64ToTagged:
+ return ChangeFloat64ToTagged(node->InputAt(0), control);
case IrOpcode::kChangeInt32ToTagged:
- return ChangeInt32ToTagged(node->InputAt(0), effect, control);
+ return ChangeInt32ToTagged(node->InputAt(0), control);
case IrOpcode::kChangeTaggedToFloat64:
- return ChangeTaggedToFloat64(node->InputAt(0), effect, control);
+ return ChangeTaggedToFloat64(node->InputAt(0), control);
+ case IrOpcode::kChangeTaggedToInt32:
+ return ChangeTaggedToInt32(node->InputAt(0), control);
default:
return NoChange();
}
}
-Reduction ChangeLowering::ChangeInt32ToTagged(Node* val, Node* effect,
- Node* control) {
+Reduction ChangeLowering::ChangeFloat64ToTagged(Node* val, Node* control) {
+ return Replace(AllocateHeapNumberWithValue(val, control));
+}
+
+
+Reduction ChangeLowering::ChangeInt32ToTagged(Node* val, Node* control) {
if (machine()->is64()) {
return Replace(
graph()->NewNode(machine()->WordShl(), val, SmiShiftBitsConstant()));
}
- Node* context = jsgraph()->SmiConstant(0);
-
Node* add = graph()->NewNode(machine()->Int32AddWithOverflow(), val, val);
Node* ovf = graph()->NewNode(common()->Projection(1), add);
Node* branch = graph()->NewNode(common()->Branch(), ovf, control);
Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
- Node* number = graph()->NewNode(machine()->ChangeInt32ToFloat64(), val);
-
- const Runtime::Function* fn =
- Runtime::FunctionForId(Runtime::kAllocateHeapNumber);
- DCHECK_EQ(0, fn->nargs);
- CallDescriptor* desc = linkage()->GetRuntimeCallDescriptor(
- fn->function_id, 0, Operator::kNoProperties);
- Node* heap_number = graph()->NewNode(
- common()->Call(desc), jsgraph()->CEntryStubConstant(),
- jsgraph()->ExternalConstant(ExternalReference(fn, isolate())),
- jsgraph()->Int32Constant(fn->nargs), context, effect, if_true);
- Node* store = graph()->NewNode(
- machine()->Store(kMachFloat64, kNoWriteBarrier), heap_number,
- HeapNumberValueIndexConstant(), number, heap_number, if_true);
- Node* finish = graph()->NewNode(common()->Finish(1), heap_number, store);
+ Node* heap_number = AllocateHeapNumberWithValue(
+ graph()->NewNode(machine()->ChangeInt32ToFloat64(), val), if_true);
Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
Node* smi = graph()->NewNode(common()->Projection(0), add);
Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
- Node* phi = graph()->NewNode(common()->Phi(2), finish, smi, merge);
+ Node* phi = graph()->NewNode(common()->Phi(2), heap_number, smi, merge);
return Replace(phi);
}
-Reduction ChangeLowering::ChangeTaggedToFloat64(Node* val, Node* effect,
- Node* control) {
+Reduction ChangeLowering::ChangeTaggedToInt32(Node* val, Node* control) {
+ STATIC_ASSERT(kSmiTag == 0);
+ STATIC_ASSERT(kSmiTagMask == 1);
+
+ Node* tag = graph()->NewNode(machine()->WordAnd(), val,
+ jsgraph()->Int32Constant(kSmiTagMask));
+ Node* branch = graph()->NewNode(common()->Branch(), tag, control);
+
+ Node* if_true = graph()->NewNode(common()->IfTrue(), branch);
+ Node* load = graph()->NewNode(
+ machine()->Load(kMachFloat64), val, HeapNumberValueIndexConstant(),
+ graph()->NewNode(common()->ControlEffect(), if_true));
+ Node* change = graph()->NewNode(machine()->ChangeFloat64ToInt32(), load);
+
+ Node* if_false = graph()->NewNode(common()->IfFalse(), branch);
+ Node* integer =
+ graph()->NewNode(machine()->WordSar(), val, SmiShiftBitsConstant());
+ Node* number =
+ machine()->is64()
+ ? graph()->NewNode(machine()->ConvertInt64ToInt32(), integer)
+ : integer;
+
+ Node* merge = graph()->NewNode(common()->Merge(2), if_true, if_false);
+ Node* phi = graph()->NewNode(common()->Phi(2), change, number, merge);
+
+ return Replace(phi);
+}
+
+
+Reduction ChangeLowering::ChangeTaggedToFloat64(Node* val, Node* control) {
+ STATIC_ASSERT(kSmiTag == 0);
STATIC_ASSERT(kSmiTagMask == 1);
Node* tag = graph()->NewNode(machine()->WordAnd(), val,
return jsgraph()->common();
}
+
+Node* ChangeLowering::AllocateHeapNumberWithValue(Node* value, Node* control) {
+ // The AllocateHeapNumber() runtime function does not use the context, so we
+ // can safely pass in Smi zero here.
+ Node* context = jsgraph()->ZeroConstant();
+ Node* effect = graph()->NewNode(common()->ValueEffect(1), value);
+ const Runtime::Function* function =
+ Runtime::FunctionForId(Runtime::kAllocateHeapNumber);
+ DCHECK_EQ(0, function->nargs);
+ CallDescriptor* desc = linkage()->GetRuntimeCallDescriptor(
+ function->function_id, 0, Operator::kNoProperties);
+ Node* heap_number = graph()->NewNode(
+ common()->Call(desc), jsgraph()->CEntryStubConstant(),
+ jsgraph()->ExternalConstant(ExternalReference(function, isolate())),
+ jsgraph()->Int32Constant(function->nargs), context, effect, control);
+ Node* store = graph()->NewNode(
+ machine()->Store(kMachFloat64, kNoWriteBarrier), heap_number,
+ HeapNumberValueIndexConstant(), value, heap_number, control);
+ return graph()->NewNode(common()->Finish(1), heap_number, store);
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
namespace internal {
namespace compiler {
-template <typename T>
+// TODO(bmeurer): Find a new home for these functions.
+inline std::ostream& operator<<(std::ostream& os, const MachineType& type) {
+ OStringStream ost;
+ ost << type;
+ return os << ost.c_str();
+}
+
+
class ChangeLoweringTest : public GraphTest {
public:
- static const size_t kPointerSize = sizeof(T);
- static const MachineType kWordRepresentation =
- (kPointerSize == 4) ? kRepWord32 : kRepWord64;
- STATIC_ASSERT(HeapNumber::kValueOffset % kApiPointerSize == 0);
- static const int kHeapNumberValueOffset = static_cast<int>(
- (HeapNumber::kValueOffset / kApiPointerSize) * kPointerSize);
-
ChangeLoweringTest() : simplified_(zone()) {}
virtual ~ChangeLoweringTest() {}
+ virtual MachineType WordRepresentation() const = 0;
+
protected:
+ int HeapNumberValueOffset() const {
+ STATIC_ASSERT(HeapNumber::kValueOffset % kApiPointerSize == 0);
+ return (HeapNumber::kValueOffset / kApiPointerSize) * PointerSize() -
+ kHeapObjectTag;
+ }
+ bool Is32() const { return WordRepresentation() == kRepWord32; }
+ int PointerSize() const {
+ switch (WordRepresentation()) {
+ case kRepWord32:
+ return 4;
+ case kRepWord64:
+ return 8;
+ default:
+ break;
+ }
+ UNREACHABLE();
+ return 0;
+ }
+ int SmiShiftAmount() const { return kSmiTagSize + SmiShiftSize(); }
+ int SmiShiftSize() const {
+ // TODO(turbofan): Work-around for weird GCC 4.6 linker issue:
+ // src/compiler/change-lowering.cc:46: undefined reference to
+ // `v8::internal::SmiTagging<4u>::kSmiShiftSize'
+ // src/compiler/change-lowering.cc:46: undefined reference to
+ // `v8::internal::SmiTagging<8u>::kSmiShiftSize'
+ STATIC_ASSERT(SmiTagging<4>::kSmiShiftSize == 0);
+ STATIC_ASSERT(SmiTagging<8>::kSmiShiftSize == 31);
+ return Is32() ? 0 : 31;
+ }
+
Node* Parameter(int32_t index = 0) {
return graph()->NewNode(common()->Parameter(index), graph()->start());
}
JSGraph jsgraph(graph(), common(), &typer);
CompilationInfo info(isolate(), zone());
Linkage linkage(&info);
- MachineOperatorBuilder machine(zone(), kWordRepresentation);
+ MachineOperatorBuilder machine(zone(), WordRepresentation());
ChangeLowering reducer(&jsgraph, &linkage, &machine);
return reducer.Reduce(node);
}
SimplifiedOperatorBuilder* simplified() { return &simplified_; }
- PrintableUnique<HeapObject> true_unique() {
- return PrintableUnique<HeapObject>::CreateImmovable(
- zone(), factory()->true_value());
+ Matcher<Node*> IsAllocateHeapNumber(const Matcher<Node*>& effect_matcher,
+ const Matcher<Node*>& control_matcher) {
+ return IsCall(
+ _, IsHeapConstant(PrintableUnique<HeapObject>::CreateImmovable(
+ zone(), CEntryStub(isolate(), 1).GetCode())),
+ IsExternalConstant(ExternalReference(
+ Runtime::FunctionForId(Runtime::kAllocateHeapNumber), isolate())),
+ IsInt32Constant(0), IsNumberConstant(0.0), effect_matcher,
+ control_matcher);
}
- PrintableUnique<HeapObject> false_unique() {
- return PrintableUnique<HeapObject>::CreateImmovable(
- zone(), factory()->false_value());
+ Matcher<Node*> IsFalse() {
+ return IsHeapConstant(PrintableUnique<HeapObject>::CreateImmovable(
+ zone(), factory()->false_value()));
+ }
+ Matcher<Node*> IsTrue() {
+ return IsHeapConstant(PrintableUnique<HeapObject>::CreateImmovable(
+ zone(), factory()->true_value()));
+ }
+ Matcher<Node*> IsWordEqual(const Matcher<Node*>& lhs_matcher,
+ const Matcher<Node*>& rhs_matcher) {
+ return Is32() ? IsWord32Equal(lhs_matcher, rhs_matcher)
+ : IsWord64Equal(lhs_matcher, rhs_matcher);
}
private:
};
-typedef ::testing::Types<int32_t, int64_t> ChangeLoweringTypes;
-TYPED_TEST_CASE(ChangeLoweringTest, ChangeLoweringTypes);
+// -----------------------------------------------------------------------------
+// Common.
+namespace {
-TARGET_TYPED_TEST(ChangeLoweringTest, ChangeBitToBool) {
- Node* val = this->Parameter(0);
- Node* node =
- this->graph()->NewNode(this->simplified()->ChangeBitToBool(), val);
- Reduction reduction = this->Reduce(node);
+class Common : public ChangeLoweringTest,
+ public ::testing::WithParamInterface<MachineType> {
+ public:
+ virtual ~Common() {}
+
+ virtual MachineType WordRepresentation() const V8_FINAL V8_OVERRIDE {
+ return GetParam();
+ }
+};
+
+
+TARGET_TEST_P(Common, ChangeBitToBool) {
+ Node* val = Parameter(0);
+ Node* node = graph()->NewNode(simplified()->ChangeBitToBool(), val);
+ Reduction reduction = Reduce(node);
ASSERT_TRUE(reduction.Changed());
Node* phi = reduction.replacement();
Capture<Node*> branch;
- EXPECT_THAT(
- phi, IsPhi(IsHeapConstant(this->true_unique()),
- IsHeapConstant(this->false_unique()),
- IsMerge(IsIfTrue(AllOf(CaptureEq(&branch),
- IsBranch(val, this->graph()->start()))),
- IsIfFalse(CaptureEq(&branch)))));
+ EXPECT_THAT(phi,
+ IsPhi(IsTrue(), IsFalse(),
+ IsMerge(IsIfTrue(AllOf(CaptureEq(&branch),
+ IsBranch(val, graph()->start()))),
+ IsIfFalse(CaptureEq(&branch)))));
}
-TARGET_TYPED_TEST(ChangeLoweringTest, StringAdd) {
- Node* node = this->graph()->NewNode(this->simplified()->StringAdd(),
- this->Parameter(0), this->Parameter(1));
- Reduction reduction = this->Reduce(node);
- EXPECT_FALSE(reduction.Changed());
-}
-
+TARGET_TEST_P(Common, ChangeBoolToBit) {
+ Node* val = Parameter(0);
+ Node* node = graph()->NewNode(simplified()->ChangeBoolToBit(), val);
+ Reduction reduction = Reduce(node);
+ ASSERT_TRUE(reduction.Changed());
-class ChangeLowering32Test : public ChangeLoweringTest<int32_t> {
- public:
- virtual ~ChangeLowering32Test() {}
-};
+ EXPECT_THAT(reduction.replacement(), IsWordEqual(val, IsTrue()));
+}
-TARGET_TEST_F(ChangeLowering32Test, ChangeBoolToBit) {
+TARGET_TEST_P(Common, ChangeFloat64ToTagged) {
Node* val = Parameter(0);
- Node* node = graph()->NewNode(simplified()->ChangeBoolToBit(), val);
+ Node* node = graph()->NewNode(simplified()->ChangeFloat64ToTagged(), val);
Reduction reduction = Reduce(node);
ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(),
- IsWord32Equal(val, IsHeapConstant(true_unique())));
+ Node* finish = reduction.replacement();
+ Capture<Node*> heap_number;
+ EXPECT_THAT(
+ finish,
+ IsFinish(
+ AllOf(CaptureEq(&heap_number),
+ IsAllocateHeapNumber(IsValueEffect(val), graph()->start())),
+ IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
+ IsInt32Constant(HeapNumberValueOffset()), val,
+ CaptureEq(&heap_number), graph()->start())));
}
+TARGET_TEST_P(Common, StringAdd) {
+ Node* node =
+ graph()->NewNode(simplified()->StringAdd(), Parameter(0), Parameter(1));
+ Reduction reduction = Reduce(node);
+ EXPECT_FALSE(reduction.Changed());
+}
+
+} // namespace
+
+
+INSTANTIATE_TEST_CASE_P(ChangeLoweringTest, Common,
+ ::testing::Values(kRepWord32, kRepWord64));
+
+
+// -----------------------------------------------------------------------------
+// 32-bit
+
+
+class ChangeLowering32Test : public ChangeLoweringTest {
+ public:
+ virtual ~ChangeLowering32Test() {}
+ virtual MachineType WordRepresentation() const V8_FINAL V8_OVERRIDE {
+ return kRepWord32;
+ }
+};
+
+
TARGET_TEST_F(ChangeLowering32Test, ChangeInt32ToTagged) {
Node* val = Parameter(0);
Node* node = graph()->NewNode(simplified()->ChangeInt32ToTagged(), val);
Node* phi = reduction.replacement();
Capture<Node*> add, branch, heap_number, if_true;
- const int32_t kValueOffset = kHeapNumberValueOffset - kHeapObjectTag;
EXPECT_THAT(
phi,
- IsPhi(
- IsFinish(
- AllOf(
- CaptureEq(&heap_number),
- IsCall(
- _, IsHeapConstant(
- PrintableUnique<HeapObject>::CreateImmovable(
- zone(), CEntryStub(isolate(), 1).GetCode())),
- IsExternalConstant(ExternalReference(
- Runtime::FunctionForId(Runtime::kAllocateHeapNumber),
- isolate())),
- IsInt32Constant(0), IsNumberConstant(0.0),
- graph()->start(), CaptureEq(&if_true))),
- IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
- IsInt32Constant(kValueOffset),
- IsChangeInt32ToFloat64(val), CaptureEq(&heap_number),
- CaptureEq(&if_true))),
- IsProjection(
- 0, AllOf(CaptureEq(&add), IsInt32AddWithOverflow(val, val))),
- IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
- IsIfFalse(AllOf(CaptureEq(&branch),
- IsBranch(IsProjection(1, CaptureEq(&add)),
- graph()->start()))))));
+ IsPhi(IsFinish(
+ AllOf(CaptureEq(&heap_number),
+ IsAllocateHeapNumber(_, CaptureEq(&if_true))),
+ IsStore(kMachFloat64, kNoWriteBarrier, CaptureEq(&heap_number),
+ IsInt32Constant(HeapNumberValueOffset()),
+ IsChangeInt32ToFloat64(val), CaptureEq(&heap_number),
+ CaptureEq(&if_true))),
+ IsProjection(
+ 0, AllOf(CaptureEq(&add), IsInt32AddWithOverflow(val, val))),
+ IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
+ IsIfFalse(AllOf(CaptureEq(&branch),
+ IsBranch(IsProjection(1, CaptureEq(&add)),
+ graph()->start()))))));
}
Reduction reduction = Reduce(node);
ASSERT_TRUE(reduction.Changed());
- const int32_t kShiftAmount =
- kSmiTagSize + SmiTagging<kPointerSize>::kSmiShiftSize;
- const int32_t kValueOffset = kHeapNumberValueOffset - kHeapObjectTag;
Node* phi = reduction.replacement();
Capture<Node*> branch, if_true;
EXPECT_THAT(
phi,
IsPhi(
- IsLoad(kMachFloat64, val, IsInt32Constant(kValueOffset),
+ IsLoad(kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
IsControlEffect(CaptureEq(&if_true))),
IsChangeInt32ToFloat64(
- IsWord32Sar(val, IsInt32Constant(kShiftAmount))),
+ IsWord32Sar(val, IsInt32Constant(SmiShiftAmount()))),
IsMerge(
AllOf(CaptureEq(&if_true),
IsIfTrue(AllOf(
}
-class ChangeLowering64Test : public ChangeLoweringTest<int64_t> {
- public:
- virtual ~ChangeLowering64Test() {}
-};
-
+TARGET_TEST_F(ChangeLowering32Test, ChangeTaggedToInt32) {
+ STATIC_ASSERT(kSmiTag == 0);
+ STATIC_ASSERT(kSmiTagSize == 1);
-TARGET_TEST_F(ChangeLowering64Test, ChangeBoolToBit) {
Node* val = Parameter(0);
- Node* node = graph()->NewNode(simplified()->ChangeBoolToBit(), val);
+ Node* node = graph()->NewNode(simplified()->ChangeTaggedToInt32(), val);
Reduction reduction = Reduce(node);
ASSERT_TRUE(reduction.Changed());
- EXPECT_THAT(reduction.replacement(),
- IsWord64Equal(val, IsHeapConstant(true_unique())));
+ Node* phi = reduction.replacement();
+ Capture<Node*> branch, if_true;
+ EXPECT_THAT(
+ phi,
+ IsPhi(IsChangeFloat64ToInt32(IsLoad(
+ kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
+ IsControlEffect(CaptureEq(&if_true)))),
+ IsWord32Sar(val, IsInt32Constant(SmiShiftAmount())),
+ IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
+ IsIfFalse(AllOf(
+ CaptureEq(&branch),
+ IsBranch(IsWord32And(val, IsInt32Constant(kSmiTagMask)),
+ graph()->start()))))));
}
+// -----------------------------------------------------------------------------
+// 64-bit
+
+
+class ChangeLowering64Test : public ChangeLoweringTest {
+ public:
+ virtual ~ChangeLowering64Test() {}
+ virtual MachineType WordRepresentation() const V8_FINAL V8_OVERRIDE {
+ return kRepWord64;
+ }
+};
+
+
TARGET_TEST_F(ChangeLowering64Test, ChangeInt32ToTagged) {
Node* val = Parameter(0);
Node* node = graph()->NewNode(simplified()->ChangeInt32ToTagged(), val);
Reduction reduction = Reduce(node);
ASSERT_TRUE(reduction.Changed());
- const int32_t kShiftAmount =
- kSmiTagSize + SmiTagging<kPointerSize>::kSmiShiftSize;
EXPECT_THAT(reduction.replacement(),
- IsWord64Shl(val, IsInt32Constant(kShiftAmount)));
+ IsWord64Shl(val, IsInt32Constant(SmiShiftAmount())));
}
Reduction reduction = Reduce(node);
ASSERT_TRUE(reduction.Changed());
- const int32_t kShiftAmount =
- kSmiTagSize + SmiTagging<kPointerSize>::kSmiShiftSize;
- const int32_t kValueOffset = kHeapNumberValueOffset - kHeapObjectTag;
Node* phi = reduction.replacement();
Capture<Node*> branch, if_true;
EXPECT_THAT(
phi,
IsPhi(
- IsLoad(kMachFloat64, val, IsInt32Constant(kValueOffset),
+ IsLoad(kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
IsControlEffect(CaptureEq(&if_true))),
IsChangeInt32ToFloat64(IsConvertInt64ToInt32(
- IsWord64Sar(val, IsInt32Constant(kShiftAmount)))),
+ IsWord64Sar(val, IsInt32Constant(SmiShiftAmount())))),
IsMerge(
AllOf(CaptureEq(&if_true),
IsIfTrue(AllOf(
IsIfFalse(CaptureEq(&branch)))));
}
+
+TARGET_TEST_F(ChangeLowering64Test, ChangeTaggedToInt32) {
+ STATIC_ASSERT(kSmiTag == 0);
+ STATIC_ASSERT(kSmiTagSize == 1);
+
+ Node* val = Parameter(0);
+ Node* node = graph()->NewNode(simplified()->ChangeTaggedToInt32(), val);
+ Reduction reduction = Reduce(node);
+ ASSERT_TRUE(reduction.Changed());
+
+ Node* phi = reduction.replacement();
+ Capture<Node*> branch, if_true;
+ EXPECT_THAT(
+ phi,
+ IsPhi(IsChangeFloat64ToInt32(IsLoad(
+ kMachFloat64, val, IsInt32Constant(HeapNumberValueOffset()),
+ IsControlEffect(CaptureEq(&if_true)))),
+ IsConvertInt64ToInt32(
+ IsWord64Sar(val, IsInt32Constant(SmiShiftAmount()))),
+ IsMerge(AllOf(CaptureEq(&if_true), IsIfTrue(CaptureEq(&branch))),
+ IsIfFalse(AllOf(
+ CaptureEq(&branch),
+ IsBranch(IsWord64And(val, IsInt32Constant(kSmiTagMask)),
+ graph()->start()))))));
+}
+
} // namespace compiler
} // namespace internal
} // namespace v8
projects / platform / upstream / v8.git / commitdiff