def main(args):
"""
List the analyzers' basic information supported by CodeChecker.
"""
logger.setup_logger(args.verbose if 'verbose' in args else None)
context = generic_package_context.get_context()
working, errored = \
analyzer_types.check_supported_analyzers(
analyzer_types.supported_analyzers,
context)
if args.dump_config:
binary = context.analyzer_binaries.get(args.dump_config)
if args.dump_config == 'clang-tidy':
subprocess.call([binary, '-dump-config', '-checks=*'])
elif args.dump_config == 'clangsa':
# TODO: Not supported by ClangSA yet!
LOG.warning("'--dump-config clangsa' is not supported yet.")
return
if args.output_format not in ['csv', 'json']:
if 'details' not in args:
header = ['Name']
else:
header = ['Name', 'Path', 'Version']
else:
if 'details' not in args:
header = ['name']
else:
header = ['name', 'path', 'version_string']
rows = []
for analyzer in working:
if 'details' not in args:
rows.append([analyzer])
else:
binary = context.analyzer_binaries.get(analyzer)
try:
version = subprocess.check_output([binary, '--version'])
except (subprocess.CalledProcessError, OSError):
version = 'ERROR'
rows.append([analyzer, binary, version])
if 'all' in args:
for analyzer, err_reason in errored:
if 'details' not in args:
rows.append([analyzer])
else:
rows.append([
analyzer,
context.analyzer_binaries.get(analyzer), err_reason
])
if len(rows) > 0:
print(output_formatters.twodim_to_str(args.output_format, header,
rows))
def is_statistics_capable(context):
""" Detects if the current clang is Statistics compatible. """
# Resolve potentially missing binaries.
check_supported_analyzers([ClangSA.ANALYZER_NAME], context)
clangsa_cfg = ClangSA.construct_config_handler([], context)
check_env = analyzer_env.get_check_env(context.path_env_extra,
context.ld_lib_path_extra)
checkers = ClangSA.get_analyzer_checkers(clangsa_cfg, check_env)
stat_checkers_pattern = re.compile(r'.+statisticscollector.+')
for checker_name, _ in checkers:
if stat_checkers_pattern.match(checker_name):
return True
return False
def add_arguments_to_parser(parser):
"""
Add the subcommand's arguments to the given argparse.ArgumentParser.
"""
context = generic_package_context.get_context()
working, _ = analyzer_types.check_supported_analyzers(
analyzer_types.supported_analyzers, context)
parser.add_argument('--all',
dest="all",
action='store_true',
default=argparse.SUPPRESS,
required=False,
help="Show all supported analyzers, not just the "
"available ones.")
parser.add_argument('--details',
dest="details",
action='store_true',
default=argparse.SUPPRESS,
required=False,
help="Show details about the analyzers, not just "
"their names.")
parser.add_argument('--dump-config',
dest='dump_config',
required=False,
choices=list(working),
help="Dump the available checker options for the "
"given analyzer to the standard output. "
"Currently only clang-tidy supports this option. "
"The output can be redirected to a file named "
".clang-tidy. If this file is placed to the "
"project directory then the options are applied "
"to the files under that directory. This config "
"file can also be provided via "
"'CodeChecker analyze' and 'CodeChecker check' "
"commands.")
parser.add_argument('-o',
'--output',
dest='output_format',
required=False,
default='rows',
choices=output_formatters.USER_FORMATS,
help="Specify the format of the output list.")
logger.add_verbose_arguments(parser)
parser.set_defaults(func=main)
def main(args):
"""
List the analyzers' basic information supported by CodeChecker.
"""
context = generic_package_context.get_context()
working, errored = \
analyzer_types.check_supported_analyzers(
analyzer_types.supported_analyzers,
context)
if args.output_format not in ['csv', 'json']:
if 'details' not in args:
header = ['Name']
else:
header = ['Name', 'Path', 'Version']
else:
if 'details' not in args:
header = ['name']
else:
header = ['name', 'path', 'version_string']
rows = []
for analyzer in working:
if 'details' not in args:
rows.append([analyzer])
else:
binary = context.analyzer_binaries.get(analyzer)
try:
version = subprocess.check_output([binary,
'--version'])
except (subprocess.CalledProcessError, OSError):
version = 'ERROR'
rows.append([analyzer,
binary,
version])
if 'all' in args:
for analyzer, err_reason in errored:
if 'details' not in args:
rows.append([analyzer])
else:
rows.append([analyzer,
context.analyzer_binaries.get(analyzer),
err_reason])
if len(rows) > 0:
print(output_formatters.twodim_to_str(args.output_format,
header, rows))
def perform_analysis(args, context, actions, metadata):
"""
Perform static analysis via the given (or if not, all) analyzers,
in the given analysis context for the supplied build actions.
Additionally, insert statistical information into the metadata dict.
"""
analyzers = args.analyzers if 'analyzers' in args \
else analyzer_types.supported_analyzers
analyzers, _ = analyzer_types.check_supported_analyzers(analyzers, context)
actions = prepare_actions(actions, analyzers)
config_map = analyzer_types.build_config_handlers(args, context, analyzers)
# Save some metadata information.
versions = __get_analyzer_version(context, config_map)
metadata['versions'].update(versions)
metadata['checkers'] = {}
for analyzer in analyzers:
metadata['checkers'][analyzer] = []
for check, data in config_map[analyzer].checks().items():
enabled, _ = data
if not enabled:
continue
metadata['checkers'][analyzer].append(check)
# Run analysis.
LOG.info("Starting static analysis ...")
start_time = time.time()
analysis_manager.start_workers(actions, context, config_map,
args.jobs, args.output_path,
__get_skip_handler(args), metadata)
end_time = time.time()
LOG.info("Analysis length: " + str(end_time - start_time) + " sec.")
metadata['timestamps'] = {'begin': start_time, 'end': end_time}
def perform_analysis(args, context, actions, metadata):
"""
Perform static analysis via the given (or if not, all) analyzers,
in the given analysis context for the supplied build actions.
Additionally, insert statistical information into the metadata dict.
"""
analyzers = args.analyzers if 'analyzers' in args \
else analyzer_types.supported_analyzers
analyzers, _ = analyzer_types.check_supported_analyzers(
analyzers, context)
ctu_collect = False
ctu_analyze = False
ctu_dir = ''
if 'ctu_phases' in args:
ctu_collect = args.ctu_phases[0]
ctu_analyze = args.ctu_phases[1]
ctu_dir = os.path.join(args.output_path, 'ctu-dir')
args.ctu_dir = ctu_dir
if analyzer_types.CLANG_SA not in analyzers:
LOG.error("CTU can only be used with the clang static analyzer.")
return
if 'stats_enabled' in args and args.stats_enabled:
if analyzer_types.CLANG_SA not in analyzers:
LOG.debug("Statistics can only be used with "
"the Clang Static Analyzer.")
return
actions = prepare_actions(actions, analyzers)
config_map = analyzer_types.build_config_handlers(args, context, analyzers)
# Save some metadata information.
versions = __get_analyzer_version(context, config_map)
metadata['versions'].update(versions)
metadata['checkers'] = {}
for analyzer in analyzers:
metadata['checkers'][analyzer] = []
for check, data in config_map[analyzer].checks().items():
enabled, _ = data
if not enabled:
continue
metadata['checkers'][analyzer].append(check)
if ctu_collect:
shutil.rmtree(ctu_dir, ignore_errors=True)
elif ctu_analyze and not os.path.exists(ctu_dir):
LOG.error("CTU directory:'" + ctu_dir + "' does not exist.")
return
start_time = time.time()
# Use Manager to create data objects which can be
# safely shared between processes.
manager = Manager()
config_map = manager.dict(config_map)
actions_map = create_actions_map(actions, manager)
# Setting to not None value will enable statistical analysis features.
statistics_data = None
if 'stats_enabled' in args and args.stats_enabled:
statistics_data = manager.dict({
'stats_out_dir': os.path.join(args.output_path, "stats")})
if 'stats_output' in args and args.stats_output:
statistics_data = manager.dict({'stats_out_dir':
args.stats_output})
skip_handler = __get_skip_handler(args)
if ctu_collect or statistics_data:
ctu_data = None
if ctu_collect or ctu_analyze:
ctu_data = manager.dict({'ctu_dir': ctu_dir,
'ctu_func_map_file': 'externalFnMap.txt',
'ctu_temp_fnmap_folder':
'tmpExternalFnMaps'})
pre_analyze = [a for a in actions
if a.analyzer_type == analyzer_types.CLANG_SA]
pre_analysis_manager.run_pre_analysis(pre_analyze,
context,
config_map,
args.jobs,
skip_handler,
ctu_data,
statistics_data)
if 'stats_output' in args and args.stats_output:
return
if 'stats_dir' in args and args.stats_dir:
statistics_data = manager.dict({'stats_out_dir': args.stats_dir})
ctu_reanalyze_on_failure = 'ctu_reanalyze_on_failure' in args and \
args.ctu_reanalyze_on_failure
if ctu_analyze or statistics_data or (not ctu_analyze and not ctu_collect):
LOG.info("Starting static analysis ...")
analysis_manager.start_workers(actions_map, actions, context,
config_map, args.jobs,
args.output_path,
skip_handler,
metadata,
'quiet' in args,
'capture_analysis_output' in args,
args.timeout if 'timeout' in args
else None,
ctu_reanalyze_on_failure,
statistics_data)
LOG.info("Analysis finished.")
LOG.info("To view results in the terminal use the "
"\"CodeChecker parse\" command.")
LOG.info("To store results use the \"CodeChecker store\" command.")
LOG.info("See --help and the user guide for further options about"
" parsing and storing the reports.")
LOG.info("----=================----")
end_time = time.time()
LOG.info("Analysis length: " + str(end_time - start_time) + " sec.")
metadata['timestamps'] = {'begin': start_time,
'end': end_time}
# Remove previous skip file if there was any.
skip_file_to_send = os.path.join(args.output_path, 'skip_file')
if os.path.exists(skip_file_to_send):
os.remove(skip_file_to_send)
if 'skipfile' in args:
LOG.debug("Copying skip file %s to %s",
args.skipfile, skip_file_to_send)
shutil.copyfile(args.skipfile, skip_file_to_send)
if ctu_collect and ctu_analyze:
shutil.rmtree(ctu_dir, ignore_errors=True)
def main(args):
"""
List the checkers available in the specified (or all supported) analyzers
alongside with their description or enabled status in various formats.
"""
logger.setup_logger(args.verbose if 'verbose' in args else None)
# If nothing is set, list checkers for all supported analyzers.
analyzers = args.analyzers \
if 'analyzers' in args \
else analyzer_types.supported_analyzers
context = package_context.get_context()
working, errored = analyzer_types.check_supported_analyzers(
analyzers, context)
analyzer_environment = analyzer_env.get_check_env(
context.path_env_extra, context.ld_lib_path_extra)
analyzer_config_map = analyzer_types.build_config_handlers(
args, context, working)
# List available checker profiles.
if 'profile' in args and args.profile == 'list':
if 'details' not in args:
if args.output_format not in ['csv', 'json']:
header = ['Profile name']
else:
header = ['profile_name']
else:
if args.output_format not in ['csv', 'json']:
header = ['Profile name', 'Description']
else:
header = ['profile_name', 'description']
rows = []
for (profile, description) in context.available_profiles.items():
if 'details' not in args:
rows.append([profile])
else:
rows.append([profile, description])
print(output_formatters.twodim_to_str(args.output_format, header,
rows))
return
# Use good looking different headers based on format.
if 'details' not in args:
if args.output_format not in ['csv', 'json']:
header = ['Name']
else:
header = ['name']
else:
if args.output_format not in ['csv', 'json']:
header = ['', 'Name', 'Analyzer', 'Severity', 'Description']
else:
header = ['enabled', 'name', 'analyzer', 'severity', 'description']
rows = []
for analyzer in working:
config_handler = analyzer_config_map.get(analyzer)
analyzer_class = \
analyzer_types.supported_analyzers[analyzer]
checkers = analyzer_class.get_analyzer_checkers(
config_handler, analyzer_environment)
default_checker_cfg = context.checker_config.get(analyzer +
'_checkers')
profile_checkers = None
if 'profile' in args:
if args.profile not in context.available_profiles:
LOG.error("Checker profile '" + args.profile +
"' does not exist!")
LOG.error("To list available profiles, use '--profile list'.")
return
profile_checkers = [(args.profile, True)]
config_handler.initialize_checkers(context.available_profiles,
context.package_root, checkers,
default_checker_cfg,
profile_checkers)
for checker_name, value in config_handler.checks().items():
enabled, description = value
if not enabled and 'profile' in args:
continue
if enabled and 'only_disabled' in args:
continue
elif not enabled and 'only_enabled' in args:
continue
if args.output_format != 'json':
enabled = '+' if enabled else '-'
if 'details' not in args:
rows.append([checker_name])
else:
severity = context.severity_map.get(checker_name)
rows.append(
[enabled, checker_name, analyzer, severity, description])
if len(rows) > 0:
print(output_formatters.twodim_to_str(args.output_format, header,
rows))
for analyzer_binary, reason in errored:
LOG.error("Failed to get checkers for '" + analyzer_binary +
"'! The error reason was: '" + reason + "'")
LOG.error("Please check your installation and the "
"'config/package_layout.json' file!")
def run_check(args, actions, context):
"""
Prepare:
- analyzer config handlers
- skiplist handling
- analyzer severity levels
Stores analysis related data to the database and starts the analysis.
"""
if args.jobs <= 0:
args.jobs = 1
LOG.debug_analyzer("Checking supported analyzers.")
enabled_analyzers = analyzer_types.check_supported_analyzers(
args.analyzers,
context)
actions = prepare_actions(actions, enabled_analyzers)
suppress_file = ''
try:
suppress_file = os.path.realpath(args.suppress)
except AttributeError:
LOG.debug_analyzer('Suppress file was not set in the command line.')
# Create one skip list handler shared between the analysis manager workers.
skip_handler = _get_skip_handler(args)
with client.get_connection() as connection:
context.run_id = connection.add_checker_run(' '.join(sys.argv),
args.name,
context.version,
args.force)
# Clean previous suppress information.
client.clean_suppress(connection, context.run_id)
if os.path.exists(suppress_file):
client.send_suppress(context.run_id, connection, suppress_file)
analyzer_config_map = analyzer_types. \
build_config_handlers(args,
context,
enabled_analyzers,
connection)
if skip_handler:
connection.add_skip_paths(context.run_id,
skip_handler.get_skiplist())
__print_analyzer_version(context, analyzer_config_map)
LOG.info("Static analysis is starting ...")
start_time = time.time()
analysis_manager.start_workers(args,
actions,
context,
analyzer_config_map,
skip_handler)
end_time = time.time()
with client.get_connection() as connection:
connection.finish_checker_run(context.run_id)
LOG.info("Analysis length: " + str(end_time - start_time) + " sec.")
def perform_analysis(args, context, actions, metadata):
"""
Perform static analysis via the given (or if not, all) analyzers,
in the given analysis context for the supplied build actions.
Additionally, insert statistical information into the metadata dict.
"""
analyzers = args.analyzers if 'analyzers' in args \
else analyzer_types.supported_analyzers
analyzers, _ = analyzer_types.check_supported_analyzers(
analyzers, context)
ctu_collect = False
ctu_analyze = False
ctu_dir = ''
if 'ctu_phases' in args:
ctu_collect = args.ctu_phases[0]
ctu_analyze = args.ctu_phases[1]
ctu_dir = os.path.join(args.output_path, 'ctu-dir')
args.ctu_dir = ctu_dir
if analyzer_types.CLANG_SA not in analyzers:
LOG.error("CTU can only be used with the clang static analyzer.")
return
actions = prepare_actions(actions, analyzers)
config_map = analyzer_types.build_config_handlers(args, context, analyzers)
# Save some metadata information.
versions = __get_analyzer_version(context, config_map)
metadata['versions'].update(versions)
metadata['checkers'] = {}
for analyzer in analyzers:
metadata['checkers'][analyzer] = []
for check, data in config_map[analyzer].checks().items():
enabled, _ = data
if not enabled:
continue
metadata['checkers'][analyzer].append(check)
if ctu_collect:
shutil.rmtree(ctu_dir, ignore_errors=True)
elif ctu_analyze and not os.path.exists(ctu_dir):
LOG.error("CTU directory:'" + ctu_dir + "' does not exist.")
return
# Run analysis.
LOG.info("Starting static analysis ...")
start_time = time.time()
if ctu_collect:
ctu_manager.do_ctu_collect(actions, context, config_map, args.jobs,
__get_skip_handler(args), ctu_dir)
if ctu_analyze or (not ctu_analyze and not ctu_collect):
analysis_manager.start_workers(actions, context, config_map,
args.jobs, args.output_path,
__get_skip_handler(args),
metadata,
'quiet' in args,
'capture_analysis_output' in args)
end_time = time.time()
LOG.info("Analysis length: " + str(end_time - start_time) + " sec.")
metadata['timestamps'] = {'begin': start_time,
'end': end_time}
if ctu_collect and ctu_analyze:
shutil.rmtree(ctu_dir, ignore_errors=True)
def main(args):
"""
List the checkers available in the specified (or all supported) analyzers
alongside with their description or enabled status in various formats.
"""
# If nothing is set, list checkers for all supported analyzers.
analyzers = args.analyzers \
if 'analyzers' in args \
else analyzer_types.supported_analyzers
context = generic_package_context.get_context()
working, errored = analyzer_types.check_supported_analyzers(analyzers,
context)
analyzer_environment = analyzer_env.get_check_env(
context.path_env_extra, context.ld_lib_path_extra)
analyzer_config_map = analyzer_types.build_config_handlers(args,
context,
working)
# Use good looking different headers based on format.
if not args.details:
if args.output_format not in ['csv', 'json']:
header = ['Name']
else:
header = ['name']
else:
if args.output_format not in ['csv', 'json']:
header = ['', 'Name', 'Analyzer', 'Severity', 'Description']
else:
header = ['enabled', 'name', 'analyzer', 'severity', 'description']
rows = []
for analyzer in working:
config_handler = analyzer_config_map.get(analyzer)
source_analyzer = \
analyzer_types.construct_analyzer_type(analyzer,
config_handler,
None)
checkers = source_analyzer.get_analyzer_checkers(config_handler,
analyzer_environment)
default_checker_cfg = context.default_checkers_config.get(
analyzer + '_checkers')
analyzer_types.initialize_checkers(config_handler,
checkers,
default_checker_cfg)
for checker_name, value in config_handler.checks().items():
enabled, description = value
if enabled and args.only_disabled:
continue
elif not enabled and args.only_enabled:
continue
if args.output_format != 'json':
enabled = '+' if enabled else '-'
if not args.details:
rows.append([checker_name])
else:
severity = context.severity_map.get(checker_name,
'UNSPECIFIED')
rows.append([enabled, checker_name, analyzer,
severity, description])
if len(rows) > 0:
print(output_formatters.twodim_to_str(args.output_format,
header, rows))
for analyzer_binary, reason in errored:
LOG.error("Failed to get checkers for '" + analyzer_binary +
"'! The error reason was: '" + reason + "'")
LOG.error("Please check your installation and the "
"'config/package_layout.json' file!")