[turbofan] Simplify BinaryOperationHints and CompareOperationHints.

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 264 matching lines @@
 
  protected:
   Node* NewPathToken(int token_id) {
     return owner_->jsgraph()->Constant(token_id);
   }
   Node* NewPathTokenForImplicitFallThrough() {
     return NewPathToken(TokenDispenserForFinally::kFallThroughToken);
   }
   Node* NewPathDispatchCondition(Node* t1, Node* t2) {
     return owner_->NewNode(
-        owner_->javascript()->StrictEqual(CompareOperationHints::Any()), t1,
-        t2);
+        owner_->javascript()->StrictEqual(CompareOperationHint::kAny), t1, t2);
   }
 
  private:
   TokenDispenserForFinally dispenser_;
   AstGraphBuilder* owner_;
   ZoneVector<Entry> deferred_;
   Node* return_token_;
   Node* throw_token_;
 };
 
@@ skipping 970 matching lines @@
       default_index = i;
       continue;
     }
 
     // Create nodes to perform label comparison as if via '==='. The switch
     // value is still on the operand stack while the label is evaluated.
     VisitForValue(clause->label());
     Node* label = environment()->Pop();
     Node* tag = environment()->Top();
 
-    CompareOperationHints hints;
+    CompareOperationHint hint;
     if (!type_hint_analysis_ ||
-        !type_hint_analysis_->GetCompareOperationHints(clause->CompareId(),
-                                                       &hints)) {
-      hints = CompareOperationHints::Any();
+        !type_hint_analysis_->GetCompareOperationHint(clause->CompareId(),
+                                                      &hint)) {
+      hint = CompareOperationHint::kAny;
     }
 
-    const Operator* op = javascript()->StrictEqual(hints);
+    const Operator* op = javascript()->StrictEqual(hint);
     Node* condition = NewNode(op, tag, label);
     compare_switch.BeginLabel(i, condition);
 
     // Discard the switch value at label match.
     environment()->Pop();
     compare_switch.EndLabel();
   }
 
   // Discard the switch value and mark the default case.
   environment()->Pop();
