scripts/gen_compile_commands.py

   1 #!/usr/bin/env python
   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
  16 _DEFAULT_OUTPUT = 'compile_commands.json'
  17 _DEFAULT_LOG_LEVEL = 'WARNING'
  18
  19 _FILENAME_PATTERN = r'^\..*\.cmd$'
  20 _LINE_PATTERN = r'^cmd_[^ ]*\.o := (.* )([^ ]*\.c)$'
  21 _VALID_LOG_LEVELS = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL']
  22
  23 # A kernel build generally has over 2000 entries in its compile_commands.json
  24 # database. If this code finds 300 or fewer, then warn the user that they might
  25 # not have all the .cmd files, and they might need to compile the kernel.
  26 _LOW_COUNT_THRESHOLD = 300
  27
  28
  29 def parse_arguments():
  30     """Sets up and parses command-line arguments.
  31
  32     Returns:
  33         log_level: A logging level to filter log output.
  34         directory: The work directory where the objects were built.
  35         output: Where to write the compile-commands JSON file.
  36         paths: The list of 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     args = parser.parse_args()
  57
  58     return (args.log_level,
  59             os.path.abspath(args.directory),
  60             args.output,
  61             [args.directory])
  62
  63
  64 def cmdfiles_in_dir(directory):
  65     """Generate the iterator of .cmd files found under the directory.
  66
  67     Walk under the given directory, and yield every .cmd file found.
  68
  69     Args:
  70         directory: The directory to search for .cmd files.
  71
  72     Yields:
  73         The path to a .cmd file.
  74     """
  75
  76     filename_matcher = re.compile(_FILENAME_PATTERN)
  77
  78     for dirpath, _, filenames in os.walk(directory):
  79         for filename in filenames:
  80             if filename_matcher.match(filename):
  81                 yield os.path.join(dirpath, filename)
  82
  83
  84 def process_line(root_directory, command_prefix, file_path):
  85     """Extracts information from a .cmd line and creates an entry from it.
  86
  87     Args:
  88         root_directory: The directory that was searched for .cmd files. Usually
  89             used directly in the "directory" entry in compile_commands.json.
  90         command_prefix: The extracted command line, up to the last element.
  91         file_path: The .c file from the end of the extracted command.
  92             Usually relative to root_directory, but sometimes absolute.
  93
  94     Returns:
  95         An entry to append to compile_commands.
  96
  97     Raises:
  98         ValueError: Could not find the extracted file based on file_path and
  99             root_directory or file_directory.
 100     """
 101     # The .cmd files are intended to be included directly by Make, so they
 102     # escape the pound sign '#', either as '\#' or '$(pound)' (depending on the
 103     # kernel version). The compile_commands.json file is not interepreted
 104     # by Make, so this code replaces the escaped version with '#'.
 105     prefix = command_prefix.replace('\#', '#').replace('$(pound)', '#')
 106
 107     # Use os.path.abspath() to normalize the path resolving '.' and '..' .
 108     abs_path = os.path.abspath(os.path.join(root_directory, file_path))
 109     if not os.path.exists(abs_path):
 110         raise ValueError('File %s not found' % abs_path)
 111     return {
 112         'directory': root_directory,
 113         'file': abs_path,
 114         'command': prefix + file_path,
 115     }
 116
 117
 118 def main():
 119     """Walks through the directory and finds and parses .cmd files."""
 120     log_level, directory, output, paths = parse_arguments()
 121
 122     level = getattr(logging, log_level)
 123     logging.basicConfig(format='%(levelname)s: %(message)s', level=level)
 124
 125     line_matcher = re.compile(_LINE_PATTERN)
 126
 127     compile_commands = []
 128
 129     for path in paths:
 130         cmdfiles = cmdfiles_in_dir(path)
 131
 132         for cmdfile in cmdfiles:
 133             with open(cmdfile, 'rt') as f:
 134                 result = line_matcher.match(f.readline())
 135                 if result:
 136                     try:
 137                         entry = process_line(directory, result.group(1),
 138                                              result.group(2))
 139                         compile_commands.append(entry)
 140                     except ValueError as err:
 141                         logging.info('Could not add line from %s: %s',
 142                                      cmdfile, err)
 143
 144     with open(output, 'wt') as f:
 145         json.dump(compile_commands, f, indent=2, sort_keys=True)
 146
 147     count = len(compile_commands)
 148     if count < _LOW_COUNT_THRESHOLD:
 149         logging.warning(
 150             'Found %s entries. Have you compiled the kernel?', count)
 151
 152
 153 if __name__ == '__main__':
 154     main()