scripts/clang-tools/gen_compile_commands.py

   1 #!/usr/bin/env python3
   2 # SPDX-License-Identifier: GPL-2.0
   3 #
   4 # Copyright (C) Google LLC, 2018
   5 #
   6 # Author: Tom Roeder <tmroeder@google.com>
   7 #
   8 """A tool for generating compile_commands.json in the Linux kernel."""
   9
  10 import argparse
  11 import json
  12 import logging
  13 import os
  14 import re
  15 import subprocess
  16 import sys
  17
  18 _DEFAULT_OUTPUT = 'compile_commands.json'
  19 _DEFAULT_LOG_LEVEL = 'WARNING'
  20
  21 _FILENAME_PATTERN = r'^\..*\.cmd$'
  22 _LINE_PATTERN = r'^cmd_[^ ]*\.o := (.* )([^ ]*\.c) *(;|$)'
  23 _VALID_LOG_LEVELS = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
  24 # The tools/ directory adopts a different build system, and produces .cmd
  25 # files in a different format. Do not support it.
  26 _EXCLUDE_DIRS = ['.git', 'Documentation', 'include', 'tools']
  27
  28 def parse_arguments():
  29     """Sets up and parses command-line arguments.
  30
  31     Returns:
  32         log_level: A logging level to filter log output.
  33         directory: The work directory where the objects were built.
  34         ar: Command used for parsing .a archives.
  35         output: Where to write the compile-commands JSON file.
  36         paths: The list of files/directories to handle to find .cmd files.
  37     """
  38     usage = 'Creates a compile_commands.json database from kernel .cmd files'
  39     parser = argparse.ArgumentParser(description=usage)
  40
  41     directory_help = ('specify the output directory used for the kernel build '
  42                       '(defaults to the working directory)')
  43     parser.add_argument('-d', '--directory', type=str, default='.',
  44                         help=directory_help)
  45
  46     output_help = ('path to the output command database (defaults to ' +
  47                    _DEFAULT_OUTPUT + ')')
  48     parser.add_argument('-o', '--output', type=str, default=_DEFAULT_OUTPUT,
  49                         help=output_help)
  50
  51     log_level_help = ('the level of log messages to produce (defaults to ' +
  52                       _DEFAULT_LOG_LEVEL + ')')
  53     parser.add_argument('--log_level', choices=_VALID_LOG_LEVELS,
  54                         default=_DEFAULT_LOG_LEVEL, help=log_level_help)
  55
  56     ar_help = 'command used for parsing .a archives'
  57     parser.add_argument('-a', '--ar', type=str, default='llvm-ar', help=ar_help)
  58
  59     paths_help = ('directories to search or files to parse '
  60                   '(files should be *.o, *.a, or modules.order). '
  61                   'If nothing is specified, the current directory is searched')
  62     parser.add_argument('paths', type=str, nargs='*', help=paths_help)
  63
  64     args = parser.parse_args()
  65
  66     return (args.log_level,
  67             os.path.abspath(args.directory),
  68             args.output,
  69             args.ar,
  70             args.paths if len(args.paths) > 0 else [args.directory])
  71
  72
  73 def cmdfiles_in_dir(directory):
  74     """Generate the iterator of .cmd files found under the directory.
  75
  76     Walk under the given directory, and yield every .cmd file found.
  77
  78     Args:
  79         directory: The directory to search for .cmd files.
  80
  81     Yields:
  82         The path to a .cmd file.
  83     """
  84
  85     filename_matcher = re.compile(_FILENAME_PATTERN)
  86     exclude_dirs = [ os.path.join(directory, d) for d in _EXCLUDE_DIRS ]
  87
  88     for dirpath, dirnames, filenames in os.walk(directory, topdown=True):
  89         # Prune unwanted directories.
  90         if dirpath in exclude_dirs:
  91             dirnames[:] = []
  92             continue
  93
  94         for filename in filenames:
  95             if filename_matcher.match(filename):
  96                 yield os.path.join(dirpath, filename)
  97
  98
  99 def to_cmdfile(path):
 100     """Return the path of .cmd file used for the given build artifact
 101
 102     Args:
 103         Path: file path
 104
 105     Returns:
 106         The path to .cmd file
 107     """
 108     dir, base = os.path.split(path)
 109     return os.path.join(dir, '.' + base + '.cmd')
 110
 111
 112 def cmdfiles_for_o(obj):
 113     """Generate the iterator of .cmd files associated with the object
 114
 115     Yield the .cmd file used to build the given object
 116
 117     Args:
 118         obj: The object path
 119
 120     Yields:
 121         The path to .cmd file
 122     """
 123     yield to_cmdfile(obj)
 124
 125
 126 def cmdfiles_for_a(archive, ar):
 127     """Generate the iterator of .cmd files associated with the archive.
 128
 129     Parse the given archive, and yield every .cmd file used to build it.
 130
 131     Args:
 132         archive: The archive to parse
 133
 134     Yields:
 135         The path to every .cmd file found
 136     """
 137     for obj in subprocess.check_output([ar, '-t', archive]).decode().split():
 138         yield to_cmdfile(obj)
 139
 140
 141 def cmdfiles_for_modorder(modorder):
 142     """Generate the iterator of .cmd files associated with the modules.order.
 143
 144     Parse the given modules.order, and yield every .cmd file used to build the
 145     contained modules.
 146
 147     Args:
 148         modorder: The modules.order file to parse
 149
 150     Yields:
 151         The path to every .cmd file found
 152     """
 153     with open(modorder) as f:
 154         for line in f:
 155             ko = line.rstrip()
 156             base, ext = os.path.splitext(ko)
 157             if ext != '.ko':
 158                 sys.exit('{}: module path must end with .ko'.format(ko))
 159             mod = base + '.mod'
 160             # The first line of *.mod lists the objects that compose the module.
 161             with open(mod) as m:
 162                 for obj in m.readline().split():
 163                     yield to_cmdfile(obj)
 164
 165
 166 def process_line(root_directory, command_prefix, file_path):
 167     """Extracts information from a .cmd line and creates an entry from it.
 168
 169     Args:
 170         root_directory: The directory that was searched for .cmd files. Usually
 171             used directly in the "directory" entry in compile_commands.json.
 172         command_prefix: The extracted command line, up to the last element.
 173         file_path: The .c file from the end of the extracted command.
 174             Usually relative to root_directory, but sometimes absolute.
 175
 176     Returns:
 177         An entry to append to compile_commands.
 178
 179     Raises:
 180         ValueError: Could not find the extracted file based on file_path and
 181             root_directory or file_directory.
 182     """
 183     # The .cmd files are intended to be included directly by Make, so they
 184     # escape the pound sign '#', either as '\#' or '$(pound)' (depending on the
 185     # kernel version). The compile_commands.json file is not interepreted
 186     # by Make, so this code replaces the escaped version with '#'.
 187     prefix = command_prefix.replace('\#', '#').replace('$(pound)', '#')
 188
 189     # Use os.path.abspath() to normalize the path resolving '.' and '..' .
 190     abs_path = os.path.abspath(os.path.join(root_directory, file_path))
 191     if not os.path.exists(abs_path):
 192         raise ValueError('File %s not found' % abs_path)
 193     return {
 194         'directory': root_directory,
 195         'file': abs_path,
 196         'command': prefix + file_path,
 197     }
 198
 199
 200 def main():
 201     """Walks through the directory and finds and parses .cmd files."""
 202     log_level, directory, output, ar, paths = parse_arguments()
 203
 204     level = getattr(logging, log_level)
 205     logging.basicConfig(format='%(levelname)s: %(message)s', level=level)
 206
 207     line_matcher = re.compile(_LINE_PATTERN)
 208
 209     compile_commands = []
 210
 211     for path in paths:
 212         # If 'path' is a directory, handle all .cmd files under it.
 213         # Otherwise, handle .cmd files associated with the file.
 214         # Most of built-in objects are linked via archives (built-in.a or lib.a)
 215         # but some objects are linked to vmlinux directly.
 216         # Modules are listed in modules.order.
 217         if os.path.isdir(path):
 218             cmdfiles = cmdfiles_in_dir(path)
 219         elif path.endswith('.o'):
 220             cmdfiles = cmdfiles_for_o(path)
 221         elif path.endswith('.a'):
 222             cmdfiles = cmdfiles_for_a(path, ar)
 223         elif path.endswith('modules.order'):
 224             cmdfiles = cmdfiles_for_modorder(path)
 225         else:
 226             sys.exit('{}: unknown file type'.format(path))
 227
 228         for cmdfile in cmdfiles:
 229             with open(cmdfile, 'rt') as f:
 230                 result = line_matcher.match(f.readline())
 231                 if result:
 232                     try:
 233                         entry = process_line(directory, result.group(1),
 234                                              result.group(2))
 235                         compile_commands.append(entry)
 236                     except ValueError as err:
 237                         logging.info('Could not add line from %s: %s',
 238                                      cmdfile, err)
 239
 240     with open(output, 'wt') as f:
 241         json.dump(compile_commands, f, indent=2, sort_keys=True)
 242
 243
 244 if __name__ == '__main__':
 245     main()