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.OutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.File;
import java.util.Vector;
import java.util.HashMap;
import java.util.HashSet;
 
class GenerateMicrocode {
    static void entry(boolean newline, String name) throws Exception {
        /*
         * if newline is true: end of last line
         * if name is "offset_" + label: branch label
         * if name is "label_" + label: label declaration
         */
 
        if(ParseParams.prefixes == null || labels == null || lines == null) throw new Exception("Entry validator not initialized.");
 
        // save last line
        if(newline == true && current_line != null && current_line.size() > 0) lines.add(current_line);
        // prepare a new line
        if(newline == true) current_line = new HashMap<String,String>();
 
        // save label location
        if(name.startsWith("label_")) {
            String label = name.substring(6);
            if(labels.containsKey(label)) throw new Exception("Double label declaration: " + label);
            labels.put(label, lines.size());
            return;
        }
 
        // get prefix
        String prefix = "PROCEDURE_";
        if(name.startsWith("offset_")) {
            String label = name.substring(7);
            name = "label_" + label;
        }
        else {
            prefix = null;
            for(String p : ParseParams.prefixes) {
                if(name.startsWith(p)) {
                    prefix = p;
                    break;
                }
            }
        }
 
        if(prefix == null) throw new Exception("Unknown prefix for name: " + name);
 
        // check for double prefix
        if(current_line.containsKey(prefix)) throw new Exception("Double prefix call: " + prefix);
 
        // extend current line
        current_line.put(prefix, name);
    }
 
