Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(352)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: test/cctest/compiler/test-representation-change.cc

Issue 602713002: Add tests for representation change of constants. (Closed) Base URL: https://v8.googlecode.com/svn/branches/bleeding_edge
Patch Set: Created 6 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « no previous file | no next file » | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: test/cctest/compiler/test-representation-change.cc
diff --git a/test/cctest/compiler/test-representation-change.cc b/test/cctest/compiler/test-representation-change.cc
index 24e47a8f618c4b6b46b0e3eb3f649db375c909ed..eccfb717a624952d265bdddcf86549520be9b144 100644
--- a/test/cctest/compiler/test-representation-change.cc
+++ b/test/cctest/compiler/test-representation-change.cc
@@ -7,6 +7,7 @@
#include "src/v8.h"
#include "test/cctest/cctest.h"
#include "test/cctest/compiler/graph-builder-tester.h"
+#include "test/cctest/compiler/value-helper.h"
#include "src/compiler/node-matchers.h"
#include "src/compiler/representation-change.h"
@@ -51,6 +52,24 @@ class RepresentationChangerTester : public HandleAndZoneScope,
CHECK_EQ(expected, m.Value());
}
+ void CheckUint32Constant(Node* n, uint32_t expected) {
+ Uint32Matcher m(n);
+ CHECK(m.HasValue());
+ CHECK_EQ(static_cast<int>(expected), static_cast<int>(m.Value()));
+ }
+
+ void CheckFloat64Constant(Node* n, double expected) {
+ Float64Matcher m(n);
+ CHECK(m.HasValue());
+ CHECK_EQ(expected, m.Value());
+ }
+
+ void CheckFloat32Constant(Node* n, float expected) {
+ CHECK_EQ(IrOpcode::kFloat32Constant, n->opcode());
+ float fval = OpParameter<float>(n->op());
+ CHECK_EQ(expected, fval);
+ }
+
void CheckHeapConstant(Node* n, HeapObject* expected) {
HeapObjectMatcher<HeapObject> m(n);
CHECK(m.HasValue());
@@ -92,25 +111,6 @@ static const MachineType all_reps[] = {kRepBit, kRepWord32, kRepWord64,
kRepFloat32, kRepFloat64, kRepTagged};
-// TODO(titzer): lift this to ValueHelper
-static const double double_inputs[] = {
- 0.0, -0.0, 1.0, -1.0, 0.1, 1.4, -1.7,
- 2, 5, 6, 982983, 888, -999.8, 3.1e7,
- -2e66, 2.3e124, -12e73, V8_INFINITY, -V8_INFINITY};
-
-
-static const int32_t int32_inputs[] = {
- 0, 1, -1,
- 2, 5, 6,
- 982983, 888, -999,
- 65535, static_cast<int32_t>(0xFFFFFFFF), static_cast<int32_t>(0x80000000)};
-
-
-static const uint32_t uint32_inputs[] = {
- 0, 1, static_cast<uint32_t>(-1), 2, 5, 6,
- 982983, 888, static_cast<uint32_t>(-999), 65535, 0xFFFFFFFF, 0x80000000};
-
-
TEST(BoolToBit_constant) {
RepresentationChangerTester r;
@@ -141,31 +141,234 @@ TEST(BitToBool_constant) {
TEST(ToTagged_constant) {
RepresentationChangerTester r;
- for (size_t i = 0; i < arraysize(double_inputs); i++) {
- Node* n = r.jsgraph()->Float64Constant(double_inputs[i]);
- Node* c = r.changer()->GetRepresentationFor(n, kRepFloat64, kRepTagged);
- r.CheckNumberConstant(c, double_inputs[i]);
+ {
+ FOR_FLOAT64_INPUTS(i) {
+ Node* n = r.jsgraph()->Float64Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat64, kRepTagged);
+ r.CheckNumberConstant(c, *i);
+ }
+ }
+
+ {
+ FOR_FLOAT64_INPUTS(i) {
+ Node* n = r.jsgraph()->Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat64, kRepTagged);
+ r.CheckNumberConstant(c, *i);
+ }
+ }
+
+ {
+ FOR_FLOAT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Float32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat32, kRepTagged);
+ r.CheckNumberConstant(c, *i);
+ }
+ }
+
+ {
+ FOR_INT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeInt32,
+ kRepTagged);
+ r.CheckNumberConstant(c, *i);
+ }
+ }
+
+ {
+ FOR_UINT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeUint32,
+ kRepTagged);
+ r.CheckNumberConstant(c, *i);
+ }
+ }
+}
+
+
+TEST(ToFloat64_constant) {
+ RepresentationChangerTester r;
+
+ {
+ FOR_FLOAT64_INPUTS(i) {
+ Node* n = r.jsgraph()->Float64Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat64, kRepFloat64);
+ CHECK_EQ(n, c);
+ }
}
- for (size_t i = 0; i < arraysize(double_inputs); i++) {
- volatile float fval = static_cast<float>(double_inputs[i]);
- Node* n = r.jsgraph()->Float32Constant(fval);
- Node* c = r.changer()->GetRepresentationFor(n, kRepFloat32, kRepTagged);
- r.CheckNumberConstant(c, fval);
+ {
+ FOR_FLOAT64_INPUTS(i) {
+ Node* n = r.jsgraph()->Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepTagged, kRepFloat64);
+ r.CheckFloat64Constant(c, *i);
+ }
}
- for (size_t i = 0; i < arraysize(int32_inputs); i++) {
- Node* n = r.jsgraph()->Int32Constant(int32_inputs[i]);
- Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeInt32,
- kRepTagged);
- r.CheckNumberConstant(c, static_cast<double>(int32_inputs[i]));
+ {
+ FOR_FLOAT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Float32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat32, kRepFloat64);
+ r.CheckFloat64Constant(c, *i);
+ }
}
- for (size_t i = 0; i < arraysize(uint32_inputs); i++) {
- Node* n = r.jsgraph()->Int32Constant(uint32_inputs[i]);
- Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeUint32,
- kRepTagged);
- r.CheckNumberConstant(c, static_cast<double>(uint32_inputs[i]));
+ {
+ FOR_INT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeInt32,
+ kRepFloat64);
+ r.CheckFloat64Constant(c, *i);
+ }
+ }
+
+ {
+ FOR_UINT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeUint32,
+ kRepFloat64);
+ r.CheckFloat64Constant(c, *i);
+ }
+ }
+}
+
+
+static bool IsFloat32Int32(int32_t val) {
+ return val >= -(1 << 23) && val <= (1 << 23);
+}
+
+
+static bool IsFloat32Uint32(uint32_t val) { return val <= (1 << 23); }
+
+
+TEST(ToFloat32_constant) {
+ RepresentationChangerTester r;
+
+ {
+ FOR_FLOAT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Float32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat32, kRepFloat32);
+ CHECK_EQ(n, c);
+ }
+ }
+
+ {
+ FOR_FLOAT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepTagged, kRepFloat32);
+ r.CheckFloat32Constant(c, *i);
+ }
+ }
+
+ {
+ FOR_FLOAT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Float64Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat64, kRepFloat32);
+ r.CheckFloat32Constant(c, *i);
+ }
+ }
+
+ {
+ FOR_INT32_INPUTS(i) {
+ if (!IsFloat32Int32(*i)) continue;
+ Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeInt32,
+ kRepFloat32);
+ r.CheckFloat32Constant(c, *i);
+ }
+ }
+
+ {
+ FOR_UINT32_INPUTS(i) {
+ if (!IsFloat32Uint32(*i)) continue;
+ Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeUint32,
+ kRepFloat32);
+ r.CheckFloat32Constant(c, *i);
+ }
+ }
+}
+
+
+TEST(ToInt32_constant) {
+ RepresentationChangerTester r;
+
+ {
+ FOR_INT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeInt32,
+ kRepWord32);
+ r.CheckInt32Constant(c, *i);
+ }
+ }
+
+ {
+ FOR_INT32_INPUTS(i) {
+ if (!IsFloat32Int32(*i)) continue;
+ Node* n = r.jsgraph()->Float32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat32 | kTypeInt32,
+ kRepWord32);
+ r.CheckInt32Constant(c, *i);
+ }
+ }
+
+ {
+ FOR_INT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Float64Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat64 | kTypeInt32,
+ kRepWord32);
+ r.CheckInt32Constant(c, *i);
+ }
+ }
+
+ {
+ FOR_INT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepTagged | kTypeInt32,
+ kRepWord32);
+ r.CheckInt32Constant(c, *i);
+ }
+ }
+}
+
+
+TEST(ToUint32_constant) {
+ RepresentationChangerTester r;
+
+ {
+ FOR_UINT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Int32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepWord32 | kTypeUint32,
+ kRepWord32);
+ r.CheckInt32Constant(c, *i);
Jarin 2014/09/24 15:11:21 Should not this (+ the guys below) be CheckUint32C
titzer 2014/09/24 15:53:08 Good catch. Done.
+ }
+ }
+
+ {
+ FOR_UINT32_INPUTS(i) {
+ if (!IsFloat32Uint32(*i)) continue;
+ Node* n = r.jsgraph()->Float32Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat32 | kTypeUint32,
+ kRepWord32);
+ r.CheckInt32Constant(c, *i);
+ }
+ }
+
+ {
+ FOR_UINT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Float64Constant(*i);
+ Node* c = r.changer()->GetRepresentationFor(n, kRepFloat64 | kTypeUint32,
+ kRepWord32);
+ r.CheckInt32Constant(c, *i);
+ }
+ }
+
+ {
+ FOR_UINT32_INPUTS(i) {
+ Node* n = r.jsgraph()->Constant(static_cast<double>(*i));
+ Node* c = r.changer()->GetRepresentationFor(n, kRepTagged | kTypeUint32,
+ kRepWord32);
+ r.CheckInt32Constant(c, *i);
+ }
}
}
@@ -248,9 +451,6 @@ TEST(SingleChanges) {
}
-// TODO(titzer): test constant folding of changes between int/float
-
-
TEST(SignednessInWord32) {
RepresentationChangerTester r;
« no previous file with comments | « no previous file | no next file » | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698