[flang][runtime] Handle conflicts for derived types with dynamic components.

[vzakhari]

Summary

When creating a temporary for conflicting LHS and RHS we have to deep copy
the dynamic (allocatable, automatic) components from RHS to the temp.
Otherwise, the conflict may still be present between LHS and temp.

gfortran/regression/alloc_comp_assign_1.f90 is an example where the current
runtime code produces wrong result:
https://github.com/llvm/llvm-test-suite/blob/7b5b5dcbf9bdde729a14722eb67f9c3ab01647c7/Fortran/gfortran/regression/alloc_comp_assign_1.f90#L50

[klausler]

flang/runtime/derived.cpp

262

I think that this would be more consistent with other runtime code (and perhaps more clear) as:

if (const DescriptorAddendum *addendum{descriptor.Addendum()}) {
  if (const auto *derived{addendum->derivedType()}) {
   const Descriptor &componentDesc{...};
   ...
  }
}
return false;

[vzakhari]

Thanks for the review! I reordered the code.

[vzakhari]

Fixed a mistype.

[vzakhari]

clang-format

[tblah]

Looks good to me, thanks!

flang/runtime/assign.cpp

if (mustDeallocateLHS) {
       Descriptor &newFrom{staticDesc.descriptor()};
       std::memcpy(&newFrom, &from, descBytes);
       // Pretend the temporary descriptor is for an ALLOCATABLE
       // entity, otherwise, the Deallocate() below will not
       // free the descriptor memory.
       newFrom.raw().attribute = CFI_attribute_allocatable;
       auto stat{ReturnError(terminator, newFrom.Allocate())};
       if (stat == StatOk) {
+        if (HasDynamicComponent(from)) {
+          // If 'from' has allocatable/automatic component, we cannot
+          // just make a shallow copy of the descriptor member.
+          // This will still leave data overlap in 'to' and 'newFrom'.
+          // For example:
+          //   type t
+          //     character, allocatable :: c(:)
+          //   end type t
+          //   type(t) :: x(3)
+          //   x(2:3) = x(1:2)
+          // We have to make a deep copy into 'newFrom' in this case.
+          RTNAME(AssignTemporary)
+          (newFrom, from, terminator.sourceFileName(), terminator.sourceLine());
+        } else {
           char *toAt{newFrom.OffsetElement()};
           std::size_t fromElements{from.Elements()};
           if (from.IsContiguous()) {
             std::memcpy(
                 toAt, from.OffsetElement(), fromElements * fromElementBytes);
           } else {
             SubscriptValue fromAt[maxRank];
             for (from.GetLowerBounds(fromAt); fromElements-- > 0;
                  toAt += fromElementBytes, from.IncrementSubscripts(fromAt)) {
               std::memcpy(toAt, from.Element<char>(fromAt), fromElementBytes);
             }
           }
+        }
         Assign(to, newFrom, terminator,
             flags &
                 (NeedFinalization | ComponentCanBeDefinedAssignment |
                     ExplicitLengthCharacterLHS | CanBeDefinedAssignment));
         newFrom.Deallocate();
       }
       return;
     }

flang/runtime/derived.h

 
 // Call FINAL subroutines, if any
 void Finalize(const Descriptor &, const typeInfo::DerivedType &derived);
 
 // Call FINAL subroutines, deallocate allocatable & automatic components.
 // Does not deallocate the original descriptor.
 void Destroy(const Descriptor &, bool finalize, const typeInfo::DerivedType &);
 
+// Return true if the passed descriptor is for a derived type
+// entity that has a dynamic (allocatable, automatic) component.
+bool HasDynamicComponent(const Descriptor &);
+
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_DERIVED_H_

flang/runtime/derived.cpp

if (comp.genre() == typeInfo::Component::Genre::Allocatable ||
             descriptor.Element<char>(at) + comp.offset())};
         d->Deallocate();
         descriptor.IncrementSubscripts(at);
       }
     }
   }
 }
 
+bool HasDynamicComponent(const Descriptor &descriptor) {
+  if (const DescriptorAddendum * addendum{descriptor.Addendum()}) {
+    if (const auto *derived = addendum->derivedType()) {
+      const Descriptor &componentDesc{derived->component()};
+      std::size_t myComponents{componentDesc.Elements()};
+      for (std::size_t k{0}; k < myComponents; ++k) {
+        const auto &comp{
+            *componentDesc.ZeroBasedIndexedElement<typeInfo::Component>(k)};
+        if (comp.genre() == typeInfo::Component::Genre::Allocatable ||
+            comp.genre() == typeInfo::Component::Genre::Automatic) {
+          return true;
+        }
+      }
+    }
+  }
+  return false;
+}
+
 } // namespace Fortran::runtime