cmpcodesize

#!/usr/bin/env python

import re
import sys
import os
import os.path
import glob
import subprocess
import collections
from operator import itemgetter

def help():
  print """\
cmpcodesize [options] <old-files> [--] <new-files>

Compares code sizes of "new" files, taking "old" files as a reference.

Options:
    -a           Show sizes of additional sections
    -c           Show functions by category
    -l           List all functions (can be a very long list)
    -s           Summarize the sizes of multiple files instead of listing each file separatly

Environment variables:
    SWIFT_NEW_BUILDDIR   The old build-dir
E.g. $HOME/swift-work/build/Ninja-ReleaseAssert+stdlib-Release/swift-macosx-x86_64
    SWIFT_OLD_BUILDDIR   The new build-dir
E.g. $HOME/swift-reference/build/Ninja-ReleaseAssert+stdlib-Release/swift-macosx-x86_64

How to specify files:
1) No files:
    Compares codesize of the PerfTests_* executables and the swiftCore dylib in the new and old build-dirs.
    Example:
        cmpcodesize

2) One ore more pathes relative to the build-dirs (can be a pattern):
    Compares that files in the new and old build-dirs.
    Aliases:
        O          => bin/PerfTests_O
        Ounchecked => bin/PerfTests_Ounchecked
        Onone      => bin/PerfTests_Onone
        dylib      => lib/swift/macosx/x86_64/libswiftCore.dylib
    Examples:
        cmpcodesize Onone
        cmpcodesize benchmark/PerfTestSuite/O/*.o

3) Two files:
    Compares these two files (the first is the old file).
    Example:
        cmpcodesize test.o newversion.o

4) Two lists of files, separated by '--':
    Compares a set a files.
    Example:
        cmpcodesize olddir/*.o -- newdir/*.o

5) One file (only available with the -l option):
    Lists function sizes for that file
    Example:
        cmpcodesize -l test.o
"""

Prefixes = {
    # Cpp
    "__Z" : "CPP",
    "_swift" : "CPP",
    "__swift" : "CPP",

    # Objective-C
    "+[" : "ObjC",
    "-[" : "ObjC",

    # Swift
    "__TP"  : "Partial Apply",
    "__TTW" : "Protocol Witness",
    "__Tw"  : "Value Witness",
    "__TM"  : "Type Metadata",
    "__TF"  : "Swift Function",
    "__TTSg" : "Generic Spec",
    "__TTSf" : "FuncSig Spec",
    "__TZF" : "Static Func",
    # Function signature specialization of a generic specialization.
    "__TTSGF" : "FuncSigGen Spec",
    "__TTo" : "Swift @objc Func",
}

Infixes = {
  #Swift
  "q_" : "Generic Function"
}

GenericFunctionPrefix = "__TTSg"

SortedPrefixes = sorted(Prefixes)
SortedInfixes = sorted(Infixes)

def addFunction(sizes, function, startAddr, endAddr, groupByPrefix):
    if not function or startAddr == None or endAddr == None:
        return

    size = endAddr - startAddr

    if groupByPrefix:
        for infix in SortedInfixes:
	    if infix in function:
               if not GenericFunctionPrefix in function:
	           sizes[Infixes[infix]] += size
                   return
        for prefix in SortedPrefixes:
	    if function.startswith(prefix):
                # Special handling for function signature specializations
                # of generic specializations.
                if prefix == "__TTSf" and GenericFunctionPrefix in function:
                    prefix = "__TTSGF"
                sizes[Prefixes[prefix]] += size
                return
        sizes["Unknown"] += size
    else:
        sizes[function] += size

def flatten(*args):
    for x in args:
        if hasattr(x, '__iter__'):
            for y in flatten(*x):
                yield y
        else:
            yield x

