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
"""))
