check.c (gfc_check_move_alloc): Prevent error that avoids aliasing between to…

check.c (gfc_check_move_alloc): Prevent error that avoids aliasing between to and from arguments from rejecting...

2016-11-09  Paul Thomas  <pault@gcc.gnu.org>

	* check.c (gfc_check_move_alloc): Prevent error that avoids
	aliasing between to and from arguments from rejecting valid
	code.

2016-11-09  Paul Thomas  <pault@gcc.gnu.org>

	* gfortran.dg/move_alloc_18.f90: New test.

From-SVN: r241995

gcc/fortran/ChangeLog

+2016-11-09  Paul Thomas  <pault@gcc.gnu.org>
+
+	* check.c (gfc_check_move_alloc): Prevent error that avoids
+	aliasing between to and from arguments from rejecting valid
+	code.
+
 2016-11-09  Janus Weil  <janus@gcc.gnu.org>
 
 	PR fortran/71894

gcc/fortran/check.c

@@ -3342,15 +3342,45 @@ gfc_check_move_alloc (gfc_expr *from, gfc_expr *to)
       return false;
     }
 
-  /*  F2003 12.4.1.7  */
-  if (to->expr_type == EXPR_VARIABLE && from->expr_type ==EXPR_VARIABLE
+  /*  This is based losely on F2003 12.4.1.7. It is intended to prevent
+      the likes of to = sym->cmp1->cmp2 and from = sym->cmp1, where cmp1
+      and cmp2 are allocatable.  After the allocation is transferred,
+      the 'to' chain is broken by the nullification of the 'from'. A bit
+      of reflection reveals that this can only occur for derived types
+      with recursive allocatable components.  */
+  if (to->expr_type == EXPR_VARIABLE && from->expr_type == EXPR_VARIABLE
       && !strcmp (to->symtree->n.sym->name, from->symtree->n.sym->name))
     {
-      gfc_error ("The FROM and TO arguments at %L are either the same object "
-		 "or subobjects thereof and so violate aliasing restrictions "
-		 "(F2003 12.4.1.7)", &to->where);
+      gfc_ref *to_ref, *from_ref;
+      to_ref = to->ref;
+      from_ref = from->ref;
+      bool aliasing = true;
+
+      for (; from_ref && to_ref;
+	   from_ref = from_ref->next, to_ref = to_ref->next)
+	{
+	  if (to_ref->type != from->ref->type)
+	    aliasing = false;
+	  else if (to_ref->type == REF_ARRAY
+		   && to_ref->u.ar.type != AR_FULL
+		   && from_ref->u.ar.type != AR_FULL)
+	    /* Play safe; assume sections and elements are different.  */
+	    aliasing = false;
+	  else if (to_ref->type == REF_COMPONENT
+		   && to_ref->u.c.component != from_ref->u.c.component)
+	    aliasing = false;
+
+	  if (!aliasing)
+	    break;
+	}
+
+      if (aliasing)
+	{
+	  gfc_error ("The FROM and TO arguments at %L violate aliasing "
+		     "restrictions (F2003 12.4.1.7)", &to->where);
 	  return false;
 	}
+    }
 
   /* CLASS arguments: Make sure the vtab of from is present.  */
   if (to->ts.type == BT_CLASS && !UNLIMITED_POLY (from))

gcc/testsuite/ChangeLog

+2016-11-09  Paul Thomas  <pault@gcc.gnu.org>
+
+	* gfortran.dg/move_alloc_18.f90: New test.
+
 2016-11-09  Prathamesh Kulkarni  <prathamesh.kulkarni@linaro.org>
 
 	PR middle-end/78256

gcc/testsuite/gfortran.dg/move_alloc_18.f90

+! { dg-do compile }
+!
+! Test that the anti-aliasing restriction does not knock out valid code.
+!
+! Contributed by  Andrew Balwin on
+! https://groups.google.com/forum/#!topic/comp.lang.fortran/oiXdl1LPb_s
+!
+      PROGRAM TEST
+        IMPLICIT NONE
+
+        TYPE FOOBAR
+          INTEGER, ALLOCATABLE :: COMP(:)
+        END TYPE
+
+        TYPE (FOOBAR) :: MY_ARRAY(6)
+
+        ALLOCATE (MY_ARRAY(1)%COMP(10))
+
+        CALL MOVE_ALLOC (MY_ARRAY(1)%COMP, MY_ARRAY(2)%COMP)
+
+      END PROGRAM TEST