Subversion Repositories ao68000

/*

 * Copyright 2010, Aleksander Osman, alfik@poczta.fm. All rights reserved.

 *

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

 * permitted provided that the following conditions are met:

 *

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

 *     conditions and the following disclaimer.

 *

 *  2. 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 AUTHOR ``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 AUTHOR 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 ao68000_tool;

import java.io.File;

import java.util.HashMap;

import java.util.Random;

import java.util.Vector;

/*

 * 0000 0000 ss ddd DDD : ORI

 *

 * 0000 rrr1 00 ddd DDD : BTST

 * 0000 ddd1 ss 001 sss : MOVEP from memory

 *

 * 0000 rrr1 01 ddd DDD : BCHG

 * 0000 rrr1 10 ddd DDD : BCLR

 * 0000 rrr1 11 ddd DDD : BSET

 *

 * 0000 0010 ss ddd DDD : ANDI

 *

 * 0000 0100 ss ddd DDD : SUBI

 *

 * 0000 0110 ss ddd DDD : ADDI

 *

 * 0000 1000 00 ddd DDD : BTST imm

 * 0000 1000 01 ddd DDD : BCHG imm

 * 0000 1000 10 ddd DDD : BCLR imm

 * 0000 1000 11 ddd DDD : BSET imm

 *

 * 0000 1010 ss ddd DDD : EORI

 * 0000 1100 ss ddd DDD : CMPI

 *

 * 0000 1110 xx xxx xxx : illegal instruction

 *

 * 00ss DDDd dd sss SSS : MOVE

 * 00ss DDD0 01 sss SSS : MOVEA

 *

 * 0100 0000 ss ddd DDD : NEGX

 * 0100 0000 11 ddd DDD : MOVE FROM SR

 *

 * 0100 0001 00 xxx xxx : illegal instruction

 *

 * 0100 rrrs s0 ddd DDD : CHK

 * 0100 rrr1 11 ddd DDD : LEA

 *

 * 0100 0010 ss ddd DDD : CLR

 *

 * 0100 0100 ss ddd DDD : NEG

 * 0100 0100 11 sss SSS : MOVE TO CCR

 * 0100 0110 ss ddd DDD : NOT

 * 0100 0110 11 sss SSS : MOVE TO SR

 *

 * 0100 1000 00 ddd DDD : NBCD

 * 0100 1000 01 000 rrr : SWAP

 *

 * 0100 1000 01 001 xxx : illegal instruction

 * 0100 1000 01 ddd DDD : PEA

 *

 * 0100 1000 ss ddd DDD : EXT

 * 0100 1000 ss 001 rrr : MOVEM register to memory

 *

 * 0100 1010 ss ddd DDD : TST

 * 0100 1010 11 ddd DDD : TAS

 *

 * 0100 1010 11 111 100 : ILLEGAL

 *

 * 0100 1100 ss ddd DDD : MOVEM memory to register

 *

 * 0100 1110 01 00i iii : TRAP

 *

 * 0100 1110 01 010 rrr : LNK

 * 0100 1110 01 011 rrr : ULNK

 *

 * 0100 1110 01 10d rrr : MOVE USP

 *

 * 0100 1110 01 110 000 : RESET

 * 0100 1110 01 110 001 : NOP

 * 0100 1110 01 110 010 : STOP

 * 0100 1110 01 110 011 : RTE

 * 0100 1110 01 110 100 : illegal instruction

 * 0100 1110 01 110 101 : RTS

 * 0100 1110 01 110 110 : TRAPV

 * 0100 1110 01 110 111 : RTR

 *

 * 0100 1110 01 111 xxx : illegal instruction

 * 0100 1110 10 sss SSS : JSR

 * 0100 1110 11 sss SSS : JMP

 *

 * 0101 cccc 11 001 rrr : DBcc

 * 0101 cccc 11 ddd DDD : Scc

 * 0101 qqq1 ss ddd DDD : SUBQ

 * 0101 qqq0 ss ddd DDD : ADDQ

 *

 * 0110 0001 dd ddd ddd : BSR

 * 0110 0000 dd ddd ddd : BRA

 * 0110 cccc dd ddd ddd : Bcc

 *

 * 0111 rrr0 dd ddd ddd : MOVEQ

 *

 * 1011 rrro oo sss SSS : CMP

 * 1011 rrro oo sss SSS : CMPA

 * 1011 ddd1 ss 001 sss : CMPM

 * 1011 ssso oo ddd DDD : EOR

 *

 * 1101 rrro oo eee EEE : ADD

 * 1100 rrro oo eee EEE : AND

 * 1000 rrro oo eee EEE : OR

 * 1001 rrro oo eee EEE : SUB

 *

 * 1001 rrro oo sss SSS : SUBA

 * 1101 rrro oo sss SSS : ADDA

 *

 * 1101 ddd1 oo 00m sss : ADDX

 * 1001 ddd1 oo 00m sss : SUBX

 *

 * 1100 ddd1 00 00m sss : ABCD

 * 1000 ddd1 00 00m sss : SBCD

 *

 * 1100 ddd1 oo ooo aaa : EXG

 *

 * 1100 ddd0 11 sss SSS : MULU

 * 1100 ddd1 11 sss SSS : MULS

 * 1000 ddd0 11 sss SSS : DIVU

 * 1000 ddd1 11 sss SSS : DIVS

 *

 * 1110 000d 11 sss SSS : ASL,ASR memory

 * 1110 cccd ss i00 rrr : ASL,ASR register/immediate

 * 1110 001d 11 sss SSS : LSL,LSR memory

 * 1110 cccd ss i01 rrr : LSL,LSR register/immediate

 * 1110 011d 11 sss SSS : ROL,ROR memory

 * 1110 cccd ss i11 rrr : ROL,ROR register/immediate

 * 1110 010d 11 sss SSS : ROXL,ROXR memory

 * 1110 cccd ss i10 rrr : ROXL,ROXR register/immediate

 */

