v86 0.4.0 → 0.5.11

package/bios/seabios/scripts/python23compat.py

@@ -1,14 +0,0 @@
-# Helper code for compatibility of the code with both Python 2 and Python 3
-#
-# Copyright (C) 2014 Johannes Krampf <johannes.krampf@googlemail.com>
-#
-# This file may be distributed under the terms of the GNU GPLv3 license.
-
-import sys
-
-if (sys.version_info > (3, 0)):
-    def as_bytes(str):
-        return bytes(str, "ASCII")
-else:
-    def as_bytes(str):
-        return str

package/bios/seabios/scripts/readserial.py

@@ -1,190 +0,0 @@
-#!/usr/bin/env python
-# Script that can read from a serial device and show timestamps.
-#
-# Copyright (C) 2009  Kevin O'Connor <kevin@koconnor.net>
-#
-# This file may be distributed under the terms of the GNU GPLv3 license.
-
-# Usage:
-#   scripts/readserial.py /dev/ttyUSB0 115200
-
-import sys, os, time, select, optparse
-
-from python23compat import as_bytes
-
-# Reset time counter after this much idle time.
-RESTARTINTERVAL = 60
-# Number of bits in a transmitted byte - 8N1 is 1 start bit + 8 data
-# bits + 1 stop bit.
-BITSPERBYTE = 10
-
-def calibrateserialwrite(outfile, byteadjust):
-    # Build 4000 bytes of dummy data.
-    data = "0123456789" * 4 + "012345678" + "\n"
-    data = data * 80
-    while 1:
-        st = time.time()
-        outfile.write(as_bytes(data))
-        outfile.flush()
-        et = time.time()
-        sys.stdout.write(
-            "Wrote %d - %.1fus per char (theory states %.1fus)\n" % (
-                len(data), (et-st) / len(data) * 1000000, byteadjust * 1000000))
-        sys.stdout.flush()
-        time.sleep(3)
-
-def calibrateserialread(infile, byteadjust):
-    starttime = lasttime = 0
-    totalchars = 0
-    while 1:
-        select.select([infile], [], [])
-        d = infile.read(4096)
-        curtime = time.time()
-        if curtime - lasttime > 1.0:
-            if starttime and totalchars:
-                sys.stdout.write(
-                    "Calibrating on %d bytes - %.1fus per char"
-                    " (theory states %.1fus)\n" % (
-                        totalchars,
-                        float(lasttime - starttime) * 1000000 / totalchars,
-                        byteadjust * 1000000))
-            totalchars = 0
-            starttime = curtime
-        else:
-            totalchars += len(d)
-        lasttime = curtime
-
-def readserial(infile, logfile, byteadjust):
-    lasttime = 0
-    while 1:
-        # Read data
-        try:
-            res = select.select([infile, sys.stdin], [], [])
-        except KeyboardInterrupt:
-            sys.stdout.write("\n")
-            return -1
-        if sys.stdin in res[0]:
-            # Got keyboard input - force reset on next serial input
-            sys.stdin.read(1)
-            lasttime = 0
-            if len(res[0]) == 1:
-                continue
-        d = infile.read(4096)
-        if not d:
-            return 0
-        datatime = time.time()
-
-        datatime -= len(d) * byteadjust
-
-        # Reset start time if no data for some time
-        if datatime - lasttime > RESTARTINTERVAL:
-            starttime = datatime
-            charcount = 0
-            isnewline = 1
-            msg = "\n\n======= %s (adjust=%.1fus)\n" % (
-                time.asctime(time.localtime(datatime)), byteadjust * 1000000)
-            sys.stdout.write(msg)
-            logfile.write(as_bytes(msg))
-        lasttime = datatime
-
-        # Translate unprintable chars; add timestamps
-        out = as_bytes("")
-        for c in d:
-            if isnewline:
-                delta = datatime - starttime - (charcount * byteadjust)
-                out += "%06.3f: " % delta
-                isnewline = 0
-            oc = ord(c)
-            charcount += 1
-            datatime += byteadjust
-            if oc == 0x0d:
-                continue
-            if oc == 0x00:
-                out += "<00>\n"
-                isnewline = 1
-                continue
-            if oc == 0x0a:
-                out += "\n"
-                isnewline = 1
-                continue
-            if oc < 0x20 or oc >= 0x7f and oc != 0x09:
-                out += "<%02x>" % oc
-                continue
-            out += c
-
-        if (sys.version_info > (3, 0)):
-            sys.stdout.buffer.write(out)
-        else:
-            sys.stdout.write(out)
-        sys.stdout.flush()
-        logfile.write(out)
-        logfile.flush()
-
-def main():
-    usage = "%prog [options] [<serialdevice> [<baud>]]"
-    opts = optparse.OptionParser(usage)
-    opts.add_option("-f", "--file",
-                    action="store_false", dest="serial", default=True,
-                    help="read from unix named pipe instead of serialdevice")
-    opts.add_option("-n", "--no-adjust",
-                    action="store_false", dest="adjustbaud", default=True,
-                    help="don't adjust times by serial rate")
-    opts.add_option("-c", "--calibrate-read",
-                    action="store_true", dest="calibrate_read", default=False,
-                    help="read from serial port to calibrate it")
-    opts.add_option("-C", "--calibrate-write",
-                    action="store_true", dest="calibrate_write", default=False,
-                    help="write to serial port to calibrate it")
-    opts.add_option("-t", "--time",
-                    type="float", dest="time", default=None,
-                    help="time to write one byte on serial port (in us)")
-    options, args = opts.parse_args()
-    serialport = 0
-    baud = 115200
-    if len(args) > 2:
-        opts.error("Too many arguments")
-    if len(args) > 0:
-        serialport = args[0]
-    if len(args) > 1:
-        baud = int(args[1])
-    byteadjust = float(BITSPERBYTE) / baud
-    if options.time is not None:
-        byteadjust = options.time / 1000000.0
-    if not options.adjustbaud:
-        byteadjust = 0.0
-
-    if options.serial:
-        # Read from serial port
-        try:
-            import serial
-        except ImportError:
-            print("""
-Unable to find pyserial package ( http://pyserial.sourceforge.net/ ).
-On Linux machines try: yum install pyserial
-Or: apt-get install python-serial
-""")
-            sys.exit(1)
-        ser = serial.Serial(serialport, baud, timeout=0)
-
-    if options.calibrate_read:
-        calibrateserialread(ser, byteadjust)
-        return
-    if options.calibrate_write:
-        calibrateserialwrite(ser, byteadjust)
-        return
-
-    logname = time.strftime("seriallog-%Y%m%d_%H%M%S.log")
-    f = open(logname, 'wb')
-    if options.serial:
-        readserial(ser, f, byteadjust)
-    else:
-        # Read from a pipe
-        while 1:
-            ser = os.fdopen(os.open(serialport, os.O_RDONLY|os.O_NONBLOCK), 'rb')
-            res = readserial(ser, f, byteadjust)
-            ser.close()
-            if res < 0:
-                break
-
-if __name__ == '__main__':
-    main()

