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

src/builtins/builtins-regexp.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-utils.h"
 #include "src/builtins/builtins.h"
 
 #include "src/code-factory.h"
 #include "src/regexp/jsregexp.h"
 #include "src/regexp/regexp-utils.h"
@@ skipping 1584 matching lines @@
   // If no matches, return the subject string.
   var_result.Bind(subject_string);
   a->GotoIf(a->WordEqual(res, null), &out);
 
   // Reload last match info since it might have changed.
   last_match_info = a->LoadContextElement(
       native_context, Context::REGEXP_LAST_MATCH_INFO_INDEX);
 
   Node* const res_length = a->LoadJSArrayLength(res);
   Node* const res_elems = a->LoadElements(res);
-  a->CSA_ASSERT(a->HasInstanceType(res_elems, FIXED_ARRAY_TYPE));
+  CSA_ASSERT(a, a->HasInstanceType(res_elems, FIXED_ARRAY_TYPE));
 
   CodeStubAssembler::ParameterMode mode = CodeStubAssembler::INTPTR_PARAMETERS;
   Node* const num_capture_registers = a->LoadFixedArrayElement(
       last_match_info,
       a->IntPtrConstant(RegExpMatchInfo::kNumberOfCapturesIndex), 0, mode);
 
   Label if_hasexplicitcaptures(a), if_noexplicitcaptures(a), create_result(a);
   a->Branch(a->SmiEqual(num_capture_registers, a->SmiConstant(Smi::FromInt(2))),
             &if_noexplicitcaptures, &if_hasexplicitcaptures);
 
@@ skipping 54 matching lines @@
               a->LoadFixedArrayElement(res_elems, next_i, 0, mode);
 
           Node* const new_match_start = a->SmiSub(next_elem, elem);
           var_match_start.Bind(new_match_start);
           a->Goto(&loop_epilogue);
         }
       }
 
       a->Bind(&if_isstring);
       {
-        a->Assert(a->IsStringInstanceType(a->LoadInstanceType(elem)));
+        CSA_ASSERT(a, a->IsStringInstanceType(a->LoadInstanceType(elem)));
 
         Callable call_callable = CodeFactory::Call(isolate);
         Node* const replacement_obj =
             a->CallJS(call_callable, context, replace_callable, undefined, elem,
                       var_match_start.value(), subject_string);
 
         Node* const replacement_str = a->ToString(context, replacement_obj);
         a->StoreFixedArrayElement(res_elems, i, replacement_str);
 
         Node* const elem_length = a->LoadStringLength(elem);
@@ skipping 27 matching lines @@
          replace_callable, mode](CodeStubAssembler* a, Node* index) {
           Node* const elem =
               a->LoadFixedArrayElement(res_elems, index, 0, mode);
 
           Label do_continue(a);
           a->GotoIf(a->TaggedIsSmi(elem), &do_continue);
 
           // elem must be an Array.
           // Use the apply argument as backing for global RegExp properties.
 
-          a->CSA_ASSERT(a->HasInstanceType(elem, JS_ARRAY_TYPE));
+          CSA_ASSERT(a, a->HasInstanceType(elem, JS_ARRAY_TYPE));
 
           // TODO(jgruber): Remove indirection through Call->ReflectApply.
           Callable call_callable = CodeFactory::Call(isolate);
           Node* const reflect_apply = a->LoadContextElement(
               native_context, Context::REFLECT_APPLY_INDEX);
 
           Node* const replacement_obj =
               a->CallJS(call_callable, context, reflect_apply, undefined,
                         replace_callable, undefined, elem);
 
@@ skipping 269 matching lines @@
   a->Bind(&if_matched);
   {
     Node* result = ConstructNewResultFromMatchInfo(isolate, a, context,
                                                    match_indices, string);
     a->Return(result);
   }
 }
 
 }  // namespace internal
 }  // namespace v8