[Turbofan] Introduce OtherNumberConstant.

src/compiler/typed-optimization.cc

 // Copyright 2016 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/compiler/typed-optimization.h"
 
 #include "src/compilation-dependencies.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/simplified-operator.h"
 #include "src/compiler/type-cache.h"
 #include "src/isolate-inl.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 TypedOptimization::TypedOptimization(Editor* editor,
                                      CompilationDependencies* dependencies,
                                      Flags flags, JSGraph* jsgraph)
     : AdvancedReducer(editor),
       dependencies_(dependencies),
       flags_(flags),
       jsgraph_(jsgraph),
-      true_type_(Type::Constant(factory()->true_value(), graph()->zone())),
-      false_type_(Type::Constant(factory()->false_value(), graph()->zone())),
+      true_type_(Type::HeapConstant(factory()->true_value(), graph()->zone())),
+      false_type_(
+          Type::HeapConstant(factory()->false_value(), graph()->zone())),
       type_cache_(TypeCache::Get()) {}
 
 TypedOptimization::~TypedOptimization() {}
 
 Reduction TypedOptimization::Reduce(Node* node) {
   // Check if the output type is a singleton.  In that case we already know the
   // result value and can simply replace the node if it's eliminable.
   if (!NodeProperties::IsConstant(node) && NodeProperties::IsTyped(node) &&
       node->op()->HasProperty(Operator::kEliminatable)) {
     // TODO(v8:5303): We must not eliminate FinishRegion here. This special
     // case can be removed once we have separate operators for value and
     // effect regions.
     if (node->opcode() == IrOpcode::kFinishRegion) return NoChange();
     // We can only constant-fold nodes here, that are known to not cause any
     // side-effect, may it be a JavaScript observable side-effect or a possible
     // eager deoptimization exit (i.e. {node} has an operator that doesn't have
     // the Operator::kNoDeopt property).
     Type* upper = NodeProperties::GetType(node);
     if (upper->IsInhabited()) {
-      if (upper->IsConstant()) {
-        Node* replacement = jsgraph()->Constant(upper->AsConstant()->Value());
+      if (upper->IsHeapConstant()) {
+        Node* replacement =
+            jsgraph()->Constant(upper->AsHeapConstant()->Value());
         ReplaceWithValue(node, replacement);
         return Changed(replacement);
       } else if (upper->Is(Type::MinusZero())) {
         Node* replacement = jsgraph()->Constant(factory()->minus_zero_value());
         ReplaceWithValue(node, replacement);
         return Changed(replacement);
       } else if (upper->Is(Type::NaN())) {
         Node* replacement = jsgraph()->NaNConstant();
         ReplaceWithValue(node, replacement);
         return Changed(replacement);
@@ skipping 31 matching lines @@
       return ReduceSelect(node);
     default:
       break;
   }
   return NoChange();
 }
 
 namespace {
 
 MaybeHandle<Map> GetStableMapFromObjectType(Type* object_type) {
-  if (object_type->IsConstant() &&
-      object_type->AsConstant()->Value()->IsHeapObject()) {
+  if (object_type->IsHeapConstant() &&
+      object_type->AsHeapConstant()->Value()->IsHeapObject()) {
     Handle<Map> object_map(
-        Handle<HeapObject>::cast(object_type->AsConstant()->Value())->map());
+        Handle<HeapObject>::cast(object_type->AsHeapConstant()->Value())
+            ->map());
     if (object_map->is_stable()) return object_map;
   }
   return MaybeHandle<Map>();
 }
 
 }  // namespace
 
 Reduction TypedOptimization::ReduceCheckMaps(Node* node) {
   // The CheckMaps(o, ...map...) can be eliminated if map is stable,
   // o has type Constant(object) and map == object->map, and either
   //  (1) map cannot transition further, or
   //  (2) we can add a code dependency on the stability of map
   //      (to guard the Constant type information).
   Node* const object = NodeProperties::GetValueInput(node, 0);
   Type* const object_type = NodeProperties::GetType(object);
   Node* const effect = NodeProperties::GetEffectInput(node);
   Handle<Map> object_map;
   if (GetStableMapFromObjectType(object_type).ToHandle(&object_map)) {
     for (int i = 1; i < node->op()->ValueInputCount(); ++i) {
       Node* const map = NodeProperties::GetValueInput(node, i);
       Type* const map_type = NodeProperties::GetType(map);
-      if (map_type->IsConstant() &&
-          map_type->AsConstant()->Value().is_identical_to(object_map)) {
+      if (map_type->IsHeapConstant() &&
+          map_type->AsHeapConstant()->Value().is_identical_to(object_map)) {
         if (object_map->CanTransition()) {
           dependencies()->AssumeMapStable(object_map);
         }
         return Replace(effect);
       }
     }
   }
   return NoChange();
 }
 
@@ skipping 108 matching lines @@
 
 Isolate* TypedOptimization::isolate() const { return jsgraph()->isolate(); }
 
 SimplifiedOperatorBuilder* TypedOptimization::simplified() const {
   return jsgraph()->simplified();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8