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.Runner.CMD_start_output;

import ao486.test.Runner.CMD_start_completed;

import java.io.File;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.io.LineNumberReader;

import java.io.OutputStream;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.util.HashMap;

import java.util.LinkedList;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class Runner {

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

    static class CMD_start_completed {

        long time;

        long rep;

        long seg;

        long lock;

        long os32;

        long as32;

        long consumed;

    }

    void start_completed(CMD_start_completed params) throws Exception {

        System.out.println("----------------------------------------------------------------[Runner]: start_completed");

        unit.run_log.add(params);

    }

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

    static class CMD_start_output {

        long time;

        //only from verilog testbench

        long tb_wr_cmd_last;

        long tb_can_ignore;

        long eax, ebx, ecx, edx, esi, edi, ebp, esp;

        long eip;

        long cflag, pflag, aflag, zflag, sflag, tflag, iflag, dflag, oflag, iopl, ntflag, rflag, vmflag, acflag, idflag;

        long cs_cache_valid,   cs,   cs_rpl,   cs_base,   cs_limit,   cs_g,   cs_d_b,   cs_avl,   cs_p,   cs_dpl,   cs_s,   cs_type;

        long ds_cache_valid,   ds,   ds_rpl,   ds_base,   ds_limit,   ds_g,   ds_d_b,   ds_avl,   ds_p,   ds_dpl,   ds_s,   ds_type;

        long es_cache_valid,   es,   es_rpl,   es_base,   es_limit,   es_g,   es_d_b,   es_avl,   es_p,   es_dpl,   es_s,   es_type;

        long fs_cache_valid,   fs,   fs_rpl,   fs_base,   fs_limit,   fs_g,   fs_d_b,   fs_avl,   fs_p,   fs_dpl,   fs_s,   fs_type;

        long gs_cache_valid,   gs,   gs_rpl,   gs_base,   gs_limit,   gs_g,   gs_d_b,   gs_avl,   gs_p,   gs_dpl,   gs_s,   gs_type;

        long ss_cache_valid,   ss,   ss_rpl,   ss_base,   ss_limit,   ss_g,   ss_d_b,   ss_avl,   ss_p,   ss_dpl,   ss_s,   ss_type;

        long ldtr_cache_valid, ldtr, ldtr_rpl, ldtr_base, ldtr_limit, ldtr_g, ldtr_d_b, ldtr_avl, ldtr_p, ldtr_dpl, ldtr_s, ldtr_type;

        long tr_cache_valid,   tr,   tr_rpl,   tr_base,   tr_limit,   tr_g,   tr_d_b,   tr_avl,   tr_p,   tr_dpl,   tr_s,   tr_type;

        long gdtr_base, gdtr_limit;

        long idtr_base, idtr_limit;

        long cr0_pe, cr0_mp, cr0_em, cr0_ts, cr0_ne, cr0_wp, cr0_am, cr0_nw, cr0_cd, cr0_pg;

        long cr2, cr3;

        long dr0, dr1, dr2, dr3;

        long dr6, dr7;

    }

    void start_output(CMD_start_output params) throws Exception {

        System.out.println("[Runner]: start_output");

        unit.run_log.add(params);

    }

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

    static class CMD_start_check_interrupt {

        long time;

    }

    void start_check_interrupt(CMD_start_check_interrupt params) throws Exception {

        System.out.println("[Runner]: start_check_interrupt");

        long value = unit.check_interrupt(params.time);

        out.write(String.format("%x\n", value).getBytes());

        out.flush();

    }

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

    static class CMD_start_interrupt {

        long time;

        long vector;

    }

    void start_interrupt(CMD_start_interrupt params) throws Exception {

        System.out.println("[Runner]: start_interrupt");

        unit.run_log.add(params);

    }

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

    static class CMD_start_exception {

        long time;

        long vector;

        long push_error;

        long error_code;

    }

    void start_exception(CMD_start_exception params) throws Exception {

        System.out.println("[Runner]: start_exception");

        unit.run_log.add(params);

    }

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

    static class CMD_start_read {

        long time;

        long address;

        long byteena;

        long can_ignore;

    }

    void start_read(CMD_start_read params) throws Exception {

        System.out.printf("[Runner]: start_read, address: %08x, byteena: %x\n", params.address, params.byteena);

        unit.run_log.add(params);

        long value = unit.read(params);

        params.byteena |= (value & 0xFFFFFFFFL) << 8;

        out.write(String.format("%x\n", value).getBytes());

        out.flush();

System.out.printf("[Runner]: start_read done: %08x\n", value);

    }

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

    static class CMD_start_read_code {

        long time;

        long address;

        long byteena;

    }

    void start_read_code(CMD_start_read_code params) throws Exception {

//System.out.printf("[Runner]: start_read_code: %08x ena %x\n", params.address, params.byteena);

        long value = unit.read_code(params);

//System.out.printf("[Runner]: start_read_code result: %08x\n", value);

        out.write(String.format("%x\n", value).getBytes());

        out.flush();

    }

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

    static class CMD_start_write {

        long time;

        long address;

        long data;

        long byteena;

        long can_ignore;

    }

    void start_write(CMD_start_write params) throws Exception {

        System.out.println("[Runner]: start_write");

        if(((params.byteena >> 0) & 1) == 0) params.data &= 0xFFFFFF00L;

        if(((params.byteena >> 1) & 1) == 0) params.data &= 0xFFFF00FFL;

        if(((params.byteena >> 2) & 1) == 0) params.data &= 0xFF00FFFFL;

        if(((params.byteena >> 3) & 1) == 0) params.data &= 0x00FFFFFFL;

        unit.run_log.add(params);

        unit.write(params);

    }

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

    static class CMD_start_io_write {

        long time;

        long address;

        long data;

        long byteena;

        long can_ignore;

    }

    void start_io_write(CMD_start_io_write params) throws Exception {

        System.out.printf("[Runner]: start_io_write: %04x byteena: %x\n", params.address, params.byteena);

        if(((params.byteena >> 0) & 1) == 0) params.data &= 0xFFFFFF00L;

        if(((params.byteena >> 1) & 1) == 0) params.data &= 0xFFFF00FFL;

        if(((params.byteena >> 2) & 1) == 0) params.data &= 0xFF00FFFFL;

        if(((params.byteena >> 3) & 1) == 0) params.data &= 0x00FFFFFFL;

        unit.run_log.add(params);

        unit.write_io(params);

    }

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

    static class CMD_start_io_read {

        long time;

        long address;

        long byteena;

        long can_ignore;

    }

    void start_io_read(CMD_start_io_read params) throws Exception {

        System.out.println("[Runner]: start_io_read");

        unit.run_log.add(params);

        boolean read_ff =

                (params.address >= 0x0010 && params.address < 0x0020)     ||

                (params.address == 0x0020 && (params.byteena & 0x3) == 0) ||

                (params.address >= 0x0024 &&  params.address < 0x0040)    ||

                (params.address >= 0x0044 &&  params.address < 0x0060)    ||

                (params.address >= 0x0068 &&  params.address < 0x0070)    ||

                (params.address == 0x0070 && (params.byteena & 0x3) == 0) ||

                (params.address >= 0x0074 &&  params.address < 0x0080)    ||

                (params.address == 0x00A0 && (params.byteena & 0x3) == 0) ||

                (params.address >= 0x00A4 &&  params.address < 0x00C0)    ||

                (params.address >= 0x00E0 &&  params.address < 0x01F0)    ||

                (params.address >= 0x01F8 &&  params.address < 0x0220)    ||

                (params.address >= 0x0230 &&  params.address < 0x0388)    ||

                (params.address == 0x0388 && (params.byteena & 0x3) == 0) ||

                (params.address >= 0x038C &&  params.address < 0x03B0)    ||

                (params.address >= 0x03E0 &&  params.address < 0x03F0)    ||

                (params.address >= 0x03F8 &&  params.address < 0x8888)    ||

                (params.address >= 0x8890);

        boolean read_ff_part =

                (params.address == 0x0020) ||

                (params.address == 0x0070) ||

                (params.address == 0x00A0) ||

                (params.address == 0x0388);

        long value =

                (read_ff)?          0xFFFFFFFFL :

                (read_ff_part)?     0xFFFF0000L | unit.read_io(params) :

                                    unit.read_io(params);

        params.byteena |= (value & 0xFFFFFFFFL) << 8;

        out.write(String.format("%x\n", value).getBytes());

        out.flush();

    }

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

    static class CMD_start_input {

        long time;

    }

    void start_input(CMD_start_input params) throws Exception {

        System.out.println("[Runner]: start_input");

        for(Field field : CMD_start_output.class.getDeclaredFields()) {

            if(field.getName().equals("time"))              continue;

            if(field.getName().equals("tb_wr_cmd_last"))    continue;

            if(field.getName().equals("tb_can_ignore"))     continue;

            long value = unit.getInput(field.getName());

//System.out.println("start_input: " + field.getName() + ", " + value);        

            out.write(String.format("%s: %x\n", field.getName(), value).getBytes());

        }

        out.write(String.format("test_type: %x\n", unit.getTestType()).getBytes());

        out.write("continue: 0\n".getBytes());

        out.flush();

    }

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

    static class CMD_start_shutdown {

        long time;

    }

    void start_shutdown(CMD_start_shutdown params) throws Exception {

        System.out.println("[Runner]: start_shutdown");

        unit.run_log.add(params);

    }

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

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

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

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

    void execute(LinkedList<String> command_line, File directory, TestUnit unit) throws Exception {

        Process p = null;

        this.unit = unit;

        try {

            ProcessBuilder pb = new ProcessBuilder(command_line);

            pb.directory(directory);

            pb.redirectErrorStream(true);

            p = pb.start();

            InputStream  in  = p.getInputStream();

            out = p.getOutputStream();

            boolean started = false;

            LineNumberReader reader = new LineNumberReader(new InputStreamReader(in));

            HashMap<String, Long> params = new HashMap<>();

            while(true) {

                String line = reader.readLine();

                if(line == null) {

                    in.close();

                    out.close();

                    p.waitFor();

                    break;

                }

                line = line.trim();

//System.out.println("line: " + line);

                if(line.startsWith("START")) {

                    started = true;

                    continue;

                }

                if(started == false) continue;

                if(line.startsWith("#")) {

//System.out.println("line: " + line);

                    continue;

                }

                if(line.equals("")) {

                    if(params.isEmpty()) continue;

                    dispatch(params);

                    params.clear();

                    continue;

                }

                //match name: hex_value

                Pattern pat = Pattern.compile("(\\w+?):\\s*([0-9a-fA-F]+)");

                Matcher mat = pat.matcher(line);

                boolean found = mat.find();

                if(found == false) throw new Exception("Invalid line: " + line);

                String s1 = mat.group(1).trim();

                String s2 = mat.group(2).trim();

                params.put(s1, Long.parseLong(s2, 16));

//System.out.println("PUT: " + s1 + " = " + s2);

            }

        }

        finally {

            if(p != null) p.destroy();

        }

    }

    private void dispatch(HashMap<String, Long> params) throws Exception {

        //find name starting with: start_

        String start = null;

        for(String name : params.keySet()) if(name.startsWith("start_")) { start = name; break; }

        if(start == null) throw new Exception("No start_* in command.");

        Class this_class = this.getClass();

        //find class

        Class command_class = null;

        for(Class inner_class : this_class.getDeclaredClasses()) {

            if(inner_class.getSimpleName().equals("CMD_" + start)) {

                command_class = inner_class;

                break;

            }

        }

        if(command_class == null) throw new Exception("No command class found for: " + start);

        //find method

        Method method = null;

        for(Method m : this_class.getDeclaredMethods()) {

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

                method = m;

                break;

            }

        }

        if(method == null) throw new Exception("No method found for: " + start);

        //command class instance

        Object class_obj = command_class.newInstance();

        for(Field f : command_class.getDeclaredFields()) {

            String field_name = f.getName();

            if(field_name.equals("time")) {

                f.set(class_obj, params.get(start));

            }

            else if(params.containsKey(field_name)) {

                f.set(class_obj, params.get(field_name));

            }

            else throw new Exception("Unknown field name: " + field_name + " for class: " + command_class.getSimpleName());

        }

        //execute method

        method.setAccessible(true);

        method.invoke(this, class_obj);

    }

    private TestUnit     unit;

    private OutputStream out;

}