[stubs] Cleanup usages of CSA::Select().

src/interpreter/interpreter.cc

 // Copyright 2015 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/interpreter/interpreter.h"
 
 #include <fstream>
 #include <memory>
 
 #include "src/ast/prettyprinter.h"
@@ skipping 1040 matching lines @@
               __ Word32Equal(lhs_instance_type, __ Int32Constant(ODDBALL_TYPE)),
               &lhs_is_not_oddball);
 
           var_type_feedback.Bind(
               __ Int32Constant(CompareOperationFeedback::kNumberOrOddball));
           __ Goto(&gather_rhs_type);
 
           __ Bind(&lhs_is_not_oddball);
         }
 
-        var_type_feedback.Bind(
-            __ Select(__ IsStringInstanceType(lhs_instance_type),
-                      __ Int32Constant(CompareOperationFeedback::kString),
-                      __ Int32Constant(CompareOperationFeedback::kAny)));
+        var_type_feedback.Bind(__ SelectInt32Constant(
+            __ IsStringInstanceType(lhs_instance_type),
+            CompareOperationFeedback::kString, CompareOperationFeedback::kAny));
         __ Goto(&gather_rhs_type);
       }
     }
 
     __ Bind(&gather_rhs_type);
     {
       Label rhs_is_not_smi(assembler), rhs_is_not_number(assembler);
 
       __ GotoUnless(__ TaggedIsSmi(rhs), &rhs_is_not_smi);
 
@@ skipping 24 matching lines @@
             var_type_feedback.Bind(__ Word32Or(
                 var_type_feedback.value(),
                 __ Int32Constant(CompareOperationFeedback::kNumberOrOddball)));
             __ Goto(&update_feedback);
 
             __ Bind(&rhs_is_not_oddball);
           }
 
           var_type_feedback.Bind(__ Word32Or(
               var_type_feedback.value(),
-              __ Select(__ IsStringInstanceType(rhs_instance_type),
-                        __ Int32Constant(CompareOperationFeedback::kString),
-                        __ Int32Constant(CompareOperationFeedback::kAny))));
+              __ SelectInt32Constant(__ IsStringInstanceType(rhs_instance_type),
+                                     CompareOperationFeedback::kString,
+                                     CompareOperationFeedback::kAny)));
           __ Goto(&update_feedback);
         }
       }
     }
 
     __ Bind(&update_feedback);
     {
       __ UpdateFeedback(var_type_feedback.value(), type_feedback_vector,
                         slot_index);
       __ Goto(&do_compare);
@@ skipping 115 matching lines @@
     } break;
     case Token::SAR: {
       Node* value = __ Word32Sar(
           lhs_value, __ Word32And(rhs_value, __ Int32Constant(0x1f)));
       result = __ ChangeInt32ToTagged(value);
     } break;
     default:
       UNREACHABLE();
   }
 
-  Node* result_type =
-      __ Select(__ TaggedIsSmi(result),
-                __ Int32Constant(BinaryOperationFeedback::kSignedSmall),
-                __ Int32Constant(BinaryOperationFeedback::kNumber));
+  Node* result_type = __ SelectInt32Constant(
+      __ TaggedIsSmi(result), BinaryOperationFeedback::kSignedSmall,
+      BinaryOperationFeedback::kNumber);
 
   if (FLAG_debug_code) {
     Label ok(assembler);
     __ GotoIf(__ TaggedIsSmi(result), &ok);
     Node* result_map = __ LoadMap(result);
     __ AbortIfWordNotEqual(result_map, __ HeapNumberMapConstant(),
                            kExpectedHeapNumber);
     __ Goto(&ok);
     __ Bind(&ok);
   }
@@ skipping 176 matching lines @@
   Node* right = __ SmiTag(raw_int);
   Node* context = __ GetContext();
   Node* slot_index = __ BytecodeOperandIdx(2);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
   Variable var_lhs_type_feedback(assembler, MachineRepresentation::kWord32);
   Node* lhs_value = __ TruncateTaggedToWord32WithFeedback(
       context, left, &var_lhs_type_feedback);
   Node* rhs_value = __ SmiToWord32(right);
   Node* value = __ Word32Or(lhs_value, rhs_value);
   Node* result = __ ChangeInt32ToTagged(value);
