When typing phi nodes, weaken union of integer constants to a range.

src/compiler/typer.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/compiler/typer.h"
 
 #include "src/base/flags.h"
 #include "src/base/lazy-instance.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/common-operator.h"
@@ skipping 179 matching lines @@
                                          : Bounds(Type::None());
   }
 
   Bounds Operand(Node* node, int i) {
     Node* operand_node = NodeProperties::GetValueInput(node, i);
     return BoundsOrNone(operand_node);
   }
 
   Bounds WrapContextBoundsForInput(Node* node);
   Type* Weaken(Node* node, Type* current_type, Type* previous_type);
+  Type* WeakenConstants(Type* type);
 
   Zone* zone() { return typer_->zone(); }
   Isolate* isolate() { return typer_->isolate(); }
   Graph* graph() { return typer_->graph(); }
 
   void SetWeakened(NodeId node_id) { weakened_nodes_.insert(node_id); }
   bool IsWeakened(NodeId node_id) {
     return weakened_nodes_.find(node_id) != weakened_nodes_.end();
   }
 
@@ skipping 338 matching lines @@
 Bounds Typer::Visitor::TypeExternalConstant(Node* node) {
   return Bounds(Type::None(zone()), Type::Internal(zone()));
 }
 
 
 Bounds Typer::Visitor::TypeSelect(Node* node) {
   return Bounds::Either(Operand(node, 1), Operand(node, 2), zone());
 }
 
 
+Type* Typer::Visitor::WeakenConstants(Type* type) {
+  Type* const integer = typer_->cache_.kInteger;
+  if (!type->Maybe(integer)) return type;
+  Type* myinteger = Type::Intersect(type, integer, zone());

[Jarin, 2015/09/14 08:06:29]

Could you come up with a better name than myinteger? (E.g.. integer_part or some
such.)

+  if (myinteger->NumConstants() <= 1) return type;
+  return Type::Union(
+      type, Type::Range(myinteger->Min(), myinteger->Max(), typer_->zone()),
+      typer_->zone());
+}
+
+
 Bounds Typer::Visitor::TypePhi(Node* node) {
   int arity = node->op()->ValueInputCount();
   Bounds bounds = Operand(node, 0);
   for (int i = 1; i < arity; ++i) {
     bounds = Bounds::Either(bounds, Operand(node, i), zone());
+    // In order to avoid huge unions, we weaken multiple integer constants
+    // to a single range.
+    bounds.upper = WeakenConstants(bounds.upper);
+    bounds.lower = WeakenConstants(bounds.lower);
   }
   return bounds;
 }
 
 
 Bounds Typer::Visitor::TypeEffectPhi(Node* node) {
   UNREACHABLE();
   return Bounds();
 }
 
@@ skipping 1714 matching lines @@
       TYPED_ARRAYS(TYPED_ARRAY_CASE)
 #undef TYPED_ARRAY_CASE
     }
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8