[flang] Fix element indexing in Destroy component deallocation

[clementval]

Summary

Derived type Destroy function does not take step into consideration
when indexing the component element for deallocation. This leads to
incorrect deallocation in case like:

module mod1
  type :: t
    real, allocatable :: r(:)
  end type
contains
  subroutine do_smth(c)
    class(t), intent(out) :: c(:)
    do i = 1, size(c)
      if (allocated(c(i)%r)) then
        print*, i, 'not deallocated'
      end if
    end do
  end subroutine
end module

program test
  use mod1
  type(t) :: z(6)
  integer :: i
  do i = 1, 6
    Allocate(z(i)%r(i))
  end do
  call do_smth(z(::2))
end

Similar change was done in D142527

[klausler]

The bug here is that the original code assumes that descriptor's array is contiguous. ZeroBasedIndexedElement is slow and we don't want to have to call it on every iteration. When the original descriptor is not contiguous, it would be better to use a vector of subscripts and adjust them with IncrementSubscripts on each iteration.

[clementval]

Use subscripts and increment them.

[klausler]

flang/runtime/derived.cpp

229

descriptor.GetLowerBounds(at); is the usage that's most common in the runtime, and might be faster.

[clementval]

flang/runtime/derived.cpp

229

Ok thanks. I'll update that.

[clementval]

Use GetLowerBounds

flang/runtime/derived.cpp

void Destroy(const Descriptor &descriptor, bool finalize,
   }
   if (finalize && !derived.noFinalizationNeeded()) {
     Finalize(descriptor, derived);
   }
   const Descriptor &componentDesc{derived.component()};
   std::size_t myComponents{componentDesc.Elements()};
   std::size_t elements{descriptor.Elements()};
   std::size_t byteStride{descriptor.ElementBytes()};
+  SubscriptValue at[maxRank];
+  descriptor.GetLowerBounds(at);
   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) {
       for (std::size_t j{0}; j < elements; ++j) {
-        descriptor.OffsetElement<Descriptor>(j * byteStride + comp.offset())
-            ->Deallocate();
+        Descriptor *d{reinterpret_cast<Descriptor *>(
+            descriptor.Element<char>(at) + comp.offset())};
+        d->Deallocate();
+        descriptor.IncrementSubscripts(at);
       }
     }
   }
 }
 
 } // namespace Fortran::runtime