[flang] Don't crash on initialization with a zero-sized derived type

[klausler]

Summary

Avoid calls to memcpy with zero byte counts if their address argument
calculations may not be valid expressions.

flang/include/flang/Evaluate/initial-image.h

Result Add(ConstantSubscript offset, std::size_t bytes, const Constant<T> &x,
     if (offset < 0 || offset + bytes > data_.size()) {
       return OutOfRange;
     } else {
       auto elementBytes{ToInt64(x.GetType().MeasureSizeInBytes(context, true))};
       if (!elementBytes ||
           bytes !=
               x.values().size() * static_cast<std::size_t>(*elementBytes)) {
         return SizeMismatch;
+      } else if (bytes == 0) {
+        return Ok;
       } else {
         std::memcpy(&data_.at(offset), &x.values().at(0), bytes);
         return Ok;
       }
     }
   }
   template <int KIND>
   Result Add(ConstantSubscript offset, std::size_t bytes,
       const Constant<Type<TypeCategory::Character, KIND>> &x,
       FoldingContext &) {
     if (offset < 0 || offset + bytes > data_.size()) {
       return OutOfRange;
     } else {
       auto elements{TotalElementCount(x.shape())};
       auto elementBytes{bytes > 0 ? bytes / elements : 0};
       if (elements * elementBytes != bytes) {
         return SizeMismatch;
+      } else if (bytes == 0) {
+        return Ok;
       } else {
         for (auto at{x.lbounds()}; elements-- > 0; x.IncrementSubscripts(at)) {
           auto scalar{x.At(at)}; // this is a std string; size() in chars
           // Subtle: an initializer for a substring may have been
           // expanded to the length of the entire string.
           auto scalarBytes{scalar.size() * KIND};
           if (scalarBytes < elementBytes ||
               (scalarBytes > elementBytes && elements != 0)) {
             return SizeMismatch;
           }
-          std::memcpy(&data_[offset], scalar.data(), elementBytes);
+          std::memcpy(&data_.at(offset), scalar.data(), elementBytes);
           offset += elementBytes;
         }
         return Ok;
       }
     }
   }
   Result Add(ConstantSubscript, std::size_t, const Constant<SomeDerived> &,
       FoldingContext &);

flang/lib/Evaluate/initial-image.cpp

if (offset < 0 || offset + bytes > data_.size()) {
     return OutOfRange;
   } else {
     auto elements{TotalElementCount(x.shape())};
     auto elementBytes{bytes > 0 ? bytes / elements : 0};
     if (elements * elementBytes != bytes) {
       return SizeMismatch;
     } else {
       auto at{x.lbounds()};
-      for (auto elements{TotalElementCount(x.shape())}; elements-- > 0;
-           x.IncrementSubscripts(at)) {
+      for (; elements-- > 0; x.IncrementSubscripts(at)) {
         auto scalar{x.At(at)};
         // TODO: length type parameter values?
         for (const auto &[symbolRef, indExpr] : scalar) {
           const Symbol &component{*symbolRef};
           if (component.offset() + component.size() > elementBytes) {
             return SizeMismatch;
           } else if (IsPointer(component)) {
             AddPointer(offset + component.offset(), indExpr.value());
           } else {
             Result added{Add(offset + component.offset(), component.size(),
                 indExpr.value(), context)};
             if (added != Ok) {
-              return Ok;
+              return added;
             }
           }
         }
         offset += elementBytes;
       }
     }
     return Ok;
   }