Commit | Line | Data |
---|---|---|
b3020464 TR |
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 500 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 = 500 | |
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 directory to search for .cmd files. | |
35 | output: Where to write the compile-commands JSON file. | |
36 | """ | |
37 | usage = 'Creates a compile_commands.json database from kernel .cmd files' | |
38 | parser = argparse.ArgumentParser(description=usage) | |
39 | ||
40 | directory_help = ('Path to the kernel source directory to search ' | |
41 | '(defaults to the working directory)') | |
42 | parser.add_argument('-d', '--directory', type=str, help=directory_help) | |
43 | ||
44 | output_help = ('The location to write compile_commands.json (defaults to ' | |
45 | 'compile_commands.json in the search directory)') | |
46 | parser.add_argument('-o', '--output', type=str, help=output_help) | |
47 | ||
48 | log_level_help = ('The level of log messages to produce (one of ' + | |
49 | ', '.join(_VALID_LOG_LEVELS) + '; defaults to ' + | |
50 | _DEFAULT_LOG_LEVEL + ')') | |
51 | parser.add_argument( | |
52 | '--log_level', type=str, default=_DEFAULT_LOG_LEVEL, | |
53 | help=log_level_help) | |
54 | ||
55 | args = parser.parse_args() | |
56 | ||
57 | log_level = args.log_level | |
58 | if log_level not in _VALID_LOG_LEVELS: | |
59 | raise ValueError('%s is not a valid log level' % log_level) | |
60 | ||
61 | directory = args.directory or os.getcwd() | |
62 | output = args.output or os.path.join(directory, _DEFAULT_OUTPUT) | |
63 | directory = os.path.abspath(directory) | |
64 | ||
65 | return log_level, directory, output | |
66 | ||
67 | ||
68 | def process_line(root_directory, file_directory, command_prefix, relative_path): | |
69 | """Extracts information from a .cmd line and creates an entry from it. | |
70 | ||
71 | Args: | |
72 | root_directory: The directory that was searched for .cmd files. Usually | |
73 | used directly in the "directory" entry in compile_commands.json. | |
74 | file_directory: The path to the directory the .cmd file was found in. | |
75 | command_prefix: The extracted command line, up to the last element. | |
76 | relative_path: The .c file from the end of the extracted command. | |
77 | Usually relative to root_directory, but sometimes relative to | |
78 | file_directory and sometimes neither. | |
79 | ||
80 | Returns: | |
81 | An entry to append to compile_commands. | |
82 | ||
83 | Raises: | |
84 | ValueError: Could not find the extracted file based on relative_path and | |
85 | root_directory or file_directory. | |
86 | """ | |
87 | # The .cmd files are intended to be included directly by Make, so they | |
88 | # escape the pound sign '#', either as '\#' or '$(pound)' (depending on the | |
89 | # kernel version). The compile_commands.json file is not interepreted | |
90 | # by Make, so this code replaces the escaped version with '#'. | |
91 | prefix = command_prefix.replace('\#', '#').replace('$(pound)', '#') | |
92 | ||
93 | cur_dir = root_directory | |
94 | expected_path = os.path.join(cur_dir, relative_path) | |
95 | if not os.path.exists(expected_path): | |
96 | # Try using file_directory instead. Some of the tools have a different | |
97 | # style of .cmd file than the kernel. | |
98 | cur_dir = file_directory | |
99 | expected_path = os.path.join(cur_dir, relative_path) | |
100 | if not os.path.exists(expected_path): | |
101 | raise ValueError('File %s not in %s or %s' % | |
102 | (relative_path, root_directory, file_directory)) | |
103 | return { | |
104 | 'directory': cur_dir, | |
105 | 'file': relative_path, | |
106 | 'command': prefix + relative_path, | |
107 | } | |
108 | ||
109 | ||
110 | def main(): | |
111 | """Walks through the directory and finds and parses .cmd files.""" | |
112 | log_level, directory, output = parse_arguments() | |
113 | ||
114 | level = getattr(logging, log_level) | |
115 | logging.basicConfig(format='%(levelname)s: %(message)s', level=level) | |
116 | ||
117 | filename_matcher = re.compile(_FILENAME_PATTERN) | |
118 | line_matcher = re.compile(_LINE_PATTERN) | |
119 | ||
120 | compile_commands = [] | |
121 | for dirpath, _, filenames in os.walk(directory): | |
122 | for filename in filenames: | |
123 | if not filename_matcher.match(filename): | |
124 | continue | |
125 | filepath = os.path.join(dirpath, filename) | |
126 | ||
127 | with open(filepath, 'rt') as f: | |
128 | for line in f: | |
129 | result = line_matcher.match(line) | |
130 | if not result: | |
131 | continue | |
132 | ||
133 | try: | |
134 | entry = process_line(directory, dirpath, | |
135 | result.group(1), result.group(2)) | |
136 | compile_commands.append(entry) | |
137 | except ValueError as err: | |
138 | logging.info('Could not add line from %s: %s', | |
139 | filepath, err) | |
140 | ||
141 | with open(output, 'wt') as f: | |
142 | json.dump(compile_commands, f, indent=2, sort_keys=True) | |
143 | ||
144 | count = len(compile_commands) | |
145 | if count < _LOW_COUNT_THRESHOLD: | |
146 | logging.warning( | |
147 | 'Found %s entries. Have you compiled the kernel?', count) | |
148 | ||
149 | ||
150 | if __name__ == '__main__': | |
151 | main() |