public class Tester {

    static int get_random(Random random, boolean must_be_even) {

        if(global_zero) return 0;

        while(true) {

            int rand = random.nextInt();

            if(must_be_even == false) return rand;

            else if(must_be_even == true && (rand % 2) == 0) return rand;

        }

    }

    static int get_random_bit(Random random) {

        if(global_zero) return 0;

        return (random.nextInt() % 2 == 0) ? 0 : 1;

    }

    static int get_random_ipm(Random random) {

        if(global_zero) return 0;

        int rand = random.nextInt();

        rand = rand % 8;

        return (rand < 0) ? -rand : rand;

    }

    static String get_8_char_hex_string(int val) throws Exception {

        String s = Integer.toHexString(val>>>2);

        while(s.length() < 8) s = "0" + s;

        return s.substring(s.length()-8);

    }

    static String get_4_char_hex_string(int val) throws Exception {

        String s = Integer.toHexString(val);

        while(s.length() < 4) s = "0" + s;

        return s.substring(s.length()-4);

    }

    static void start_test(File exe1, File exe2, int start, int end) throws Exception {

        random = new Random();

        for(int i=start; i<end; i++) {

            String ir = Integer.toBinaryString(i);

            while(ir.length() < 16) ir = "0" + ir;

            instruction = "ir=" + ir + ", " + i + "/" + end;

            System.out.println(instruction);

            for(int j=0; j<6; j++) {

                if(j==0) global_zero = true;

                else global_zero = false;

                System.out.println("j=" + j);

                start_test_hex(i,exe1,exe2);

            }

        }

    }