@@ skipping 55 matching lines @@
 }
 
 
 void AstGraphBuilder::VisitForInStatement(ForInStatement* stmt) {
   VisitForValue(stmt->subject());
   Node* object = environment()->Pop();
   BlockBuilder for_block(this);
   for_block.BeginBlock();
   // Check for null or undefined before entering loop.
   Node* is_null_cond =
-      NewNode(javascript()->StrictEqual(CompareOperationHints::Any()), object,
+      NewNode(javascript()->StrictEqual(CompareOperationHint::kAny), object,
               jsgraph()->NullConstant());
   for_block.BreakWhen(is_null_cond, BranchHint::kFalse);
   Node* is_undefined_cond =
-      NewNode(javascript()->StrictEqual(CompareOperationHints::Any()), object,
+      NewNode(javascript()->StrictEqual(CompareOperationHint::kAny), object,
               jsgraph()->UndefinedConstant());
   for_block.BreakWhen(is_undefined_cond, BranchHint::kFalse);
   {
     // Convert object to jsobject.
     object = BuildToObject(object, stmt->ToObjectId());
     environment()->Push(object);
 
     // Prepare for-in cache.
     Node* prepare = NewNode(javascript()->ForInPrepare(), object);
     PrepareFrameState(prepare, stmt->PrepareId(),
@@ skipping 24 matching lines @@
       Node* exit_cond = NewNode(javascript()->ForInDone(), index, cache_length);
       for_loop.BreakWhen(exit_cond);
 
       // Compute the next enumerated value.
       Node* value = NewNode(javascript()->ForInNext(), object, cache_array,
                             cache_type, index);
       PrepareFrameState(value, stmt->FilterId(),
                         OutputFrameStateCombine::Push());
       IfBuilder test_value(this);
       Node* test_value_cond =
-          NewNode(javascript()->StrictEqual(CompareOperationHints::Any()),
-                  value, jsgraph()->UndefinedConstant());
+          NewNode(javascript()->StrictEqual(CompareOperationHint::kAny), value,
+                  jsgraph()->UndefinedConstant());
       test_value.If(test_value_cond, BranchHint::kFalse);
       test_value.Then();
       test_value.Else();
       {
         environment()->Push(value);
         PrepareEagerCheckpoint(stmt->FilterId());
         value = environment()->Pop();
         // Bind value and do loop body.
         VectorSlotPair feedback =
             CreateVectorSlotPair(stmt->EachFeedbackSlot());
@@ skipping 1328 matching lines @@
     }
   }
 }
 
 void AstGraphBuilder::VisitLiteralCompareNil(CompareOperation* expr,
                                              Expression* sub_expr,
                                              Node* nil_value) {
   const Operator* op = nullptr;
   switch (expr->op()) {
     case Token::EQ:
-      op = javascript()->Equal(CompareOperationHints::Any());
+      op = javascript()->Equal(CompareOperationHint::kAny);
       break;
     case Token::EQ_STRICT:
-      op = javascript()->StrictEqual(CompareOperationHints::Any());
+      op = javascript()->StrictEqual(CompareOperationHint::kAny);
       break;
     default:
       UNREACHABLE();
   }
   VisitForValue(sub_expr);
   Node* value_to_compare = environment()->Pop();
   Node* value = NewNode(op, value_to_compare, nil_value);
   PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
   return ast_context()->ProduceValue(expr, value);
 }
 
 void AstGraphBuilder::VisitLiteralCompareTypeof(CompareOperation* expr,
                                                 Expression* sub_expr,
                                                 Handle<String> check) {
   VisitTypeofExpression(sub_expr);
   Node* typeof_arg = NewNode(javascript()->TypeOf(), environment()->Pop());
-  Node* value = NewNode(javascript()->StrictEqual(CompareOperationHints::Any()),
+  Node* value = NewNode(javascript()->StrictEqual(CompareOperationHint::kAny),
                         typeof_arg, jsgraph()->Constant(check));
   PrepareFrameState(value, expr->id(), ast_context()->GetStateCombine());
   return ast_context()->ProduceValue(expr, value);
 }
 
 void AstGraphBuilder::VisitCompareOperation(CompareOperation* expr) {
   // Check for a few fast cases. The AST visiting behavior must be in sync
   // with the full codegen: We don't push both left and right values onto
   // the expression stack when one side is a special-case literal.
   Expression* sub_expr = nullptr;
   Handle<String> check;
   if (expr->IsLiteralCompareTypeof(&sub_expr, &check)) {
     return VisitLiteralCompareTypeof(expr, sub_expr, check);
   }
   if (expr->IsLiteralCompareUndefined(&sub_expr)) {
     return VisitLiteralCompareNil(expr, sub_expr,
                                   jsgraph()->UndefinedConstant());
   }
   if (expr->IsLiteralCompareNull(&sub_expr)) {
     return VisitLiteralCompareNil(expr, sub_expr, jsgraph()->NullConstant());
   }
 
-  CompareOperationHints hints;
+  CompareOperationHint hint;
   if (!type_hint_analysis_ ||
-      !type_hint_analysis_->GetCompareOperationHints(
-          expr->CompareOperationFeedbackId(), &hints)) {
-    hints = CompareOperationHints::Any();
+      !type_hint_analysis_->GetCompareOperationHint(
+          expr->CompareOperationFeedbackId(), &hint)) {
+    hint = CompareOperationHint::kAny;
   }
 
   const Operator* op;
   switch (expr->op()) {
     case Token::EQ:
-      op = javascript()->Equal(hints);
+      op = javascript()->Equal(hint);
       break;
     case Token::NE:
-      op = javascript()->NotEqual(hints);
+      op = javascript()->NotEqual(hint);
       break;
     case Token::EQ_STRICT:
-      op = javascript()->StrictEqual(hints);
+      op = javascript()->StrictEqual(hint);
       break;
     case Token::NE_STRICT:
-      op = javascript()->StrictNotEqual(hints);
+      op = javascript()->StrictNotEqual(hint);
       break;
     case Token::LT:
-      op = javascript()->LessThan(hints);
+      op = javascript()->LessThan(hint);
       break;
     case Token::GT:
-      op = javascript()->GreaterThan(hints);
+      op = javascript()->GreaterThan(hint);
       break;
     case Token::LTE:
-      op = javascript()->LessThanOrEqual(hints);
+      op = javascript()->LessThanOrEqual(hint);
       break;
     case Token::GTE:
-      op = javascript()->GreaterThanOrEqual(hints);
+      op = javascript()->GreaterThanOrEqual(hint);
       break;
     case Token::INSTANCEOF:
       op = javascript()->InstanceOf();
       break;
     case Token::IN:
       op = javascript()->HasProperty();
       break;
     default:
       op = nullptr;
       UNREACHABLE();
@@ skipping 421 matching lines @@
                           BailoutId::None());
   return object;
 }
 
 
 Node* AstGraphBuilder::BuildHoleCheckThenThrow(Node* value, Variable* variable,
                                                Node* not_hole,
                                                BailoutId bailout_id) {
   IfBuilder hole_check(this);
   Node* the_hole = jsgraph()->TheHoleConstant();
-  Node* check = NewNode(javascript()->StrictEqual(CompareOperationHints::Any()),
+  Node* check = NewNode(javascript()->StrictEqual(CompareOperationHint::kAny),
                         value, the_hole);
   hole_check.If(check);
   hole_check.Then();
   Node* error = BuildThrowReferenceError(variable, bailout_id);
   environment()->Push(error);
   hole_check.Else();
   environment()->Push(not_hole);
   hole_check.End();
   return environment()->Pop();
 }
 
 
 Node* AstGraphBuilder::BuildHoleCheckElseThrow(Node* value, Variable* variable,
                                                Node* for_hole,
                                                BailoutId bailout_id) {
   IfBuilder hole_check(this);
   Node* the_hole = jsgraph()->TheHoleConstant();
-  Node* check = NewNode(javascript()->StrictEqual(CompareOperationHints::Any()),
+  Node* check = NewNode(javascript()->StrictEqual(CompareOperationHint::kAny),
                         value, the_hole);
   hole_check.If(check);
   hole_check.Then();
   environment()->Push(for_hole);
   hole_check.Else();
   Node* error = BuildThrowReferenceError(variable, bailout_id);
   environment()->Push(error);
   hole_check.End();
   return environment()->Pop();
 }
 
 
 Node* AstGraphBuilder::BuildThrowIfStaticPrototype(Node* name,
                                                    BailoutId bailout_id) {
   IfBuilder prototype_check(this);
   Node* prototype_string =
       jsgraph()->Constant(isolate()->factory()->prototype_string());
-  Node* check = NewNode(javascript()->StrictEqual(CompareOperationHints::Any()),
+  Node* check = NewNode(javascript()->StrictEqual(CompareOperationHint::kAny),
                         name, prototype_string);
   prototype_check.If(check);
   prototype_check.Then();
   Node* error = BuildThrowStaticPrototypeError(bailout_id);
   environment()->Push(error);
   prototype_check.Else();
   environment()->Push(name);
   prototype_check.End();
   return environment()->Pop();
 }
@@ skipping 449 matching lines @@
   NewNode(javascript()->CallRuntime(Runtime::kReThrow), exception_value);
   Node* control = NewNode(common()->Throw(), exception_value);
   UpdateControlDependencyToLeaveFunction(control);
   return control;
 }
 
 
 Node* AstGraphBuilder::BuildBinaryOp(Node* left, Node* right, Token::Value op,
                                      TypeFeedbackId feedback_id) {
   const Operator* js_op;
-  BinaryOperationHints hints;
+  BinaryOperationHint hint;
   if (!type_hint_analysis_ ||
-      !type_hint_analysis_->GetBinaryOperationHints(feedback_id, &hints)) {
-    hints = BinaryOperationHints::Any();
+      !type_hint_analysis_->GetBinaryOperationHint(feedback_id, &hint)) {
+    hint = BinaryOperationHint::kAny;
   }
   switch (op) {
     case Token::BIT_OR:
-      js_op = javascript()->BitwiseOr(hints);
+      js_op = javascript()->BitwiseOr(hint);
       break;
     case Token::BIT_AND:
-      js_op = javascript()->BitwiseAnd(hints);
+      js_op = javascript()->BitwiseAnd(hint);
       break;
     case Token::BIT_XOR:
-      js_op = javascript()->BitwiseXor(hints);
+      js_op = javascript()->BitwiseXor(hint);
       break;
     case Token::SHL:
-      js_op = javascript()->ShiftLeft(hints);
+      js_op = javascript()->ShiftLeft(hint);
       break;
     case Token::SAR:
-      js_op = javascript()->ShiftRight(hints);
+      js_op = javascript()->ShiftRight(hint);
       break;
     case Token::SHR:
-      js_op = javascript()->ShiftRightLogical(hints);
+      js_op = javascript()->ShiftRightLogical(hint);
       break;
     case Token::ADD:
-      js_op = javascript()->Add(hints);
+      js_op = javascript()->Add(hint);
       break;
     case Token::SUB:
-      js_op = javascript()->Subtract(hints);
+      js_op = javascript()->Subtract(hint);
       break;
     case Token::MUL:
-      js_op = javascript()->Multiply(hints);
+      js_op = javascript()->Multiply(hint);
       break;
     case Token::DIV:
-      js_op = javascript()->Divide(hints);
+      js_op = javascript()->Divide(hint);
       break;
     case Token::MOD:
-      js_op = javascript()->Modulus(hints);
+      js_op = javascript()->Modulus(hint);
       break;
     default:
       UNREACHABLE();
       js_op = nullptr;
   }
   return NewNode(js_op, left, right);
 }
 
 
 Node* AstGraphBuilder::TryLoadGlobalConstant(Handle<Name> name) {
@@ skipping 24 matching lines @@
     fast_block.BeginBlock();
 
     // Perform checks whether the fast mode applies, by looking for any
     // extension object which might shadow the optimistic declaration.
     for (int depth = 0; bitset != 0; bitset >>= 1, depth++) {
       if ((bitset & 1) == 0) continue;
       Node* load = NewNode(
           javascript()->LoadContext(depth, Context::EXTENSION_INDEX, false),
           current_context());
       Node* check =
-          NewNode(javascript()->StrictEqual(CompareOperationHints::Any()), load,
+          NewNode(javascript()->StrictEqual(CompareOperationHint::kAny), load,
                   jsgraph()->TheHoleConstant());
       fast_block.BreakUnless(check, BranchHint::kTrue);
     }
 
     // Fast case, because variable is not shadowed.
     if (Node* constant = TryLoadGlobalConstant(name)) {
       environment()->Push(constant);
     } else {
       // Perform global slot load.
       Node* fast = BuildGlobalLoad(name, feedback, typeof_mode);
@@ skipping 26 matching lines @@
     fast_block.BeginBlock();
 
     // Perform checks whether the fast mode applies, by looking for any
     // extension object which might shadow the optimistic declaration.
     for (int depth = 0; bitset != 0; bitset >>= 1, depth++) {
       if ((bitset & 1) == 0) continue;
       Node* load = NewNode(
           javascript()->LoadContext(depth, Context::EXTENSION_INDEX, false),
           current_context());
       Node* check =
-          NewNode(javascript()->StrictEqual(CompareOperationHints::Any()), load,
+          NewNode(javascript()->StrictEqual(CompareOperationHint::kAny), load,
                   jsgraph()->TheHoleConstant());
       fast_block.BreakUnless(check, BranchHint::kTrue);
     }
 
     // Fast case, because variable is not shadowed. Perform context slot load.
     Variable* local = variable->local_if_not_shadowed();
     DCHECK(local->location() == VariableLocation::CONTEXT);  // Must be context.
     Node* fast =
         BuildVariableLoad(local, bailout_id, feedback, combine, typeof_mode);
     environment()->Push(fast);
@@ skipping 400 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