v86 0.4.0 → 0.5.11

package/bios/seabios/scripts/acpi_extract.py

@@ -1,366 +0,0 @@
-#!/usr/bin/python
-# Copyright (C) 2011 Red Hat, Inc., Michael S. Tsirkin <mst@redhat.com>
-#
-# This file may be distributed under the terms of the GNU GPLv3 license.
-
-# Process mixed ASL/AML listing (.lst file) produced by iasl -l
-# Locate and execute ACPI_EXTRACT directives, output offset info
-# 
-# Documentation of ACPI_EXTRACT_* directive tags:
-# 
-# These directive tags output offset information from AML for BIOS runtime
-# table generation.
-# Each directive is of the form:
-# ACPI_EXTRACT_<TYPE> <array_name> <Operator> (...)
-# and causes the extractor to create an array
-# named <array_name> with offset, in the generated AML,
-# of an object of a given type in the following <Operator>.
-# 
-# A directive must fit on a single code line.
-# 
-# Object type in AML is verified, a mismatch causes a build failure.
-# 
-# Directives and operators currently supported are:
-# ACPI_EXTRACT_NAME_DWORD_CONST - extract a Dword Const object from Name()
-# ACPI_EXTRACT_NAME_WORD_CONST - extract a Word Const object from Name()
-# ACPI_EXTRACT_NAME_BYTE_CONST - extract a Byte Const object from Name()
-# ACPI_EXTRACT_METHOD_STRING - extract a NameString from Method()
-# ACPI_EXTRACT_NAME_STRING - extract a NameString from Name()
-# ACPI_EXTRACT_PROCESSOR_START - start of Processor() block
-# ACPI_EXTRACT_PROCESSOR_STRING - extract a NameString from Processor()
-# ACPI_EXTRACT_PROCESSOR_END - offset at last byte of Processor() + 1
-# ACPI_EXTRACT_DEVICE_START - start of Device() block
-# ACPI_EXTRACT_DEVICE_STRING - extract a NameString from Device()
-# ACPI_EXTRACT_DEVICE_END - offset at last byte of Device() + 1
-# ACPI_EXTRACT_PKG_START - start of Package block
-#
-# ACPI_EXTRACT_ALL_CODE - create an array storing the generated AML bytecode
-# 
-# ACPI_EXTRACT is not allowed anywhere else in code, except in comments.
-
-import re
-import sys
-import fileinput
-
-aml = []
-asl = []
-output = {}
-debug = ""
-
-class asl_line:
-    line = None
-    lineno = None
-    aml_offset = None
-
-def die(diag):
-    sys.stderr.write("Error: %s; %s\n" % (diag, debug))
-    sys.exit(1)
-
-#Store an ASL command, matching AML offset, and input line (for debugging)
-def add_asl(lineno, line):
-    l = asl_line()
-    l.line = line
-    l.lineno = lineno
-    l.aml_offset = len(aml)
-    asl.append(l)
-
-#Store an AML byte sequence
-#Verify that offset output by iasl matches # of bytes so far
-def add_aml(offset, line):
-    o = int(offset, 16)
-    # Sanity check: offset must match size of code so far
-    if (o != len(aml)):
-        die("Offset 0x%x != 0x%x" % (o, len(aml)))
-    # Strip any trailing dots and ASCII dump after "
-    line = re.sub(r'\s*\.*\s*".*$', "", line)
-    # Strip traling whitespace
-    line = re.sub(r'\s+$', "", line)
-    # Strip leading whitespace
-    line = re.sub(r'^\s+', "", line)
-    # Split on whitespace
-    code = re.split(r'\s+', line)
-    for c in code:
-        # Require a legal hex number, two digits
-        if (not(re.search(r'^[0-9A-Fa-f][0-9A-Fa-f]$', c))):
-            die("Unexpected octet %s" % c)
-        aml.append(int(c, 16))
-
-# Process aml bytecode array, decoding AML
-def aml_pkglen_bytes(offset):
-    # PkgLength can be multibyte. Bits 8-7 give the # of extra bytes.
-    pkglenbytes = aml[offset] >> 6
-    return pkglenbytes + 1
-
-def aml_pkglen(offset):
-    pkgstart = offset
-    pkglenbytes = aml_pkglen_bytes(offset)
-    pkglen = aml[offset] & 0x3F
-    # If multibyte, first nibble only uses bits 0-3
-    if ((pkglenbytes > 1) and (pkglen & 0x30)):
-        die("PkgLen bytes 0x%x but first nibble 0x%x expected 0x0X" %
-            (pkglen, pkglen))
-    offset += 1
-    pkglenbytes -= 1
-    for i in range(pkglenbytes):
-        pkglen |= aml[offset + i] << (i * 8 + 4)
-    if (len(aml) < pkgstart + pkglen):
-        die("PckgLen 0x%x at offset 0x%x exceeds AML size 0x%x" %
-            (pkglen, offset, len(aml)))
-    return pkglen
-
-# Given method offset, find its NameString offset
-def aml_method_string(offset):
-    #0x14 MethodOp PkgLength NameString MethodFlags TermList
-    if (aml[offset] != 0x14):
-        die( "Method offset 0x%x: expected 0x14 actual 0x%x" %
-             (offset, aml[offset]))
-    offset += 1
-    pkglenbytes = aml_pkglen_bytes(offset)
-    offset += pkglenbytes
-    return offset
-
-# Given name offset, find its NameString offset
-def aml_name_string(offset):
-    #0x08 NameOp NameString DataRef
-    if (aml[offset] != 0x08):
-        die( "Name offset 0x%x: expected 0x08 actual 0x%x" %
-             (offset, aml[offset]))
-    offset += 1
-    # Block Name Modifier. Skip it.
-    if (aml[offset] == 0x5c or aml[offset] == 0x5e):
-        offset += 1
-    return offset
-
-# Given data offset, find 8 byte buffer offset
-def aml_data_buffer8(offset):
-    #0x08 NameOp NameString DataRef
-    expect = [0x11, 0x0B, 0x0A, 0x08]
-    if (aml[offset:offset+4] != expect):
-        die( "Name offset 0x%x: expected %s actual %s" %
-             (offset, aml[offset:offset+4], expect))
-    return offset + len(expect)
-
-# Given data offset, find dword const offset
-def aml_data_dword_const(offset):
-    #0x08 NameOp NameString DataRef
-    if (aml[offset] != 0x0C):
-        die( "Name offset 0x%x: expected 0x0C actual 0x%x" %
-             (offset, aml[offset]))
-    return offset + 1
-
-# Given data offset, find word const offset
-def aml_data_word_const(offset):
-    #0x08 NameOp NameString DataRef
-    if (aml[offset] != 0x0B):
-        die( "Name offset 0x%x: expected 0x0B actual 0x%x" %
-             (offset, aml[offset]))
-    return offset + 1
-
-# Given data offset, find byte const offset
-def aml_data_byte_const(offset):
-    #0x08 NameOp NameString DataRef
-    if (aml[offset] != 0x0A):
-        die( "Name offset 0x%x: expected 0x0A actual 0x%x" %
-             (offset, aml[offset]))
-    return offset + 1
-
-# Find name'd buffer8
-def aml_name_buffer8(offset):
-    return aml_data_buffer8(aml_name_string(offset) + 4)
-
-# Given name offset, find dword const offset
-def aml_name_dword_const(offset):
-    return aml_data_dword_const(aml_name_string(offset) + 4)
-
-# Given name offset, find word const offset
-def aml_name_word_const(offset):
-    return aml_data_word_const(aml_name_string(offset) + 4)
-
-# Given name offset, find byte const offset
-def aml_name_byte_const(offset):
-    return aml_data_byte_const(aml_name_string(offset) + 4)
-
-def aml_device_start(offset):
-    #0x5B 0x82 DeviceOp PkgLength NameString
-    if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x82)):
-        die( "Name offset 0x%x: expected 0x5B 0x82 actual 0x%x 0x%x" %
-             (offset, aml[offset], aml[offset + 1]))
-    return offset
-
-def aml_device_string(offset):
-    #0x5B 0x82 DeviceOp PkgLength NameString
-    start = aml_device_start(offset)
-    offset += 2
-    pkglenbytes = aml_pkglen_bytes(offset)
-    offset += pkglenbytes
-    return offset
-
-def aml_device_end(offset):
-    start = aml_device_start(offset)
-    offset += 2
-    pkglenbytes = aml_pkglen_bytes(offset)
-    pkglen = aml_pkglen(offset)
-    return offset + pkglen
-
-def aml_processor_start(offset):
-    #0x5B 0x83 ProcessorOp PkgLength NameString ProcID
-    if ((aml[offset] != 0x5B) or (aml[offset + 1] != 0x83)):
-        die( "Name offset 0x%x: expected 0x5B 0x83 actual 0x%x 0x%x" %
-             (offset, aml[offset], aml[offset + 1]))
-    return offset
-
-def aml_processor_string(offset):
-    #0x5B 0x83 ProcessorOp PkgLength NameString ProcID
-    start = aml_processor_start(offset)
-    offset += 2
-    pkglenbytes = aml_pkglen_bytes(offset)
-    offset += pkglenbytes
-    return offset
-
-def aml_processor_end(offset):
-    start = aml_processor_start(offset)
-    offset += 2
-    pkglenbytes = aml_pkglen_bytes(offset)
-    pkglen = aml_pkglen(offset)
-    return offset + pkglen
-
-def aml_package_start(offset):
-    offset = aml_name_string(offset) + 4
-    # 0x12 PkgLength NumElements PackageElementList
-    if (aml[offset] != 0x12):
-        die( "Name offset 0x%x: expected 0x12 actual 0x%x" %
-             (offset, aml[offset]))
-    offset += 1
-    return offset + aml_pkglen_bytes(offset) + 1
-
-def get_value_type(maxvalue):
-    #Use type large enough to fit the table
-    if (maxvalue >= 0x10000):
-        return "int"
-    elif (maxvalue >= 0x100):
-        return "short"
-    else:
-        return "char"
-
-def main():
-    global debug
-    lineno = 0
-    for line in fileinput.input():
-        # Strip trailing newline
-        line = line.rstrip()
-        # line number and debug string to output in case of errors
-        lineno = lineno + 1
-        debug = "input line %d: %s" % (lineno, line)
-        #ASL listing: space, then line#, then ...., then code
-        pasl = re.compile('^\s+([0-9]+)(:\s\s|\.\.\.\.)\s*')
-        m = pasl.search(line)
-        if (m):
-            add_asl(lineno, pasl.sub("", line))
-        # AML listing: offset in hex, then ...., then code
-        paml = re.compile('^([0-9A-Fa-f]+)(:\s\s|\.\.\.\.)\s*')
-        m = paml.search(line)
-        if (m):
-            add_aml(m.group(1), paml.sub("", line))
-
-    # Now go over code
-    # Track AML offset of a previous non-empty ASL command
-    prev_aml_offset = -1
-    for i in range(len(asl)):
-        debug = "input line %d: %s" % (asl[i].lineno, asl[i].line)
-
-        l = asl[i].line
-
-        # skip if not an extract directive
-        a = len(re.findall(r'ACPI_EXTRACT', l))
-        if (not a):
-            # If not empty, store AML offset. Will be used for sanity checks
-            # IASL seems to put {}. at random places in the listing.
-            # Ignore any non-words for the purpose of this test.
-            m = re.search(r'\w+', l)
-            if (m):
-                prev_aml_offset = asl[i].aml_offset
-            continue
-
-        if (a > 1):
-            die("Expected at most one ACPI_EXTRACT per line, actual %d" % a)
-
-        mext = re.search(r'''
-                          ^\s* # leading whitespace
-                          /\*\s* # start C comment
-                          (ACPI_EXTRACT_\w+) # directive: group(1)
-                          \s+ # whitspace separates directive from array name
-                          (\w+) # array name: group(2)
-                          \s*\*/ # end of C comment
-                          \s*$ # trailing whitespace
-                          ''', l, re.VERBOSE)
-        if (not mext):
-            die("Stray ACPI_EXTRACT in input")
-
-        # previous command must have produced some AML,
-        # otherwise we are in a middle of a block
-        if (prev_aml_offset == asl[i].aml_offset):
-            die("ACPI_EXTRACT directive in the middle of a block")
-
-        directive = mext.group(1)
-        array = mext.group(2)
-        offset = asl[i].aml_offset
-
-        if (directive == "ACPI_EXTRACT_ALL_CODE"):
-            if array in output:
-                die("%s directive used more than once" % directive)
-            output[array] = aml
-            continue
-        if (directive == "ACPI_EXTRACT_NAME_BUFFER8"):
-            offset = aml_name_buffer8(offset)
-        elif (directive == "ACPI_EXTRACT_NAME_DWORD_CONST"):
-            offset = aml_name_dword_const(offset)
-        elif (directive == "ACPI_EXTRACT_NAME_WORD_CONST"):
-            offset = aml_name_word_const(offset)
-        elif (directive == "ACPI_EXTRACT_NAME_BYTE_CONST"):
-            offset = aml_name_byte_const(offset)
-        elif (directive == "ACPI_EXTRACT_NAME_STRING"):
-            offset = aml_name_string(offset)
-        elif (directive == "ACPI_EXTRACT_METHOD_STRING"):
-            offset = aml_method_string(offset)
-        elif (directive == "ACPI_EXTRACT_DEVICE_START"):
-            offset = aml_device_start(offset)
-        elif (directive == "ACPI_EXTRACT_DEVICE_STRING"):
-            offset = aml_device_string(offset)
-        elif (directive == "ACPI_EXTRACT_DEVICE_END"):
-            offset = aml_device_end(offset)
-        elif (directive == "ACPI_EXTRACT_PROCESSOR_START"):
-            offset = aml_processor_start(offset)
-        elif (directive == "ACPI_EXTRACT_PROCESSOR_STRING"):
-            offset = aml_processor_string(offset)
-        elif (directive == "ACPI_EXTRACT_PROCESSOR_END"):
-            offset = aml_processor_end(offset)
-        elif (directive == "ACPI_EXTRACT_PKG_START"):
-            offset = aml_package_start(offset)
-        else:
-            die("Unsupported directive %s" % directive)
-
-        if array not in output:
-            output[array] = []
-        output[array].append(offset)
-
-    debug = "at end of file"
-
-    # Pretty print output
-    outstrs = ["/* DO NOT EDIT!  This is an autogenerated file."
-               "  See scripts/acpi_extract.py. */"]
-    for array in output.keys():
-        otype = get_value_type(max(output[array]))
-        outstrs.append("static unsigned %s %s[] = {" % (otype, array))
-        odata = []
-        for value in output[array]:
-            odata.append("0x%02x" % value)
-            if len(odata) >= 8:
-                outstrs.append("    %s," % (', '.join(odata),))
-                del odata[:]
-        outstrs.append("    %s" % (', '.join(odata),))
-        outstrs.append('};')
-        outstrs.append('')
-    sys.stdout.write('\n'.join(outstrs))
-
-if __name__ == '__main__':
-    main()

