From a2832071b9eee90e5814d8c90d3b35585a062772 Mon Sep 17 00:00:00 2001 From: karans5 Date: Wed, 29 Mar 2023 14:00:12 +0530 Subject: [PATCH 1/5] added functions for various instruction sequences --- uatg/instruction_constants.py | 1059 +++++++++++++++++++++++++++++++++ 1 file changed, 1059 insertions(+) diff --git a/uatg/instruction_constants.py b/uatg/instruction_constants.py index 427caab..ed61de9 100644 --- a/uatg/instruction_constants.py +++ b/uatg/instruction_constants.py @@ -597,3 +597,1062 @@ def illegal_generator(isa='RV32I') -> list: illegal_list[i] -= 2 << 12 # converting illegal 2,3 to 0,1 return illegal_list + + + +############################################################################ +# Function to return ASM-string of reg-reg dependent sequences # +############################################################################ + +def seq_test_rr_rr_op(inst1, inst2, destreg1, destreg2, reg1, reg2, reg3, \ + val1, val2, val3, swreg, offset, depth, dependency): + asm_string = '' + nop_op = '' + d=0 + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + li {reg3}, {val3} + ''' + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + if dependency == 'RAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {nop_op} + {inst2} {destreg2}, {destreg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + if dependency == 'WAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {nop_op} + {inst2} {destreg1}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + if dependency == 'WAR': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {nop_op} + {inst2} {reg1}, {reg2}, {reg3} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + else: + + if dependency == 'RAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {inst2} {destreg2}, {destreg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {inst2} {destreg1}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + if dependency == 'WAR': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {inst2} {reg1}, {reg2}, {reg3} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + return asm_string + + +############################################################################ +# Function to return ASM-string of imm-imm dependent sequences # +############################################################################ +def seq_test_ri_ri_op(inst1, inst2, destreg1, destreg2, reg1, reg2, val1, val2,\ + imm_val, swreg, offset, depth, dependency=''): + asm_string = '' + nop_op = '' + d=0 + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + ''' + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + if dependency == 'RAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + {inst2} {destreg2}, {destreg1}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + {inst2} {destreg1}, {reg2}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + if dependency == 'WAR': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + {inst2} {reg1}, {reg2}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + else: + if dependency == 'RAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {inst2} {destreg2}, {destreg1}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {inst2} {destreg1}, {reg2}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + if dependency == 'WAR': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {inst2} {reg1}, {reg2}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + return asm_string + + + +############################################################################ +# Function to return ASM-string of reg-imm dependent inst sequences # +############################################################################ +def seq_test_rr_ri_op(inst1, inst2, destreg1, destreg2, \ + reg1, reg2, val1, val2, imm_val, \ + swreg, offset, depth, dependency=''): + asm_string = '' + nop_op = '' + d=0 + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + ''' + + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + if dependency == 'RAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {nop_op} + {inst2} {destreg2}, {destreg1}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + + if dependency == 'WAR': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {nop_op} + {inst2} {reg1}, {reg2}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {nop_op} + {inst2} {destreg1}, {reg2}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + else: + if dependency == 'RAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {inst2} {destreg2}, {destreg1}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + if dependency == 'WAR': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {inst2} {reg1}, {reg2}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, {reg2} + {inst2} {destreg1}, {reg2}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + return asm_string + + + +############################################################################ +# Function to return ASM-string of imm-reg dependent inst sequences # +############################################################################ +def seq_test_ri_rr_op(inst1, inst2, destreg1, destreg2, \ + reg1, reg2, reg3, val1, val2, val3, \ + imm_val, swreg, offset, depth, dependency=''): + asm_string = '' + nop_op = '' + d=0 + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + li {reg3}, {val3} + ''' + + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + if dependency == 'RAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + {inst2} {destreg2}, {destreg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + + if dependency == 'WAR': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + {inst2} {reg1}, {reg2}, {reg3} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + {inst2} {destreg1}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + else: + if dependency == 'RAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {inst2} {destreg2}, {destreg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + + if dependency == 'WAR': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {inst2} {reg1}, {reg2}, {reg3} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {inst1} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {inst2} {destreg1}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + return asm_string + + + +################################################################### +# Function to return 3 back to back dependent reg inst ASM-String # +################################################################### +def seq_test_three_back_to_back_reg_op(inst, destreg1, destreg2, destreg3, \ + reg1, reg2, reg3, reg4, val1, val2, val3, val4,\ + swreg, offset, dependency=''): + asm_string = '' + + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + li {reg3}, {val3} + li {reg4}, {val4} + ''' + + if dependency == 'RAW': + asm_string += f''' + {inst} {destreg1}, {reg1}, {reg2} + {inst} {destreg2}, {destreg1}, {reg2} + {inst} {destreg3}, {destreg2}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg3}, {offset}) + ''' + if dependency == 'WAR': + asm_string += f''' + {inst} {destreg1}, {reg1}, {reg2} + {inst} {reg1}, {reg2}, {reg3} + {inst} {reg2}, {reg3}, {reg4} + RVTEST_SIGUPD({swreg}, {reg2}, {offset}) + ''' + if dependency == 'WAW': + asm_string += f''' + {inst} {destreg1}, {reg1}, {reg2} + {inst} {destreg1}, {reg1}, {reg2} + {inst} {destreg1}, {reg2}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + return asm_string + + +################################################################### +# Function to return 3 back to back dependent imm inst ASM-String # +################################################################### +def seq_test_three_back_to_back_dep_imm_op(inst, destreg1, destreg2, destreg3, \ + reg1, reg1_val, reg2, reg2_val, reg3, reg3_val,\ + imm_val, swreg, offset, dependency=''): + asm_string = '' + + asm_string = f''' + li {reg1}, {reg1_val} + li {reg2}, {reg2_val} + li {reg3}, {reg3_val} + ''' + + if dependency == 'RAW': + asm_string = f''' + {inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {inst} {destreg2}, {destreg1}, SEXT_IMM({imm_val}) + {inst} {destreg3}, {destreg2}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {destreg3}, {offset}) + ''' + if dependency == 'WAR': + asm_string = f''' + {inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {inst} {reg1}, {reg2}, SEXT_IMM({imm_val}) + {inst} {reg2}, {reg3}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {reg2}, {offset}) + ''' + if dependency == 'WAW': + asm_string = f''' + {inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + return asm_string + + +############################################################################ +# Function to return ASM-string of inst pipeline sequences # +############################################################################ +def seq_test_rr_inst_pipeline_check_op(inst, destreg, reg1, reg2, val1, val2, swreg, offset, pipeline_depth): + asm_string = '' + inst_seq = '' + d=0 + if pipeline_depth>0: + while d != pipeline_depth: + inst_seq += f'{inst} {destreg}, {reg1}, {reg2}\n' + d += 1 + + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + {inst_seq} + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + return asm_string + + +############################################################################ +# Function to return ASM-string of reg-branch RAW dependent inst sequences # +############################################################################ +def seq_test_rr_branch_raw_op(reg_inst, branch_inst, destreg, reg1, reg2, val1, val2, swreg, offset, depth): + asm_string = '' + nop_op = '' + d=0 + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + {reg_inst} {destreg}, {reg1}, {reg2} + {nop_op} + {branch_inst} {destreg}, {reg2}, 1f + add {destreg}, {reg1}, {reg2} + 1: add {destreg}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + else: + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + {reg_inst} {destreg}, {reg1}, {reg2} + {branch_inst} {destreg}, {reg2}, 1f + add {destreg}, {reg1}, {reg2} + 1: add {destreg}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + return asm_string + + +############################################################################ +# Function to return ASM-string of imm-branch RAW dependent inst sequences # +############################################################################ +def seq_test_imm_branch_raw_op(imm_inst, branch_inst, destreg, reg1, reg2, val1, val2, imm_val, swreg, offset, depth): + asm_string = '' + nop_op = '' + d=0 + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + {imm_inst} {destreg}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + {branch_inst} {destreg}, {reg2}, 1f + add {destreg}, {reg1}, {reg2} + 1: add {destreg}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + else: + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + {imm_inst} {destreg}, {reg1}, SEXT_IMM({imm_val}) + {branch_inst} {destreg}, {reg2}, 1f + add {destreg}, {reg1}, {reg2} + 1: add {destreg}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + return asm_string + + + +############################################################################ +# Function to return ASM-string of load-reg dependent inst sequences # +############################################################################ +def seq_test_load_rr_raw_op(load_inst, reg_inst, destreg1, destreg2, reg1, reg2, reg3, val2, val3, imm_val, swreg, offset, depth, dependency='', index=0,adj=0): + asm_string = '' + nop_op = '' + d=0 + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + asm_string = f''' + LA({reg1},rvtest_data+({index}*4)+{adj}-{imm_val}) + li {reg2}, {val2} + li {reg3}, {val3} + ''' + if dependency == 'RAW': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {nop_op} + {reg_inst} {destreg2}, {destreg1}, {reg2} + ''' + if dependency == 'WAW': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {nop_op} + {reg_inst} {destreg1}, {reg2}, {reg3} + ''' + if dependency == 'WAR': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {nop_op} + {reg_inst} {reg1}, {reg2}, {reg3} + ''' + asm_string += f''' + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + else: + asm_string = f''' + LA({reg1},rvtest_data+({index}*4)+{adj}-{imm_val}) + li {reg2}, {val2} + li {reg3}, {val3} + ''' + if dependency == 'RAW': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {reg_inst} {destreg2}, {destreg1}, {reg2} + ''' + if dependency == 'WAW': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {reg_inst} {destreg1}, {reg2}, {reg3} + ''' + if dependency == 'WAR': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {reg_inst} {reg1}, {reg2}, {reg3} + ''' + asm_string += f''' + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + + + return asm_string + + +############################################################################ +# Function to return ASM-string of load-imm dependent inst sequences # +############################################################################ +def seq_test_load_ri_op(load_inst, imm_inst, destreg1, destreg2, reg1, reg2, val2, imm_val, swreg, offset, depth, dependency='', index=0,adj=0): + asm_string = '' + nop_op = '' + d=0 + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + asm_string = f''' + LA({reg1},rvtest_data+({index}*4)+{adj}-{imm_val}) + li {reg2}, {val2} + ''' + if dependency == 'RAW': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {nop_op} + {imm_inst} {destreg2}, {destreg1}, SEXT_IMM({imm_val}) + ''' + if dependency == 'WAW': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {nop_op} + {imm_inst} {destreg1}, {reg2}, SEXT_IMM({imm_val}) + ''' + if dependency == 'WAR': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {nop_op} + {imm_inst} {reg1}, {reg2}, SEXT_IMM({imm_val}) + ''' + asm_string += f''' + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + else: + asm_string = f''' + LA({reg1},rvtest_data+({index}*4)+{adj}-{imm_val}) + li {reg2}, {val2} + ''' + if dependency == 'RAW': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {imm_inst} {destreg2}, {destreg1}, SEXT_IMM({imm_val}) + ''' + if dependency == 'WAW': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {imm_inst} {destreg1}, {reg2}, SEXT_IMM({imm_val}) + ''' + if dependency == 'WAR': + asm_string += f''' + {load_inst} {destreg1}, {imm_val}({reg1}) + {imm_inst} {reg1}, {reg2}, SEXT_IMM({imm_val}) + ''' + asm_string += f''' + RVTEST_SIGUPD({swreg}, {destreg2}, {offset}) + ''' + + return asm_string + + +############################################################################ +# Function to return ASM-string of reg-load dependent inst sequences # +############################################################################ +def seq_test_rr_load_op(reg_inst, load_inst, destreg, reg1, reg2, reg3, val1, val2, imm_val, swreg, offset, depth, dependency='', index=0,adj=0): + asm_string = '' + nop_op = '' + d=0 + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + asm_string = f''' + LA({reg3},rvtest_data+({index}*4)+{adj}-{imm_val}) + li {reg2}, {val2} + li {reg1}, {val1} + ''' + + if dependency == 'WAW': + asm_string += f''' + {reg_inst} {destreg}, {reg1}, {reg2} + {nop_op} + {load_inst} {destreg}, {imm_val}({reg3}) + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + if dependency == 'WAR': + asm_string += f''' + {reg_inst} {destreg}, {reg1}, {reg2} + {nop_op} + {load_inst} {reg1}, {imm_val}({reg3}) + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + else: + asm_string = f''' + LA({reg3},rvtest_data+({index}*4)+{adj}-{imm_val}) + li {reg2}, {val2} + li {reg1}, {val1} + ''' + if dependency == 'WAW': + asm_string += f''' + {reg_inst} {destreg}, {reg1}, {reg2} + {load_inst} {destreg}, {imm_val}({reg3}) + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + + ''' + if dependency == 'WAR': + asm_string += f''' + {reg_inst} {destreg}, {reg1}, {reg2} + {load_inst} {reg1}, {imm_val}({reg3}) + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + return asm_string + + +############################################################################ +# Function to return ASM-string of imm-load dependent inst sequences # +############################################################################ +def seq_test_ri_load_op(imm_inst, load_inst, destreg, reg1, reg2, reg_val, imm_val, swreg, offset, depth, dependency='', index=0,adj=0): + asm_string = '' + nop_op = '' + d=0 + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + asm_string = f''' + LA({reg2},rvtest_data+({index}*4)+{adj}-{imm_val}) + li {reg1}, {reg_val} + ''' + + if dependency == 'WAW': + asm_string += f''' + {imm_inst} {destreg}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + {load_inst} {destreg}, {imm_val}({reg2}) + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + if dependency == 'WAR': + asm_string += f''' + {imm_inst} {destreg}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + {load_inst} {reg1}, {imm_val}({reg2}) + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + else: + asm_string = f''' + LA({reg2},rvtest_data+({index}*4)+{adj}-{imm_val}) + li {reg1}, {reg_val} + ''' + + if dependency == 'WAW': + asm_string += f''' + {imm_inst} {destreg}, {reg1}, SEXT_IMM({imm_val}) + {load_inst} {destreg}, {imm_val}({reg2}) + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + if dependency == 'WAR': + asm_string += f''' + {imm_inst} {destreg}, {reg1}, SEXT_IMM({imm_val}) + {load_inst} {reg1}, {imm_val}({reg2}) + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + return asm_string + + +############################################################################ +# Function to return ASM-string of load-branch RAW dependent inst sequences # +############################################################################ +def seq_test_load_branch_raw_op(load_inst, branch_inst, destreg, reg1, reg2, val2, imm_val, swreg, offset, depth, index=0,adj=0): + asm_string = '' + nop_op = '' + d=0 + + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + asm_string = f''' + LA({reg1},rvtest_data+({index}*4)+{adj}-{imm_val}) + li {reg2}, {val2} + {load_inst} {destreg}, {imm_val}({reg1}) + {nop_op} + {branch_inst} {destreg}, {reg2}, 1f + add {destreg}, {reg1}, {reg2} + 1: add {destreg}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + else: + asm_string = f''' + LA({reg1},rvtest_data+({index}*4)+{adj}-{imm_val}) + li {reg2}, {val2} + {load_inst} {destreg}, {imm_val}({reg1}) + {branch_inst} {destreg}, {reg2}, 1f + add {destreg}, {reg1}, {reg2} + 1: add {destreg}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + return asm_string + + +############################################################################ +# Function to return ASM-string of reg-store dependent inst sequences # +############################################################################ +def seq_test_rr_store_raw_op(reg_inst, store_inst, destreg, reg1, reg2, reg3, val1, val2, imm_val, swreg, offset, depth, dependency): + asm_string = '' + nop_op = '' + d=0 + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + LA({reg3},rvtest_data-{imm_val}) + ''' + if dependency == 'RAW': + asm_string += f''' + {reg_inst} {destreg}, {reg1}, {reg2} + {nop_op} + {store_inst} {destreg}, {imm_val}({reg3}) + ''' + if dependency == 'WAR': + asm_string += f''' + {reg_inst} {destreg}, {reg1}, {reg2} + {nop_op} + {store_inst} {destreg}, {imm_val}({reg3}) + ''' + asm_string += f''' + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + else: + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + LA({reg3},rvtest_data-{imm_val}) + ''' + if dependency == 'RAW': + asm_string += f''' + {reg_inst} {destreg}, {reg1}, {reg2} + {store_inst} {destreg}, {imm_val}({reg3}) + ''' + if dependency == 'WAR': + asm_string += f''' + {reg_inst} {destreg}, {reg1}, {reg2} + {store_inst} {destreg}, {imm_val}({reg3}) + ''' + asm_string += f''' + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + return asm_string + + +############################################################################ +# Function to return ASM-string of imm-store dependent inst sequences # +############################################################################ +def seq_test_ri_store_op(imm_inst, store_inst, destreg, reg1, reg2, val1, imm_val, swreg, offset, depth, dependency=''): + asm_string = '' + nop_op = '' + d=0 + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + asm_string = f''' + li {reg1}, {val1} + LA({reg2},rvtest_data-{imm_val}) + ''' + if dependency == 'RAW': #imm inst followed by store inst + asm_string += f''' + {imm_inst} {destreg}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + {store_inst} {destreg}, {imm_val}({reg2}) + ''' + if dependency == 'WAR': #store inst followed by imm inst + asm_string += f''' + {store_inst} {destreg}, {imm_val}({reg2}) + {nop_op} + {imm_inst} {destreg}, {reg1}, SEXT_IMM({imm_val}) + ''' + asm_string += f''' + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + + else: + asm_string = f''' + li {reg1}, {val1} + LA({reg2},rvtest_data-{imm_val}) + ''' + if dependency == 'RAW': #imm inst followed by store inst + asm_string += f''' + {imm_inst} {destreg}, {reg1}, SEXT_IMM({imm_val}) + {store_inst} {destreg}, {imm_val}({reg2}) + ''' + if dependency == 'WAR': #store inst followed by imm inst + asm_string += f''' + {store_inst} {destreg}, {imm_val}({reg2}) + {imm_inst} {destreg}, {reg1}, SEXT_IMM({imm_val}) + ''' + asm_string += f''' + RVTEST_SIGUPD({swreg}, {destreg}, {offset}) + ''' + return asm_string + + +################################################################################### +# Function to return ASM-string of reg-jal dependent sequences # +################################################################################### +def seq_test_rr_jal_op(reg_inst, destreg1, destreg2, \ + reg1, reg2, val1, val2, \ + swreg, offset, depth, dependency=''): + asm_string = '' + nop_op = '' + d=0 + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + ''' + + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + if dependency == 'WAR': + asm_string += f''' + {reg_inst} {destreg1}, {reg1}, {reg2} + {nop_op} + jal {reg1}, 1f + 1: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {reg_inst} {destreg1}, {reg1}, {reg2} + {nop_op} + jal {destreg1}, 2f + 2: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + else: + + if dependency == 'WAR': + asm_string += f''' + {reg_inst} {destreg1}, {reg1}, {reg2} + jal {reg1}, 1f + 1: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {reg_inst} {destreg1}, {reg1}, {reg2} + jal {destreg1}, 2f + 2: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + return asm_string + + +################################################################################### +# Function to return ASM-string of imm-jal dependent sequences # +################################################################################### +def seq_test_ri_jal_op(imm_inst, destreg1, destreg2,\ + reg1, reg2, val1, val2, imm_val,\ + swreg, offset, depth, dependency=''): + asm_string = '' + nop_op = '' + d=0 + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + ''' + + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + if dependency == 'WAR': + asm_string += f''' + {imm_inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + jal {reg1}, 1f + 1: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {imm_inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + jal {destreg1}, 2f + 2: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + else: + + if dependency == 'WAR': + asm_string += f''' + {imm_inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + jal {reg1}, 1f + 1: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + {imm_inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + jal {destreg1}, 2f + 2: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + return asm_string + + +################################################################################### +# Function to return ASM-string of imm-jalr dependent sequences # +################################################################################### +def seq_test_ri_jalr_op(imm_inst, destreg1, destreg2, \ + reg1, reg2, reg3, reg4, val1, val2, imm_val, \ + swreg, offset, depth, dependency=''): + asm_string = '' + nop_op = '' + d=0 + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + ''' + + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + if dependency == 'WAR': + asm_string += f''' + la {reg3}, 1f + {imm_inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + jalr {reg1}, {imm_val}({reg3}) + 1: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + la {reg4}, 2f + {imm_inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + {nop_op} + jalr {destreg1}, {imm_val}({reg4}) + 2: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + else: + + if dependency == 'WAR': + asm_string += f''' + la {reg3}, 1f + {imm_inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + jalr {reg1}, {imm_val}({reg3}) + 1: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + la {reg4}, 2f + {imm_inst} {destreg1}, {reg1}, SEXT_IMM({imm_val}) + jalr {destreg1}, {imm_val}({reg4}) + 2: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + return asm_string + + +################################################################################### +# Function to return ASM-string of reg-jalr dependent sequences # +################################################################################### +def seq_test_rr_jalr_op(reg_inst, destreg1, destreg2, \ + reg1, reg2, reg3, reg4, val1, val2, imm_val, \ + swreg, offset, depth, dependency=''): + asm_string = '' + nop_op = '' + d=0 + asm_string = f''' + li {reg1}, {val1} + li {reg2}, {val2} + ''' + + if depth>0: + while d != depth: + nop_op += 'addi x0, x0, 0\n' + d += 1 + + if dependency == 'WAR': + asm_string += f''' + la {reg3}, 1f + {reg_inst} {destreg1}, {reg1}, {reg2} + {nop_op} + jalr {reg1}, {imm_val}({reg3}) + 1: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + la {reg4}, 2f + {reg_inst} {destreg1}, {reg1}, {reg2} + {nop_op} + jalr {destreg1}, {imm_val}({reg4}) + 2: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + + else: + + if dependency == 'WAR': + asm_string += f''' + la {reg3}, 1f + {reg_inst} {destreg1}, {reg1}, {reg2} + jalr {reg1}, {imm_val}({reg3}) + 1: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {reg1}, {offset}) + ''' + + if dependency == 'WAW': + asm_string += f''' + la {reg4}, 2f + {reg_inst} {destreg1}, {reg1}, {reg2} + jalr {destreg1}, {imm_val}({reg4}) + 2: add {destreg2}, {reg1}, {reg2} + RVTEST_SIGUPD({swreg}, {destreg1}, {offset}) + ''' + return asm_string +##################################################################################################################### From ad6b2f992aaf68eb74ad781b49ddb10fa7cb20e6 Mon Sep 17 00:00:00 2001 From: karans5 Date: Wed, 29 Mar 2023 14:42:15 +0530 Subject: [PATCH 2/5] =?UTF-8?q?Bump=20version:=201.6.0=20=E2=86=92=201.6.1?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- setup.cfg | 2 +- setup.py | 2 +- uatg/__init__.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/setup.cfg b/setup.cfg index 1885403..8af6c94 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 1.6.0 +current_version = 1.6.1 commit = True tag = True diff --git a/setup.py b/setup.py index 732f611..dbd31c6 100644 --- a/setup.py +++ b/setup.py @@ -29,7 +29,7 @@ def read_requires(): setup( name='uatg', - version='1.6.0', + version='1.6.1', description="UATG - Micro-Architecture (µArch) Tests Generator", long_description=readme + '\n\n', classifiers=[ diff --git a/uatg/__init__.py b/uatg/__init__.py index 0c8d588..8f6d896 100644 --- a/uatg/__init__.py +++ b/uatg/__init__.py @@ -3,4 +3,4 @@ __author__ = """InCore Semiconductors Pvt Ltd""" __email__ = 'neelgala@incoresemi.com' -__version__ = '1.6.0' +__version__ = '1.6.1' From f21c6a46bafa01f389128744d79601cb727c6fa1 Mon Sep 17 00:00:00 2001 From: karans5 Date: Wed, 29 Mar 2023 14:48:14 +0530 Subject: [PATCH 3/5] update changelog --- CHANGELOG.md | 3 +++ 1 file changed, 3 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 98bbe4f..fc32bbf 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,9 @@ This project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html). +## [1.7.0] - 2023-03-29 +- added functions in instruction_constants.py to generate ASM strings for various instruction sequences + ## [1.6.0] - 2022-11-25 - fix march and mabi generation From 9f1e2dc314540186d8bc326772755cea2067c8cf Mon Sep 17 00:00:00 2001 From: karans5 Date: Wed, 29 Mar 2023 15:00:05 +0530 Subject: [PATCH 4/5] =?UTF-8?q?Revert=20"Bump=20version:=201.6.0=20?= =?UTF-8?q?=E2=86=92=201.6.1"?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This reverts commit ad6b2f992aaf68eb74ad781b49ddb10fa7cb20e6. --- setup.cfg | 2 +- setup.py | 2 +- uatg/__init__.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/setup.cfg b/setup.cfg index 8af6c94..1885403 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 1.6.1 +current_version = 1.6.0 commit = True tag = True diff --git a/setup.py b/setup.py index dbd31c6..732f611 100644 --- a/setup.py +++ b/setup.py @@ -29,7 +29,7 @@ def read_requires(): setup( name='uatg', - version='1.6.1', + version='1.6.0', description="UATG - Micro-Architecture (µArch) Tests Generator", long_description=readme + '\n\n', classifiers=[ diff --git a/uatg/__init__.py b/uatg/__init__.py index 8f6d896..0c8d588 100644 --- a/uatg/__init__.py +++ b/uatg/__init__.py @@ -3,4 +3,4 @@ __author__ = """InCore Semiconductors Pvt Ltd""" __email__ = 'neelgala@incoresemi.com' -__version__ = '1.6.1' +__version__ = '1.6.0' From 9f240472dd2932958e8afa734576039eda103e4d Mon Sep 17 00:00:00 2001 From: karans5 Date: Wed, 29 Mar 2023 15:16:01 +0530 Subject: [PATCH 5/5] =?UTF-8?q?Bump=20version:=201.6.0=20=E2=86=92=201.7.0?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- setup.cfg | 2 +- setup.py | 2 +- uatg/__init__.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/setup.cfg b/setup.cfg index 1885403..8563df6 100644 --- a/setup.cfg +++ b/setup.cfg @@ -1,5 +1,5 @@ [bumpversion] -current_version = 1.6.0 +current_version = 1.7.0 commit = True tag = True diff --git a/setup.py b/setup.py index 732f611..5f272ff 100644 --- a/setup.py +++ b/setup.py @@ -29,7 +29,7 @@ def read_requires(): setup( name='uatg', - version='1.6.0', + version='1.7.0', description="UATG - Micro-Architecture (µArch) Tests Generator", long_description=readme + '\n\n', classifiers=[ diff --git a/uatg/__init__.py b/uatg/__init__.py index 0c8d588..fc2e206 100644 --- a/uatg/__init__.py +++ b/uatg/__init__.py @@ -3,4 +3,4 @@ __author__ = """InCore Semiconductors Pvt Ltd""" __email__ = 'neelgala@incoresemi.com' -__version__ = '1.6.0' +__version__ = '1.7.0'