package/bios/seabios/scripts/tarball.sh

@@ -1,36 +0,0 @@
-#!/bin/sh
-#
-# Script to create seabios release and snapshot tarballs.
-# Accepts conmmit (hash, tag, branch, ...) as first argument,
-# uses HEAD if unspecified.
-#
-
-commit="${1-HEAD}"
-
-# figure name for the tarball
-reltag="$(git describe --tags --match 'rel-*' --exact $commit 2>/dev/null)"
-if test "$reltag" != ""; then
-	# release
-	name="${reltag#rel-}"
-else
-	# snapshot
-	reltag="$(git describe --tags --match 'rel-*' $commit 2>/dev/null)"
-	name="snap-${reltag#rel-}"
-fi
-
-# export tarball archive from git
-prefix="seabios-${name}/"
-output="seabios-${name}.tar"
-echo "# commit $commit  ->  tarball: ${output}.gz"
-rm -f "$output" "${output}.gz"
-git archive --format=tar --prefix="$prefix" "$commit" > "$output"
-
-# add .version file to tarball
-dotver="$(mktemp dotver.XXXXXX)"
-echo "$name" > "$dotver"
-tar --append --file="$output" --owner=root --group=root --mode=0664 \
-	--transform "s:${dotver}:${prefix}.version:" "$dotver"
-rm -f "$dotver"
-
-# finally compress it
-gzip "$output"

package/bios/seabios/scripts/test-build.sh

