[flang] Descriptor-based I/O using wrong size for contiguous unformatted I/O

[klausler]

Summary

The descriptor-based I/O routine was using the size of the descriptor
rather than the size of the described data for the transfer. Fix,
and add a comment to the relevant API.

[PeteSteinfeld]

All builds, tests, and looks good.

flang/runtime/descriptor-io.h

static bool DescriptorIO(IoStatementState &io, const Descriptor &descriptor) {
   }
   if constexpr (DIR == Direction::Input) {
     io.BeginReadingRecord();
   }
   if (auto *unf{io.get_if<UnformattedIoStatementState<DIR>>()}) {
     std::size_t elementBytes{descriptor.ElementBytes()};
     SubscriptValue subscripts[maxRank];
     descriptor.GetLowerBounds(subscripts);
+    std::size_t numElements{descriptor.Elements()};
     if (descriptor.IsContiguous()) { // contiguous unformatted I/O
       char &x{ExtractElement<char>(io, descriptor, subscripts)};
-      auto totalBytes{descriptor.SizeInBytes()};
+      auto totalBytes{numElements * elementBytes};
       if constexpr (DIR == Direction::Output) {
         return unf->Emit(&x, totalBytes, elementBytes);
       } else {
         return unf->Receive(&x, totalBytes, elementBytes);
       }
     } else { // non-contiguous unformatted I/O
-      std::size_t numElements{descriptor.Elements()};
       for (std::size_t j{0}; j < numElements; ++j) {
         char &x{ExtractElement<char>(io, descriptor, subscripts)};
         if constexpr (DIR == Direction::Output) {
           if (!unf->Emit(&x, elementBytes, elementBytes)) {
             return false;
           }
         } else {
           if (!unf->Receive(&x, elementBytes, elementBytes)) {

flang/runtime/descriptor.h

const DescriptorAddendum *Addendum() const {
     if (raw_.f18Addendum != 0) {
       return reinterpret_cast<const DescriptorAddendum *>(
           &GetDimension(rank()));
     } else {
       return nullptr;
     }
   }
 
+  // Returns size in bytes of the descriptor (not the data)
   static constexpr std::size_t SizeInBytes(
       int rank, bool addendum = false, int lengthTypeParameters = 0) {
     std::size_t bytes{sizeof(Descriptor) - sizeof(Dimension)};
     bytes += rank * sizeof(Dimension);
     if (addendum || lengthTypeParameters > 0) {
       bytes += DescriptorAddendum::SizeInBytes(lengthTypeParameters);
     }
     return bytes;