text: #!/usr/bin/python
  # Copyright (c) 2016, Google Inc.
  #
  # Permission to use, copy, modify, and/or distribute this software for any
  # purpose with or without fee is hereby granted, provided that the above
  # copyright notice and this permission notice appear in all copies.
  #
  # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  # SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  # OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  # CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  import os
  import os.path
  import subprocess
  import sys
  
  
  # The LCOV output format for each source file is:
  #
  # SF:<filename>
  # DA:<line>,<execution count>
  # ...
  # end_of_record
  #
  # The <execution count> can either be 0 for an unexecuted instruction or a
  # value representing the number of executions. The DA line should be omitted
  # for lines not representing an instruction.
  
  SECTION_SEPERATOR = '-' * 80
  
  def is_asm(l):
    """Returns whether a line should be considered to be an instruction."""
    l = l.strip()
    # Empty lines
    if l == '':
      return False
    # Comments
    if l.startswith('#'):
      return False
    # Assembly Macros
    if l.startswith('.'):
      return False
    # Label
    if l.endswith(':'):
      return False
    return True
  
  def merge(callgrind_files, srcs):
    """Calls callgrind_annotate over the set of callgrind output
    |callgrind_files| using the sources |srcs| and merges the results
    together."""
    out = ''
    for file in callgrind_files:
      data = subprocess.check_output(['callgrind_annotate', file] + srcs)
      out += '%s\n%s\n' % (data, SECTION_SEPERATOR)
    return out
  
  def parse(filename, data, current):
    """Parses an annotated execution flow |data| from callgrind_annotate for
    source |filename| and updates the current execution counts from |current|."""
    with open(filename) as f:
      source = f.read().split('\n')
  
    out = current
    if out == None:
      out = [0 if is_asm(l) else None for l in source]
  
    # Lines are of the following formats:
    #   -- line: Indicates that analysis continues from a different place.
    #   Ir     : Indicates the start of a file.
    #   =>     : Indicates a call/jump in the control flow.
    #   <Count> <Code>: Indicates that the line has been executed that many times.
    line = None
    for l in data:
      l = l.strip() + ' '
      if l.startswith('-- line'):
        line = int(l.split(' ')[2]) - 1
      elif l.strip() == 'Ir':
        line = 0
      elif line != None and l.strip() and '=>' not in l and 'unidentified lines' not in l:
        count = l.split(' ')[0].replace(',', '').replace('.', '0')
        instruction = l.split(' ', 1)[1].strip()
        if count != '0' or is_asm(instruction):
          if out[line] == None:
            out[line] = 0
          out[line] += int(count)
        line += 1
  
    return out
  
  
  def generate(data):
    """Parses the merged callgrind_annotate output |data| and generates execution
    counts for all annotated files."""
    out = {}
    data = [p.strip() for p in data.split(SECTION_SEPERATOR)]
  
  
    # Most sections are ignored, but a section with:
    #  User-annotated source: <file>
    # precedes a listing of execution count for that <file>.
    for i in range(len(data)):
      if 'User-annotated source' in data[i] and i < len(data) - 1:
        filename = data[i].split(':', 1)[1].strip()
        res = data[i + 1]
        if filename not in out:
          out[filename] = None
        if 'No information' in res:
          res = []
        else:
          res = res.split('\n')
        out[filename] = parse(filename, res, out[filename])
    return out
  
  def output(data):
    """Takes a dictionary |data| of filenames and execution counts and generates
    a LCOV coverage output."""
    out = ''
    for filename, counts in data.iteritems():
      out += 'SF:%s\n' % (os.path.abspath(filename))
      for line, count in enumerate(counts):
        if count != None:
          out += 'DA:%d,%s\n' % (line + 1, count)
      out += 'end_of_record\n'
    return out
  
  if __name__ == '__main__':
    if len(sys.argv) != 3:
      print '%s <Callgrind Folder> <Build Folder>' % (__file__)
      sys.exit()
  
    cg_folder = sys.argv[1]
    build_folder = sys.argv[2]
  
    cg_files = []
    for (cwd, _, files) in os.walk(cg_folder):
      for f in files:
        if f.startswith('callgrind.out'):
          cg_files.append(os.path.abspath(os.path.join(cwd, f)))
  
    srcs = []
    for (cwd, _, files) in os.walk(build_folder):
      for f in files:
        fn = os.path.join(cwd, f)
        if fn.endswith('.S'):
          srcs.append(fn)
  
    annotated = merge(cg_files, srcs)
    lcov = generate(annotated)
    print output(lcov)
  