diff options
| -rw-r--r-- | ed25519/ed25519_microcode_parser.py | 566 |
1 files changed, 566 insertions, 0 deletions
diff --git a/ed25519/ed25519_microcode_parser.py b/ed25519/ed25519_microcode_parser.py new file mode 100644 index 0000000..5017125 --- /dev/null +++ b/ed25519/ed25519_microcode_parser.py @@ -0,0 +1,566 @@ +# +# ed25519_microcode_parser.py +# +# Author: Pavel Shatov +# +# Copyright (c) 2018, NORDUnet A/S +# +# 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. +# +# * Neither the name of the NORDUnet A/S nor the +# names of its contributors may be used to endorse or promote products +# derived from this software without specific prior written permission. +# +# 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 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. + +# Imports +import re +import sys +from enum import Enum + +# Source File +C_FILES = [ "ed25519_fpga_curve_microcode.cpp", + "../curve25519/curve25519_fpga_microcode.cpp"] + +class MICROCODE_PARSER: + + # enumerate microcode pieces + class MICROCODE_PIECE_ENUM(Enum): + NONE = -1 + PREPARE = 0 + BEFORE_ROUND_K0 = 1 + BEFORE_ROUND_K1 = 2 + DURING_ROUND = 3 + AFTER_ROUND_K0 = 4 + AFTER_ROUND_K1 = 5 + BEFORE_INVERSION = 6 + DURING_INVERSION = 7 + AFTER_INVERSION = 8 + FINAL_REDUCTION = 9 + HANDLE_SIGN = 10 + OUTPUT = 11 + + # magic pair of begin/end markers + MARKER_BEGIN_MICROCODE = "BEGIN_MICROCODE:" + MARKER_END_MICROCODE = "END_MICROCODE" + + # names of banks + MICROCODE_C_NAME_BANK_LO = "BANK_LO" + MICROCODE_C_NAME_BANK_HI = "BANK_HI" + + # micro-operation names + MICROCODE_C_NAME_UOP_MOVE = "uop_move" + MICROCODE_C_NAME_UOP_CALC = "uop_calc" + MICROCODE_C_NAME_UOP_CYCLE = "uop_cycle" + MICROCODE_C_NAME_UOP_REPEAT = "uop_repeat" + MICROCODE_C_NAME_UOP_CALC_EVEN = "uop_calc_if_even" + MICROCODE_C_NAME_UOP_CALC_ODD = "uop_calc_if_odd" + + # calculate micro-operations + MICROCODE_C_NAME_UOP_MATH_MUL = "MUL" + MICROCODE_C_NAME_UOP_MATH_ADD = "ADD" + MICROCODE_C_NAME_UOP_MATH_SUB = "SUB" + + # names of banks in C source + MICROCODE_C_NAMES_BANKS = [MICROCODE_C_NAME_BANK_LO, MICROCODE_C_NAME_BANK_HI] + + # names of operands in C source + MICROCODE_C_NAMES_OPERANDS = [ "CONST_ZERO", "CONST_ONE", + "INVERT_R1", "INVERT_R2", + "INVERT_T_1", "INVERT_T_10", "INVERT_T_1001", "INVERT_T_1011", + "INVERT_T_X5", "INVERT_T_X10", "INVERT_T_X20", "INVERT_T_X40", + "INVERT_T_X50", "INVERT_T_X100", + "CONST_G_X", "CONST_G_Y", "CONST_G_T", + "CYCLE_R0_X", "CYCLE_R0_Y", "CYCLE_R0_Z", "CYCLE_R0_T", + "CYCLE_R1_X", "CYCLE_R1_Y", "CYCLE_R1_Z", "CYCLE_R1_T", + "CYCLE_S_X", "CYCLE_S_Y", "CYCLE_S_Z", "CYCLE_S_T", + "CYCLE_T_X", "CYCLE_T_Y", "CYCLE_T_Z", "CYCLE_T_T", + "CYCLE_U_X", "CYCLE_U_Y", "CYCLE_U_Z", "CYCLE_U_T", + "CYCLE_V_X", "CYCLE_V_Y", "CYCLE_V_Z", "CYCLE_V_T", + "PROC_A", "PROC_B", "PROC_C", "PROC_D", + "PROC_E", "PROC_F", "PROC_G", "PROC_H", + "PROC_I", "PROC_J"] + + # names of banks in Verilog source + MICROCODE_V_NAME_BANKS_DUMMY = "UOP_BANKS_DUMMY" + + MICROCODE_V_NAMES_BANKS = ["UOP_BANKS_LO2HI", "UOP_BANKS_HI2LO"] + + # names of operands in Verilog source + MICROCODE_V_NAMES_OPERANDS = ["UOP_OPERAND_" + op for op in MICROCODE_C_NAMES_OPERANDS] + + # names of opcodes in Verilog source + MICROCODE_V_NAME_OPCODE_MOVE = "UOP_OPCODE_COPY" + MICROCODE_V_NAME_OPCODE_MUL = "UOP_OPCODE_MUL" + MICROCODE_V_NAME_OPCODE_ADD = "UOP_OPCODE_ADD" + MICROCODE_V_NAME_OPCODE_SUB = "UOP_OPCODE_SUB" + MICROCODE_V_NAME_OPCODE_STOP = "UOP_OPCODE_STOP" + + MICROCODE_V_NAME_OPERAND_DONTCARE = "UOP_OPERAND_DONTCARE" + + # match group to catch operand names + MATCH_GROUP_09AZ = "([0-9A-Z_]+)" + + # match group to catch bank names + MATCH_GROUP_BANK = "(" + MICROCODE_C_NAME_BANK_LO + "|" + MICROCODE_C_NAME_BANK_HI + ")" + + # match group to catch number of loop iterations + MATCH_GROUP_NUMBER = "(\d+)" + + # match group to catch math instruction + MATCH_GROUP_MATH = "(" + MICROCODE_C_NAME_UOP_MATH_MUL + "|" + MICROCODE_C_NAME_UOP_MATH_ADD + "|" + MICROCODE_C_NAME_UOP_MATH_SUB + ")" + + # match groups to catch dummy C pointers + MATCH_GROUP_DUMMY_C_PTR = "BUF_LO\,\s*BUF_HI" + MATCH_GROUP_DUMMY_C_MOD = "MOD_[1-2]P" + + # match group to catch calculation micro-operation + MATCH_GROUP_CALC = "(" + MICROCODE_C_NAME_UOP_CALC + "|" + MICROCODE_C_NAME_UOP_CALC_EVEN + "|" + MICROCODE_C_NAME_UOP_CALC_ODD + ")" + + # map string microcode piece names to enum values + MICROCODE_PIECE_DICT = { "PREPARE": MICROCODE_PIECE_ENUM.PREPARE, + "BEFORE_ROUND_K0": MICROCODE_PIECE_ENUM.BEFORE_ROUND_K0, + "BEFORE_ROUND_K1": MICROCODE_PIECE_ENUM.BEFORE_ROUND_K1, + "DURING_ROUND": MICROCODE_PIECE_ENUM.DURING_ROUND, + "AFTER_ROUND_K0": MICROCODE_PIECE_ENUM.AFTER_ROUND_K0, + "AFTER_ROUND_K1": MICROCODE_PIECE_ENUM.AFTER_ROUND_K1, + "BEFORE_INVERSION": MICROCODE_PIECE_ENUM.BEFORE_INVERSION, + "DURING_INVERSION": MICROCODE_PIECE_ENUM.DURING_INVERSION, + "AFTER_INVERSION": MICROCODE_PIECE_ENUM.AFTER_INVERSION, + "FINAL_REDUCTION": MICROCODE_PIECE_ENUM.FINAL_REDUCTION, + "HANDLE_SIGN": MICROCODE_PIECE_ENUM.HANDLE_SIGN, + "OUTPUT": MICROCODE_PIECE_ENUM.OUTPUT} + + # map C bank names to Verilog bank names + MICROCODE_BANK_DICT = dict(zip(MICROCODE_C_NAMES_BANKS, MICROCODE_V_NAMES_BANKS)) + + # map C operand names to Verilog operand names + MICROCODE_OPERAND_DICT = dict(zip(MICROCODE_C_NAMES_OPERANDS, MICROCODE_V_NAMES_OPERANDS)) + + # map C calculation names to Verilog opcode names + MICROCODE_MATH_DICT = { MICROCODE_C_NAME_UOP_MATH_MUL: MICROCODE_V_NAME_OPCODE_MUL, + MICROCODE_C_NAME_UOP_MATH_ADD: MICROCODE_V_NAME_OPCODE_ADD, + MICROCODE_C_NAME_UOP_MATH_SUB: MICROCODE_V_NAME_OPCODE_SUB} + + # microcode format + MICROCODE_FORMAT_ADDR = "9'd%03d" + MICROCODE_FORMAT_LINE = MICROCODE_FORMAT_ADDR + ": data <= %s;" + MICROCODE_FORMAT_OFFSET = "localparam [UOP_ADDR_WIDTH-1:0] %s = " + MICROCODE_FORMAT_ADDR + ";" + + # pieces of microcode + MICROCODE_LINES_PREPARE = [] + MICROCODE_LINES_BEFORE_ROUND_K0 = [] + MICROCODE_LINES_BEFORE_ROUND_K1 = [] + MICROCODE_LINES_DURING_ROUND = [] + MICROCODE_LINES_AFTER_ROUND_K0 = [] + MICROCODE_LINES_AFTER_ROUND_K1 = [] + MICROCODE_LINES_BEFORE_INVERSION = [] + MICROCODE_LINES_DURING_INVERSION = [] + MICROCODE_LINES_AFTER_INVERSION = [] + MICROCODE_LINES_FINAL_REDUCTION = [] + MICROCODE_LINES_HANDLE_SIGN = [] + MICROCODE_LINES_OUTPUT = [] + + MICROCODE_LINE_STOP = "{%s, %s, %s, %s, %s}" % ( MICROCODE_V_NAME_OPCODE_STOP, + MICROCODE_V_NAME_BANKS_DUMMY, + MICROCODE_V_NAME_OPERAND_DONTCARE, + MICROCODE_V_NAME_OPERAND_DONTCARE, + MICROCODE_V_NAME_OPERAND_DONTCARE) + + def __init__(self, filenames): + self.__filenames = filenames + + def parse(self): + for next_filename in self.__filenames: + print("Parsing '%s'..." % (next_filename)) + parsing_now = False + line_num = 0 + with open(next_filename, "r") as c_file: + c_lines = c_file.readlines() + for next_c_line in c_lines: + line_num += 1 + self.__line_num = line_num + self.__next_c_line = next_c_line.strip() + if len(self.__next_c_line) == 0: continue + if self.__next_c_line.startswith("//"): continue + if not parsing_now: + self.__current_piece = self.__try_start_parsing() + if self.__current_piece != self.MICROCODE_PIECE_ENUM.NONE: + print(" Found piece of microcode: %s" % (str(self.__current_piece))) + parsing_now = True + else: + parsing_now = self.__continue_parsing() + + def format(self): + + if len(self.MICROCODE_LINES_PREPARE) == 0: sys.exit("sys.exit(): Empty PREPARE piece!") + if len(self.MICROCODE_LINES_BEFORE_ROUND_K0) == 0: sys.exit("sys.exit(): Empty BEFORE_ROUND_K0 piece!") + if len(self.MICROCODE_LINES_BEFORE_ROUND_K1) == 0: sys.exit("sys.exit(): Empty BEFORE_ROUND_K1 piece!") + if len(self.MICROCODE_LINES_DURING_ROUND) == 0: sys.exit("sys.exit(): Empty DURING_ROUND piece!") + if len(self.MICROCODE_LINES_AFTER_ROUND_K0) == 0: sys.exit("sys.exit(): Empty AFTER_ROUND_K0 piece!") + if len(self.MICROCODE_LINES_AFTER_ROUND_K1) == 0: sys.exit("sys.exit(): Empty AFTER_ROUND_K1 piece!") + if len(self.MICROCODE_LINES_BEFORE_INVERSION) == 0: sys.exit("sys.exit(): Empty BEFORE_INVERSION piece!") + if len(self.MICROCODE_LINES_DURING_INVERSION) == 0: sys.exit("sys.exit(): Empty DURING_INVERSION piece!") + if len(self.MICROCODE_LINES_AFTER_INVERSION) == 0: sys.exit("sys.exit(): Empty AFTER_INVERSION piece!") + if len(self.MICROCODE_LINES_FINAL_REDUCTION) == 0: sys.exit("sys.exit(): Empty FINAL_REDUCTION piece!") + if len(self.MICROCODE_LINES_HANDLE_SIGN) == 0: sys.exit("sys.exit(): Empty HANDLE_SIGN piece!") + if len(self.MICROCODE_LINES_OUTPUT) == 0: sys.exit("sys.exit(): Empty OUTPUT piece!") + + length = 0 + length += len(self.MICROCODE_LINES_PREPARE) + length += len(self.MICROCODE_LINES_BEFORE_ROUND_K0) + length += len(self.MICROCODE_LINES_BEFORE_ROUND_K1) + length += len(self.MICROCODE_LINES_DURING_ROUND) + length += len(self.MICROCODE_LINES_AFTER_ROUND_K0) + length += len(self.MICROCODE_LINES_AFTER_ROUND_K1) + length += len(self.MICROCODE_LINES_BEFORE_INVERSION) + length += len(self.MICROCODE_LINES_DURING_INVERSION) + length += len(self.MICROCODE_LINES_AFTER_INVERSION) + length += len(self.MICROCODE_LINES_FINAL_REDUCTION) + length += len(self.MICROCODE_LINES_OUTPUT) + + print("Total number of micro-operations (w/o stops): %s" % (length)) + + + self.__addr = 0 + + print("\n -=-=-=-=-=- CUT AND PASTE BELOW -=-=-=-=-=-\n") + + offset_prepare = self.__addr; + print("// PREPARE"); + for line in self.MICROCODE_LINES_PREPARE: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_before_round_k0 = self.__addr; + print("// BEFORE_ROUND_K0"); + for line in self.MICROCODE_LINES_BEFORE_ROUND_K0: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_before_round_k1 = self.__addr; + print("// BEFORE_ROUND_K1"); + for line in self.MICROCODE_LINES_BEFORE_ROUND_K1: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_during_round = self.__addr; + print("// DURING_ROUND"); + for line in self.MICROCODE_LINES_DURING_ROUND: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_after_round_k0 = self.__addr; + print("// AFTER_ROUND_K0"); + for line in self.MICROCODE_LINES_AFTER_ROUND_K0: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_after_round_k1 = self.__addr; + print("// AFTER_ROUND_K1"); + for line in self.MICROCODE_LINES_AFTER_ROUND_K1: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_before_inversion = self.__addr; + print("// BEFORE_INVERSION"); + for line in self.MICROCODE_LINES_BEFORE_INVERSION: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_during_inversion = self.__addr; + print("// DURING_INVERSION"); + for line in self.MICROCODE_LINES_DURING_INVERSION: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_after_inversion = self.__addr; + print("// AFTER_INVERSION"); + for line in self.MICROCODE_LINES_AFTER_INVERSION: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_final_reduction = self.__addr; + print("// FINAL_REDUCTION"); + for line in self.MICROCODE_LINES_FINAL_REDUCTION: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_handle_sign = self.__addr; + print("// HANDLE_SIGN"); + for line in self.MICROCODE_LINES_HANDLE_SIGN: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + offset_output = self.__addr; + print("// OUTPUT"); + for line in self.MICROCODE_LINES_OUTPUT: + self.__format_line(line) + self.__format_line(self.MICROCODE_LINE_STOP) + + print("\n") + self.__format_offset("UOP_OFFSET_PREPARE ", offset_prepare) + self.__format_offset("UOP_OFFSET_BEFORE_ROUND_K0 ", offset_before_round_k0) + self.__format_offset("UOP_OFFSET_BEFORE_ROUND_K1 ", offset_before_round_k1) + self.__format_offset("UOP_OFFSET_DURING_ROUND ", offset_during_round) + self.__format_offset("UOP_OFFSET_AFTER_ROUND_K0 ", offset_after_round_k0) + self.__format_offset("UOP_OFFSET_AFTER_ROUND_K1 ", offset_after_round_k1) + self.__format_offset("UOP_OFFSET_BEFORE_INVERSION", offset_before_inversion) + self.__format_offset("UOP_OFFSET_DURING_INVERSION", offset_during_inversion) + self.__format_offset("UOP_OFFSET_AFTER_INVERSION ", offset_after_inversion) + self.__format_offset("UOP_OFFSET_FINAL_REDUCTION ", offset_final_reduction) + self.__format_offset("UOP_OFFSET_HANDLE_SIGN ", offset_handle_sign) + self.__format_offset("UOP_OFFSET_OUTPUT ", offset_output) + + def __format_line(self, line): + print(self.MICROCODE_FORMAT_LINE % (self.__addr, line)) + self.__addr += 1 + + def __format_offset(self, name, offset): + print(self.MICROCODE_FORMAT_OFFSET % (name, offset)) + + def __try_start_parsing(self): + piece = self.MICROCODE_PIECE_ENUM.NONE + begin_marker = re.match("^/\*\s*" + self.MARKER_BEGIN_MICROCODE + "\s*" + + self.MATCH_GROUP_09AZ + "\s*\*/$", + self.__next_c_line); + if begin_marker: + piece = self.MICROCODE_PIECE_DICT[begin_marker.group(1)] + + return piece + + def __encode_uop(self, opcode, banks, src1, src2, dst): + return "{%s, %s, %s, %s, %s}" % (opcode, banks, src1, src2, dst) + + def __continue_parsing(self): + + end_marker = re.match("^/\*\s*" + self.MARKER_END_MICROCODE + "\s*\*/$", + self.__next_c_line); + if end_marker: return False + + # move? + uop_move = re.match("^" + self.MICROCODE_C_NAME_UOP_MOVE + "\(" + + self.MATCH_GROUP_BANK + "\,\s*" + + self.MATCH_GROUP_09AZ + "\,\s*" + + self.MATCH_GROUP_BANK + "\,\s*" + + self.MATCH_GROUP_09AZ + "\,\s*" + + self.MATCH_GROUP_DUMMY_C_PTR + "\)\;$", + self.__next_c_line, re.IGNORECASE) + if uop_move: + ok = self.__parse_uop_move(uop_move) + if ok: return True + else: + self.__print_parse_error("parse_uop_move() failed!") + self.__abort() + + # calc? + uop_calc = re.match("^" + self.MATCH_GROUP_CALC + "\s*\(" + + self.MATCH_GROUP_MATH + "\,\s*" + + self.MATCH_GROUP_BANK + "\,\s*" + + self.MATCH_GROUP_09AZ + "\,\s*" + + self.MATCH_GROUP_09AZ + "\,\s*" + + self.MATCH_GROUP_BANK + "\,\s*" + + self.MATCH_GROUP_09AZ + "\,\s*" + + self.MATCH_GROUP_DUMMY_C_PTR + "\,\s*" + + self.MATCH_GROUP_DUMMY_C_MOD + "\)\;$", + self.__next_c_line, re.IGNORECASE) + if uop_calc: + ok = self.__parse_uop_calc(uop_calc) + if ok: return True + else: + self.__print_parse_error("parse_uop_calc() failed!") + self.__abort() + + # cycle? + uop_cycle = re.match("^" + self.MICROCODE_C_NAME_UOP_CYCLE + "\(" + + self.MATCH_GROUP_NUMBER + "\)\;$", + self.__next_c_line, re.IGNORECASE) + if uop_cycle: + ok = self.__parse_uop_cycle(uop_cycle) + if ok: return True + else: + self.__print_parse_error("parse_uop_cycle() failed!") + self.__abort() + + # repeat? + uop_repeat = re.match("^" + self.MICROCODE_C_NAME_UOP_REPEAT + "\(" + "\)\;$", + self.__next_c_line, re.IGNORECASE) + if uop_repeat: + ok = self.__parse_uop_repeat() + if ok: return True + else: + self.__print_parse_error("__parse_uop_repeat() failed!") + self.__abort() + + self.__print_parse_error("unknown micro-operation!") + self.__abort() + + def __check_math(self, math): + if not math in self.MICROCODE_MATH_DICT: + print_parse_error("bad math!") + return False + + return True + + def __check_banks(self, src, dst): + if not src in self.MICROCODE_BANK_DICT: + print_parse_error("bad src bank!") + return False + + if not dst in self.MICROCODE_BANK_DICT: + print_parse_error("bad dst bank!") + return False + + if src == dst: + print_parse_error("src bank == dst bank!") + return False + + return True + + def __check_op3(self, src1, src2, dst): + + if not src1 in self.MICROCODE_OPERAND_DICT: + self.__print_parse_error("bad src1 operand!") + return False + + if src2 != "" and not src2 in self.MICROCODE_OPERAND_DICT: + self.__print_parse_error("bad src2 operand!") + return False + + if not dst in self.MICROCODE_OPERAND_DICT: + self.__print_parse_error("bad dst operand!") + return False + + return True + + def __check_op2(self, src, dst): + return self.__check_op3(src, "", dst) + + def __parse_uop_move(self, params): + bank_src = params.group(1) + bank_dst = params.group(3) + op_src = params.group(2) + op_dst = params.group(4) + + if not self.__check_banks(bank_src, bank_dst): + self.__print_parse_error("check_banks() failed!") + return False + + if not self.__check_op2(op_src, op_dst): + self.__print_parse_error("check_op2() failed!") + return False + + opcode = self.MICROCODE_V_NAME_OPCODE_MOVE + bank = self.MICROCODE_BANK_DICT[bank_src] + src1 = self.MICROCODE_OPERAND_DICT[op_src] + src2 = self.MICROCODE_V_NAME_OPERAND_DONTCARE + dst = self.MICROCODE_OPERAND_DICT[op_dst] + + data = self.__encode_uop(opcode, bank, src1, src2, dst) + self.__store_uop(data) + return True + + def __parse_uop_calc(self, params): + calc = params.group(1) + math = params.group(2) + bank_src = params.group(3) + bank_dst = params.group(6) + op_src1 = params.group(4) + op_src2 = params.group(5) + op_dst = params.group(7) + + if not self.__check_math(math): + self.__print_parse_error("check_calc() failed!") + return False + + if not self.__check_banks(bank_src, bank_dst): + self.__print_parse_error("check_banks() failed!") + return False + + if not self.__check_op3(op_src1, op_src2, op_dst): + self.__print_parse_error("check_op3() failed!") + return False + + opcode = self.MICROCODE_MATH_DICT[math] + banks = self.MICROCODE_BANK_DICT[bank_src] + src1 = self.MICROCODE_OPERAND_DICT[op_src1] + src2 = self.MICROCODE_OPERAND_DICT[op_src2] + dst = self.MICROCODE_OPERAND_DICT[op_dst] + + data = self.__encode_uop(opcode, banks, src1, src2, dst) + if calc == self.MICROCODE_C_NAME_UOP_CALC: self.__store_uop(data) + elif calc == self.MICROCODE_C_NAME_UOP_CALC_EVEN: self.__loop_even = data + elif calc == self.MICROCODE_C_NAME_UOP_CALC_ODD: self.__loop_odd = data + else: return False + + return True + + def __parse_uop_cycle(self, params): + self.__loop_iters = int(params.group(1)) + return True + + def __parse_uop_repeat(self): + print(" Unrolling loop (%d iters)..." % (self.__loop_iters)) + + for i in range(0, self.__loop_iters): + if i % 2 == 0: self.__store_uop(self.__loop_even) + else: self.__store_uop(self.__loop_odd) + + return True + + def __store_uop(self, data): + #print("\t" + data) + if self.__current_piece == self.MICROCODE_PIECE_ENUM.PREPARE: self.MICROCODE_LINES_PREPARE.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.BEFORE_ROUND_K0: self.MICROCODE_LINES_BEFORE_ROUND_K0.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.BEFORE_ROUND_K1: self.MICROCODE_LINES_BEFORE_ROUND_K1.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.DURING_ROUND: self.MICROCODE_LINES_DURING_ROUND.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.AFTER_ROUND_K0: self.MICROCODE_LINES_AFTER_ROUND_K0.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.AFTER_ROUND_K1: self.MICROCODE_LINES_AFTER_ROUND_K1.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.BEFORE_INVERSION: self.MICROCODE_LINES_BEFORE_INVERSION.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.DURING_INVERSION: self.MICROCODE_LINES_DURING_INVERSION.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.AFTER_INVERSION: self.MICROCODE_LINES_AFTER_INVERSION.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.FINAL_REDUCTION: self.MICROCODE_LINES_FINAL_REDUCTION.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.HANDLE_SIGN: self.MICROCODE_LINES_HANDLE_SIGN.append(data) + elif self.__current_piece == self.MICROCODE_PIECE_ENUM.OUTPUT: self.MICROCODE_LINES_OUTPUT.append(data) + + def __print_parse_error(self, msg): + print("PARSE ERROR: %s" % (msg)) + + def __abort(self): + sys.exit("Stopped at line #%d:\n%s" % (self.__line_num, self.__next_c_line)) + + +# ----------------------------------------------------------------------------- +def main(filenames): +# ----------------------------------------------------------------------------- + parser = MICROCODE_PARSER(filenames) + parser.parse() + parser.format() + +# ----------------------------------------------------------------------------- +if __name__ == "__main__": +# ----------------------------------------------------------------------------- + main(C_FILES) + +# +# End-of-File +# |