package/bios/seabios/scripts/acpi_extract_preprocess.py

@@ -1,41 +0,0 @@
-#!/usr/bin/python
-# Copyright (C) 2011 Red Hat, Inc., Michael S. Tsirkin <mst@redhat.com>
-#
-# This file may be distributed under the terms of the GNU GPLv3 license.
-
-# Read a preprocessed ASL listing and put each ACPI_EXTRACT
-# directive in a comment, to make iasl skip it.
-# We also put each directive on a new line, the machinery
-# in scripts/acpi_extract.py requires this.
-
-import re
-import sys
-import fileinput
-
-def die(diag):
-    sys.stderr.write("Error: %s\n" % (diag))
-    sys.exit(1)
-
-# Note: () around pattern make split return matched string as part of list
-psplit = re.compile(r''' (
-                          \b # At word boundary
-                          ACPI_EXTRACT_\w+ # directive
-                          \s+ # some whitespace
-                          \w+ # array name
-                         )''', re.VERBOSE)
-
-lineno = 0
-for line in fileinput.input():
-    # line number and debug string to output in case of errors
-    lineno = lineno + 1
-    debug = "input line %d: %s" % (lineno, line.rstrip())
-
-    s = psplit.split(line)
-    # The way split works, each odd item is the matching ACPI_EXTRACT directive.
-    # Put each in a comment, and on a line by itself.
-    for i in range(len(s)):
-        if (i % 2):
-            sys.stdout.write("\n/* %s */\n" % s[i])
-        else:
-            sys.stdout.write(s[i])
-

