Updates for inlining with common variables

src/psyclone/psyir/symbols/symbol_table.py

@@ -706,6 +706,12 @@ def check_for_clashes(self, other_table, symbols_to_skip=()):
                     isinstance(other_sym, IntrinsicSymbol)):
                 continue
 
+            # If both symbols have CommonBlockInterface, they represent the
+            # same shared COMMON-block data. They cannot (and do not need to)
+            # be renamed, so treat this as a benign clash.
+            if this_sym.is_commonblock and other_sym.is_commonblock:
+                continue
+
             if other_sym.is_import and this_sym.is_import:
                 # Both symbols are imported. That's fine as long as they have
                 # the same import interface (are imported from the same
@@ -947,13 +953,42 @@ def _add_symbols_from_table(self, other_table, symbols_to_skip=()):
             already been updated to refer to a Container in this table.
 
         '''
+        # pylint: disable=import-outside-toplevel
+        from psyclone.psyir.symbols.datatypes import UnsupportedFortranType
+
+        # Names (normalised) of commonblock variables already in this table.
+        # Used below to decide whether a _PSYCLONE_INTERNAL_COMMONBLOCK marker
+        # from other_table is a duplicate that must be skipped.
+        self_cb_names = frozenset(
+            self._normalize(s.name)
+            for s in self.symbols if s.is_commonblock)
+
+        # Normalised names of commonblock variables in other_table.  Any
+        # overlap with self_cb_names means the COMMON block is already
+        # declared in this table and the incoming marker is a duplicate.
+        other_cb_names = frozenset(
+            self._normalize(s.name)
+            for s in other_table.symbols if s.is_commonblock)
+        cb_overlap = bool(self_cb_names & other_cb_names)
+
         for old_sym in other_table.symbols:
 
             if old_sym in symbols_to_skip or isinstance(old_sym,
                                                         ContainerSymbol):
                 # We've dealt with Container symbols in _add_container_symbols.
                 continue
 
+            # Skip _PSYCLONE_INTERNAL_COMMONBLOCK marker symbols when any of
+            # the COMMON-block variables they represent are already present in
+            # this table.  Adding such a marker would produce a duplicate
+            # COMMON declaration and a Fortran compile error like
+            # "Symbol 'x' is already in a COMMON block".
+            if (cb_overlap and
+                    self._normalize(old_sym.name).startswith(
+                        "_psyclone_internal_commonblock") and
+                    isinstance(old_sym.datatype, UnsupportedFortranType)):
+                continue
+
             try:
                 self.add(old_sym)
 
@@ -1007,6 +1042,33 @@ def _handle_symbol_clash(self, old_sym, other_table):
             # refer to the same thing and we don't have to do anything.
             return
 
+        if old_sym.is_commonblock and self_sym.is_commonblock:
+            return
+
+        from psyclone.psyir.symbols.datatypes import UnsupportedFortranType
+        if (isinstance(old_sym.datatype, UnsupportedFortranType) and
+                isinstance(self_sym.datatype, UnsupportedFortranType)):
+            if old_sym.datatype.declaration == self_sym.datatype.declaration:
+                # Identical COMMON-block markers – already present in self.
+                return
+            # Markers have different declarations.  Skip the incoming one only
+            # if its COMMON-block name(s) overlap with those already in self:
+            # that means the block is already declared and adding a second
+            # marker for it would produce a "Symbol X is already in a COMMON
+            # block" compile error.  If the block names are different this is
+            # a genuinely new COMMON block and we fall through to the
+            # rename-and-add path below.
+            if self._normalize(old_sym.name).startswith(
+                    "_psyclone_internal_commonblock"):
+                import re  # pylint: disable=import-outside-toplevel
+                _blk_re = re.compile(r"/\s*(\w*)\s*/", re.IGNORECASE)
+                old_blocks = set(_blk_re.findall(
+                    old_sym.datatype.declaration))
+                self_blocks = set(_blk_re.findall(
+                    self_sym.datatype.declaration))
+                if old_blocks & self_blocks:
+                    return
+
         # A Symbol with the same name already exists so we attempt to rename
         # first the one that we are adding and failing that, the existing
         # symbol in this table.

src/psyclone/tests/psyir/transformations/inline_trans_test.py

@@ -2844,3 +2844,49 @@ def test_apply_array_access_check_unresolved_override_option(
     inline_trans.apply(
         call, use_first_callee_and_no_arg_check=True)
     # TODO check results
+
+
+def test_apply_common_block_no_duplicate(fortran_reader, fortran_writer):
+    '''Test that inlining two routines that share a COMMON block does not
+    produce duplicate COMMON declarations (which would cause a Fortran compile
+    error "Symbol X is already in a COMMON block").'''
+
+    src_caller = """\
+subroutine caller()
+  implicit none
+  call sub1()
+  call sub2()
+end subroutine caller
+"""
+    src_sub1 = """\
+subroutine sub1()
+  implicit none
+  real :: volume, lmmpi
+  COMMON /blk/ volume, lmmpi
+  volume = 1.0
+end subroutine sub1
+"""
+    src_sub2 = """\
+subroutine sub2()
+  implicit none
+  real :: volume, lmmpi
+  COMMON /blk/ volume, lmmpi
+  lmmpi = 2.0
+end subroutine sub2
+"""
+    caller = fortran_reader.psyir_from_source(src_caller).walk(Routine)[0]
+    sub1 = fortran_reader.psyir_from_source(src_sub1).walk(Routine)[0]
+    sub2 = fortran_reader.psyir_from_source(src_sub2).walk(Routine)[0]
+
+    trans = InlineTrans()
+    calls = caller.walk(Call)
+    trans.apply(calls[0], routine=sub1)
+    calls = caller.walk(Call)
+    trans.apply(calls[0], routine=sub2)
+
+    result = fortran_writer(caller)
+    # Exactly one COMMON declaration must appear.
+    assert result.count("COMMON /blk/") == 1
+    # Both variables must still be present.
+    assert "volume" in result
+    assert "lmmpi" in result