[turbofan] Insert sigma nodes for loop variable backedge.

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 <iomanip>
+
 #include "src/base/flags.h"
 #include "src/bootstrapper.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/graph-reducer.h"
 #include "src/compiler/js-operator.h"
 #include "src/compiler/loop-variable-optimizer.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/node.h"
 #include "src/compiler/operation-typer.h"
 #include "src/compiler/simplified-operator.h"
@@ skipping 313 matching lines @@
   if (induction_vars != nullptr) {
     induction_vars->ChangeToInductionVariablePhis();
   }
   Visitor visitor(this, induction_vars);
   GraphReducer graph_reducer(zone(), graph());
   graph_reducer.AddReducer(&visitor);
   for (Node* const root : roots) graph_reducer.ReduceNode(root);
   graph_reducer.ReduceGraph();
 
   if (induction_vars != nullptr) {
-    induction_vars->ChangeFromInductionVariablePhis();
+    induction_vars->ChangeToPhisAndInsertGuards();
   }
 }
 
 void Typer::Decorator::Decorate(Node* node) {
   if (node->op()->ValueOutputCount() > 0) {
     // Only eagerly type-decorate nodes with known input types.
     // Other cases will generally require a proper fixpoint iteration with Run.
     bool is_typed = NodeProperties::IsTyped(node);
     if (is_typed || NodeProperties::AllValueInputsAreTyped(node)) {
       Visitor typing(typer_, nullptr);
@@ skipping 337 matching lines @@
     }
     // The lower bound must be at most the initial value's lower bound.
     min = std::min(min, initial_type->Min());
   } else {
     // Shortcut: If the increment can be both positive and negative,
     // the variable can go arbitrarily far, so just return integer.
     return typer_->cache_.kInteger;
   }
   if (FLAG_trace_turbo_loop) {
     OFStream os(stdout);
+    os << std::setprecision(10);
     os << "Loop (" << NodeProperties::GetControlInput(node)->id()
        << ") variable bounds for phi " << node->id() << ": (" << min << ", "
        << max << ")\n";
   }
   return Type::Range(min, max, typer_->zone());
 }
 
 Type* Typer::Visitor::TypeEffectPhi(Node* node) {
   UNREACHABLE();
   return nullptr;
@@ skipping 50 matching lines @@
 Type* Typer::Visitor::TypeProjection(Node* node) {
   Type* const type = Operand(node, 0);
   if (type->Is(Type::None())) return Type::None();
   int const index = static_cast<int>(ProjectionIndexOf(node->op()));
   if (type->IsTuple() && index < type->AsTuple()->Arity()) {
     return type->AsTuple()->Element(index);
   }
   return Type::Any();
 }
 
+Type* Typer::Visitor::TypeTypeGuard(Node* node) {
+  Type* const type = Operand(node, 0);
+  return typer_->operation_typer()->TypeTypeGuard(node->op(), type);
+}
+
 Type* Typer::Visitor::TypeDead(Node* node) { return Type::None(); }
 
 // JS comparison operators.
 
 
 Type* Typer::Visitor::JSEqualTyper(Type* lhs, Type* rhs, Typer* t) {
   if (lhs->Is(Type::NaN()) || rhs->Is(Type::NaN())) return t->singleton_false_;
   if (lhs->Is(Type::NullOrUndefined()) && rhs->Is(Type::NullOrUndefined())) {
     return t->singleton_true_;
   }
@@ skipping 1514 matching lines @@
   }
   if (Type::IsInteger(*value)) {
     return Type::Range(value->Number(), value->Number(), zone());
   }
   return Type::Constant(value, zone());
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8