[flang] Don't crash attempting to fold absurdly large TRANSFER()

[klausler]

Summary

Apply some sanity checking to the type size and SIZE= values and
avoid crashing on stress tests that attempt to create excessively
large results.

flang/lib/Evaluate/fold.cpp

std::optional<Expr<SomeType>> FoldTransfer(
   } else if (arguments[2]) { // SIZE= is present
     if (const auto *sizeExpr{arguments[2]->UnwrapExpr()}) {
       if (auto sizeValue{ToInt64(*sizeExpr)}) {
         extents = ConstantSubscripts{*sizeValue};
       }
     }
   }
   if (sourceBytes && IsActuallyConstant(*source) && moldType && extents) {
+    std::size_t elements{
+        extents->empty() ? 1 : static_cast<std::size_t>((*extents)[0])};
+    std::size_t totalBytes{*sourceBytes * elements};
+    // Don't fold intentional overflow cases from sneaky tests
+    if (totalBytes < std::size_t{1000000} &&
+        (elements == 0 || totalBytes / elements == *sourceBytes)) {
       InitialImage image{*sourceBytes};
       InitialImage::Result imageResult{
           image.Add(0, *sourceBytes, *source, context)};
       CHECK(imageResult == InitialImage::Ok);
-    return image.AsConstant(context, *moldType, *extents, true /*pad with 0*/);
-  } else {
-    return std::nullopt;
+      return image.AsConstant(
+          context, *moldType, *extents, true /*pad with 0*/);
     }
   }
+  return std::nullopt;
+}
 
 template class ExpressionBase<SomeDerived>;
 template class ExpressionBase<SomeType>;
 
 } // namespace Fortran::evaluate