[stubs] Ensure CSA_ASSERT and CSA_SLOW_ASSERT do not produce unused instructions in release mode.

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 1047 matching lines @@
       a->GotoUnless(a->SmiLessThanOrEqual(var_length.value(), zero), &out);
       a->Return(a->EmptyStringConstant());
     }
 
     a->Bind(&if_isheapnumber);
     {
       // If {length} is a heap number, it is definitely out of bounds. There are
       // two cases according to the spec: if it is negative, "" is returned; if
       // it is positive, then length is set to {string_length} - {start}.
 
-      a->Assert(a->WordEqual(a->LoadMap(var_length.value()),
-                             a->HeapNumberMapConstant()));
+      a->CSA_ASSERT(a->WordEqual(a->LoadMap(var_length.value()),
+                                 a->HeapNumberMapConstant()));
 
       Label if_isnegative(a), if_ispositive(a);
       Node* const float_zero = a->Float64Constant(0.);
       Node* const length_float = a->LoadHeapNumberValue(var_length.value());
       a->Branch(a->Float64LessThan(length_float, float_zero), &if_isnegative,
                 &if_ispositive);
 
       a->Bind(&if_isnegative);
       a->Return(a->EmptyStringConstant());
 
@@ skipping 48 matching lines @@
     {
       Node* const zero = a->SmiConstant(Smi::kZero);
       var_result.Bind(a->Select(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.
-    a->Assert(a->WordEqual(a->LoadMap(value_int), a->HeapNumberMapConstant()));
+    a->CSA_ASSERT(
+        a->WordEqual(a->LoadMap(value_int), a->HeapNumberMapConstant()));
 
     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));
     a->Goto(&out);
   }
 
   a->Bind(&out);
@@ skipping 211 matching lines @@
                                              assembler->Int32Constant(0xFC00)),
                         assembler->Int32Constant(0xDC00)),
                     &handle_surrogate_pair, &return_result);
 
   assembler->Bind(&handle_surrogate_pair);
   {
     Node* lead = var_result.value();
     Node* trail = var_trail.value();
 #ifdef ENABLE_SLOW_DCHECKS
     // Check that this path is only taken if a surrogate pair is found
-    assembler->Assert(assembler->Uint32GreaterThanOrEqual(
+    assembler->CSA_ASSERT(assembler->Uint32GreaterThanOrEqual(
         lead, assembler->Int32Constant(0xD800)));
-    assembler->Assert(
+    assembler->CSA_ASSERT(
         assembler->Uint32LessThan(lead, assembler->Int32Constant(0xDC00)));
-    assembler->Assert(assembler->Uint32GreaterThanOrEqual(
+    assembler->CSA_ASSERT(assembler->Uint32GreaterThanOrEqual(
         trail, assembler->Int32Constant(0xDC00)));
-    assembler->Assert(
+    assembler->CSA_ASSERT(
         assembler->Uint32LessThan(trail, assembler->Int32Constant(0xE000)));
 #endif
 
     switch (encoding) {
       case UnicodeEncoding::UTF16:
         var_result.Bind(assembler->WordOr(
 // Need to swap the order for big-endian platforms
 #if V8_TARGET_BIG_ENDIAN
             assembler->WordShl(lead, assembler->Int32Constant(16)), trail));
 #else
@@ skipping 104 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