package/bios/seabios/scripts/buildrom.py

@@ -1,56 +0,0 @@
-#!/usr/bin/env python
-# Fill in checksum/size of an option rom, and pad it to proper length.
-#
-# Copyright (C) 2009  Kevin O'Connor <kevin@koconnor.net>
-#
-# This file may be distributed under the terms of the GNU GPLv3 license.
-
-import sys, struct
-
-from python23compat import as_bytes
-
-def alignpos(pos, alignbytes):
-    mask = alignbytes - 1
-    return (pos + mask) & ~mask
-
-def checksum(data):
-    if (sys.version_info > (3, 0)):
-        cksum = sum(data)
-    else:
-        cksum = sum(map(ord, data))
-    return struct.pack('<B', (0x100 - cksum) & 0xff)
-
-def main():
-    inname = sys.argv[1]
-    outname = sys.argv[2]
-
-    # Read data in
-    f = open(inname, 'rb')
-    data = f.read()
-    f.close()
-    count = len(data)
-
-    # Pad to a 512 byte boundary
-    data += as_bytes("\0") * (alignpos(count, 512) - count)
-    count = len(data)
-
-    # Check if a pci header is present
-    pcidata = ord(data[24:25]) + (ord(data[25:26]) << 8)
-    if pcidata != 0:
-        blocks = struct.pack('<H', int(count/512))
-        data = data[:pcidata + 16] + blocks + data[pcidata + 18:]
-
-    # Fill in size field; clear checksum field
-    blocks = struct.pack('<B', int(count/512))
-    data = data[:2] + blocks + data[3:6] + as_bytes("\0") + data[7:]
-
-    # Checksum rom
-    data = data[:6] + checksum(data) + data[7:]
-
-    # Write new rom
-    f = open(outname, 'wb')
-    f.write(data)
-    f.close()
-
-if __name__ == '__main__':
-    main()

