build/toolchain/clang_code_coverage_wrapper.py

   1 #!/usr/bin/env python3
   2 # Copyright 2018 The Chromium Authors
   3 # Use of this source code is governed by a BSD-style license that can be
   4 # found in the LICENSE file.
   5 """Removes code coverage flags from invocations of the Clang C/C++ compiler.
   6
   7 If the GN arg `use_clang_coverage=true`, this script will be invoked by default.
   8 GN will add coverage instrumentation flags to almost all source files.
   9
  10 This script is used to remove instrumentation flags from a subset of the source
  11 files. By default, it will not remove flags from any files. If the option
  12 --files-to-instrument is passed, this script will remove flags from all files
  13 except the ones listed in --files-to-instrument.
  14
  15 This script also contains hard-coded exclusion lists of files to never
  16 instrument, indexed by target operating system. Files in these lists have their
  17 flags removed in both modes. The OS can be selected with --target-os.
  18
  19 This script also contains hard-coded force lists of files to always instrument,
  20 indexed by target operating system. Files in these lists never have their flags
  21 removed in either mode. The OS can be selected with --target-os.
  22
  23 The order of precedence is: force list, exclusion list, --files-to-instrument.
  24
  25 The path to the coverage instrumentation input file should be relative to the
  26 root build directory, and the file consists of multiple lines where each line
  27 represents a path to a source file, and the specified paths must be relative to
  28 the root build directory. e.g. ../../base/task/post_task.cc for build
  29 directory 'out/Release'. The paths should be written using OS-native path
  30 separators for the current platform.
  31
  32 One caveat with this compiler wrapper is that it may introduce unexpected
  33 behaviors in incremental builds when the file path to the coverage
  34 instrumentation input file changes between consecutive runs, so callers of this
  35 script are strongly advised to always use the same path such as
  36 "${root_build_dir}/coverage_instrumentation_input.txt".
  37
  38 It's worth noting on try job builders, if the contents of the instrumentation
  39 file changes so that a file doesn't need to be instrumented any longer, it will
  40 be recompiled automatically because if try job B runs after try job A, the files
  41 that were instrumented in A will be updated (i.e., reverted to the checked in
  42 version) in B, and so they'll be considered out of date by ninja and recompiled.
  43
  44 Example usage:
  45   clang_code_coverage_wrapper.py \\
  46       --files-to-instrument=coverage_instrumentation_input.txt
  47
  48 Siso implements the same logic in
  49 build/config/siso/clang_code_coverage_wrapper.star, which avoids the wrapper
  50 invocations for remote execution and performance improvement.
  51 Please update the Siso starlark file when updating this file.
  52 """
  53 # LINT.IfChange
  54
  55 import argparse
  56 import os
  57 import subprocess
  58 import sys
  59
  60 # Flags used to enable coverage instrumentation.
  61 # Flags should be listed in the same order that they are added in
  62 # build/config/coverage/BUILD.gn
  63 _COVERAGE_FLAGS = [
  64     '-fprofile-instr-generate',
  65     '-fcoverage-mapping',
  66     # Following experimental flags remove unused header functions from the
  67     # coverage mapping data embedded in the test binaries, and the reduction
  68     # of binary size enables building Chrome's large unit test targets on
  69     # MacOS. Please refer to crbug.com/796290 for more details.
  70     '-mllvm',
  71     '-limited-coverage-experimental=true',
  72 ]
  73
  74 # Files that should not be built with coverage flags by default.
  75 _DEFAULT_COVERAGE_EXCLUSION_LIST = []
  76
  77 # Map of exclusion lists indexed by target OS.
  78 # If no target OS is defined, or one is defined that doesn't have a specific
  79 # entry, use _DEFAULT_COVERAGE_EXCLUSION_LIST.
  80 _COVERAGE_EXCLUSION_LIST_MAP = {
  81     'android': [
  82         # This file caused webview native library failed on arm64.
  83         '../../device/gamepad/dualshock4_controller.cc',
  84     ],
  85     'fuchsia': [
  86         # TODO(crbug.com/1174725): These files caused clang to crash while
  87         # compiling them.
  88         '../../base/allocator/partition_allocator/src/partition_alloc/pcscan.cc',
  89         '../../third_party/skia/src/core/SkOpts.cpp',
  90         '../../third_party/skia/src/opts/SkOpts_hsw.cpp',
  91         '../../third_party/skia/third_party/skcms/skcms.cc',
  92     ],
  93     'linux': [
  94         # These files caused a static initializer to be generated, which
  95         # shouldn't.
  96         # TODO(crbug.com/990948): Remove when the bug is fixed.
  97         '../../chrome/browser/media/router/providers/cast/cast_internal_message_util.cc',  #pylint: disable=line-too-long
  98         '../../components/media_router/common/providers/cast/channel/cast_channel_enum.cc',  #pylint: disable=line-too-long
  99         '../../components/media_router/common/providers/cast/channel/cast_message_util.cc',  #pylint: disable=line-too-long
 100         '../../components/media_router/common/providers/cast/cast_media_source.cc',  #pylint: disable=line-too-long
 101         '../../ui/events/keycodes/dom/keycode_converter.cc',
 102     ],
 103     'chromeos': [
 104         # These files caused clang to crash while compiling them. They are
 105         # excluded pending an investigation into the underlying compiler bug.
 106         '../../third_party/webrtc/p2p/base/p2p_transport_channel.cc',
 107         '../../third_party/icu/source/common/uts46.cpp',
 108         '../../third_party/icu/source/common/ucnvmbcs.cpp',
 109         '../../base/android/android_image_reader_compat.cc',
 110     ],
 111 }
 112
 113 # Map of force lists indexed by target OS.
 114 _COVERAGE_FORCE_LIST_MAP = {
 115     # clang_profiling.cc refers to the symbol `__llvm_profile_dump` from the
 116     # profiling runtime. In a partial coverage build, it is possible for a
 117     # binary to include clang_profiling.cc but have no instrumented files, thus
 118     # causing an unresolved symbol error because the profiling runtime will not
 119     # be linked in. Therefore we force coverage for this file to ensure that
 120     # any target that includes it will also get the profiling runtime.
 121     'win': [r'..\..\base\test\clang_profiling.cc'],
 122     # TODO(crbug.com/1141727) We're seeing runtime LLVM errors in mac-rel when
 123     # no files are changed, so we suspect that this is similar to the other
 124     # problem with clang_profiling.cc on Windows. The TODO here is to force
 125     # coverage for this specific file on ALL platforms, if it turns out to fix
 126     # this issue on Mac as well. It's the only file that directly calls
 127     # `__llvm_profile_dump` so it warrants some special treatment.
 128     'mac': ['../../base/test/clang_profiling.cc'],
 129 }
 130
 131
 132 def _remove_flags_from_command(command):
 133   # We need to remove the coverage flags for this file, but we only want to
 134   # remove them if we see the exact sequence defined in _COVERAGE_FLAGS.
 135   # That ensures that we only remove the flags added by GN when
 136   # "use_clang_coverage" is true. Otherwise, we would remove flags set by
 137   # other parts of the build system.
 138   start_flag = _COVERAGE_FLAGS[0]
 139   num_flags = len(_COVERAGE_FLAGS)
 140   start_idx = 0
 141   try:
 142     while True:
 143       idx = command.index(start_flag, start_idx)
 144       if command[idx:idx + num_flags] == _COVERAGE_FLAGS:
 145         del command[idx:idx + num_flags]
 146         # There can be multiple sets of _COVERAGE_FLAGS. All of these need to be
 147         # removed.
 148         start_idx = idx
 149       else:
 150         start_idx = idx + 1
 151   except ValueError:
 152     pass
 153
 154
 155 def main():
 156   arg_parser = argparse.ArgumentParser()
 157   arg_parser.usage = __doc__
 158   arg_parser.add_argument(
 159       '--files-to-instrument',
 160       type=str,
 161       help='Path to a file that contains a list of file names to instrument.')
 162   arg_parser.add_argument(
 163       '--target-os', required=False, help='The OS to compile for.')
 164   arg_parser.add_argument('args', nargs=argparse.REMAINDER)
 165   parsed_args = arg_parser.parse_args()
 166
 167   if (parsed_args.files_to_instrument and
 168       not os.path.isfile(parsed_args.files_to_instrument)):
 169     raise Exception('Path to the coverage instrumentation file: "%s" doesn\'t '
 170                     'exist.' % parsed_args.files_to_instrument)
 171
 172   compile_command = parsed_args.args
 173   if not any('clang' in s for s in compile_command):
 174     return subprocess.call(compile_command)
 175
 176   target_os = parsed_args.target_os
 177
 178   try:
 179     # The command is assumed to use Clang as the compiler, and the path to the
 180     # source file is behind the -c argument, and the path to the source path is
 181     # relative to the root build directory. For example:
 182     # clang++ -fvisibility=hidden -c ../../base/files/file_path.cc -o \
 183     #   obj/base/base/file_path.o
 184     # On Windows, clang-cl.exe uses /c instead of -c.
 185     source_flag = '/c' if target_os == 'win' else '-c'
 186     source_flag_index = compile_command.index(source_flag)
 187   except ValueError:
 188     print('%s argument is not found in the compile command.' % source_flag)
 189     raise
 190
 191   if source_flag_index + 1 >= len(compile_command):
 192     raise Exception('Source file to be compiled is missing from the command.')
 193
 194   # On Windows, filesystem paths should use '\', but GN creates build commands
 195   # that use '/'. We invoke os.path.normpath to ensure that the path uses the
 196   # correct separator for the current platform (i.e. '\' on Windows and '/'
 197   # otherwise).
 198   compile_source_file = os.path.normpath(compile_command[source_flag_index + 1])
 199   extension = os.path.splitext(compile_source_file)[1]
 200   if not extension in ['.c', '.cc', '.cpp', '.cxx', '.m', '.mm', '.S']:
 201     raise Exception('Invalid source file %s found' % compile_source_file)
 202   exclusion_list = _COVERAGE_EXCLUSION_LIST_MAP.get(
 203       target_os, _DEFAULT_COVERAGE_EXCLUSION_LIST)
 204   force_list = _COVERAGE_FORCE_LIST_MAP.get(target_os, [])
 205
 206   should_remove_flags = False
 207   if compile_source_file not in force_list:
 208     if compile_source_file in exclusion_list:
 209       should_remove_flags = True
 210     elif parsed_args.files_to_instrument:
 211       with open(parsed_args.files_to_instrument) as f:
 212         if compile_source_file not in f.read():
 213           should_remove_flags = True
 214
 215   if should_remove_flags:
 216     _remove_flags_from_command(compile_command)
 217
 218   return subprocess.call(compile_command)
 219
 220
 221 if __name__ == '__main__':
 222   sys.exit(main())
 223
 224 # LINT.ThenChange(/build/config/siso/clang_code_coverage_wrapper.star)