Esempio n. 1
0
    def test_rename_given_repeated_definition(self):
        as_tree = AstBuilder().string_build(
            dedent("""\
                    a = 3           # 1st
                    if a > 3:       #  |
                        a = 3       # 2nd
                        a = 98
                    else:           # 3rd
                        z = 4       #  |
                    # expected phi func for 'a' here
                    y = a           # 4th
                    a = 4
                    """))
        cfg_real = Cfg(as_tree)
        cfg_real.fill_df()
        cfg_real.gather_initial_info()
        cfg_real.ins_phi_function_all()
        cfg_real.rename_to_ssa()

        self.assertBlockSsaList(
            cfg_real.block_list,
            {
                "Module":
                dedent("""\
                                      Module
                                            """),
                "L1":
                dedent("""\
                                      Assign: (a_0,) = 3
                                      a_0 > 3
                                      """),
                "L3":
                dedent("""\
                                      Assign: (a_1,) = 3
                                      Assign: (a_2,) = 98
                                      """),
                "L6":
                dedent("""\
                                      Assign: (z_0,) = 4
                                      """),
                "L8":
                """\
                                      Assign: (z_1,) = Phi(z, z_0)
                                      Assign: (a_3,) = Phi(a_2, a_0)
                                      Assign: (y_0,) = a_3
                                      Assign: (a_4,) = 4
                                      """,
            },
        )
 def test_insert_phi_function_if_else(self):
     as_tree = AstBuilder().string_build(
         dedent(
             """\
                 a = 3           # 1st
                 if a > 3:       #  |
                     a = 3       # 2nd
                     b = 3
                 else:           # 3rd
                     z = 4       #  |
                 # expected phi func for 'a' here
                 y = a           # 4th
                 """
         )
     )
     cfg_real = Cfg(as_tree)
     cfg_real.fill_df()
     cfg_real.gather_initial_info()
     cfg_real.ins_phi_function_all()
     assert cfg_real.block_list[-2]._phi_repr == {"a", "b", "z"}
     cfg_real.rename_to_ssa()
     assert "Phi(a_1, a_0)" in str(cfg_real.block_list[-2].ssa_code.code_list)
Esempio n. 3
0
    def test_rename_given_custom_4_blocks(self):
        r"""
               A
            /    \
           B      E
          / \     |
         C  D     |
         \ /      |
          F  <----
        """
        blocks, as_tree = self.build_arbitrary_blocks(
            block_links={
                "A": ["B", "E"],
                "B": ["C", "D"],
                "C": ["F"],
                "D": ["F"],
                "E": ["G"],
                "F": ["G"],
                "G": []
            },
            block_type={"A": ParentScopeBlock},
            code={
                "A":
                dedent("""\
                                                            """),
                "B":
                dedent("""\
                                                            a = 1 #a_0
                                                            """),
                "C":
                dedent("""\
                                                            a = 22 #a_1
                                                            """),
                "D":
                dedent("""\
                                                            a = 33 #a_2
                                                            """),
                "E":
                dedent("""\
                                                            a = 44 #a_4
                                                            """),
                "F":
                dedent("""\
                                                            a = 55 #a_3
                                                            """),
                "G":
                dedent("""\
                                                            a = 66 #a_5
                                                            """),
            },
        )

        cfg_real = Cfg()
        cfg_real.block_list = blocks
        cfg_real.as_tree = as_tree
        cfg_real.root = cfg_real.block_list[0]
        cfg_real.root.ast_node = as_tree
        cfg_real.root.ssa_code.code_list.append(as_tree)
        cfg_real.root.blocks = blocks
        cfg_real.fill_df()
        cfg_real.gather_initial_info()
        cfg_real.compute_live_out()

        cfg_real.rename_to_ssa()

        self.assertBlockSsaList(
            cfg_real.block_list,
            {
                "A":
                dedent("""\
                                    Module
                                """),
                "B":
                dedent("""\
                                      Assign: (a_0,) = 1
                                      """),
                "C":
                dedent("""\
                                      Assign: (a_1,) = 22
                                      """),
                "D":
                dedent("""\
                                      Assign: (a_2,) = 33
                                      """),
                "E":
                dedent("""\
                                      Assign: (a_4,) = 44
                                      """),
                "F":
                dedent("""\
                                      Assign: (a_3,) = 55
                                      """),
                "G":
                dedent("""\
                                      Assign: (a_5,) = 66
                                      """),
            },
        )