[turbofan] Introduce ToBooleanHints on ToBoolean operators.

src/compiler/ast-graph-builder.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/ast-graph-builder.h"
 
 #include "src/ast/scopes.h"
 #include "src/compiler.h"
 #include "src/compiler/ast-loop-assignment-analyzer.h"
 #include "src/compiler/control-builders.h"
@@ skipping 76 matching lines @@
       : AstContext(owner, Expression::kValue) {}
   ~AstValueContext() final;
   void ProduceValue(Node* value) final;
   Node* ConsumeValue() final;
 };
 
 
 // Context to evaluate expression for a condition value (and side effects).
 class AstGraphBuilder::AstTestContext final : public AstContext {
  public:
-  explicit AstTestContext(AstGraphBuilder* owner)
-      : AstContext(owner, Expression::kTest) {}
+  AstTestContext(AstGraphBuilder* owner, TypeFeedbackId feedback_id)
+      : AstContext(owner, Expression::kTest), feedback_id_(feedback_id) {}
   ~AstTestContext() final;
   void ProduceValue(Node* value) final;
   Node* ConsumeValue() final;
+
+ private:
+  TypeFeedbackId const feedback_id_;
 };
 
 
 // Scoped class tracking context objects created by the visitor. Represents
 // mutations of the context chain within the function body and allows to
 // change the current {scope} and {context} during visitation.
 class AstGraphBuilder::ContextScope BASE_EMBEDDED {
  public:
   ContextScope(AstGraphBuilder* builder, Scope* scope, Node* context)
       : builder_(builder),
@@ skipping 808 matching lines @@
   // The value is ignored.
 }
 
 
 void AstGraphBuilder::AstValueContext::ProduceValue(Node* value) {
   environment()->Push(value);
 }
 
 
 void AstGraphBuilder::AstTestContext::ProduceValue(Node* value) {
-  environment()->Push(owner()->BuildToBoolean(value));
+  environment()->Push(owner()->BuildToBoolean(value, feedback_id_));
 }
 
 
 Node* AstGraphBuilder::AstEffectContext::ConsumeValue() { return NULL; }
 
 
 Node* AstGraphBuilder::AstValueContext::ConsumeValue() {
   return environment()->Pop();
 }
 
@@ skipping 86 matching lines @@
   AstEffectContext for_effect(this);
   if (!CheckStackOverflow()) {
     expr->Accept(this);
   } else {
     ast_context()->ProduceValue(jsgraph()->UndefinedConstant());
   }
 }
 
 
 void AstGraphBuilder::VisitForTest(Expression* expr) {
-  AstTestContext for_condition(this);
+  AstTestContext for_condition(this, expr->test_id());
   if (!CheckStackOverflow()) {
     expr->Accept(this);
   } else {
     ast_context()->ProduceValue(jsgraph()->UndefinedConstant());
   }
 }
 
 
 void AstGraphBuilder::Visit(Expression* expr) {
   // Reuses enclosing AstContext.
@@ skipping 1956 matching lines @@
     operand = environment()->Pop();
   }
   Node* value = NewNode(javascript()->TypeOf(), operand);
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitNot(UnaryOperation* expr) {
   VisitForValue(expr->expression());
   Node* operand = environment()->Pop();
-  Node* input = BuildToBoolean(operand);
+  Node* input = BuildToBoolean(operand, expr->expression()->test_id());
   Node* value = NewNode(common()->Select(kMachAnyTagged), input,
                         jsgraph()->FalseConstant(), jsgraph()->TrueConstant());
   ast_context()->ProduceValue(value);
 }
 
 
 void AstGraphBuilder::VisitComma(BinaryOperation* expr) {
   VisitForEffect(expr->left());
   Visit(expr->right());
   ast_context()->ReplaceValue();
 }
 
 
 void AstGraphBuilder::VisitLogicalExpression(BinaryOperation* expr) {
   bool is_logical_and = expr->op() == Token::AND;
   IfBuilder compare_if(this);
   VisitForValue(expr->left());
   Node* condition = environment()->Top();
-  compare_if.If(BuildToBoolean(condition));
+  compare_if.If(BuildToBoolean(condition, expr->left()->test_id()));
   compare_if.Then();
   if (is_logical_and) {
     environment()->Pop();
     Visit(expr->right());
   } else if (ast_context()->IsEffect()) {
     environment()->Pop();
   } else if (ast_context()->IsTest()) {
     environment()->Poke(0, jsgraph()->TrueConstant());
   }
   compare_if.Else();
@@ skipping 631 matching lines @@
     Node* shared = BuildLoadImmutableObjectField(
         closure, JSFunction::kSharedFunctionInfoOffset);
     Node* vector = BuildLoadImmutableObjectField(
         shared, SharedFunctionInfo::kFeedbackVectorOffset);
     feedback_vector_.set(vector);
   }
   return feedback_vector_.get();
 }
 
 
-Node* AstGraphBuilder::BuildToBoolean(Node* input) {
+Node* AstGraphBuilder::BuildToBoolean(Node* input, TypeFeedbackId feedback_id) {
   if (Node* node = TryFastToBoolean(input)) return node;
-  return NewNode(javascript()->ToBoolean(), input);
+  ToBooleanHints hints;
+  if (!type_hint_analysis_ ||
+      !type_hint_analysis_->GetToBooleanHints(feedback_id, &hints)) {
+    hints = ToBooleanHint::kAny;
+  }
+  return NewNode(javascript()->ToBoolean(hints), input);
 }
 
 
 Node* AstGraphBuilder::BuildToName(Node* input, BailoutId bailout_id) {
   if (Node* node = TryFastToName(input)) return node;
   Node* name = NewNode(javascript()->ToName(), input);
   PrepareFrameState(name, bailout_id);
   return name;
 }
 
@@ skipping 619 matching lines @@
     // Phi does not exist yet, introduce one.
     value = NewPhi(inputs, value, control);
     value->ReplaceInput(inputs - 1, other);
   }
   return value;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8