@@ -1,90 +0,0 @@
-#!/bin/sh
-# Script to test if the build works properly.
-
-mkdir -p ${OUT}
-TMPFILE1=${OUT}/tmp_testcompile1.c
-TMPFILE1o=${OUT}/tmp_testcompile1.o
-TMPFILE1_ld=${OUT}/tmp_testcompile1.lds
-TMPFILE2=${OUT}/tmp_testcompile2.c
-TMPFILE2o=${OUT}/tmp_testcompile2.o
-TMPFILE3o=${OUT}/tmp_testcompile3.o
-
-# Test if ld's alignment handling is correct.  This is a known problem
-# with the linker that ships with Ubuntu 11.04.
-cat - > $TMPFILE1 <<EOF
-const char v1[] __attribute__((section(".text.v1"))) = "0123456789";
-const char v2[] __attribute__((section(".text.v2"))) = "0123456789";
-EOF
-cat - > $TMPFILE1_ld <<EOF
-SECTIONS
-{
-     .mysection 0x88f0 : {
-. = 0x10 ;
-*(.text.v1)
-. = 0x20 ;
-*(.text.v2)
-. = 0x30 ;
-     }
-}
-EOF
-$CC -O -g -c $TMPFILE1 -o $TMPFILE1o > /dev/null 2>&1
-if [ $? -ne 0 ]; then
-    echo "Unable to execute the C compiler ($CC)." >&2
-    echo "" >&2
-    echo "Please install a working compiler and retry." >&2
-    echo -1
-    exit 0
-fi
-$LD -T $TMPFILE1_ld $TMPFILE1o -o $TMPFILE2o > /dev/null 2>&1
-if [ $? -ne 0 ]; then
-    echo "The version of LD on this system ($LD) does not properly handle" >&2
-    echo "alignments.  As a result, this project can not be built." >&2
-    echo "" >&2
-    echo "The problem may be the result of this LD bug report:" >&2
-    echo " http://sourceware.org/bugzilla/show_bug.cgi?id=12726" >&2
-    echo "" >&2
-    echo "Please update to a working version of binutils and retry." >&2
-    echo -1
-    exit 0
-fi
-
-# Test for "-fwhole-program".  Older versions of gcc (pre v4.1) don't
-# support the whole-program optimization - detect that.
-$CC -fwhole-program -S -o /dev/null -xc /dev/null > /dev/null 2>&1
-if [ $? -ne 0 ]; then
-    echo "  Working around no -fwhole-program" >&2
-    echo 2
-    exit 0
-fi
-
-# Test if "visible" variables and functions are marked global.  On
-# OpenSuse 10.3 "visible" variables declared with "extern" first
-# aren't marked as global in the resulting assembler.  On Ubuntu 7.10
-# "visible" functions aren't marked as global in the resulting
-# assembler.
-cat - > $TMPFILE1 <<EOF
-void __attribute__((externally_visible)) t1() { }
-extern unsigned char v1;
-unsigned char v1 __attribute__((section(".data16.foo.19"))) __attribute__((externally_visible));
-EOF
-$CC -Os -c -fwhole-program $TMPFILE1 -o $TMPFILE1o > /dev/null 2>&1
-cat - > $TMPFILE2 <<EOF
-void t1();
-extern unsigned char v1;
-int __attribute__((externally_visible)) main() { t1(); return v1; }
-EOF
-$CC -Os -c -fwhole-program $TMPFILE2 -o $TMPFILE2o > /dev/null 2>&1
-$CC -nostdlib -Os $TMPFILE1o $TMPFILE2o -o $TMPFILE3o > /dev/null 2>&1
-if [ $? -ne 0 ]; then
-    echo "  Working around non-functional -fwhole-program" >&2
-    echo 2
-    exit 0
-fi
-
-echo 0
-
-# Also, the Ubuntu 8.04 compiler has a bug causing corruption when the
-# "ebp" register is clobberred in an "asm" statement.  The code has
-# been modified to not clobber "ebp" - no test is available yet.
-
-rm -f $TMPFILE1 $TMPFILE1o $TMPFILE1_ld $TMPFILE2 $TMPFILE2o $TMPFILE3o

package/bios/seabios/scripts/transdump.py

@@ -1,53 +0,0 @@
-#!/usr/bin/env python
-
-# This script is useful for taking the output of memdump() and
-# converting it back into binary output.  This can be useful, for
-# example, when one wants to push that data into other tools like
-# objdump or hexdump.
-#
-# (C) Copyright 2010 Kevin O'Connor <kevin@koconnor.net>
-#
-# This file may be distributed under the terms of the GNU GPLv3 license.
-
-import sys
-import struct
-
-def unhex(str):
-    return int(str, 16)
-
-def parseMem(filehdl):
-    mem = []
-    for line in filehdl:
-        parts = line.split(':')
-        if len(parts) < 2:
-            continue
-        try:
-            vaddr = unhex(parts[0])
-            parts = parts[1].split()
-            mem.extend([unhex(v) for v in parts])
-        except ValueError:
-            continue
-    return mem
-
-def printUsage():
-    sys.stderr.write("Usage:\n %s <file | ->\n"
-                     % (sys.argv[0],))
-    sys.exit(1)
-
-def main():
-    if len(sys.argv) != 2:
-        printUsage()
-    filename = sys.argv[1]
-    if filename == '-':
-        filehdl = sys.stdin
-    else:
-        filehdl = open(filename, 'r')
-    mem = parseMem(filehdl)
-    for i in mem:
-        if (sys.version_info > (3, 0)):
-            sys.stdout.buffer.write(struct.pack("<I", i))
-        else:
-            sys.stdout.write(struct.pack("<I", i))
-
-if __name__ == '__main__':
-    main()

