[turbofan] Float32Constant/Float64Constant cannot occur in JS level graph.

test/cctest/compiler/test-js-constant-cache.cc

 // 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 "src/assembler.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-properties.h"
-#include "src/compiler/typer.h"
-#include "src/types.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 class JSCacheTesterHelper {
  protected:
   JSCacheTesterHelper(Isolate* isolate, Zone* zone)
       : main_graph_(zone),
         main_common_(zone),
         main_javascript_(zone),
-        main_typer_(isolate, &main_graph_),
         main_machine_(zone) {}
   Graph main_graph_;
   CommonOperatorBuilder main_common_;
   JSOperatorBuilder main_javascript_;
-  Typer main_typer_;
   MachineOperatorBuilder main_machine_;
 };
 
 
 // TODO(dcarney): JSConstantCacheTester inherits from JSGraph???
 class JSConstantCacheTester : public HandleAndZoneScope,
                               public JSCacheTesterHelper,
                               public JSGraph {
  public:
   JSConstantCacheTester()
       : JSCacheTesterHelper(main_isolate(), main_zone()),
         JSGraph(main_isolate(), &main_graph_, &main_common_, &main_javascript_,
                 nullptr, &main_machine_) {
     main_graph_.SetStart(main_graph_.NewNode(common()->Start(0)));
     main_graph_.SetEnd(
         main_graph_.NewNode(common()->End(1), main_graph_.start()));
-    main_typer_.Run();
   }
 
-  Type* TypeOf(Node* node) { return NodeProperties::GetType(node); }
-
   Handle<HeapObject> handle(Node* node) {
     CHECK_EQ(IrOpcode::kHeapConstant, node->opcode());
     return OpParameter<Handle<HeapObject>>(node);
   }
 
   Factory* factory() { return main_isolate()->factory(); }
 };
 
 
 TEST(ZeroConstant1) {
   JSConstantCacheTester T;
 
   Node* zero = T.ZeroConstant();
 
   CHECK_EQ(IrOpcode::kNumberConstant, zero->opcode());
   CHECK_EQ(zero, T.Constant(0));
   CHECK_NE(zero, T.Constant(-0.0));
   CHECK_NE(zero, T.Constant(1.0));
   CHECK_NE(zero, T.Constant(std::numeric_limits<double>::quiet_NaN()));
   CHECK_NE(zero, T.Float64Constant(0));
   CHECK_NE(zero, T.Int32Constant(0));
-
-  Type* t = T.TypeOf(zero);
-
-  CHECK(t->Is(Type::Number()));
-  CHECK(t->Is(Type::Integral32()));
-  CHECK(t->Is(Type::Signed32()));
-  CHECK(t->Is(Type::Unsigned32()));
-  CHECK(t->Is(Type::SignedSmall()));
-  CHECK(t->Is(Type::UnsignedSmall()));
 }
 
 
 TEST(MinusZeroConstant) {
   JSConstantCacheTester T;
 
   Node* minus_zero = T.Constant(-0.0);
   Node* zero = T.ZeroConstant();
 
   CHECK_EQ(IrOpcode::kNumberConstant, minus_zero->opcode());
   CHECK_EQ(minus_zero, T.Constant(-0.0));
   CHECK_NE(zero, minus_zero);
 
-  Type* t = T.TypeOf(minus_zero);
-
-  CHECK(t->Is(Type::Number()));
-  CHECK(t->Is(Type::MinusZero()));
-  CHECK(!t->Is(Type::Integral32()));
-  CHECK(!t->Is(Type::Signed32()));
-  CHECK(!t->Is(Type::Unsigned32()));
-  CHECK(!t->Is(Type::SignedSmall()));
-  CHECK(!t->Is(Type::UnsignedSmall()));
-
   double zero_value = OpParameter<double>(zero);
   double minus_zero_value = OpParameter<double>(minus_zero);
 
   CHECK(bit_cast<uint64_t>(0.0) == bit_cast<uint64_t>(zero_value));
   CHECK(bit_cast<uint64_t>(-0.0) != bit_cast<uint64_t>(zero_value));
   CHECK(bit_cast<uint64_t>(0.0) != bit_cast<uint64_t>(minus_zero_value));
   CHECK(bit_cast<uint64_t>(-0.0) == bit_cast<uint64_t>(minus_zero_value));
 }
 
 
 TEST(ZeroConstant2) {
   JSConstantCacheTester T;
 
   Node* zero = T.Constant(0);
 
   CHECK_EQ(IrOpcode::kNumberConstant, zero->opcode());
   CHECK_EQ(zero, T.ZeroConstant());
   CHECK_NE(zero, T.Constant(-0.0));
   CHECK_NE(zero, T.Constant(1.0));
   CHECK_NE(zero, T.Constant(std::numeric_limits<double>::quiet_NaN()));
   CHECK_NE(zero, T.Float64Constant(0));
   CHECK_NE(zero, T.Int32Constant(0));
-
-  Type* t = T.TypeOf(zero);
-
-  CHECK(t->Is(Type::Number()));
-  CHECK(t->Is(Type::Integral32()));
-  CHECK(t->Is(Type::Signed32()));
-  CHECK(t->Is(Type::Unsigned32()));
-  CHECK(t->Is(Type::SignedSmall()));
-  CHECK(t->Is(Type::UnsignedSmall()));
 }
 
 
 TEST(OneConstant1) {
   JSConstantCacheTester T;
 
   Node* one = T.OneConstant();
 
   CHECK_EQ(IrOpcode::kNumberConstant, one->opcode());
   CHECK_EQ(one, T.Constant(1));
   CHECK_EQ(one, T.Constant(1.0));
   CHECK_NE(one, T.Constant(1.01));
   CHECK_NE(one, T.Constant(-1.01));
   CHECK_NE(one, T.Constant(std::numeric_limits<double>::quiet_NaN()));
   CHECK_NE(one, T.Float64Constant(1.0));
   CHECK_NE(one, T.Int32Constant(1));
-
-  Type* t = T.TypeOf(one);
-
-  CHECK(t->Is(Type::Number()));
-  CHECK(t->Is(Type::Integral32()));
-  CHECK(t->Is(Type::Signed32()));
-  CHECK(t->Is(Type::Unsigned32()));
-  CHECK(t->Is(Type::SignedSmall()));
-  CHECK(t->Is(Type::UnsignedSmall()));
 }
 
 
 TEST(OneConstant2) {
   JSConstantCacheTester T;
 
   Node* one = T.Constant(1);
 
   CHECK_EQ(IrOpcode::kNumberConstant, one->opcode());
   CHECK_EQ(one, T.OneConstant());
   CHECK_EQ(one, T.Constant(1.0));
   CHECK_NE(one, T.Constant(1.01));
   CHECK_NE(one, T.Constant(-1.01));
   CHECK_NE(one, T.Constant(std::numeric_limits<double>::quiet_NaN()));
   CHECK_NE(one, T.Float64Constant(1.0));
   CHECK_NE(one, T.Int32Constant(1));
-
-  Type* t = T.TypeOf(one);
-
-  CHECK(t->Is(Type::Number()));
-  CHECK(t->Is(Type::Integral32()));
-  CHECK(t->Is(Type::Signed32()));
-  CHECK(t->Is(Type::Unsigned32()));
-  CHECK(t->Is(Type::SignedSmall()));
-  CHECK(t->Is(Type::UnsignedSmall()));
 }
 
 
 TEST(Canonicalizations) {
   JSConstantCacheTester T;
 
   CHECK_EQ(T.ZeroConstant(), T.ZeroConstant());
   CHECK_EQ(T.UndefinedConstant(), T.UndefinedConstant());
   CHECK_EQ(T.TheHoleConstant(), T.TheHoleConstant());
   CHECK_EQ(T.TrueConstant(), T.TrueConstant());
@@ skipping 26 matching lines @@
 
   FOR_FLOAT64_INPUTS(i) {
     Node* node = T.Constant(*i);
     for (int j = 0; j < 5; j++) {
       CHECK_EQ(node, T.Constant(*i));
     }
   }
 }
 
 
