Subversion Repositories ao486

/*

 * Copyright (c) 2014, Aleksander Osman

 * All rights reserved.

 *

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions are met:

 *

 * * Redistributions of source code must retain the above copyright notice, this

 *   list of conditions and the following disclaimer.

 *

 * * Redistributions in binary form must reproduce the above copyright notice,

 *   this list of conditions and the following disclaimer in the documentation

 *   and/or other materials provided with the distribution.

 *

 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR

 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER

 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,

 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

 */

package ao486.test;

import ao486.test.layers.Layer;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.ObjectInputStream;

import java.io.ObjectOutputStream;

import java.io.Serializable;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.Properties;

import java.util.Random;

public abstract class TestUnit {

    //--------------------------------------------------------------------------

    public long getInput(String name) throws Exception {

//System.out.println("getInput for " + name);

        return (Long)executeMethod(name, false);

    }

    long check_interrupt(long time) throws Exception {

        Long ret = (Long)executeMethod("check_interrupt", false, check_interrupt_index++);

        return (ret == null)? 0x100 : ret;

    }

    long getTestType() throws Exception {

        return (Long)executeMethod("get_test_type", false);

    }

    long read_io(Runner.CMD_start_io_read params) throws Exception {

        return read(params.byteena, params.address, local_io, null, "get_io");

    }

    long read(Runner.CMD_start_read params) throws Exception {

        return read(params.byteena, params.address, local_memory, local_memory_read_only, "get_memory");

    }

    long read_code(Runner.CMD_start_read_code params) throws Exception {

        return read(params.byteena, params.address, local_memory, local_memory_read_only, "get_memory");

    }

    void write_io(Runner.CMD_start_io_write params) throws Exception {

        // do nothing; params saved in Runner

    }

    void write(Runner.CMD_start_write params) throws Exception {

        long byteenable = params.byteena;

        long data       = params.data;

        for(int i=0; i<4; i++) {

            if((byteenable & 1) == 1) local_memory.put(params.address + i, (byte)(data & 0xFF));

            byteenable >>= 1;

            data >>= 8;

        }

    }

    //--------------------------------------------------------------------------

    LinkedList<Object>          run_log                 = new LinkedList<>();

    HashMap<Long, Byte>         local_memory            = new HashMap<>();

    HashMap<Long, Byte>         local_memory_read_only  = new HashMap<>();

    HashMap<Long, Byte>         local_io                = new HashMap<>();

    long                        check_interrupt_index   = 0;

    public Random               random;

    public int                  index;

    public LinkedList<Layer>    layers = new LinkedList<>();

    //--------------------------------------------------------------------------

    private Object executeMethod(String name, boolean null_is_skip, Object ...args) throws Exception {

        for(Layer layer : layers) {

            for(Method m : layer.getClass().getDeclaredMethods()) {

                if(m.getName().equals(name)) {

                    m.setAccessible(true);

                    Object ret = m.invoke(layer, args);

                    if(ret != null || null_is_skip == false) {

                        return ret;

                    }

                }

            }

        }

        return null;

    }

    private long read(long byteenable, long address, HashMap<Long, Byte> map, HashMap<Long, Byte> map_ro, String method_name) throws Exception {

        long data = 0;

        for(int i=0; i<4; i++) {

            data <<= 8;

            if((byteenable & 1) == 1) {

                if(map.containsKey(address + i)) {

                    data |= map.get(address + i) & 0xFFL;

//System.out.printf("in map: %08x = %x\n", (address+i), data & 0xFFL);

                }

                else {

                    Object obj = executeMethod(method_name, true, (address + i));

//System.out.printf("executed: %08x = %x, in class: %s, method_name: %s\n", (address+i), (obj != null)? (Byte)obj : 0, executed_in_class, method_name);

                    if(obj == null) data |= random.nextInt() & 0xFFL;

                    else            data |= ((Byte)obj) & 0xFFL;

                    map.put(address + i, (byte)(data & 0xFFL));

                    if(map_ro != null) map_ro.put(address + i, (byte)(data & 0xFFL));

                }

            }

            byteenable >>= 1;

        }

        return ((data >> 24) & 0xFFL) | ((data >> 8) & 0xFF00L) | ((data << 8) & 0xFF0000L) | ((data << 24) & 0xFF000000L);

    }

    //--------------------------------------------------------------------------

    public boolean is_memory_not_random(long address) throws Exception {

        Boolean ret = (Boolean)executeMethod("is_memory_not_random", false, address);

        return (ret == null)? false : ret;

    }

    public String bytesToHex(byte bytes[]) {

        String s = "";

        for(byte b : bytes) s += String.format("%02x", b);

        return s;

    }

    static public byte[] hexToBytes(String hex) throws Exception {

        if((hex.length() %2) != 0) throw new Exception("Not full hex string: " + hex);

        byte bytes[] = new byte[hex.length()/2];

        for(int i=0; i<bytes.length; i++) bytes[i] = (byte)Integer.valueOf(hex.substring(i*2, i*2+2), 16).intValue();

        return bytes;

    }