package/bios/seabios/scripts/buildversion.py

@@ -1,134 +0,0 @@
-#!/usr/bin/env python
-# Generate version information for a program
-#
-# Copyright (C) 2015  Kevin O'Connor <kevin@koconnor.net>
-#
-# This file may be distributed under the terms of the GNU GPLv3 license.
-import sys, os, subprocess, shlex, time, socket, optparse, logging, traceback
-
-VERSION_FORMAT = """
-/* DO NOT EDIT!  This is an autogenerated file.  See scripts/buildversion.py. */
-#define BUILD_VERSION "%s"
-#define BUILD_TOOLS "%s"
-"""
-
-# Run program and return the specified output
-def check_output(prog):
-    logging.debug("Running %s" % (repr(prog),))
-    try:
-        process = subprocess.Popen(shlex.split(prog), stdout=subprocess.PIPE)
-        output = process.communicate()[0]
-        retcode = process.poll()
-    except OSError:
-        logging.debug("Exception on run: %s" % (traceback.format_exc(),))
-        return ""
-    logging.debug("Got (code=%s): %s" % (retcode, repr(output)))
-    if retcode:
-        return ""
-    try:
-        return output.decode()
-    except UnicodeError:
-        logging.debug("Exception on decode: %s" % (traceback.format_exc(),))
-        return ""
-
-# Obtain version info from "git" program
-def git_version():
-    if not os.path.exists('.git'):
-        logging.debug("No '.git' file/directory found")
-        return ""
-    ver = check_output("git describe --always --tags --long --dirty").strip()
-    logging.debug("Got git version: %s" % (repr(ver),))
-    return ver
-
-# Look for version in a ".version" file.  Official release tarballs
-# have this file (see scripts/tarball.sh).
-def file_version():
-    if not os.path.isfile('.version'):
-        logging.debug("No '.version' file found")
-        return ""
-    try:
-        f = open('.version', 'r')
-        ver = f.readline().strip()
-        f.close()
-    except OSError:
-        logging.debug("Exception on read: %s" % (traceback.format_exc(),))
-        return ""
-    logging.debug("Got .version: %s" % (repr(ver),))
-    return ver
-
-# Generate an output file with the version information
-def write_version(outfile, version, toolstr):
-    logging.debug("Write file %s and %s" % (repr(version), repr(toolstr)))
-    sys.stdout.write("Version: %s\n" % (version,))
-    f = open(outfile, 'w')
-    f.write(VERSION_FORMAT % (version, toolstr))
-    f.close()
-
-# Run "tool --version" for each specified tool and extract versions
-def tool_versions(tools):
-    tools = [t.strip() for t in tools.split(';')]
-    versions = ['', '']
-    success = 0
-    for tool in tools:
-        # Extract first line from "tool --version" output
-        verstr = check_output("%s --version" % (tool,)).split('\n')[0]
-        # Check if this tool looks like a binutils program
-        isbinutils = 0
-        if verstr.startswith('GNU '):
-            isbinutils = 1
-            verstr = verstr[4:]
-        # Extract version information and exclude program name
-        if ' ' not in verstr:
-            continue
-        prog, ver = verstr.split(' ', 1)
-        if not prog or not ver:
-            continue
-        # Check for any version conflicts
-        if versions[isbinutils] and versions[isbinutils] != ver:
-            logging.debug("Mixed version %s vs %s" % (
-                repr(versions[isbinutils]), repr(ver)))
-            versions[isbinutils] = "mixed"
-            continue
-        versions[isbinutils] = ver
-        success += 1
-    cleanbuild = versions[0] and versions[1] and success == len(tools)
-    return cleanbuild, "gcc: %s binutils: %s" % (versions[0], versions[1])
-
-def main():
-    usage = "%prog [options] <outputheader.h>"
-    opts = optparse.OptionParser(usage)
-    opts.add_option("-e", "--extra", dest="extra", default="",
-                    help="extra version string to append to version")
-    opts.add_option("-t", "--tools", dest="tools", default="",
-                    help="list of build programs to extract version from")
-    opts.add_option("-v", action="store_true", dest="verbose",
-                    help="enable debug messages")
-
-    options, args = opts.parse_args()
-    if len(args) != 1:
-        opts.error("Incorrect arguments")
-    outfile = args[0]
-    if options.verbose:
-        logging.basicConfig(level=logging.DEBUG)
-
-    cleanbuild, toolstr = tool_versions(options.tools)
-
-    ver = git_version()
-    cleanbuild = cleanbuild and 'dirty' not in ver
-    if not ver:
-        ver = file_version()
-        # We expect the "extra version" to contain information on the
-        # distributor and distribution package version (if
-        # applicable).  It is a "clean" build if this is a build from
-        # an official release tarball and the above info is present.
-        cleanbuild = cleanbuild and ver and options.extra != ""
-        if not ver:
-            ver = "?"
-    if not cleanbuild:
-        btime = time.strftime("%Y%m%d_%H%M%S")
-        hostname = socket.gethostname()
-        ver = "%s-%s-%s" % (ver, btime, hostname)
-    write_version(outfile, ver + options.extra, toolstr)
-
-if __name__ == '__main__':
-    main()