    static void start_test_hex(int i, File exe1, File exe2) throws Exception {

        Vector<String> common = new Vector<String>();

        try {

            common.add("+A0=" + Integer.toHexString(get_random(random, false)));

            common.add("+A1=" + Integer.toHexString(get_random(random, false)));

            common.add("+A2=" + Integer.toHexString(get_random(random, false)));

            common.add("+A3=" + Integer.toHexString(get_random(random, false)));

            common.add("+A4=" + Integer.toHexString(get_random(random, false)));

            common.add("+A5=" + Integer.toHexString(get_random(random, false)));

            common.add("+A6=" + Integer.toHexString(get_random(random, false)));

            common.add("+SSP=" + Integer.toHexString(get_random(random, false)));

            common.add("+USP=" + Integer.toHexString(get_random(random, false)));

            common.add("+D0=" + Integer.toHexString(get_random(random, false)));

            common.add("+D1=" + Integer.toHexString(get_random(random, false)));

            common.add("+D2=" + Integer.toHexString(get_random(random, false)));

            common.add("+D3=" + Integer.toHexString(get_random(random, false)));

            common.add("+D4=" + Integer.toHexString(get_random(random, false)));

            common.add("+D5=" + Integer.toHexString(get_random(random, false)));

            common.add("+D6=" + Integer.toHexString(get_random(random, false)));

            common.add("+D7=" + Integer.toHexString(get_random(random, false)));

            common.add("+C=" + get_random_bit(random));

            common.add("+V=" + get_random_bit(random));

            common.add("+Z=" + get_random_bit(random));

            common.add("+N=" + get_random_bit(random));

            common.add("+X=" + get_random_bit(random));

            common.add("+IPM=" + get_random_ipm(random));

            common.add("+S=" + get_random_bit(random));

            common.add("+T=" + "0"); //get_random_bit(random));

            int pc = get_random(random, true);

            common.add("+PC=" + Integer.toHexString(pc));

            if((pc % 4) == 0) {

                common.add("+MEM" + get_8_char_hex_string(pc) + "=" +

                        get_4_char_hex_string(i) +

                        get_4_char_hex_string(get_random(random, false)));

            }

            else {

                common.add("+MEM" + get_8_char_hex_string(pc) + "=" +

                        get_4_char_hex_string(get_random(random, false)) +

                        get_4_char_hex_string(i));

            }

            program_output = "Running exe1: " + exe1.getName() + "\n";

            common.add(0,  exe1.getCanonicalPath());

            HashMap<String, String> map_exe1 = start_test_process(common, exe1);

            if(map_exe1 == null) throw new Exception("Exe1 odd address read/write.");

            program_output += "\nRunning exe2: " + exe2.getName() + "\n";

            common.remove(0);

            common.add(0, exe2.getCanonicalPath());

            HashMap<String, String> map_exe2 = start_test_process(common, exe2);

            if(map_exe2 == null) throw new Exception("Exe2 odd address read/write.");

            boolean failed = false;

            boolean is_blocked = (map_exe1.containsKey("processor blocked") && map_exe2.containsKey("processor blocked")) ? true : false;

            for(String key : map_exe1.keySet()) {

                String value_emu = map_exe1.get(key);

                String value_verilog = map_exe2.get(key);

                map_exe2.remove(key);

                // if processor blocked, do not compare PC and SSP registers

                if(is_blocked && key.equals("PC")) continue;

                if(is_blocked && key.equals("SSP")) continue;

                if(value_emu.equals(value_verilog) == false) {

                    if(failed == false) System.out.println("");

                    System.out.println("Key mismatch: " + key + ": Exe1=" + value_emu + " / Exe2=" + value_verilog);

                    failed = true;

                }

            }

            for(String key : map_exe2.keySet()) {

                if(failed == false) System.out.println("");

                System.out.println("Key mismatch: " + key + ": EXE1=" + null + " / EXE2=" + map_exe2.get(key));

                failed = true;

            }

            if(failed) {

                System.out.println("");

                throw new Exception("Mismatch detected. Program output:\n" + program_output);

            }

        }

        catch(Exception e) {

            String result = "";

            for(String s : common) {

                result += s + "\n";

            }

            throw new Exception(e.getMessage() + "\nCommon dump:\n" + result + "\nInstruction:\n" + instruction);

        }

    }

    static HashMap<String, String> start_test_process(Vector<String> common, File file) throws Exception {

        Runtime runtime = Runtime.getRuntime();

        String result = "";

        String addresses = "\n";

        int count=0;

        while(true) {

            result = "";

            if(file.isDirectory() == false) file = new File(file.getParent());

            Process p = runtime.exec(common.toArray(new String[0]), null, file);

            int read = p.getInputStream().read();

            while(read != -1) {

                result += (char)read;

                read = p.getInputStream().read();

            }

            p.waitFor();

            p.getErrorStream().close();

            p.getInputStream().close();

            p.getOutputStream().close();

            if(p.exitValue() == 0) break;

            else {

                int index = result.indexOf("Missing argument: MEM");

                int index2 = result.indexOf("on odd address");

                if(index != -1) {

                    index += new String("Missing argument: MEM").length();

                    result = result.substring(index, index+8);

                    addresses += result + "\n";

                    String to_add = "+MEM" + result + "=" + Integer.toHexString(get_random(random, false));

                    if(to_add.length() > 4+8+1+8) throw new Exception("Illegal memory value length: " + to_add);

                    common.add(to_add);

                }

                else if(index2 != -1) {

                    throw new Exception("Odd address:" + result);

                }

                else throw new Exception("Error running process:\n" + result);

            }

            count++;

            if(count == 100) throw new Exception("Number of memory reads exceeded: " + common.firstElement() + " " + addresses);

        }

        program_output += result;

        result = result.substring(result.indexOf("START TEST") + new String("START TEST").length());

        String split[] = result.split("\n");

        HashMap<String, String> map = new HashMap<String, String>();

        for(int i=0; i<split.length; i++) {

            if(split[i].trim().length() == 0) continue;

            if(split[i].startsWith("memory read")) continue;

            String split2[] = split[i].split(":");

            if(split2.length == 1) throw new Exception("Line not split: " + split2[0]);

            map.put(split2[0].trim(), split2[1].trim());

        }

        return map;

    }

    static String program_output;

    static Random random;

    static boolean global_zero;

    static String instruction;

}