-TEST(NumberTypes) {
-  JSConstantCacheTester T;
-
-  FOR_FLOAT64_INPUTS(i) {
-    double value = *i;
-    Node* node = T.Constant(value);
-    CHECK(T.TypeOf(node)->Is(Type::Of(value, T.main_zone())));
-  }
-}
-
-
 TEST(HeapNumbers) {
   JSConstantCacheTester T;
 
   FOR_FLOAT64_INPUTS(i) {
     double value = *i;
     Handle<Object> num = T.factory()->NewNumber(value);
     Handle<HeapNumber> heap = T.factory()->NewHeapNumber(value);
     Node* node1 = T.Constant(value);
     Node* node2 = T.Constant(num);
     Node* node3 = T.Constant(heap);
@@ skipping 19 matching lines @@
   JSConstantCacheTester T;
 
   CHECK_EQ(*T.factory()->undefined_value(), *T.handle(T.UndefinedConstant()));
   CHECK_EQ(*T.factory()->the_hole_value(), *T.handle(T.TheHoleConstant()));
   CHECK_EQ(*T.factory()->true_value(), *T.handle(T.TrueConstant()));
   CHECK_EQ(*T.factory()->false_value(), *T.handle(T.FalseConstant()));
   CHECK_EQ(*T.factory()->null_value(), *T.handle(T.NullConstant()));
 }
 
 
-TEST(OddballTypes) {
-  JSConstantCacheTester T;
-
-  CHECK(T.TypeOf(T.UndefinedConstant())->Is(Type::Undefined()));
-  // TODO(dcarney): figure this out.
-  // CHECK(T.TypeOf(T.TheHoleConstant())->Is(Type::Internal()));
-  CHECK(T.TypeOf(T.TrueConstant())->Is(Type::Boolean()));
-  CHECK(T.TypeOf(T.FalseConstant())->Is(Type::Boolean()));
-  CHECK(T.TypeOf(T.NullConstant())->Is(Type::Null()));
-  CHECK(T.TypeOf(T.ZeroConstant())->Is(Type::Number()));
-  CHECK(T.TypeOf(T.OneConstant())->Is(Type::Number()));
-  CHECK(T.TypeOf(T.NaNConstant())->Is(Type::NaN()));
-}
-
-
 TEST(ExternalReferences) {
   // TODO(titzer): test canonicalization of external references.
 }
 
 
 static bool Contains(NodeVector* nodes, Node* n) {
   for (size_t i = 0; i < nodes->size(); i++) {
     if (nodes->at(i) == n) return true;
   }
   return false;
@@ skipping 164 matching lines @@
   T.GetCachedNodes(&nodes);
 
   for (size_t i = 0; i < arraysize(constants); i++) {
     CHECK(Contains(&nodes, constants[i]));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8