package/bios/seabios/scripts/vgafixup.py

@@ -1,96 +0,0 @@
-#!/usr/bin/env python
-# Work around x86emu bugs by replacing problematic instructions.
-#
-# Copyright (C) 2012  Kevin O'Connor <kevin@koconnor.net>
-#
-# This file may be distributed under the terms of the GNU GPLv3 license.
-
-# The x86emu code widely used in Linux distributions when running Xorg
-# in vesamode is known to have issues with "retl", "leavel", "entryl",
-# "leal", and some variants of "calll".  This code modifies those
-# instructions that are known to be generated by gcc to avoid
-# triggering the x86emu bugs.
-
-# It is also known that the Windows vgabios emulator has issues with
-# addressing negative offsets to the %esp register.  That has been
-# worked around by not using the gcc parameter "-fomit-frame-pointer"
-# when compiling.
-
-import sys, re
-
-# leal parameter regex - example string: -3(%edx,%eax,8), %eax
-re_leal = re.compile(
-    r'^\s*(?P<offset>[^(]*?)\s*'
-    r'\(\s*(?P<base>[^,)]*?)\s*(?:,\s*(?P<index>[^,)]*?)\s*)?'
-    r'(?:,\s*(?P<scale>[^,)]*?)\s*)?\)\s*'
-    r',\s*(?P<dest>.*?)\s*$')
-
-# Find an alternate set of instructions for a given "leal" instruction
-def handle_leal(sline):
-    m = re_leal.match(sline[5:])
-    if m is None or m.group('index') == '%esp':
-        print("Unable to fixup leal instruction: %s" % (sline,))
-        sys.exit(-1)
-    offset, base, index, scale, dest = m.group(
-        'offset', 'base', 'index', 'scale', 'dest')
-    if dest == '%esp':
-        # If destination is %esp then just use 16bit leaw instead
-        return 'leaw %s\n' % (sline[5:].replace('%e', '%'),)
-    if not scale:
-        scale = '1'
-    scale = {1: 0, 2: 1, 4: 2, 8: 3}[int(scale, 0)]
-    # Try to rearrange arguments to simplify 'base' (to improve code gen)
-    if not scale and base == index:
-        base, index, scale = '', index, 1
-    elif not index or (not scale and base in (dest, '%esp') and index != dest):
-        base, index, scale = index, base, 0
-    # Produce instructions to calculate "leal"
-    insns = ['pushfw']
-    if base != dest:
-        # Calculate "leal" directly in dest register
-        if index != dest:
-            insns.insert(0, 'movl %s, %s' % (index, dest))
-        if scale:
-            insns.append('shll $%d, %s' % (scale, dest))
-        if base:
-            if base == '%esp':
-                offset += '+2'
-            insns.append('addl %s, %s' % (base, dest))
-    elif base == index:
-        # Use "imull" method
-        insns.append('imull $%d, %s' % ((1<<scale)+1, dest))
-    else:
-        # Backup/restore index register and do scaling in index register
-        insns.append('pushl %s' % (index,))
-        insns.append('shll $%d, %s' % (scale, index))
-        insns.append('addl %s, %s' % (index, dest))
-        insns.append('popl %s' % (index,))
-    if offset and offset != '0':
-        insns.append('addl $%s, %s' % (offset, dest))
-    insns.append('popfw\n')
-    return ' ; '.join(insns)
-
-def main():
-    infilename, outfilename = sys.argv[1:]
-    infile = open(infilename, 'r')
-    out = []
-    for line in infile:
-        sline = line.strip()
-        if sline == 'ret':
-            out.append('retw $2\n')
-        elif sline == 'leave':
-            out.append('movl %ebp, %esp ; popl %ebp\n')
-        elif sline.startswith('call'):
-            out.append('pushw %ax ; callw' + sline[4:] + '\n')
-        elif sline.startswith('leal'):
-            out.append(handle_leal(sline))
-            #print("-> %s\n   %s" % (sline, out[-1].strip()))
-        else:
-            out.append(line)
-    infile.close()
-    outfile = open(outfilename, 'w')
-    outfile.write(''.join(out))
-    outfile.close()
-
-if __name__ == '__main__':
-    main()