def readSizes(sizes, fileName, functionDetails, groupByPrefix):
    # Check if multiple architectures are supported by the object file.
    # Prefer arm64 if available.
    architectures = subprocess.check_output(["otool", "-V", "-f", fileName]).split("\n")
    arch = None
    archPattern = re.compile('architecture ([\S]+)')
    for architecture in architectures:
        archMatch = archPattern.match(architecture)
        if archMatch:
            if arch is None:
                arch = archMatch.group(1)
            if "arm64" in arch:
                arch = "arm64"
    if arch is not None:
      archParams = ["-arch", arch]
    else:
      archParams = []

    if functionDetails:
        content = subprocess.check_output(flatten(["otool", archParams, "-l", "-v", "-t", fileName])).split("\n")
        content += subprocess.check_output(flatten(["otool", archParams, "-v", "-s", "__TEXT", "__textcoal_nt", fileName])).split("\n")
    else:
        content = subprocess.check_output(flatten(["otool", archParams, "-l", fileName])).split("\n")

    sectName = None
    currFunc = None
    startAddr = None
    endAddr = None

    sectionPattern = re.compile(' +sectname ([\S]+)')
    sizePattern = re.compile(' +size ([\da-fx]+)')
    asmlinePattern = re.compile('^([0-9a-fA-F]+)\s')
    labelPattern = re.compile('^((\-*\[[^\]]*\])|[^\/\s]+):$')

    for line in content:
        asmlineMatch = asmlinePattern.match(line)
        if asmlineMatch:
            addr = int(asmlineMatch.group(1), 16)
            if startAddr == None:
                startAddr = addr
            endAddr = addr
        elif line == "Section":
            sectName = None
        else:
            labelMatch = labelPattern.match(line)
            sizeMatch = sizePattern.match(line)
            sectionMatch = sectionPattern.match(line)
            if labelMatch:
                funcName = labelMatch.group(1)
                addFunction(sizes, currFunc, startAddr, endAddr, groupByPrefix)
                currFunc = funcName
                startAddr = None
                endAddr = None
            elif sizeMatch and sectName and groupByPrefix:
                size = int(sizeMatch.group(1), 16)
                sizes[sectName] += size
            elif sectionMatch:
                sectName = sectionMatch.group(1)
                if sectName == "__textcoal_nt":
                    sectName = "__text"

    addFunction(sizes, currFunc, startAddr, endAddr, groupByPrefix)

def compareSizes(oldSizes, newSizes, nameKey, title):
    oldSize = oldSizes[nameKey]
    newSize = newSizes[nameKey]
    if oldSize != None and newSize != None:
        if oldSize != 0:
            perc = "%.1f%%" % ((1.0 - float(newSize) / float(oldSize)) * 100.0)
        else:
            perc = "- "
        print "%-26s%16s: %8d  %8d  %6s" % (title, nameKey, oldSize, newSize, perc)

def compareSizesOfFile(oldFiles, newFiles, allSections, listCategories):
    oldSizes = collections.defaultdict(int)
    newSizes = collections.defaultdict(int)
    for oldFile in oldFiles:
        readSizes(oldSizes, oldFile, listCategories, True)
    for newFile in newFiles:
        readSizes(newSizes, newFile, listCategories, True)

    if len(oldFiles) == 1 and len(newFiles) == 1:
        oldBase = os.path.basename(oldFiles[0])
        newBase = os.path.basename(newFiles[0])
        title = oldBase
        if oldBase != newBase:
            title += "-" + newBase
    else:
        title = "old-new"

    compareSizes(oldSizes, newSizes, "__text", title)
    if listCategories:
        prev = None
        for categoryName in sorted(Prefixes.values()) + sorted(Infixes.values())+ ["Unknown"]:
            if categoryName != prev:
                compareSizes(oldSizes, newSizes, categoryName, "")
            prev = categoryName

    if allSections:
        sectionTitle = "    section"
        compareSizes(oldSizes, newSizes, "__textcoal_nt", sectionTitle)
        compareSizes(oldSizes, newSizes, "__stubs", sectionTitle)
        compareSizes(oldSizes, newSizes, "__const", sectionTitle)
        compareSizes(oldSizes, newSizes, "__cstring", sectionTitle)
        compareSizes(oldSizes, newSizes, "__objc_methname", sectionTitle)
        compareSizes(oldSizes, newSizes, "__const", sectionTitle)
        compareSizes(oldSizes, newSizes, "__objc_const", sectionTitle)
        compareSizes(oldSizes, newSizes, "__data", sectionTitle)
        compareSizes(oldSizes, newSizes, "__swift1_proto", sectionTitle)
        compareSizes(oldSizes, newSizes, "__common", sectionTitle)
        compareSizes(oldSizes, newSizes, "__bss", sectionTitle)

def listFunctionSizes(sizeArray):
    for pair in sorted(sizeArray, key=itemgetter(1)):
        name = pair[0]
        size = pair[1]
        print "%8d %s" % (size, name)