-  Node* result_type =
-      __ Select(__ TaggedIsSmi(result),
-                __ Int32Constant(BinaryOperationFeedback::kSignedSmall),
-                __ Int32Constant(BinaryOperationFeedback::kNumber));
+  Node* result_type = __ SelectInt32Constant(
+      __ TaggedIsSmi(result), BinaryOperationFeedback::kSignedSmall,
+      BinaryOperationFeedback::kNumber);
   __ UpdateFeedback(__ Word32Or(result_type, var_lhs_type_feedback.value()),
                     type_feedback_vector, slot_index);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 // BitwiseAnd <imm> <reg>
 //
 // BitwiseAnd <reg> with <imm>. For this operation <reg> is the lhs
 // operand and <imm> is the rhs operand.
 void Interpreter::DoBitwiseAndSmi(InterpreterAssembler* assembler) {
   Node* reg_index = __ BytecodeOperandReg(1);
   Node* left = __ LoadRegister(reg_index);
   Node* raw_int = __ BytecodeOperandImm(0);
   Node* right = __ SmiTag(raw_int);
   Node* context = __ GetContext();
   Node* slot_index = __ BytecodeOperandIdx(2);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
   Variable var_lhs_type_feedback(assembler, MachineRepresentation::kWord32);
   Node* lhs_value = __ TruncateTaggedToWord32WithFeedback(
       context, left, &var_lhs_type_feedback);
   Node* rhs_value = __ SmiToWord32(right);
   Node* value = __ Word32And(lhs_value, rhs_value);
   Node* result = __ ChangeInt32ToTagged(value);
-  Node* result_type =
-      __ Select(__ TaggedIsSmi(result),
-                __ Int32Constant(BinaryOperationFeedback::kSignedSmall),
-                __ Int32Constant(BinaryOperationFeedback::kNumber));
+  Node* result_type = __ SelectInt32Constant(
+      __ TaggedIsSmi(result), BinaryOperationFeedback::kSignedSmall,
+      BinaryOperationFeedback::kNumber);
   __ UpdateFeedback(__ Word32Or(result_type, var_lhs_type_feedback.value()),
                     type_feedback_vector, slot_index);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 // ShiftLeftSmi <imm> <reg>
 //
 // Left shifts register <src> by the count specified in <imm>.
 // Register <src> is converted to an int32 before the operation. The 5
 // lsb bits from <imm> are used as count i.e. <src> << (<imm> & 0x1F).
 void Interpreter::DoShiftLeftSmi(InterpreterAssembler* assembler) {
   Node* reg_index = __ BytecodeOperandReg(1);
   Node* left = __ LoadRegister(reg_index);
   Node* raw_int = __ BytecodeOperandImm(0);
   Node* right = __ SmiTag(raw_int);
   Node* context = __ GetContext();
   Node* slot_index = __ BytecodeOperandIdx(2);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
   Variable var_lhs_type_feedback(assembler, MachineRepresentation::kWord32);
   Node* lhs_value = __ TruncateTaggedToWord32WithFeedback(
       context, left, &var_lhs_type_feedback);
   Node* rhs_value = __ SmiToWord32(right);
   Node* shift_count = __ Word32And(rhs_value, __ Int32Constant(0x1f));
   Node* value = __ Word32Shl(lhs_value, shift_count);
   Node* result = __ ChangeInt32ToTagged(value);
-  Node* result_type =
-      __ Select(__ TaggedIsSmi(result),
-                __ Int32Constant(BinaryOperationFeedback::kSignedSmall),
-                __ Int32Constant(BinaryOperationFeedback::kNumber));
+  Node* result_type = __ SelectInt32Constant(
+      __ TaggedIsSmi(result), BinaryOperationFeedback::kSignedSmall,
+      BinaryOperationFeedback::kNumber);
   __ UpdateFeedback(__ Word32Or(result_type, var_lhs_type_feedback.value()),
                     type_feedback_vector, slot_index);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 // ShiftRightSmi <imm> <reg>
 //
 // Right shifts register <src> by the count specified in <imm>.
 // Register <src> is converted to an int32 before the operation. The 5
 // lsb bits from <imm> are used as count i.e. <src> << (<imm> & 0x1F).
 void Interpreter::DoShiftRightSmi(InterpreterAssembler* assembler) {
   Node* reg_index = __ BytecodeOperandReg(1);
   Node* left = __ LoadRegister(reg_index);
   Node* raw_int = __ BytecodeOperandImm(0);
   Node* right = __ SmiTag(raw_int);
   Node* context = __ GetContext();
   Node* slot_index = __ BytecodeOperandIdx(2);
   Node* type_feedback_vector = __ LoadTypeFeedbackVector();
   Variable var_lhs_type_feedback(assembler, MachineRepresentation::kWord32);
   Node* lhs_value = __ TruncateTaggedToWord32WithFeedback(
       context, left, &var_lhs_type_feedback);
   Node* rhs_value = __ SmiToWord32(right);
   Node* shift_count = __ Word32And(rhs_value, __ Int32Constant(0x1f));
   Node* value = __ Word32Sar(lhs_value, shift_count);
   Node* result = __ ChangeInt32ToTagged(value);
-  Node* result_type =
-      __ Select(__ TaggedIsSmi(result),
-                __ Int32Constant(BinaryOperationFeedback::kSignedSmall),
-                __ Int32Constant(BinaryOperationFeedback::kNumber));
+  Node* result_type = __ SelectInt32Constant(
+      __ TaggedIsSmi(result), BinaryOperationFeedback::kSignedSmall,
+      BinaryOperationFeedback::kNumber);
   __ UpdateFeedback(__ Word32Or(result_type, var_lhs_type_feedback.value()),
                     type_feedback_vector, slot_index);
   __ SetAccumulator(result);
   __ Dispatch();
 }
 
 Node* Interpreter::BuildUnaryOp(Callable callable,
                                 InterpreterAssembler* assembler) {
   Node* target = __ HeapConstant(callable.code());
   Node* accumulator = __ GetAccumulator();
@@ skipping 1228 matching lines @@
   __ StoreObjectField(generator, JSGeneratorObject::kContinuationOffset,
       __ SmiTag(new_state));
   __ SetAccumulator(old_state);
 
   __ Dispatch();
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8