    static void fill_bit_part(int array[], int start, int end, int value) throws Exception {
        while(start <= end) {
            int bit = value & 0x1;
 
            array[start] = bit;
 
            value >>= 1;
            start++;
        }
    }
    static void final_process(OutputStream out) throws Exception {
        if(ParseParams.prefixes == null || labels == null || lines == null) throw new Exception("Final validator not initialized.");
        // add last line
        if(current_line != null && current_line.size() > 0) lines.add(current_line);
 
 
        int i=0;
        // resolve labels
        for(HashMap<String,String> line : lines) {
            if(line.containsKey("PROCEDURE_")) {
                String value = line.get("PROCEDURE_");
 
                if(value.startsWith("label_")) {
                    String label = value.substring(6);
 
                    if(labels.containsKey(label) == false) throw new Exception("Unresolved label: " + label);
                    int label_value = labels.get(label);
 
                    int delta = label_value - i;
 
                    if(delta < 0 || delta > 15) throw new Exception("Label: " + label + " out of bounds: " + delta);
                    line.put("PROCEDURE_", "value_" + delta);
                }
            }
            i++;
        }
 
        // prepare output header
        int depth = 1;
        while(depth < lines.size()) depth *= 2;
 
        out.write(new String("DEPTH = " + depth + ";\n").getBytes());
        out.write(new String("WIDTH = " + bit_line.length + ";\n").getBytes());
        out.write(new String("ADDRESS_RADIX = DEC;\n").getBytes());
        out.write(new String("DATA_RADIX = BIN;\n").getBytes());
        out.write(new String("CONTENT\n").getBytes());
        out.write(new String("BEGIN\n").getBytes());
 
        i=0;
        HashSet<String> set = new HashSet<String>();
        Vector<String> bit_lines = new Vector<String>();
        // prepare final bit array
        for(HashMap<String,String> line : lines) {
            for(int j=0; j<bit_line.length; j++) bit_line[j] = 0;
 
            for(String prefix : ParseParams.prefixes) {
                if(line.containsKey(prefix)) {
                    String string_value = line.get(prefix);
 
                    int value = 0;
                    if(string_value.startsWith("value_")) {
                        value = Integer.parseInt(string_value.substring(6));
                    }
                    else {
                        if(ParseParams.name_values.containsKey(string_value) == false) throw new Exception("Unknown value: " + string_value);
                        value = ParseParams.name_values.get(string_value);
                    }
                    int start = ParseParams.prefix_locations.get(prefix + "start");
                    int end = ParseParams.prefix_locations.get(prefix + "end");
 
                    fill_bit_part(bit_line, start, end, value);
                }
            }
 
            // prepare output
            String addr = "" + i + ": ";
            while(addr.length() < 8) addr = " " + addr;
            out.write(new String(addr).getBytes());
 
            String bits = "";
            for(int j=bit_line.length-1; j>=0; j--) {
                bits += bit_line[j];
            }
            set.add(bits);
            bit_lines.add(bits);
            out.write(new String(bits + ";\n").getBytes());
 
            i++;
        }
        out.write(new String("END;\n").getBytes());
 
 
        // prepare a compact microcode with a microcode decoder
        // microcode reduced to 500x8 bits = 4000 bits, but microcode decoder takes about 1000 LE
        // so currently unused
/*
        i = set.size();
        int bit_size = 0;
        while(i > 0) {
            bit_size++;
            i /= 2;
        }
        System.out.println("Set size: " + set.size() + ", bit size: " + bit_size + ", bit_line.length: " + bit_line.length);
 
        String empty_line = "";
        i = 0;
        while(i < bit_line.length) {
            empty_line += "0";
            i++;
        }
 
 
        String verilog = "assign micro_data =" + "\n";
 
        verilog += "(encoded == " + bit_size + "'d" + 0 + ") ? " + bit_line.length + "'b" + empty_line + " :" + "\n";
        HashMap<String, Integer> bit_line_numbers = new HashMap<String, Integer>();
        i = 1;
        for(String line : set) {
            verilog += "(encoded == " + bit_size + "'d" + i + ") ? " + bit_line.length + "'b" + line + " :" + "\n";
 
            bit_line_numbers.put(line, i);
            i++;
        }
        verilog += bit_line.length + "'b" + empty_line + ";" + "\n";
 
        i=0;
        for(String line : bit_lines) {
            String addr = "" + i + ": ";
            while(addr.length() < 8) addr = " " + addr;
            System.out.print(addr);
 
            String content = "" + bit_line_numbers.get(line) + ";";
            System.out.println(content);
 
            i++;
        }
        System.out.println("Verilog:\n" + verilog);
*/
    }
    static String get_microcode_defines() throws Exception {
        if(ParseParams.prefix_locations == null || ParseParams.prefixes == null) throw new Exception("No prefix_locations or prefixes set.");
 
        String output = "";
 
        for(String s : ParseParams.prefixes) {
            int start = ParseParams.prefix_locations.get(s + "start");
            int end = ParseParams.prefix_locations.get(s + "end");
 
            String short_name = s.substring(0, s.length()-1);
            short_name = short_name.toLowerCase();
 
            String str = "`define MICRO_DATA_" + short_name;
            while(str.length() < 85) str += " ";
            output +=  str + "micro_data[" + end + ":" + start + "]\n";
        }
        output += "\n";
 
        for(String label : labels.keySet()) {
            if(label.startsWith("MICROPC_")) {
                String str = "`define " + label;
                while(str.length() < 85) str += " ";
                output += str + "9'd" + labels.get(label) + "\n";
            }
        }
        return output;
    }
    static void generate(OutputStream microcode_os, String file_name) throws Exception {
        bit_line = new int[ParseParams.control_bit_offset];
        lines = new Vector<HashMap<String,String>>();
        labels = new HashMap<String,Integer>();
 
        Microcode.microcode(new Parser());
 
        final_process(microcode_os);
        String locations = get_microcode_defines();
 
        // load file
        File file = new File(file_name);
        byte bytes[] = new byte[(int)file.length()];
        FileInputStream in = new FileInputStream(file);
        if( in.read(bytes) != bytes.length ) throw new Exception("Can not read from file: " + file.getCanonicalPath());
        in.close();
 
        // find 'MICROCODE - DO NOT EDIT BELOW' and 'MICROCODE - DO NOT EDIT ABOVE' substrings
        String all_string = new String(bytes);
        int start_index = all_string.indexOf("MICROCODE - DO NOT EDIT BELOW");
        if(start_index == -1) throw new Exception("Can not find 'MICROCODE - DO NOT EDIT BELOW' substring in " + file.getCanonicalPath());
        start_index += new String("MICROCODE - DO NOT EDIT BELOW").length();
        int end_index = all_string.indexOf("MICROCODE - DO NOT EDIT ABOVE");
        if(end_index == -1) throw new Exception("Can not find 'MICROCODE - DO NOT EDIT ABOVE' substring in " + file.getCanonicalPath());
 
        String output_string = all_string.substring(0, start_index) + "\n" + locations + "// " + all_string.substring(end_index, all_string.length());
 
        FileOutputStream out = new FileOutputStream(file);
        out.write(output_string.getBytes());
        out.close();
    }
    static HashMap<String, String> current_line;
    static Vector<HashMap<String, String>> lines;
    static HashMap<String, Integer> labels;
    static int bit_line[];
}