    public boolean isAccepted(int val, boolean... conds) {

        for(boolean b : conds) {

            if((val & 1) == 1 && b == false) return false;

            if((val & 1) == 0 && b == true) return false;

            val >>= 1;

        }

        return true;

    }

    public int unsigned(byte b) {

        int result = b;

        if(result < 0) result += 256;

        return result;

    }

    public int modregrm_len(boolean a16, int modregrm, int sib) {

        int mod      = (modregrm >> 6) & 3;

        int rm       = modregrm & 7;

        int base     = sib & 7;

        // d_CRx_DRx_condition ignored

        if(a16 && mod == 0 && rm == 6) return 3;

        if(a16 && mod == 1) return 2;

        if(a16 && mod == 2) return 3;

        if(a16) return 1;

        if(mod == 0 && rm == 5) return 5;

        if(mod == 0 && rm == 4 && base == 5) return 6;

        if(mod == 0 && rm == 4) return 2;

        if(mod == 1 && rm == 4) return 3;

        if(mod == 1) return 2;

        if(mod == 2 && rm == 4) return 6;

        if(mod == 2) return 5;

        return 1;

    }

    public static class Descriptor implements Serializable {

        public Descriptor(int base, int limit, int type, boolean segment, boolean present, int dpl, boolean d_b, boolean g, boolean l, boolean avl) {

            this.base       = base;

            this.limit      = limit;

            this.type       = type;

            this.segment    = segment;

            this.present    = present;

            this.dpl        = dpl;

            this.d_b        = d_b;

            this.g          = g;

            this.l          = l;

            this.avl        = avl;

        }

        public int     base,limit,type,dpl;

        public boolean segment, present, d_b, g;

        public boolean l, avl;

        public byte get_byte(int index) {

            switch(index) {

                case 0:     return (byte)((limit >> 0) & 0xFF);

                case 1:     return (byte)((limit >> 8) & 0xFF);

                case 2:     return (byte)((base >> 0) & 0xFF);

                case 3:     return (byte)((base >> 8) & 0xFF);

                case 4:     return (byte)((base >> 16) & 0xFF);

                case 5:     return (byte)( (present? 1 << 7 : 0) | ((dpl & 3) << 5) | (segment? 1 << 4 : 0) | (type & 15) );

                case 6:     return (byte)( (g? 1 << 7 : 0) | (d_b? 1 << 6 : 0) | (l? 1 << 5 : 0) | (avl? 1 << 4 : 0) | ((limit >> 16) & 15) );

                default:    return (byte)((base >> 24) & 0xFF);

            }

        }

        public void set_dest_offset(long offset) {

            limit = (int)(offset & 0xFFFFF);

            avl   = ((offset >> 20)&1) == 1;

            l     = ((offset >> 21)&1) == 1;

            d_b   = ((offset >> 22)&1) == 1;

            g     = ((offset >> 23)&1) == 1;

            base  = (int)((offset & 0xFF000000) | (base & 0x00FFFFFF));

        }

    }

    //--------------------------------------------------------------------------

    public abstract int get_test_count() throws Exception;

    public abstract void init() throws Exception;

    //--------------------------------------------------------------------------

    //--------------------------------------------------------------------------

    public static void run_test(Class test_class) throws Exception {

        int index = 0;

        FileInputStream run_prop_files = new FileInputStream("run.properties");

        Properties run_prop = new Properties();

        run_prop.load(run_prop_files);

        run_prop_files.close();

        if(run_prop.getProperty("deserialize").toLowerCase().equals("yes")) {

            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("test.obj"));

            index = ois.readInt();

            ois.close();

        }

        File output_directory = new File(".");

        File directory;

        LinkedList<String> command_line = new LinkedList<>();

        Runner runner = new Runner();

        boolean test_failed = false;

        TestUnit test_for_size = (TestUnit)test_class.newInstance();

        for(; index<test_for_size.get_test_count(); index++) {

            System.out.println(">>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> Running test " +

                    (index+1) + "/" + test_for_size.get_test_count());

            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("test.obj"));

            oos.writeInt(index);

            oos.close();

            //run bochs486

            TestUnit test_bochs = (TestUnit)test_class.newInstance();

            test_bochs.index = index;

            test_bochs.init();

            directory = new File("./../bochs486/");

            command_line.clear();

            command_line.add("./bochs486");

            runner.execute(command_line, directory, test_bochs);

            //run verilog

            TestUnit test_verilog = (TestUnit)test_class.newInstance();

            test_verilog.index        = index;

            test_verilog.local_io     = test_bochs.local_io;

            test_verilog.local_memory = test_bochs.local_memory_read_only;

            test_verilog.init();

            directory = new File("./../sim/ao486");

            command_line.clear();

            command_line.add("/opt/iverilog/bin/vvp");

            command_line.add("tb_ao486.vvp");

            //command_line.add("-lxt");

            runner.execute(command_line, directory, test_verilog);

            test_failed = RunRaport.compare(test_bochs.run_log, test_verilog.run_log, output_directory);

            if(test_failed) break;

        }

        if(test_failed) System.out.println("TEST: FAILED.");

        else            System.out.println("TEST: OK.");

    }

}