scripts/unbalanced_allocs.py

#!/usr/bin/env python
# ===- lib/fuzzer/scripts/unbalanced_allocs.py ------------------------------===#
#
# Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
# See https://llvm.org/LICENSE.txt for license information.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
#
# ===------------------------------------------------------------------------===#
#
# Post-process -trace_malloc=2 output and printout only allocations and frees
# unbalanced inside of fuzzer runs.
# Usage:
#   my_fuzzer -trace_malloc=2 -runs=10 2>&1 | unbalanced_allocs.py -skip=5
#
# ===------------------------------------------------------------------------===#

import argparse
import sys

_skip = 0


def PrintStack(line, stack):
    global _skip
    if _skip > 0:
        return
    print("Unbalanced " + line.rstrip())
    for l in stack:
        print(l.rstrip())


def ProcessStack(line, f):
    stack = []
    while line and line.startswith("    #"):
        stack += [line]
        line = f.readline()
    return line, stack


def ProcessFree(line, f, allocs):
    if not line.startswith("FREE["):
        return f.readline()

    addr = int(line.split()[1], 16)
    next_line, stack = ProcessStack(f.readline(), f)
    if addr in allocs:
        del allocs[addr]
    else:
        PrintStack(line, stack)
    return next_line


def ProcessMalloc(line, f, allocs):
    if not line.startswith("MALLOC["):
        return ProcessFree(line, f, allocs)

    addr = int(line.split()[1], 16)
    assert not addr in allocs

    next_line, stack = ProcessStack(f.readline(), f)
    allocs[addr] = (line, stack)
    return next_line


def ProcessRun(line, f):
    if not line.startswith("MallocFreeTracer: START"):
        return ProcessMalloc(line, f, {})

    allocs = {}
    print(line.rstrip())
    line = f.readline()
    while line:
        if line.startswith("MallocFreeTracer: STOP"):
            global _skip
            _skip = _skip - 1
            for _, (l, s) in allocs.items():
                PrintStack(l, s)
            print(line.rstrip())
            return f.readline()
        line = ProcessMalloc(line, f, allocs)
    return line


def ProcessFile(f):
    line = f.readline()
    while line:
        line = ProcessRun(line, f)


def main(argv):
    parser = argparse.ArgumentParser()
    parser.add_argument("--skip", default=0, help="number of runs to ignore")
    args = parser.parse_args()
    global _skip
    _skip = int(args.skip) + 1
    ProcessFile(sys.stdin)


if __name__ == "__main__":
    main(sys.argv)