package/bios/seabios/scripts/checkrom.py

@@ -1,95 +0,0 @@
-#!/usr/bin/env python
-# Script to check a bios image and report info on it.
-#
-# Copyright (C) 2008  Kevin O'Connor <kevin@koconnor.net>
-#
-# This file may be distributed under the terms of the GNU GPLv3 license.
-
-import sys, struct
-import layoutrom, buildrom
-
-from python23compat import as_bytes
-
-def subst(data, offset, new):
-    return data[:offset] + new + data[offset + len(new):]
-
-def checksum(data, start, size, csum):
-    sumbyte = buildrom.checksum(data[start:start+size])
-    return subst(data, start+csum, sumbyte)
-
-def main():
-    # Get args
-    objinfo, finalsize, rawfile, outfile = sys.argv[1:]
-
-    # Read in symbols
-    objinfofile = open(objinfo, 'r')
-    symbols = layoutrom.parseObjDump(objinfofile, 'in')[1]
-
-    # Read in raw file
-    f = open(rawfile, 'rb')
-    rawdata = f.read()
-    f.close()
-    datasize = len(rawdata)
-    finalsize = int(finalsize) * 1024
-    if finalsize == 0:
-        finalsize = 64*1024
-        if datasize > 64*1024:
-            finalsize = 128*1024
-            if datasize > 128*1024:
-                finalsize = 256*1024
-    if datasize > finalsize:
-        print("Error!  ROM doesn't fit (%d > %d)" % (datasize, finalsize))
-        print("   You have to either increase the size (CONFIG_ROM_SIZE)")
-        print("   or turn off some features (such as hardware support not")
-        print("   needed) to make it fit.  Trying a more recent gcc version")
-        print("   might work too.")
-        sys.exit(1)
-
-    # Sanity checks
-    start = symbols['code32flat_start'].offset
-    end = symbols['code32flat_end'].offset
-    expend = layoutrom.BUILD_BIOS_ADDR + layoutrom.BUILD_BIOS_SIZE
-    if end != expend:
-        print("Error!  Code does not end at 0x%x (got 0x%x)" % (
-            expend, end))
-        sys.exit(1)
-    if datasize > finalsize:
-        print("Error!  Code is too big (0x%x vs 0x%x)" % (
-            datasize, finalsize))
-        sys.exit(1)
-    expdatasize = end - start
-    if datasize != expdatasize:
-        print("Error!  Unknown extra data (0x%x vs 0x%x)" % (
-            datasize, expdatasize))
-        sys.exit(1)
-
-    # Fix up CSM Compatibility16 table
-    if 'csm_compat_table' in symbols and 'entry_csm' in symbols:
-        # Field offsets within EFI_COMPATIBILITY16_TABLE
-        ENTRY_FIELD_OFS = 14 # Compatibility16CallOffset (UINT16)
-        SIZE_FIELD_OFS = 5   # TableLength (UINT8)
-        CSUM_FIELD_OFS = 4   # TableChecksum (UINT8)
-
-        tableofs = symbols['csm_compat_table'].offset - symbols['code32flat_start'].offset
-        entry_addr = symbols['entry_csm'].offset - layoutrom.BUILD_BIOS_ADDR
-        entry_addr = struct.pack('<H', entry_addr)
-        rawdata = subst(rawdata, tableofs+ENTRY_FIELD_OFS, entry_addr)
-
-        tsfield = tableofs+SIZE_FIELD_OFS
-        tablesize = ord(rawdata[tsfield:tsfield+1])
-        rawdata = checksum(rawdata, tableofs, tablesize, CSUM_FIELD_OFS)
-
-    # Print statistics
-    runtimesize = end - symbols['code32init_end'].offset
-    print("Total size: %d  Fixed: %d  Free: %d (used %.1f%% of %dKiB rom)" % (
-        datasize, runtimesize, finalsize - datasize
-        , (datasize / float(finalsize)) * 100.0
-        , int(finalsize / 1024)))
-
-    # Write final file
-    f = open(outfile, 'wb')
-    f.write((as_bytes("\0") * (finalsize - datasize)) + rawdata)
-    f.close()
-
-if __name__ == '__main__':
-    main()