#
# 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
#