def compareFunctionSizes(oldFiles, newFiles):
    oldSizes = collections.defaultdict(int)
    newSizes = collections.defaultdict(int)
    for name in oldFiles:
        readSizes(oldSizes, name, True, False)
    for name in newFiles:
        readSizes(newSizes, name, True, False)

    onlyInFile1 = []
    onlyInFile2 = []
    inBoth = []

    onlyInFile1Size = 0
    onlyInFile2Size = 0
    inBothSize = 0

    for func, oldSize in oldSizes.items():
        newSize = newSizes[func]
        if newSize != 0:
            inBoth.append((func, oldSize, newSize))
        else:
            onlyInFile1.append((func, oldSize))
            onlyInFile1Size += oldSize

    for func, newSize in newSizes.items():
        oldSize = oldSizes[func]
        if oldSize == 0:
            onlyInFile2.append((func, newSize))
            onlyInFile2Size += newSize

    if onlyInFile1:
        print "Only in old file(s)"
        listFunctionSizes(onlyInFile1)
        print "Total size of functions only in old file: {}".format(onlyInFile1Size)
        print

    if onlyInFile2:
        print "Only in new files(s)"
        listFunctionSizes(onlyInFile2)
        print "Total size of functions only in new file: {}".format(onlyInFile2Size) 
        print

    if inBoth:
        sizeIncrease = 0
        sizeDecrease = 0
        print "%8s %8s %8s" % ("old", "new", "diff")
        for triple in sorted(inBoth, key=lambda tup: (tup[2] - tup[1], tup[1])):
            func = triple[0]
            oldSize = triple[1]
            newSize = triple[2]
            diff = newSize - oldSize
            if diff > 0:
                sizeIncrease += diff
            else:
                sizeDecrease -= diff
            if diff == 0:
                inBothSize += newSize
            print "%8d %8d %8d %s" %(oldSize, newSize, newSize - oldSize, func)
        print "Total size of functions with the same size in both files: {}".format(inBothSize)
        print "Total size of functions that got smaller: {}".format(sizeDecrease)
        print "Total size of functions that got bigger: {}".format(sizeIncrease)
        print "Total size change of functions present in both files: {}".format(sizeIncrease - sizeDecrease)

def main():
    allSections = False
    listCategories = False
    listFunctions = False
    separatorFound = False
    sumSizes = False
    oldFileArgs = []
    newFileArgs = []
    curFiles = oldFileArgs
    for arg in sys.argv[1:]:
        if arg == "-a":
            allSections = True
        elif arg == "-c":
            listCategories = True
        elif arg == "-s":
            sumSizes = True
        elif arg == "-l":
            listFunctions = True
        elif arg == "--":
            curFiles = newFileArgs
            separatorFound = True
        elif arg == "-h":
            help()
            return
        elif arg.startswith("-"):
            sys.exit("Unknown option. Use -h to display usage.")
        else:
            curFiles.append(arg)
    

    oldBuildDir = os.environ.get("SWIFT_OLD_BUILDDIR")
    newBuildDir = os.environ.get("SWIFT_NEW_BUILDDIR")

    if separatorFound:
        oldFiles = oldFileArgs
        newFiles = newFileArgs
    else:
        if not oldFileArgs:
            if listFunctions:
                sys.exit("Must specify file for the -l option")
            if not oldBuildDir:
                sys.exit("$SWIFT_OLD_BUILDDIR not specified")
            if not newBuildDir:
                die("$SWIFT_NEW_BUILDDIR not specified")
            oldFileArgs = [ "O", "Ounchecked", "Onone", "dylib" ]
        oldFiles = []
        newFiles = []
        numExpanded = 0
        for file in oldFileArgs:
            shortcuts = {
                "O"          : "bin/PerfTests_O",
                "Ounchecked" : "bin/PerfTests_Ounchecked",
                "Onone"      : "bin/PerfTests_Onone",
                "dylib"      : "lib/swift/macosx/x86_64/libswiftCore.dylib"
            }
            if file in shortcuts:
                file = shortcuts[file]

            if not file.startswith("./") and oldBuildDir and newBuildDir:
                oldExpanded = glob.glob(oldBuildDir + "/" + file)
                newExpanded = glob.glob(newBuildDir + "/" + file)
                if oldExpanded and newExpanded:
                    oldFiles.extend(oldExpanded)
                    newFiles.extend(newExpanded)
                    numExpanded += 1

        if numExpanded != 0 and numExpanded != len(oldFileArgs):
            sys.exit("mix of expanded/not-expanded arguments") 
        if numExpanded == 0:
            if len(oldFileArgs) > 2:
                sys.exit("too many arguments")
            oldFiles = oldFileArgs[0:1]
            newFiles = oldFileArgs[1:2]

    for file in (oldFiles + newFiles):
        if not os.path.isfile(file):
            sys.exit("file " + file + " not found")

    if listFunctions:
        if allSections or listCategories:
            print >> sys.stderr, "Warning: options -a and -c ignored when using -l"
        if not newFiles:
            sizes = collections.defaultdict(int)
            for file in oldFiles:
                readSizes(sizes, file, True, False)
            listFunctionSizes(sizes.items())
        else:
            compareFunctionSizes(oldFiles, newFiles)
    else:
        print "%-26s%16s  %8s  %8s  %s" % ("", "Section", "Old", "New", "Percent")
        if sumSizes:
            compareSizesOfFile(oldFiles, newFiles, allSections, listCategories)
        else:
            if len(oldFiles) != len(newFiles):
                sys.exit("number of new files must be the same of old files")

            oldFiles.sort
            newFiles.sort

            for idx, oldFile in enumerate(oldFiles):
                newFile = newFiles[idx]
                compareSizesOfFile([oldFile], [newFile], allSections, listCategories)

main()