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

src/builtins/builtins-string.cc

 // Copyright 2016 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/builtins/builtins.h"
 #include "src/builtins/builtins-utils.h"
 
 #include "src/code-factory.h"
 #include "src/regexp/regexp-utils.h"
 
@@ skipping 953 matching lines @@
     Node* const start_int =
         a.ToInteger(context, start, CodeStubAssembler::kTruncateMinusZero);
 
     Label if_issmi(&a), if_isheapnumber(&a, Label::kDeferred);
     a.Branch(a.TaggedIsSmi(start_int), &if_issmi, &if_isheapnumber);
 
     a.Bind(&if_issmi);
     {
       Node* const length_plus_start = a.SmiAdd(string_length, start_int);
       var_start.Bind(a.Select(a.SmiLessThan(start_int, zero),
-                              a.SmiMax(length_plus_start, zero), start_int));
+                              [&] { return a.SmiMax(length_plus_start, zero); },
+                              [&] { return start_int; },
+                              MachineRepresentation::kTagged));
       a.Goto(&handle_length);
     }
 
     a.Bind(&if_isheapnumber);
     {
       // If {start} is a heap number, it is definitely out of bounds. If it is
       // negative, {start} = max({string_length} + {start}),0) = 0'. If it is
       // positive, set {start} to {string_length} which ultimately results in
       // returning an empty string.
       Node* const float_zero = a.Float64Constant(0.);
       Node* const start_float = a.LoadHeapNumberValue(start_int);
-      var_start.Bind(a.Select(a.Float64LessThan(start_float, float_zero), zero,
-                              string_length));
+      var_start.Bind(a.SelectTaggedConstant(
+          a.Float64LessThan(start_float, float_zero), zero, string_length));
       a.Goto(&handle_length);
     }
   }
 
   // Conversions and bounds-checks for {length}.
   a.Bind(&handle_length);
   {
     Label if_issmi(&a), if_isheapnumber(&a, Label::kDeferred);
 
     // Default to {string_length} if {length} is undefined.
@@ skipping 85 matching lines @@
 
     a->Bind(&if_isinbounds);
     {
       var_result.Bind(value_int);
       a->Goto(&out);
     }
 
     a->Bind(&if_isoutofbounds);
     {
       Node* const zero = a->SmiConstant(Smi::kZero);
-      var_result.Bind(a->Select(a->SmiLessThan(value_int, zero), zero, limit));
+      var_result.Bind(a->SelectTaggedConstant(a->SmiLessThan(value_int, zero),
+                                              zero, limit));
       a->Goto(&out);
     }
   }
 
   a->Bind(&if_isnotsmi);
   {
     // {value} is a heap number - in this case, it is definitely out of bounds.
     CSA_ASSERT(a, a->IsHeapNumberMap(a->LoadMap(value_int)));
 
     Node* const float_zero = a->Float64Constant(0.);
     Node* const smi_zero = a->SmiConstant(Smi::kZero);
     Node* const value_float = a->LoadHeapNumberValue(value_int);
-    var_result.Bind(a->Select(a->Float64LessThan(value_float, float_zero),
-                              smi_zero, limit));
+    var_result.Bind(a->SelectTaggedConstant(
+        a->Float64LessThan(value_float, float_zero), smi_zero, limit));
     a->Goto(&out);
   }
 
   a->Bind(&out);
   return var_result.value();
 }
 
 }  // namespace
 
 // ES6 section 21.1.3.19 String.prototype.substring ( start, end )
@@ skipping 340 matching lines @@
         Runtime::kThrowIncompatibleMethodReceiver, context,
         assembler.HeapConstant(assembler.factory()->NewStringFromAsciiChecked(
             "String Iterator.prototype.next", TENURED)),
         iterator);
     assembler.Return(result);  // Never reached.
   }
 }
 
 }  // namespace internal
 }  // namespace v8