Debian Codegraph @

llvm-project/clang/tools/scan-build-py/lib/libscanbuild/__init__.py

raw
1 # -*- coding: utf-8 -*-
2 # Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
3 # See https://llvm.org/LICENSE.txt for license information.
4 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
5 """ This module is a collection of methods commonly used in this project. """
6 import collections
7 import functools
8 import json
9 import logging
10 import os
11 import os.path
12 import re
13 import shlex
14 import subprocess
15 import sys
16
17 ENVIRONMENT_KEY = 'INTERCEPT_BUILD'
18
19 Execution = collections.namedtuple('Execution', ['pid', 'cwd', 'cmd'])
20
21 CtuConfig = collections.namedtuple('CtuConfig', ['collect', 'analyze', 'dir',
22 'extdef_map_cmd'])
23
24
25 def duplicate_check(method):
26 """ Predicate to detect duplicated entries.
27
28 Unique hash method can be use to detect duplicates. Entries are
29 represented as dictionaries, which has no default hash method.
30 This implementation uses a set datatype to store the unique hash values.
31
32 This method returns a method which can detect the duplicate values. """
33
34 def predicate(entry):
35 entry_hash = predicate.unique(entry)
36 if entry_hash not in predicate.state:
37 predicate.state.add(entry_hash)
38 return False
39 return True
40
41 predicate.unique = method
42 predicate.state = set()
43 return predicate
44
45
46 def run_build(command, *args, **kwargs):
47 """ Run and report build command execution
48
49 :param command: array of tokens
50 :return: exit code of the process
51 """
52 environment = kwargs.get('env', os.environ)
53 logging.debug('run build %s, in environment: %s', command, environment)
54 exit_code = subprocess.call(command, *args, **kwargs)
55 logging.debug('build finished with exit code: %d', exit_code)
56 return exit_code
57
58
59 def run_command(command, cwd=None):
60 """ Run a given command and report the execution.
61
62 :param command: array of tokens
63 :param cwd: the working directory where the command will be executed
64 :return: output of the command
65 """
66 def decode_when_needed(result):
67 """ check_output returns bytes or string depend on python version """
68 return result.decode('utf-8') if isinstance(result, bytes) else result
69
70 try:
71 directory = os.path.abspath(cwd) if cwd else os.getcwd()
72 logging.debug('exec command %s in %s', command, directory)
73 output = subprocess.check_output(command,
74 cwd=directory,
75 stderr=subprocess.STDOUT)
76 return decode_when_needed(output).splitlines()
77 except subprocess.CalledProcessError as ex:
78 ex.output = decode_when_needed(ex.output).splitlines()
79 raise ex
80
81
82 def reconfigure_logging(verbose_level):
83 """ Reconfigure logging level and format based on the verbose flag.
84
85 :param verbose_level: number of `-v` flags received by the command
86 :return: no return value
87 """
88 # Exit when nothing to do.
89 if verbose_level == 0:
90 return
91
92 root = logging.getLogger()
93 # Tune logging level.
94 level = logging.WARNING - min(logging.WARNING, (10 * verbose_level))
95 root.setLevel(level)
96 # Be verbose with messages.
97 if verbose_level <= 3:
98 fmt_string = '%(name)s: %(levelname)s: %(message)s'
99 else:
100 fmt_string = '%(name)s: %(levelname)s: %(funcName)s: %(message)s'
101 handler = logging.StreamHandler(sys.stdout)
102 handler.setFormatter(logging.Formatter(fmt=fmt_string))
103 root.handlers = [handler]
104
105
106 def command_entry_point(function):
107 """ Decorator for command entry methods.
108
109 The decorator initialize/shutdown logging and guard on programming
110 errors (catch exceptions).
111
112 The decorated method can have arbitrary parameters, the return value will
113 be the exit code of the process. """
114
115 @functools.wraps(function)
116 def wrapper(*args, **kwargs):
117 """ Do housekeeping tasks and execute the wrapped method. """
118
119 try:
120 logging.basicConfig(format='%(name)s: %(message)s',
121 level=logging.WARNING,
122 stream=sys.stdout)
123 # This hack to get the executable name as %(name).
124 logging.getLogger().name = os.path.basename(sys.argv[0])
125 return function(*args, **kwargs)
126 except KeyboardInterrupt:
127 logging.warning('Keyboard interrupt')
128 return 130 # Signal received exit code for bash.
129 except Exception:
130 logging.exception('Internal error.')
131 if logging.getLogger().isEnabledFor(logging.DEBUG):
132 logging.error("Please report this bug and attach the output "
133 "to the bug report")
134 else:
135 logging.error("Please run this command again and turn on "
136 "verbose mode (add '-vvvv' as argument).")
137 return 64 # Some non used exit code for internal errors.
138 finally:
139 logging.shutdown()
140
141 return wrapper
142
143
144 def compiler_wrapper(function):
145 """ Implements compiler wrapper base functionality.
146
147 A compiler wrapper executes the real compiler, then implement some
148 functionality, then returns with the real compiler exit code.
149
150 :param function: the extra functionality what the wrapper want to
151 do on top of the compiler call. If it throws exception, it will be
152 caught and logged.
153 :return: the exit code of the real compiler.
154
155 The :param function: will receive the following arguments:
156
157 :param result: the exit code of the compilation.
158 :param execution: the command executed by the wrapper. """
159
160 def is_cxx_compiler():
161 """ Find out was it a C++ compiler call. Compiler wrapper names
162 contain the compiler type. C++ compiler wrappers ends with `c++`,
163 but might have `.exe` extension on windows. """
164
165 wrapper_command = os.path.basename(sys.argv[0])
166 return re.match(r'(.+)c\+\+(.*)', wrapper_command)
167
168 def run_compiler(executable):
169 """ Execute compilation with the real compiler. """
170
171 command = executable + sys.argv[1:]
172 logging.debug('compilation: %s', command)
173 result = subprocess.call(command)
174 logging.debug('compilation exit code: %d', result)
175 return result
176
177 # Get relevant parameters from environment.
178 parameters = json.loads(os.environ[ENVIRONMENT_KEY])
179 reconfigure_logging(parameters['verbose'])
180 # Execute the requested compilation. Do crash if anything goes wrong.
181 cxx = is_cxx_compiler()
182 compiler = parameters['cxx'] if cxx else parameters['cc']
183 result = run_compiler(compiler)
184 # Call the wrapped method and ignore it's return value.
185 try:
186 call = Execution(
187 pid=os.getpid(),
188 cwd=os.getcwd(),
189 cmd=['c++' if cxx else 'cc'] + sys.argv[1:])
190 function(result, call)
191 except:
192 logging.exception('Compiler wrapper failed complete.')
193 finally:
194 # Always return the real compiler exit code.
195 return result
196
197
198 def wrapper_environment(args):
199 """ Set up environment for interpose compiler wrapper."""
200
201 return {
202 ENVIRONMENT_KEY: json.dumps({
203 'verbose': args.verbose,
204 'cc': shlex.split(args.cc),
205 'cxx': shlex.split(args.cxx)
206 })
207 }