Forward implementation for the definition use chains handling unsupported types correctly

Author: LonelyCat124

src/psyclone/psyir/tools/definition_use_chains.py

@@ -63,6 +63,7 @@
     WhileLoop,
     PSyDataNode,
 )
+from psyclone.psyir.symbols import UnsupportedType, UnresolvedType
 
 
 class DefinitionUseChain:
@@ -590,6 +591,30 @@ def _compute_forward_uses(self, basic_block_list: list[Node]):
                                 self._defsout[sig].append(defs_out[sig])
                         return
                     for i, ref in enumerate(self._references[:]):
+                        # If the DUC's searched Reference is to an
+                        # UnsupportedType then
+                        # it needs to assume the worst case
+                        # for the CodeBlock if it contains an
+                        # UnsupportedType or UnresolvedType
+                        if isinstance(ref.datatype, UnsupportedType):
+                            for sym in reference.get_symbol_names():
+                                symbol = reference.scope.symbol_table.lookup(
+                                    sym
+                                )
+                                if isinstance(symbol.datatype,
+                                              (UnsupportedType,
+                                               UnresolvedType)):
+                                    # Assume the worst for a CodeBlock and we
+                                    # count them as killed and defsout and
+                                    # uses.
+                                    sig = self._reference_signatures[i]
+                                    if defs_out[sig] is not None:
+                                        self._killed[sig].append(
+                                            defs_out[sig]
+                                        )
+                                    defs_out[sig] = reference
+                            continue
+                        # Otherwise we check if ref appears in the CodeBlock.
                         if (
                             ref.symbol.name
                             in reference.get_symbol_names()
@@ -671,6 +696,67 @@ def _compute_forward_uses(self, basic_block_list: list[Node]):
                         # condition for example.
                         if defs_out[sig] is None:
                             self._uses[sig].append(reference)
+                # If we have a reference whose datatype is an
+                # UnsupportedType then we must assume it is aliased and
+                # therefore can access any other UnsupportedType Reference.
+                elif isinstance(reference.datatype, UnsupportedType):
+                    # If its accessed on the lhs of an assignment or as an
+                    # argument of a call then its
+                    # a write to every signature, otherwise its a read to
+                    # every signature.
+                    assign = reference.ancestor(Assignment)
+                    if assign is not None:
+                        if assign.lhs is reference:
+                            for i, sig in enumerate(
+                                    self._reference_signatures
+                            ):
+                                if not isinstance(
+                                    self._references[i].datatype,
+                                    UnsupportedType
+                                ):
+                                    continue
+                                if defs_out[sig] is not None:
+                                    self._killed[sig].append(defs_out[sig])
+                                defs_out[sig] = reference
+                        # If the reference is on the rhs of an assignment
+                        # where the lhs is a write to any of the signatures
+                        # then this should be added to the uses for that
+                        # signature if its also an UnsupportedType.
+                        elif (
+                            any((defs_out[sig] is assign.lhs and
+                                 len(self._killed[sig]) == 0) for sig in
+                                self._reference_signatures)
+                        ):
+                            for i, sig in enumerate(
+                                    self._reference_signatures
+                            ):
+                                if not isinstance(
+                                    self._references[i].datatype,
+                                    UnsupportedType
+                                ):
+                                    continue
+                                if (defs_out[sig] is assign.lhs and
+                                        len(self._killed[sig]) == 0):
+                                    self._uses[sig].append(reference)
+                    elif reference.ancestor(Call):
+                        # If its an argument to a Call then it is a read to
+                        # all UnsupportedType references.
+                        for i, sig in enumerate(self._reference_signatures):
+                            if not isinstance(self._references[i].datatype,
+                                              UnsupportedType):
+                                continue
+                            if defs_out[sig] is not None:
+                                self._killed[sig].append(defs_out[sig])
+                            defs_out[sig] = reference
+                    else:
+                        # Otherwise all other UnsupportedType References
+                        # count as a read to all UnsupportedType inputs.
+                        for i, sig in enumerate(self._reference_signatures):
+                            if not isinstance(self._references[i].datatype,
+                                              UnsupportedType):
+                                continue
+                            if defs_out[sig] is None:
+                                self._uses[sig].append(reference)
         for sig in self._reference_signatures:
             if defs_out[sig] is not None:
                 self._defsout[sig].append(defs_out[sig])
@@ -994,6 +1080,41 @@ def _compute_backward_uses(self, basic_block_list: list[Node]):
                         # condition for example.
                         if defs_out[sig] is None:
                             self._uses[sig].append(reference)
+                # FIXME We need this block still.
+                # elif isinstance(reference.datatype, UnsupportedType):
+                #    # If its accessed on the lhs of an assignment or as an
+                #    # argument of a call then its
+                #    # a write to every signature, otherwise its a read to
+                #    # every signature.
+                #    assign = reference.ancestor(Assignment)
+                #    if assign is not None:
+                #        if assign.lhs is reference:
+                #            for sig in self._reference_signatures:
+                #                if defs_out[sig] is not None:
+                #                    self._killed[sig].append(defs_out[sig])
+                #                defs_out[sig] = reference
+                #        # If the reference is on the rhs of an assignment
+                #        # where the lhs is a write to any of the signatures
+                #        # then this should be added to the uses for that
+                #        # signature.
+                #        elif (
+                #            any((defs_out[sig] is assign.lhs and
+                #                 len(self._killed[sig]) == 0) for sig in
+                #                self._reference_signatures)
+                #        ):
+                #            for sig in self._reference_signatures:
+                #                if (defs_out[sig] is assign.lhs and
+                #                        len(self._killed[sig]) == 0):
+                #                    self._uses[sig].append(reference)
+                #    elif reference.ancestor(Call):
+                #        for sig in self._reference_signatures:
+                #            if defs_out[sig] is not None:
+                #                self._killed[sig].append(defs_out[sig])
+                #            defs_out[sig] = reference
+                #    else:
+                #        for sig in self._reference_signatures:
+                #            if defs_out[sig] is None:
+                #                self._uses[sig].append(reference)
         for sig in self._reference_signatures:
             if defs_out[sig] is not None:
                 self._defsout[sig].append(defs_out[sig])

src/psyclone/tests/psyir/tools/definition_use_chains_backward_dependence_test.py

@@ -905,3 +905,91 @@ def test_backward_accesses_nested_loop(fortran_reader):
     chains = DefinitionUseChain([lhs])
     reaches = chains.find_backward_accesses()[sig]
     assert len(reaches) == 1
+
+
+def test_backward_accesses_unsupported_type(fortran_reader):
+    """Test that if we have an unsupported type we get the expected
+    worst-case behaviour from the DUCs."""
+    # Test the result for assignments
+    code = """
+    subroutine x
+    integer :: a
+    integer, pointer :: c
+    integer, target :: b
+
+    c = 1
+    b = c
+    a = 1
+    end subroutine x"""
+
+    psyir = fortran_reader.psyir_from_source(code)
+    routine = psyir.walk(Routine)[0]
+    assign = routine.walk(Assignment)[-1]
+    sig = assign.lhs.get_signature_and_indices()[0]
+    chains = DefinitionUseChain(assign.lhs)
+    reaches = chains.find_backward_accesses()[sig]
+    # The result should be the access to b in the b = c
+    # assignment.
+    assert len(reaches) == 1
+    assert reaches[0] is routine.walk(Assignment)[1].lhs
+
+    code = """
+    subroutine x
+    integer :: a
+    integer, pointer :: c
+    integer :: b
+
+    c = 1
+    b = c
+    a = 1
+    end subroutine x"""
+    psyir = fortran_reader.psyir_from_source(code)
+    routine = psyir.walk(Routine)[0]
+    assign = routine.walk(Assignment)[-1]
+    sig = assign.lhs.get_signature_and_indices()[0]
+    chains = DefinitionUseChain(assign.lhs)
+    reaches = chains.find_backward_accesses()[sig]
+
+    # The result should be the two accesses to c in b = C
+    # and C = 1.
+    assert len(reaches) == 2
+    assert reaches[0] is routine.walk(Assignment)[1].rhs
+    assert reaches[1] is routine.walk(Assignment)[0].lhs
+
+    # Test that unsupported type arguments to pure subroutines
+    # is always counted as an access.
+    code = """
+    pure subroutine test(a)
+        integer :: a
+        a = a * 2
+    end subroutine test
+    subroutine test2
+        integer :: a
+        integer, pointer :: b
+        a = 1
+        call test(b)
+        a = 2
+    end subroutine test2"""
+    psyir = fortran_reader.psyir_from_source(code)
+    routine = psyir.walk(Routine)[0]
+    assign = routine.walk(Assignment)[-1]
+    sig = assign.lhs.get_signature_and_indices()[0]
+    chains = DefinitionUseChain(assign.lhs)
+    reaches = chains.find_backward_accesses()[sig]
+
+    # The result should be the b argument to call test(b)
+    assert len(reaches) == 1
+    assert reaches[0] is routine.walk(Call)[0].arguments[0]
+
+    # Test that unsupported type references in non assignment
+    # non-Call locations are counted as a read.
+    code = """subroutine test
+    integer :: a
+    logical, pointer :: b
+
+    a = 1
+    if (b) then
+    end if
+    a = 2
+    end subroutine test"""
+    assert False

src/psyclone/tests/psyir/tools/definition_use_chains_forward_dependence_test.py

@@ -1074,6 +1074,112 @@ def test_definition_use_chains_return_statement(
     assert reaches[3] is routine.walk(Assignment)[4].rhs.children[0]
 
 
+def test_definition_use_chains_forward_accesses_unsupported_type(
+    fortran_reader,
+):
+    '''Test the forward_accesses function always hits unsupported types.'''
+    # Test the code works as expected for unsupported types in an assignment.
+    code = """subroutine test
+    integer, pointer :: a
+    integer, pointer :: b
+    integer, target :: c
+    integer :: d
+    a = 1
+    d = 1
+    b => c
+    end subroutine test"""
+    psyir = fortran_reader.psyir_from_source(code)
+    routine = psyir.walk(Routine)[0]
+    # Start the chain from a = 1.
+    ref = routine.walk(Assignment)[0].lhs
+    sig = ref.get_signature_and_indices()[0]
+    chains = DefinitionUseChain(ref)
+    reaches = chains.find_forward_accesses()[sig]
+    assert len(reaches) == 2
+    # First reached is the rhs of the b => c assignment.
+    assert reaches[0] is routine.walk(Assignment)[2].rhs
+    # Second reached is the lhs of the b => c assignment.
+    assert reaches[1] is routine.walk(Assignment)[2].lhs
+
+    # Test the behaviour for a pure Call with an Unsupported type as
+    # an argument.
+    code = """
+    pure subroutine y(in)
+        integer :: in
+        in = in + 1
+    end subroutine y
+    subroutine x(a, b)
+    integer, target:: a
+    integer :: b
+    integer, pointer :: c
+    a = 2
+    b = 1
+    call y(c)
+    a = a + 2
+    c = 2
+    end subroutine"""
+    psyir = fortran_reader.psyir_from_source(code)
+    routine = psyir.walk(Routine)[1]
+    # Start the chain from a = 2.
+    ref = routine.walk(Assignment)[0].lhs
+    sig = ref.get_signature_and_indices()[0]
+    chains = DefinitionUseChain(ref)
+    reaches = chains.find_forward_accesses()[sig]
+    print(reaches[0].parent.debug_string())
+    assert len(reaches) == 1
+    # The result is the c argument of the pure call.
+    assert reaches[0] is routine.walk(Call)[0].arguments[0]
+
+    # Test we get the correct unsupported type access when
+    # we have a reference not as a child of an Assignment or Call.
+    code = """subroutine x
+    integer, target :: a
+    integer :: b
+    logical, pointer :: c
+
+    a = 1
+    if(c) then
+       b = 1
+       a = 2
+    end if
+    end subroutine x
+    """
+    psyir = fortran_reader.psyir_from_source(code)
+    routine = psyir.walk(Routine)[0]
+    # Start the chain from a = 1.
+    ref = routine.walk(Assignment)[0].lhs
+    sig = ref.get_signature_and_indices()[0]
+    chains = DefinitionUseChain(ref)
+    reaches = chains.find_forward_accesses()[sig]
+    assert len(reaches) == 2
+    # The first reached is the condition of the if statement.
+    assert reaches[0] is routine.walk(IfBlock)[0].condition
+    # The second reached is the a = 2 assignment lhs
+    assert reaches[1] is routine.walk(Assignment)[2].lhs
+
+    # Test that if we have an unsupported type in a Codeblock
+    # then we count as a read/write for all the unsupported
+    # type input references.
+    code = """subroutine x
+    integer, target :: a
+    integer :: b
+    logical, pointer :: c
+
+    a = 1
+    print *, b, c
+    a = 2
+    end subroutine x"""
+    psyir = fortran_reader.psyir_from_source(code)
+    routine = psyir.walk(Routine)[0]
+    # Start the chain from a = 1.
+    ref = routine.walk(Assignment)[0].lhs
+    sig = ref.get_signature_and_indices()[0]
+    chains = DefinitionUseChain(ref)
+    reaches = chains.find_forward_accesses()[sig]
+    assert len(reaches) == 1
+    assert reaches[0] is routine.walk(CodeBlock)[0]
+
+
 def test_definition_use_chains_forward_accesses_multiple_routines(
     fortran_reader,
 ):