| #!/usr/bin/env python |
| # |
| # Copyright 2017, Data61, CSIRO (ABN 41 687 119 230) |
| # |
| # SPDX-License-Identifier: BSD-2-Clause |
| # |
| |
| # |
| # To use this coverage script, run a binary with qemu, passing the |
| # "-singlestep" and "-d exec" options. You will probably also want to use -D to |
| # prevent the log going to stderr. Note that this logging only works on newer |
| # versions of qemu. |
| # |
| # coverage.py staging/arm/imx31/kernel.elf /tmp/qemu.log --functions --objdump | less -R |
| # |
| |
| import sys |
| import os |
| import re |
| import argparse |
| from subprocess import Popen, PIPE |
| |
| |
| class Colors(object): |
| def __init__(self, use_color): |
| c = {} |
| c['NORMAL'] = '\033[0m' |
| c['BLACK'] = '\033[0;30m' |
| c['DARK_RED'] = '\033[0;31m' |
| c['DARK_GREEN'] = '\033[0;32m' |
| c['DARK_YELLOW'] = '\033[0;33m' |
| c['DARK_BLUE'] = '\033[0;34m' |
| c['DARK_MAGENTA'] = '\033[0;35m' |
| c['DARK_CYAN'] = '\033[0;36m' |
| c['GREY'] = '\033[0;37m' |
| c['LIGHT_GREY'] = '\033[1;30m' |
| c['LIGHT_RED'] = '\033[1;31m' |
| c['LIGHT_GREEN'] = '\033[1;32m' |
| c['LIGHT_YELLOW'] = '\033[1;33m' |
| c['LIGHT_BLUE'] = '\033[1;34m' |
| c['LIGHT_MAGENTA'] = '\033[1;35m' |
| c['LIGHT_CYAN'] = '\033[1;36m' |
| c['WHITE'] = '\033[1;37m' |
| |
| if use_color: |
| self.c = c |
| else: |
| self.c = dict([(x, '') for x in c.keys()]) |
| |
| def __getattr__(self, name): |
| if name in self.c: |
| return self.c[name] |
| else: |
| return object.__getattribute__(self, name) |
| |
| |
| def get_tool(toolname): |
| default_prefix = 'arm-none-eabi-' |
| |
| return os.environ.get('TOOLPREFIX', default_prefix) + toolname |
| |
| |
| def main(): |
| parser = argparse.ArgumentParser( |
| description='Generate coverage information of a binary.') |
| parser.add_argument('kernel_elf_filename', metavar='<kernel ELF>', |
| type=str, help='The kernel ELF file used for the log.') |
| parser.add_argument('coverage_filename', metavar='<qemu log>', |
| type=str, help='The qemu logfile containing the instruction trace.') |
| parser.add_argument('--functions', action='store_true', |
| help='Produce a summary of the functions covered.') |
| parser.add_argument('--objdump', action='store_true', |
| help='Produce an objdump with coverage information.') |
| parser.add_argument('--no-color', action='store_true', default=False, |
| help='Produce coloured output.') |
| |
| args = parser.parse_args() |
| colors = Colors(not args.no_color) |
| |
| # We will need to run objdump on the ELF file. |
| kernel_elf_filename = args.kernel_elf_filename |
| |
| # This is the raw qemu.log file. |
| coverage_filename = args.coverage_filename |
| |
| # Run objdump on the kernel binary. |
| objdump_proc = Popen([get_tool('objdump'), '-d', '-j', '.text', |
| kernel_elf_filename], stdout=PIPE) |
| objdump_lines = objdump_proc.stdout.readlines() |
| |
| seL4_arm_vector_table_address = None |
| |
| # Now, parse the objdump file and retain the following data: |
| |
| # A map from address to line number within the objdump file. |
| addr2lineno = {} |
| |
| # Can be seen as a map from line number in objdump file -> address. |
| objdump_addreses = [] |
| |
| # A map from function name to a set of all executable instructions within |
| # it. |
| function_instructions = {} |
| |
| current_function = None |
| line_re = re.compile(r'^([0-9a-f]+):') |
| ignore_re = re.compile(r'\.word|\.short|\.byte|undefined instruction') |
| function_name_re = re.compile(r'^([0-9a-f]+) <([^>]+)>') |
| for i, line in enumerate(objdump_lines): |
| addr = None |
| g = line_re.match(line) |
| if g: |
| g2 = ignore_re.search(line) |
| if not g2: |
| addr = int(g.group(1), 16) |
| addr2lineno[addr] = i |
| |
| objdump_addreses.append(addr) |
| |
| if current_function is not None and addr is not None: |
| function_instructions[current_function].add(addr) |
| |
| g = function_name_re.search(line) |
| if g: |
| current_function = g.group(2) |
| function_instructions[current_function] = set() |
| |
| if current_function == 'arm_vector_table': |
| seL4_arm_vector_table_address = int(g.group(1), 16) |
| |
| try: |
| coverage_file = open(coverage_filename, 'r') |
| except: |
| print >>sys.stderr, 'Failed to open %s' % coverage_filename |
| return -1 |
| |
| # Record all executable instructions in the ELF file into a set. |
| covered_instructions = set() |
| trace_entry = re.compile(r'^Trace 0x[0-f]+ \[([0-f]+)\]') |
| for line in coverage_file.readlines(): |
| entry = re.search(trace_entry, line) |
| if not entry: |
| continue |
| addr = int(entry.group(1), 16) |
| if addr in addr2lineno: |
| covered_instructions.add(addr) |
| |
| # Sigh. And of course, here are some seL4-specific hacks. The vectors page |
| # is not at the correct address in the binary. It is mapped at 0xffff0000 |
| # in memory, but starts at arm_vector_table in the binary. Account for that |
| # here. |
| if 0xffff0000 <= addr <= 0xffff1000 and seL4_arm_vector_table_address is not None: |
| covered_instructions.add(addr - 0xffff0000 + seL4_arm_vector_table_address) |
| coverage_file.close() |
| |
| # Print basic information. |
| num_covered = len(covered_instructions) |
| num_total = len(addr2lineno) |
| print '%d/%d instructions covered (%.1f%%)' % ( |
| num_covered, num_total, |
| 100.0 * num_covered / num_total) |
| |
| if args.functions: |
| # For each function, calculate how many instructions were covered. |
| function_coverage = {} |
| for f, instructions in function_instructions.iteritems(): |
| num_instructions = len(instructions) |
| if num_instructions > 0: |
| covered = len(instructions.intersection(covered_instructions)) |
| function_coverage[f] = (covered, num_instructions) |
| |
| # Sort by coverage and print. |
| for f, x in sorted(function_coverage.items(), key=lambda (f, x): 1.0 * x[0] / x[1]): |
| pct = 100.0 * x[0] / x[1] |
| |
| if pct == 0.0: |
| colour = colors.LIGHT_RED |
| elif pct == 100.0: |
| colour = colors.DARK_GREEN |
| else: |
| colour = colors.DARK_YELLOW |
| |
| line = " %4d/%-4d %3.1f%% %s\n" % (x[0], x[1], pct, f) |
| sys.stdout.write(colour + line + colors.NORMAL) |
| |
| if args.objdump: |
| # Print a coloured objdump. |
| for i, line in enumerate(objdump_lines): |
| addr = objdump_addreses[i] |
| covered = addr in covered_instructions |
| valid = addr in addr2lineno |
| if covered: |
| colour = colors.DARK_GREEN |
| elif valid: |
| colour = colors.LIGHT_RED |
| else: |
| colour = colors.LIGHT_GREY |
| |
| sys.stdout.write(colour + line + colors.NORMAL) |
| |
| return 0 |
| |
| |
| if __name__ == '__main__': |
| sys.exit(main()) |
