def test_build_while_body_given_body_if(self):
as_tree = ast.parse(
ms("""\
while a < 3: # 1st block
if a < 2: # 2nd block
z = 2 # 3rd block
b = 2 # 4th block
"""))
while_block = RawBasicBlock(1, 1, 'While')
cfg_handler = Cfg()
cfg_handler.as_tree = as_tree
real_tail_list = cfg_handler.build_while_body(while_block)
expected_block_list = build_blocks([1, 1, 'While'], [2, 2, 'If'],
[3, 3, None], [4, 4, None],
block_links={
'0': [1],
'1': [2, 3],
'2': [3],
'3': [0]
})
self.assertBasicBlockEqual(while_block, expected_block_list[0])
self.assertBasicBlockEqual(real_tail_list[0], expected_block_list[0])
def test_insert_phi_function_pruned_given_2_df(self):
"""
Note: '|' with no arrows means pointing down
GIVEN: block B has 2 DF nodes, C and D. Definition in B will force phi function in C and D
A ---
/ \ |
B | |
/ \ | |
| C |
\ |
D ---
"""
blocks, ast_string = th.build_blocks_arb(block_links={
'A': ['B', 'C', 'D'],
'B': ['C', 'D'],
'C': [],
'D': []
},
code={
'A':
ms("""\
temp = 1
phi_var = 1
"""),
'B':
ms("""\
phi_var= 2
"""),
'C':
ms("""\
x = phi_var
"""),
'D':
ms("""\
y = phi_var
""")
})
as_tree = ast.parse(ast_string)
cfg_real = Cfg()
cfg_real.block_list = blocks
cfg_real.as_tree = as_tree
cfg_real.root = cfg_real.block_list[0]
cfg_real.fill_df()
cfg_real.gather_initial_info()
cfg_real.compute_live_out()
cfg_real.ins_phi_function_pruned()
expected_phi_list = {
'A': set(),
'B': set(),
'C': {'phi_var'},
'D': {'phi_var'}
}
self.assertPhiListEqual(cfg_real.block_list, expected_phi_list)
def test_compute_liveout_given_5_blocks(self):
blocks, ast_string = th.build_blocks_arb(block_links={
'A': ['B'],
'B': ['C', 'D'],
'C': ['D'],
'D': ['E', 'B'],
'E': []
},
code={
'A':
ms("""\
i = 1
"""),
'B':
ms("""\
if i < 0:
pass
"""),
'C':
ms("""\
s = 0
"""),
'D':
ms("""\
s = s + i
i = i + 1
if i < 0:
pass
"""),
'E':
ms("""\
if s < 3:
pass
""")
})
as_tree = ast.parse(ast_string)
cfg_real = Cfg()
cfg_real.block_list = blocks
cfg_real.as_tree = as_tree
cfg_real.root = cfg_real.block_list[0]
cfg_real.gather_initial_info()
cfg_real.compute_live_out()
expected_live_out = {
'A': {'s', 'i'},
'B': {'s', 'i'},
'C': {'s', 'i'},
'D': {'s', 'i'},
'E': set()
}
self.assertLiveOutEqual(cfg_real.block_list, expected_live_out)
def test_build_while_body_given_only_while(self):
as_tree = ast.parse(ms("""\
while a < 3: # 1st block
z = 4 # 2nd block
"""))
while_block = RawBasicBlock(1, 1, 'While')
cfg_handler = Cfg()
cfg_handler.as_tree = as_tree
real_tail_list = cfg_handler.build_while_body(while_block)
expected_block_list = build_blocks([1, 1, 'While'], [2, 2, None],
block_links={'0': [1], '1': [0]})
self.assertBasicBlockEqual(while_block, expected_block_list[0])
self.assertBasicBlockEqual(real_tail_list[0], expected_block_list[0])
def test_get_ast_stmt_from_block_given_if(self):
as_tree = ast.parse(
ms("""\
a = 3
if a < 3:
x, y = a, b
"""))
block_1 = RawBasicBlock(1, 3)
cfg_holder = Cfg()
cfg_holder.as_tree = as_tree
tuples_list_real = [(x, y) for x, y in cfg_holder.get_var_ast(block_1)]
tuples_list_expected = [(['a'], []), ([], ['a']),
(['x', 'y'], ['a', 'b'])]
self.assertListEqual(tuples_list_expected, tuples_list_real)
def test_insert_phi_function_pruned_4_blocks(self):
blocks, ast_string = th.build_blocks_arb(block_links={
'A': ['B', 'C'],
'B': ['D'],
'C': ['D'],
'D': []
},
code={
'A':
ms("""\
pass
"""),
'B':
ms("""\
var = 3
"""),
'C':
ms("""\
pass
"""),
'D':
ms("""\
if var < 3:
pass
""")
})
as_tree = ast.parse(ast_string)
cfg_real = Cfg()
cfg_real.block_list = blocks
cfg_real.as_tree = as_tree
cfg_real.root = cfg_real.block_list[0]
cfg_real.fill_df()
cfg_real.gather_initial_info()
cfg_real.compute_live_out()
cfg_real.ins_phi_function_pruned()
expected_phi_list = {'A': set(), 'B': set(), 'C': set(), 'D': {'var'}}
self.assertPhiListEqual(cfg_real.block_list, expected_phi_list)
def test_insert_phi_function_semi_pruned(self):
"""
Note: '|' with no arrows means pointing down
A
|
B <------|
/ \ |
C F |
| / \ |
| G I |
| \ / |
| H |
\ / |
D-----------|
|
E
"""
blocks, ast_string = th.build_blocks_arb(block_links={
'A': ['B'],
'B': ['C', 'F'],
'C': ['D'],
'D': ['E', 'B'],
'E': [],
'F': ['G', 'I'],
'G': ['H'],
'H': ['D'],
'I': ['H']
},
code={
'A':
ms("""\
i = 1
"""),
'B':
ms("""\
a = temp_0
c = temp_1
"""),
'C':
ms("""\
b = temp_2
c = temp_3
d = temp_4
"""),
'D':
ms("""\
y = a + b
z = c + d
i = i + 1
if i < 100:
pass
"""),
'E':
"return\n",
'F':
ms("""\
a = temp_5
d = temp_6
if a < d:
pass
"""),
'G':
ms("""\
d = temp
"""),
'H':
ms("""\
b = temp
"""),
'I':
ms("""\
c = temp
""")
})
as_tree = ast.parse(ast_string)
cfg_real = Cfg()
cfg_real.block_list = blocks
cfg_real.as_tree = as_tree
cfg_real.root = cfg_real.block_list[0]
cfg_real.fill_df()
cfg_real.gather_initial_info()
cfg_real.ins_phi_function_semi_pruned()
expected_phi_list = {
'A': set(),
'B': {'a', 'b', 'c', 'd', 'i'},
'C': set(),
'D': {'a', 'b', 'c', 'd'},
'E': set(),
'F': set(),
'G': set(),
'H': {'c', 'd'},
'I': set()
}
self.assertPhiListEqual(cfg_real.block_list, expected_phi_list)
