def test_optimize_code_with_different_operator(self): as_tree = ast.parse( ms("""\ c = d + e d = d + e f = g | h i = s ^ 3 k = g | h p = s ^ 3 q = 3 < x l = 3 < x""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ c_0 = d_0 + e_0 d_1 = c_0 f_0 = g_0 | h_0 i_0 = s_0 ^ 3 k_0 = f_0 p_0 = i_0 q_0 = 3 < x_0 l_0 = q_0 """))
def test_optimize_code_with_variable_redefinition_expect_not_update(self): """ x gets redefined at 3rd statement, result in the 4th statement not optimized :return: """ as_tree = ast.parse( ms("""\ c = d + e e = 5 d = d + e d = d + e c = d + e c = d + e""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ c_0 = d_0 + e_0 e_1 = 5 d_1 = d_0 + 5 d_2 = 5 + d_1 c_1 = 5 + d_2 """))
def test_optimize_redundant_stmt_1_stmt_d_d(self): as_tree = ast.parse(ms("""\ d = d""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual(str(ssa_code), ms("""\ """))
def test_optimize_redundant_stmt_2_stmt_a_a(self): as_tree = ast.parse(ms("""\ a = b a = a""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual(str(ssa_code), ms("""\ a_0 = b_0 """))
def test_optimize_redundant_stmt_substituted(self): as_tree = ast.parse(ms("""\ d = a a = d""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual(str(ssa_code), ms("""\ d_0 = a_0 """))
def test_optimize_simple_assignment_expect_substitute_single_var(self): as_tree = ast.parse(ms("""\ a = b c = a""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ a_0 = b_0 c_0 = b_0 """))
def test_optimize_reordering_operands_BitOr_op(self): as_tree = ast.parse( ms("""\ a = b | c d = c | b""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ a_0 = b_0 | c_0 d_0 = a_0 """))
def test_optimize_reordering_operands_Sub_op_expect_no_subs(self): as_tree = ast.parse( ms("""\ a = b - c d = c - b""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ a_0 = b_0 - c_0 d_0 = c_0 - b_0 """))
def test_optimize_code_with_2_lvn_stmt_same_expect_not_updated(self): as_tree = ast.parse( ms("""\ f = g + j # 0 + 1 k = g + 1 """)) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ f_0 = g_0 + j_0 k_0 = g_0 + 1 """))
def test_optimize_code_with_xor(self): as_tree = ast.parse( ms("""\ f = g ^ 33 k = g ^ h""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ f_0 = g_0 ^ 33 k_0 = g_0 ^ h_0 """))
def test_optimize_code_with_bin_op(self): as_tree = ast.parse( ms("""\ f = g | h k = g | j""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ f_0 = g_0 | h_0 k_0 = g_0 | j_0 """))
def test_optimize_simple_assignment_given_3_stmt_same(self): as_tree = ast.parse( ms("""\ a=3 b=a c=b""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ a_0 = 3 b_0 = 3 c_0 = 3 """))
def test_optimize_simple_assignment_given_constant(self): as_tree = ast.parse( ms("""\ a = 33 + y b = 33 c = b d = c + y""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ a_0 = 33 + y_0 b_0 = 33 c_0 = 33 d_0 = a_0 """))
def test_optimize_simple_assignment_expect_substituted(self): as_tree = ast.parse( ms("""\ z = a + y b = a c = b d = c + y""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ z_0 = a_0 + y_0 b_0 = a_0 c_0 = a_0 d_0 = z_0 """))
def test_optimize_simple_assignment_expect_constant_folding(self): as_tree = ast.parse( ms("""\ a = 5 b = a c = b + 9 d = b * c""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ a_0 = 5 b_0 = 5 c_0 = 14 d_0 = 70 """))
def test_optimize_redundant_stmt_2_stmt(self): as_tree = ast.parse( ms("""\ d = b + 0 e = b f = b - 0 g = c * 0""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ d_0 = b_0 e_0 = b_0 f_0 = b_0 g_0 = 0 """))
def test_optimize_simple_assignment_expect_constant_fold_and_replaced( self): as_tree = ast.parse( ms("""\ a = 14 + c d = 8 e = d + 6 # is 14 f = e + c""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ a_0 = 14 + c_0 d_0 = 8 e_0 = 14 f_0 = a_0 """))
def test_optimize_code_with_variable_redefinition_1(self): as_tree = ast.parse( ms("""\ a = x + y b = x + y a = 17 c = x + y""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) # Test the output self.assertEqual( str(ssa_code), ms("""\ a_0 = x_0 + y_0 b_0 = a_0 a_1 = 17 c_0 = a_0 """))
def test_optimize_simple_assignment_given_all_possible_combination(self): as_tree = ast.parse( ms("""\ z = l a = x + y b = 33 c = y + 11 d = 34 + f""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ z_0 = l_0 a_0 = x_0 + y_0 b_0 = 33 c_0 = y_0 + 11 d_0 = 34 + f_0 """))
def test_optimize_simple_assignment_given_constant_with_val_number_same_with_var( self): as_tree = ast.parse( ms("""\ a = x + 1 b = a c = b d = x + c # c will be replaced by 1, the simple expr is 0 + 1, but its diff than the first assignment (which # is also 0 + 1 because the first statement is referring to constant 1 while fourth statement is # referring to variable with value number 1 """)) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ a_0 = x_0 + 1 b_0 = a_0 c_0 = a_0 d_0 = x_0 + a_0 """))
def test_optimize_simple_assignment_expect_substituted_4_lines(self): as_tree = ast.parse( ms("""\ k = x + y z = k + h a = x + y b = a c = b d = c + h""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) self.assertEqual( str(ssa_code), ms("""\ k_0 = x_0 + y_0 z_0 = k_0 + h_0 a_0 = k_0 b_0 = k_0 c_0 = k_0 d_0 = z_0 """))
def test_optimize_code_with_variable_redefinition_2(self): """ x gets redefined at 3rd statement, result in the 4th statement not optimized :return: """ as_tree = ast.parse( ms("""\ a = x + y b = x + y x = 98 c = x + y""")) lvn_test = Lvn() ssa_code = SsaCode(as_tree) ssa_code = lvn_test.optimize(ssa_code) # Test the output self.assertEqual( str(ssa_code), ms("""\ a_0 = x_0 + y_0 b_0 = a_0 x_1 = 98 c_0 = y_0 + 98 """))