Make enabling of CSA verifier a build-time flag

test/unittests/interpreter/interpreter-assembler-unittest.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 "test/unittests/interpreter/interpreter-assembler-unittest.h"
 
 #include "src/code-factory.h"
 #include "src/compiler/node.h"
 #include "src/interface-descriptors.h"
 #include "src/isolate.h"
 #include "test/unittests/compiler/compiler-test-utils.h"
 #include "test/unittests/compiler/node-test-utils.h"
 
 using ::testing::_;
 
 namespace v8 {
 namespace internal {
 
 using namespace compiler;
 
+#ifdef ENABLE_VERIFY_CSA
+#define IS_BITCAST_WORD_TO_TAGGED_SIGNED(x) IsBitcastWordToTaggedSigned(x)
+#define IS_BITCAST_TAGGED_TO_WORD(x) IsBitcastTaggedToWord(x)
+#else
+#define IS_BITCAST_WORD_TO_TAGGED_SIGNED(x) (x)
+#define IS_BITCAST_TAGGED_TO_WORD(x) (x)
+#endif
+
 namespace interpreter {
 
 InterpreterAssemblerTestState::InterpreterAssemblerTestState(
     InterpreterAssemblerTest* test, Bytecode bytecode)
     : compiler::CodeAssemblerState(
           test->isolate(), test->zone(),
           InterpreterDispatchDescriptor(test->isolate()),
           Code::ComputeFlags(Code::BYTECODE_HANDLER),
           Bytecodes::ToString(bytecode), Bytecodes::ReturnCount(bytecode)) {}
 
@@ skipping 512 matching lines @@
                   IsWordShl(reg_index_node, IsIntPtrConstant(kPointerSizeLog2)),
                   store_value));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, SmiTag) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerTestState state(this, bytecode);
     InterpreterAssemblerForTest m(&state, bytecode);
     Node* value = m.Int32Constant(44);
-    EXPECT_THAT(m.SmiTag(value), IsBitcastWordToTaggedSigned(IsIntPtrConstant(
-                                     static_cast<intptr_t>(44)
-                                     << (kSmiShiftSize + kSmiTagSize))));
+    EXPECT_THAT(
+        m.SmiTag(value),
+        IS_BITCAST_WORD_TO_TAGGED_SIGNED(IsIntPtrConstant(
+            static_cast<intptr_t>(44) << (kSmiShiftSize + kSmiTagSize))));
     EXPECT_THAT(m.SmiUntag(value),
-                IsWordSar(IsBitcastTaggedToWord(value),
+                IsWordSar(IS_BITCAST_TAGGED_TO_WORD(value),
                           IsIntPtrConstant(kSmiShiftSize + kSmiTagSize)));
   }
 }
 
 TARGET_TEST_F(InterpreterAssemblerTest, IntPtrAdd) {
   TRACED_FOREACH(interpreter::Bytecode, bytecode, kBytecodes) {
     InterpreterAssemblerTestState state(this, bytecode);
     InterpreterAssemblerForTest m(&state, bytecode);
     Node* a = m.Parameter(0);
     Node* b = m.Int32Constant(1);
@@ skipping 155 matching lines @@
     EXPECT_THAT(feedback_vector,
                 m.IsLoad(MachineType::AnyTagged(), load_literals_matcher,
                          IsIntPtrConstant(LiteralsArray::kFeedbackVectorOffset -
                                           kHeapObjectTag)));
   }
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8