[coverage] Block coverage with support for IfStatements

src/interpreter/interpreter-generator.cc

 // Copyright 2017 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-generator.h"
 
 #include <array>
 #include <tuple>
 
 #include "src/builtins/builtins-arguments-gen.h"
@@ skipping 3420 matching lines @@
     Node* context = GetContext();                                          \
     Node* accumulator = GetAccumulator();                                  \
     Node* original_handler =                                               \
         CallRuntime(Runtime::kDebugBreakOnBytecode, context, accumulator); \
     MaybeDropFrames(context);                                              \
     DispatchToBytecodeHandler(original_handler);                           \
   }
 DEBUG_BREAK_BYTECODE_LIST(DEBUG_BREAK);
 #undef DEBUG_BREAK
 
+// IncBlockCounter <slot>
+//
+// Increment the execution count for the given slot. Used for block code
+// coverage.
+IGNITION_HANDLER(IncBlockCounter, InterpreterAssembler) {
+  Node* closure = LoadRegister(Register::function_closure());
+  Node* coverage_array_slot = BytecodeOperandIdxSmi(0);
+  Node* context = GetContext();
+
+  CallRuntime(Runtime::kIncBlockCounter, context, closure, coverage_array_slot);
+
+  Dispatch();
+}
+
 class InterpreterForInPrepareAssembler : public InterpreterAssembler {
  public:
   InterpreterForInPrepareAssembler(CodeAssemblerState* state, Bytecode bytecode,
                                    OperandScale operand_scale)
       : InterpreterAssembler(state, bytecode, operand_scale) {}
 
   void BuildForInPrepareResult(Node* output_register, Node* cache_type,
                                Node* cache_array, Node* cache_length) {
     StoreRegister(cache_type, output_register);
     output_register = NextRegister(output_register);
@@ skipping 287 matching lines @@
     code->Disassemble(Bytecodes::ToString(bytecode), os);
     os << std::flush;
   }
 #endif  // ENABLE_DISASSEMBLER
   return code;
 }
 
 }  // namespace interpreter
 }  // namespace internal
 }  // namespace v8