text: #!/usr/bin/env python
  # Merge or print the coverage data collected by asan's coverage.
  # Input files are sequences of 4-byte integers.
  # We need to merge these integers into a set and then
  # either print them (as hex) or dump them into another file.
  import array
  import struct
  import sys
  import bisect
  import os.path
  
  prog_name = "";
  
  def Usage():
    print >> sys.stderr, "Usage: \n" + \
        " " + prog_name + " merge file1 [file2 ...]  > output\n" \
        " " + prog_name + " print file1 [file2 ...]\n" \
        " " + prog_name + " unpack file1 [file2 ...]\n" \
        " " + prog_name + " rawunpack file1 [file2 ...]\n"
    exit(1)
  
  def ReadOneFile(path):
    with open(path, mode="rb") as f:
      f.seek(0, 2)
      size = f.tell()
      f.seek(0, 0)
      s = set(array.array('I', f.read(size)))
    print >>sys.stderr, "%s: read %d PCs from %s" % (prog_name, size / 4, path)
    return s
  
  def Merge(files):
    s = set()
    for f in files:
      s = s.union(ReadOneFile(f))
    print >> sys.stderr, "%s: %d files merged; %d PCs total" % \
      (prog_name, len(files), len(s))
    return sorted(s)
  
  def PrintFiles(files):
    s = Merge(files)
    for i in s:
      print "0x%x" % i
  
  def MergeAndPrint(files):
    if sys.stdout.isatty():
      Usage()
    s = Merge(files)
    a = array.array('I', s)
    a.tofile(sys.stdout)
  
  
  def UnpackOneFile(path):
    with open(path, mode="rb") as f:
      print >> sys.stderr, "%s: unpacking %s" % (prog_name, path)
      while True:
        header = f.read(12)
        if not header: return
        if len(header) < 12:
          break
        pid, module_length, blob_size = struct.unpack('iII', header)
        module = f.read(module_length)
        blob = f.read(blob_size)
        assert(len(module) == module_length)
        assert(len(blob) == blob_size)
        extracted_file = "%s.%d.sancov" % (module, pid)
        print >> sys.stderr, "%s: extracting %s" % \
          (prog_name, extracted_file)
        # The packed file may contain multiple blobs for the same pid/module
        # pair. Append to the end of the file instead of overwriting.
        with open(extracted_file, 'ab') as f2:
          f2.write(blob)
      # fail
      raise Exception('Error reading file %s' % path)
  
  
  def Unpack(files):
    for f in files:
      UnpackOneFile(f)
  
  def UnpackOneRawFile(path, map_path):
    mem_map = []
    with open(map_path, mode="rt") as f_map:
      print >> sys.stderr, "%s: reading map %s" % (prog_name, map_path)
      bits = int(f_map.readline())
      for line in f_map:
        parts = line.rstrip().split()
        mem_map.append((int(parts[0], 16),
                    int(parts[1], 16),
                    int(parts[2], 16),
                    ' '.join(parts[3:])))
    mem_map.sort(key=lambda m : m[0])
    mem_map_keys = [m[0] for m in mem_map]
  
    with open(path, mode="rb") as f:
      print >> sys.stderr, "%s: unpacking %s" % (prog_name, path)
  
      f.seek(0, 2)
      size = f.tell()
      f.seek(0, 0)
      if bits == 64:
        typecode = 'L'
      else:
        typecode = 'I'
      pcs = array.array(typecode, f.read(size))
      mem_map_pcs = [[] for i in range(0, len(mem_map))]
  
      for pc in pcs:
        if pc == 0: continue
        map_idx = bisect.bisect(mem_map_keys, pc) - 1
        (start, end, base, module_path) = mem_map[map_idx]
        assert pc >= start
        if pc >= end:
          print >> sys.stderr, "warning: %s: pc %x outside of any known mapping" % (prog_name, pc)
          continue
        mem_map_pcs[map_idx].append(pc - base)
  
      for ((start, end, base, module_path), pc_list) in zip(mem_map, mem_map_pcs):
        if len(pc_list) == 0: continue
        assert path.endswith('.sancov.raw')
        dst_path = module_path + '.' + os.path.basename(path)[:-4]
        print >> sys.stderr, "%s: writing %d PCs to %s" % (prog_name, len(pc_list), dst_path)
        arr = array.array('I')
        arr.fromlist(sorted(pc_list))
        with open(dst_path, 'ab') as f2:
          arr.tofile(f2)
  
  def RawUnpack(files):
    for f in files:
      if not f.endswith('.sancov.raw'):
        raise Exception('Unexpected raw file name %s' % f)
      f_map = f[:-3] + 'map'
      UnpackOneRawFile(f, f_map)
  
  if __name__ == '__main__':
    prog_name = sys.argv[0]
    if len(sys.argv) <= 2:
      Usage();
    if sys.argv[1] == "print":
      PrintFiles(sys.argv[2:])
    elif sys.argv[1] == "merge":
      MergeAndPrint(sys.argv[2:])
    elif sys.argv[1] == "unpack":
      Unpack(sys.argv[2:])
    elif sys.argv[1] == "rawunpack":
      RawUnpack(sys.argv[2:])
    else:
      Usage()
  