Addressed review comments.

Author: vzakhari

flang/include/flang/Runtime/memory.h

@@ -23,14 +23,17 @@ class Terminator;
 
 [[nodiscard]] RT_API_ATTRS void *AllocateMemoryOrCrash(
     const Terminator &, std::size_t bytes);
-template <typename A> [[nodiscard]] A &AllocateOrCrash(const Terminator &t) {
+template <typename A>
+[[nodiscard]] RT_API_ATTRS A &AllocateOrCrash(const Terminator &t) {
   return *reinterpret_cast<A *>(AllocateMemoryOrCrash(t, sizeof(A)));
 }
+RT_API_ATTRS void *ReallocateMemoryOrCrash(
+    const Terminator &, void *ptr, std::size_t newByteSize);
 RT_API_ATTRS void FreeMemory(void *);
 template <typename A> RT_API_ATTRS void FreeMemory(A *p) {
   FreeMemory(reinterpret_cast<void *>(p));
 }
-template <typename A> void FreeMemoryAndNullify(A *&p) {
+template <typename A> RT_API_ATTRS void FreeMemoryAndNullify(A *&p) {
   FreeMemory(p);
   p = nullptr;
 }

flang/runtime/array-constructor.cpp

@@ -74,8 +74,8 @@ static RT_API_ATTRS void AllocateOrReallocateVectorIfNeeded(
       // realloc is undefined with zero new size and ElementBytes() may be null
       // if the character length is null, or if "from" is a zero sized array.
       if (newByteSize > 0) {
-        void *p{Fortran::runtime::realloc(to.raw().base_addr, newByteSize)};
-        RUNTIME_CHECK(terminator, p);
+        void *p{ReallocateMemoryOrCrash(
+            terminator, to.raw().base_addr, newByteSize)};
         to.set_base_addr(p);
       }
       vector.actualAllocationSize = requestedAllocationSize;

flang/runtime/dot-product.cpp

@@ -91,6 +91,9 @@ static inline RT_API_ATTRS CppTypeFor<RCAT, RKIND> DoDotProduct(
         for (SubscriptValue j{0}; j < n; ++j) {
           // std::conj() may instantiate its argument twice,
           // so xp has to be incremented separately.
+          // This is a workaround for an alleged bug in clang,
+          // that shows up as:
+          //   warning: multiple unsequenced modifications to 'xp'
           accum += std::conj(static_cast<AccumType>(*xp)) *
               static_cast<AccumType>(*yp++);
           xp++;

flang/runtime/freestanding-tools.h

@@ -42,11 +42,6 @@
 #define STD_REALLOC_UNSUPPORTED 1
 #endif
 
-#if !defined(STD_CALLOC_UNSUPPORTED) && \
-    (defined(__CUDACC__) || defined(__CUDA__)) && defined(__CUDA_ARCH__)
-#define STD_CALLOC_UNSUPPORTED 1
-#endif
-
 namespace Fortran::runtime {
 
 #if STD_FILL_N_UNSUPPORTED
@@ -129,7 +124,7 @@ using std::memcmp;
 #endif // !STD_MEMCMP_UNSUPPORTED
 
 #if STD_REALLOC_UNSUPPORTED
-static inline RT_API_ATTRS void *realloc(void *ptr, std::size_t new_size) {
+static inline RT_API_ATTRS void *realloc(void *ptr, std::size_t newByteSize) {
   // Return nullptr and let the callers assert that.
   // TODO: we can provide a straightforward implementation
   // via malloc/memcpy/free.
@@ -139,19 +134,5 @@ static inline RT_API_ATTRS void *realloc(void *ptr, std::size_t new_size) {
 using std::realloc;
 #endif // !STD_REALLOC_UNSUPPORTED
 
-#if STD_CALLOC_UNSUPPORTED
-static inline RT_API_ATTRS void *calloc(std::size_t num, std::size_t size) {
-  std::size_t bytes{num * size};
-  void *ptr{nullptr};
-  if (bytes != 0) {
-    ptr = std::malloc(bytes);
-    ptr = std::memset(ptr, 0, bytes);
-  }
-  return ptr;
-}
-#else // !STD_CALLOC_UNSUPPORTED
-using std::calloc;
-#endif // !STD_CALLOC_UNSUPPORTED
-
 } // namespace Fortran::runtime
 #endif // FORTRAN_RUNTIME_FREESTANDING_TOOLS_H_

flang/runtime/memory.cpp

@@ -8,6 +8,7 @@
 
 #include "flang/Runtime/memory.h"
 #include "terminator.h"
+#include "tools.h"
 #include <cstdlib>
 
 namespace Fortran::runtime {
@@ -26,6 +27,19 @@ RT_API_ATTRS void *AllocateMemoryOrCrash(
   return nullptr;
 }
 
+RT_API_ATTRS void *ReallocateMemoryOrCrash(
+    const Terminator &terminator, void *ptr, std::size_t newByteSize) {
+  if (void *p{Fortran::runtime::realloc(ptr, newByteSize)}) {
+    return p;
+  }
+  if (newByteSize > 0) {
+    terminator.Crash("Fortran runtime internal error: memory realloc returned "
+                     "null, needed %zd bytes",
+        newByteSize);
+  }
+  return nullptr;
+}
+
 RT_API_ATTRS void FreeMemory(void *p) { std::free(p); }
 
 RT_OFFLOAD_VAR_GROUP_END

flang/runtime/ragged.cpp

@@ -34,11 +34,13 @@ RT_API_ATTRS RaggedArrayHeader *RaggedArrayAllocate(RaggedArrayHeader *header,
     header->flags = (rank << 1) | isHeader;
     header->extentPointer = extentVector;
     if (isHeader) {
-      header->bufferPointer =
-          Fortran::runtime::calloc(sizeof(RaggedArrayHeader), size);
-    } else {
-      header->bufferPointer =
-          static_cast<void *>(Fortran::runtime::calloc(elementSize, size));
+      elementSize = sizeof(RaggedArrayHeader);
+    }
+    Terminator terminator{__FILE__, __LINE__};
+    std::size_t bytes{static_cast<std::size_t>(elementSize * size)};
+    header->bufferPointer = AllocateMemoryOrCrash(terminator, bytes);
+    if (header->bufferPointer) {
+      std::memset(header->bufferPointer, 0, bytes);
     }
     return header;
   } else {