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 run_quick_check(args,
context,
actions):
"""
This function implements the "quickcheck" feature.
No result is stored to a database.
"""
enabled_analyzers = analyzer_types. \
check_supported_analyzers(args.analyzers, context)
actions = prepare_actions(actions, enabled_analyzers)
analyzer_config_map = \
analyzer_types.build_config_handlers(args,
context,
enabled_analyzers)
__print_analyzer_version(context, analyzer_config_map)
LOG.info("Static analysis is starting ...")
analysis_manager.start_workers(args, actions, context, analyzer_config_map,
_get_skip_handler(args), False)
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 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)