2012-04-22 Tobias Burnus <burnus@net-b.de>

        * Merged Revs. 185177 through 186673 from the trunk.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/fortran-dev@186674 138bc75d-0d04-0410-961f-82ee72b054a4

310 files changed, 797 insertions, 745 deletions

diff --git a/libgfortran/generated/all_l1.c b/libgfortran/generated/all_l1.c
index 5baee3b444a..a9d0611f13d 100644
--- a/libgfortran/generated/all_l1.c
+++ b/libgfortran/generated/all_l1.c
@@ -110,7 +110,7 @@ all_l1 (gfc_array_l1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/all_l16.c b/libgfortran/generated/all_l16.c
index f98f3519243..dcf3fc87545 100644
--- a/libgfortran/generated/all_l16.c
+++ b/libgfortran/generated/all_l16.c
@@ -110,7 +110,7 @@ all_l16 (gfc_array_l16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/all_l2.c b/libgfortran/generated/all_l2.c
index e39ec25d379..e4d26729e22 100644
--- a/libgfortran/generated/all_l2.c
+++ b/libgfortran/generated/all_l2.c
@@ -110,7 +110,7 @@ all_l2 (gfc_array_l2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/all_l4.c b/libgfortran/generated/all_l4.c
index 120d7884b4e..37f1468d660 100644
--- a/libgfortran/generated/all_l4.c
+++ b/libgfortran/generated/all_l4.c
@@ -110,7 +110,7 @@ all_l4 (gfc_array_l4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/all_l8.c b/libgfortran/generated/all_l8.c
index cb194e2af39..5c31c0d7c90 100644
--- a/libgfortran/generated/all_l8.c
+++ b/libgfortran/generated/all_l8.c
@@ -110,7 +110,7 @@ all_l8 (gfc_array_l8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/any_l1.c b/libgfortran/generated/any_l1.c
index ab2bdc50acf..17c7af26019 100644
--- a/libgfortran/generated/any_l1.c
+++ b/libgfortran/generated/any_l1.c
@@ -110,7 +110,7 @@ any_l1 (gfc_array_l1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/any_l16.c b/libgfortran/generated/any_l16.c
index 06266761a35..9a70867cba5 100644
--- a/libgfortran/generated/any_l16.c
+++ b/libgfortran/generated/any_l16.c
@@ -110,7 +110,7 @@ any_l16 (gfc_array_l16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/any_l2.c b/libgfortran/generated/any_l2.c
index 716def6345f..9f8396e1d86 100644
--- a/libgfortran/generated/any_l2.c
+++ b/libgfortran/generated/any_l2.c
@@ -110,7 +110,7 @@ any_l2 (gfc_array_l2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/any_l4.c b/libgfortran/generated/any_l4.c
index 3a79dc409de..cf76de26da4 100644
--- a/libgfortran/generated/any_l4.c
+++ b/libgfortran/generated/any_l4.c
@@ -110,7 +110,7 @@ any_l4 (gfc_array_l4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/any_l8.c b/libgfortran/generated/any_l8.c
index 505281a5501..a3d8f77704f 100644
--- a/libgfortran/generated/any_l8.c
+++ b/libgfortran/generated/any_l8.c
@@ -110,7 +110,7 @@ any_l8 (gfc_array_l8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/bessel_r10.c b/libgfortran/generated/bessel_r10.c
index a5185267001..1062ae4d0e1 100644
--- a/libgfortran/generated/bessel_r10.c
+++ b/libgfortran/generated/bessel_r10.c
@@ -55,7 +55,7 @@ bessel_jn_r10 (gfc_array_r10 * const restrict ret, int n1, int n2, GFC_REAL_10 x
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size, sizeof (GFC_REAL_10));
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * size);
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_10) * size);
       ret->offset = 0;
     }
 
@@ -122,7 +122,7 @@ bessel_yn_r10 (gfc_array_r10 * const restrict ret, int n1, int n2,
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size, sizeof (GFC_REAL_10));
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * size);
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_10) * size);
       ret->offset = 0;
     }
 
diff --git a/libgfortran/generated/bessel_r16.c b/libgfortran/generated/bessel_r16.c
index 9aa8f183aea..20c992ff975 100644
--- a/libgfortran/generated/bessel_r16.c
+++ b/libgfortran/generated/bessel_r16.c
@@ -59,7 +59,7 @@ bessel_jn_r16 (gfc_array_r16 * const restrict ret, int n1, int n2, GFC_REAL_16 x
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size, sizeof (GFC_REAL_16));
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * size);
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_16) * size);
       ret->offset = 0;
     }
 
@@ -126,7 +126,7 @@ bessel_yn_r16 (gfc_array_r16 * const restrict ret, int n1, int n2,
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size, sizeof (GFC_REAL_16));
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * size);
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_16) * size);
       ret->offset = 0;
     }
 
diff --git a/libgfortran/generated/bessel_r4.c b/libgfortran/generated/bessel_r4.c
index 63b6486a29d..4c67854ce90 100644
--- a/libgfortran/generated/bessel_r4.c
+++ b/libgfortran/generated/bessel_r4.c
@@ -55,7 +55,7 @@ bessel_jn_r4 (gfc_array_r4 * const restrict ret, int n1, int n2, GFC_REAL_4 x)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size, sizeof (GFC_REAL_4));
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * size);
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_4) * size);
       ret->offset = 0;
     }
 
@@ -122,7 +122,7 @@ bessel_yn_r4 (gfc_array_r4 * const restrict ret, int n1, int n2,
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size, sizeof (GFC_REAL_4));
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * size);
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_4) * size);
       ret->offset = 0;
     }
 
diff --git a/libgfortran/generated/bessel_r8.c b/libgfortran/generated/bessel_r8.c
index f3835608989..461a4084156 100644
--- a/libgfortran/generated/bessel_r8.c
+++ b/libgfortran/generated/bessel_r8.c
@@ -55,7 +55,7 @@ bessel_jn_r8 (gfc_array_r8 * const restrict ret, int n1, int n2, GFC_REAL_8 x)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size, sizeof (GFC_REAL_8));
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * size);
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_8) * size);
       ret->offset = 0;
     }
 
@@ -122,7 +122,7 @@ bessel_yn_r8 (gfc_array_r8 * const restrict ret, int n1, int n2,
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size, sizeof (GFC_REAL_8));
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * size);
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_8) * size);
       ret->offset = 0;
     }
 
diff --git a/libgfortran/generated/count_16_l.c b/libgfortran/generated/count_16_l.c
index b6c96ade997..828ebc0543e 100644
--- a/libgfortran/generated/count_16_l.c
+++ b/libgfortran/generated/count_16_l.c
@@ -110,7 +110,7 @@ count_16_l (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/count_1_l.c b/libgfortran/generated/count_1_l.c
index 0418bc05803..fba470c3148 100644
--- a/libgfortran/generated/count_1_l.c
+++ b/libgfortran/generated/count_1_l.c
@@ -110,7 +110,7 @@ count_1_l (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/count_2_l.c b/libgfortran/generated/count_2_l.c
index 43264416a75..0c694cd8b80 100644
--- a/libgfortran/generated/count_2_l.c
+++ b/libgfortran/generated/count_2_l.c
@@ -110,7 +110,7 @@ count_2_l (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/count_4_l.c b/libgfortran/generated/count_4_l.c
index 637a1832bf8..1e4d6f0598f 100644
--- a/libgfortran/generated/count_4_l.c
+++ b/libgfortran/generated/count_4_l.c
@@ -110,7 +110,7 @@ count_4_l (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/count_8_l.c b/libgfortran/generated/count_8_l.c
index 8b9fe87a1e4..e0ef0d29af3 100644
--- a/libgfortran/generated/count_8_l.c
+++ b/libgfortran/generated/count_8_l.c
@@ -110,7 +110,7 @@ count_8_l (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/cshift0_c10.c b/libgfortran/generated/cshift0_c10.c
index f1d246cc944..20f590e33bf 100644
--- a/libgfortran/generated/cshift0_c10.c
+++ b/libgfortran/generated/cshift0_c10.c
@@ -97,9 +97,13 @@ cshift0_c10 (gfc_array_c10 *ret, const gfc_array_c10 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_c16.c b/libgfortran/generated/cshift0_c16.c
index 9387ca92308..cd5be46ee2b 100644
--- a/libgfortran/generated/cshift0_c16.c
+++ b/libgfortran/generated/cshift0_c16.c
@@ -97,9 +97,13 @@ cshift0_c16 (gfc_array_c16 *ret, const gfc_array_c16 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_c4.c b/libgfortran/generated/cshift0_c4.c
index 3b6ea5ba6e9..3bc6f04a282 100644
--- a/libgfortran/generated/cshift0_c4.c
+++ b/libgfortran/generated/cshift0_c4.c
@@ -97,9 +97,13 @@ cshift0_c4 (gfc_array_c4 *ret, const gfc_array_c4 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_c8.c b/libgfortran/generated/cshift0_c8.c
index 356ece80733..20614c3089f 100644
--- a/libgfortran/generated/cshift0_c8.c
+++ b/libgfortran/generated/cshift0_c8.c
@@ -97,9 +97,13 @@ cshift0_c8 (gfc_array_c8 *ret, const gfc_array_c8 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_i1.c b/libgfortran/generated/cshift0_i1.c
index 60acf217d60..787cae82b3f 100644
--- a/libgfortran/generated/cshift0_i1.c
+++ b/libgfortran/generated/cshift0_i1.c
@@ -97,9 +97,13 @@ cshift0_i1 (gfc_array_i1 *ret, const gfc_array_i1 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_i16.c b/libgfortran/generated/cshift0_i16.c
index dd5424f3e60..b818caf394e 100644
--- a/libgfortran/generated/cshift0_i16.c
+++ b/libgfortran/generated/cshift0_i16.c
@@ -97,9 +97,13 @@ cshift0_i16 (gfc_array_i16 *ret, const gfc_array_i16 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_i2.c b/libgfortran/generated/cshift0_i2.c
index 3f7de844959..d3727a15872 100644
--- a/libgfortran/generated/cshift0_i2.c
+++ b/libgfortran/generated/cshift0_i2.c
@@ -97,9 +97,13 @@ cshift0_i2 (gfc_array_i2 *ret, const gfc_array_i2 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_i4.c b/libgfortran/generated/cshift0_i4.c
index 6c141ae3fb7..876c231cfc3 100644
--- a/libgfortran/generated/cshift0_i4.c
+++ b/libgfortran/generated/cshift0_i4.c
@@ -97,9 +97,13 @@ cshift0_i4 (gfc_array_i4 *ret, const gfc_array_i4 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_i8.c b/libgfortran/generated/cshift0_i8.c
index 397289e3b4f..e443deece2a 100644
--- a/libgfortran/generated/cshift0_i8.c
+++ b/libgfortran/generated/cshift0_i8.c
@@ -97,9 +97,13 @@ cshift0_i8 (gfc_array_i8 *ret, const gfc_array_i8 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_r10.c b/libgfortran/generated/cshift0_r10.c
index cb2517d0a21..c94fcba1517 100644
--- a/libgfortran/generated/cshift0_r10.c
+++ b/libgfortran/generated/cshift0_r10.c
@@ -97,9 +97,13 @@ cshift0_r10 (gfc_array_r10 *ret, const gfc_array_r10 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_r16.c b/libgfortran/generated/cshift0_r16.c
index 03c668b8dbb..c19e60cefba 100644
--- a/libgfortran/generated/cshift0_r16.c
+++ b/libgfortran/generated/cshift0_r16.c
@@ -97,9 +97,13 @@ cshift0_r16 (gfc_array_r16 *ret, const gfc_array_r16 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_r4.c b/libgfortran/generated/cshift0_r4.c
index e6d62be3937..44f16ce6d38 100644
--- a/libgfortran/generated/cshift0_r4.c
+++ b/libgfortran/generated/cshift0_r4.c
@@ -97,9 +97,13 @@ cshift0_r4 (gfc_array_r4 *ret, const gfc_array_r4 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift0_r8.c b/libgfortran/generated/cshift0_r8.c
index 820a57cc05d..8d0b7a5651c 100644
--- a/libgfortran/generated/cshift0_r8.c
+++ b/libgfortran/generated/cshift0_r8.c
@@ -97,9 +97,13 @@ cshift0_r8 (gfc_array_r8 *ret, const gfc_array_r8 *array, ptrdiff_t shift,
   rptr = ret->base_addr;
   sptr = array->base_addr;
 
-  shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
-  if (shift < 0)
-    shift += len;
+  /* Avoid the costly modulo for trivially in-bound shifts.  */
+  if (shift < 0 || shift >= len)
+    {
+      shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
+      if (shift < 0)
+	shift += len;
+    }
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift1_16.c b/libgfortran/generated/cshift1_16.c
index 08833bfc666..99540e6c000 100644
--- a/libgfortran/generated/cshift1_16.c
+++ b/libgfortran/generated/cshift1_16.c
@@ -80,7 +80,7 @@ cshift1 (gfc_array_char * const restrict ret,
     {
       int i;
 
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      ret->base_addr = xmalloc (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
diff --git a/libgfortran/generated/cshift1_4.c b/libgfortran/generated/cshift1_4.c
index dba8eaa40cf..cabb0987479 100644
--- a/libgfortran/generated/cshift1_4.c
+++ b/libgfortran/generated/cshift1_4.c
@@ -80,7 +80,7 @@ cshift1 (gfc_array_char * const restrict ret,
     {
       int i;
 
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      ret->base_addr = xmalloc (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
diff --git a/libgfortran/generated/cshift1_8.c b/libgfortran/generated/cshift1_8.c
index 7a2369e000a..15063c57222 100644
--- a/libgfortran/generated/cshift1_8.c
+++ b/libgfortran/generated/cshift1_8.c
@@ -80,7 +80,7 @@ cshift1 (gfc_array_char * const restrict ret,
     {
       int i;
 
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      ret->base_addr = xmalloc (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
diff --git a/libgfortran/generated/eoshift1_16.c b/libgfortran/generated/eoshift1_16.c
index f8092fdda11..200ebc6640d 100644
--- a/libgfortran/generated/eoshift1_16.c
+++ b/libgfortran/generated/eoshift1_16.c
@@ -105,8 +105,8 @@ eoshift1 (gfc_array_char * const restrict ret,
 	  GFC_DIMENSION_SET (ret->dim[i], 0, ext, sm);
 
         }
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/eoshift1_4.c b/libgfortran/generated/eoshift1_4.c
index e62e787c52c..13dbdacf14a 100644
--- a/libgfortran/generated/eoshift1_4.c
+++ b/libgfortran/generated/eoshift1_4.c
@@ -105,8 +105,8 @@ eoshift1 (gfc_array_char * const restrict ret,
 	  GFC_DIMENSION_SET (ret->dim[i], 0, ext, sm);
 
         }
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/eoshift1_8.c b/libgfortran/generated/eoshift1_8.c
index 1f4f45e3df3..d45789c7e21 100644
--- a/libgfortran/generated/eoshift1_8.c
+++ b/libgfortran/generated/eoshift1_8.c
@@ -105,8 +105,8 @@ eoshift1 (gfc_array_char * const restrict ret,
 	  GFC_DIMENSION_SET (ret->dim[i], 0, ext, sm);
 
         }
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/eoshift3_16.c b/libgfortran/generated/eoshift3_16.c
index c0c8b0deda5..4bdcab60b3f 100644
--- a/libgfortran/generated/eoshift3_16.c
+++ b/libgfortran/generated/eoshift3_16.c
@@ -89,7 +89,7 @@ eoshift3 (gfc_array_char * const restrict ret,
     {
       int i;
 
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      ret->base_addr = xmalloc (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -107,8 +107,8 @@ eoshift3 (gfc_array_char * const restrict ret,
 	  GFC_DIMENSION_SET (ret->dim[i], 0, ext, sm);
 
         }
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/eoshift3_4.c b/libgfortran/generated/eoshift3_4.c
index eb960cffaab..1ddebaf304e 100644
--- a/libgfortran/generated/eoshift3_4.c
+++ b/libgfortran/generated/eoshift3_4.c
@@ -89,7 +89,7 @@ eoshift3 (gfc_array_char * const restrict ret,
     {
       int i;
 
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      ret->base_addr = xmalloc (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -107,8 +107,8 @@ eoshift3 (gfc_array_char * const restrict ret,
 	  GFC_DIMENSION_SET (ret->dim[i], 0, ext, sm);
 
         }
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/eoshift3_8.c b/libgfortran/generated/eoshift3_8.c
index dd957c3203b..d28b0c7147f 100644
--- a/libgfortran/generated/eoshift3_8.c
+++ b/libgfortran/generated/eoshift3_8.c
@@ -89,7 +89,7 @@ eoshift3 (gfc_array_char * const restrict ret,
     {
       int i;
 
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      ret->base_addr = xmalloc (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -107,8 +107,8 @@ eoshift3 (gfc_array_char * const restrict ret,
 	  GFC_DIMENSION_SET (ret->dim[i], 0, ext, sm);
 
         }
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (size * arraysize);
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/iall_i1.c b/libgfortran/generated/iall_i1.c
index fb16109c8c4..b0d7c9caacb 100644
--- a/libgfortran/generated/iall_i1.c
+++ b/libgfortran/generated/iall_i1.c
@@ -100,7 +100,7 @@ iall_i1 (gfc_array_i1 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miall_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siall_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iall_i16.c b/libgfortran/generated/iall_i16.c
index 59da57bf5d8..8d24b841e87 100644
--- a/libgfortran/generated/iall_i16.c
+++ b/libgfortran/generated/iall_i16.c
@@ -100,7 +100,7 @@ iall_i16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miall_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siall_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iall_i2.c b/libgfortran/generated/iall_i2.c
index b527b7989c7..7b0cdb42e12 100644
--- a/libgfortran/generated/iall_i2.c
+++ b/libgfortran/generated/iall_i2.c
@@ -100,7 +100,7 @@ iall_i2 (gfc_array_i2 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miall_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siall_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iall_i4.c b/libgfortran/generated/iall_i4.c
index fb24e45425f..d165ad06282 100644
--- a/libgfortran/generated/iall_i4.c
+++ b/libgfortran/generated/iall_i4.c
@@ -100,7 +100,7 @@ iall_i4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miall_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siall_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iall_i8.c b/libgfortran/generated/iall_i8.c
index f9adf197b18..03750d692b5 100644
--- a/libgfortran/generated/iall_i8.c
+++ b/libgfortran/generated/iall_i8.c
@@ -100,7 +100,7 @@ iall_i8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miall_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siall_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iany_i1.c b/libgfortran/generated/iany_i1.c
index 2a7c10a094f..a8ad382f520 100644
--- a/libgfortran/generated/iany_i1.c
+++ b/libgfortran/generated/iany_i1.c
@@ -100,7 +100,7 @@ iany_i1 (gfc_array_i1 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miany_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siany_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iany_i16.c b/libgfortran/generated/iany_i16.c
index 4a9ba4756ff..b4c1b33b24b 100644
--- a/libgfortran/generated/iany_i16.c
+++ b/libgfortran/generated/iany_i16.c
@@ -100,7 +100,7 @@ iany_i16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miany_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siany_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iany_i2.c b/libgfortran/generated/iany_i2.c
index 09a2d861c5d..a093f159b46 100644
--- a/libgfortran/generated/iany_i2.c
+++ b/libgfortran/generated/iany_i2.c
@@ -100,7 +100,7 @@ iany_i2 (gfc_array_i2 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miany_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siany_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iany_i4.c b/libgfortran/generated/iany_i4.c
index 19fa736e5ce..4ec3963bfa8 100644
--- a/libgfortran/generated/iany_i4.c
+++ b/libgfortran/generated/iany_i4.c
@@ -100,7 +100,7 @@ iany_i4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miany_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siany_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iany_i8.c b/libgfortran/generated/iany_i8.c
index f6859753329..369961e90be 100644
--- a/libgfortran/generated/iany_i8.c
+++ b/libgfortran/generated/iany_i8.c
@@ -100,7 +100,7 @@ iany_i8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miany_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siany_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/in_pack_c10.c b/libgfortran/generated/in_pack_c10.c
index a3247072efa..1755cf85cf3 100644
--- a/libgfortran/generated/in_pack_c10.c
+++ b/libgfortran/generated/in_pack_c10.c
@@ -76,7 +76,7 @@ internal_pack_c10 (gfc_array_c10 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_COMPLEX_10 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_10));
+  destptr = (GFC_COMPLEX_10 *)xmalloc (ssize * sizeof (GFC_COMPLEX_10));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_c16.c b/libgfortran/generated/in_pack_c16.c
index 78d7dcca09d..ed1f6166c47 100644
--- a/libgfortran/generated/in_pack_c16.c
+++ b/libgfortran/generated/in_pack_c16.c
@@ -76,7 +76,7 @@ internal_pack_c16 (gfc_array_c16 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_COMPLEX_16 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_16));
+  destptr = (GFC_COMPLEX_16 *)xmalloc (ssize * sizeof (GFC_COMPLEX_16));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_c4.c b/libgfortran/generated/in_pack_c4.c
index ea1d10a8793..52c5170cbd1 100644
--- a/libgfortran/generated/in_pack_c4.c
+++ b/libgfortran/generated/in_pack_c4.c
@@ -76,7 +76,7 @@ internal_pack_c4 (gfc_array_c4 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_COMPLEX_4 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_4));
+  destptr = (GFC_COMPLEX_4 *)xmalloc (ssize * sizeof (GFC_COMPLEX_4));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_c8.c b/libgfortran/generated/in_pack_c8.c
index 5819b6187fb..3dfba49e321 100644
--- a/libgfortran/generated/in_pack_c8.c
+++ b/libgfortran/generated/in_pack_c8.c
@@ -76,7 +76,7 @@ internal_pack_c8 (gfc_array_c8 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_COMPLEX_8 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_8));
+  destptr = (GFC_COMPLEX_8 *)xmalloc (ssize * sizeof (GFC_COMPLEX_8));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_i1.c b/libgfortran/generated/in_pack_i1.c
index 93e55ec07ab..218a51278f5 100644
--- a/libgfortran/generated/in_pack_i1.c
+++ b/libgfortran/generated/in_pack_i1.c
@@ -76,7 +76,7 @@ internal_pack_1 (gfc_array_i1 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_INTEGER_1 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_1));
+  destptr = (GFC_INTEGER_1 *)xmalloc (ssize * sizeof (GFC_INTEGER_1));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_i16.c b/libgfortran/generated/in_pack_i16.c
index 430d8deaf70..aa7cc5e62c7 100644
--- a/libgfortran/generated/in_pack_i16.c
+++ b/libgfortran/generated/in_pack_i16.c
@@ -76,7 +76,7 @@ internal_pack_16 (gfc_array_i16 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_INTEGER_16 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_16));
+  destptr = (GFC_INTEGER_16 *)xmalloc (ssize * sizeof (GFC_INTEGER_16));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_i2.c b/libgfortran/generated/in_pack_i2.c
index 8e09bfb5bcb..7ffb33be189 100644
--- a/libgfortran/generated/in_pack_i2.c
+++ b/libgfortran/generated/in_pack_i2.c
@@ -76,7 +76,7 @@ internal_pack_2 (gfc_array_i2 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_INTEGER_2 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_2));
+  destptr = (GFC_INTEGER_2 *)xmalloc (ssize * sizeof (GFC_INTEGER_2));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_i4.c b/libgfortran/generated/in_pack_i4.c
index b14355482fe..b10e176e5bc 100644
--- a/libgfortran/generated/in_pack_i4.c
+++ b/libgfortran/generated/in_pack_i4.c
@@ -76,7 +76,7 @@ internal_pack_4 (gfc_array_i4 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_INTEGER_4 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_4));
+  destptr = (GFC_INTEGER_4 *)xmalloc (ssize * sizeof (GFC_INTEGER_4));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_i8.c b/libgfortran/generated/in_pack_i8.c
index 8da51e143ce..64277f8116b 100644
--- a/libgfortran/generated/in_pack_i8.c
+++ b/libgfortran/generated/in_pack_i8.c
@@ -76,7 +76,7 @@ internal_pack_8 (gfc_array_i8 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_INTEGER_8 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_8));
+  destptr = (GFC_INTEGER_8 *)xmalloc (ssize * sizeof (GFC_INTEGER_8));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_r10.c b/libgfortran/generated/in_pack_r10.c
index 4eefc06027c..93d9e013418 100644
--- a/libgfortran/generated/in_pack_r10.c
+++ b/libgfortran/generated/in_pack_r10.c
@@ -76,7 +76,7 @@ internal_pack_r10 (gfc_array_r10 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_REAL_10 *)internal_malloc_size (ssize * sizeof (GFC_REAL_10));
+  destptr = (GFC_REAL_10 *)xmalloc (ssize * sizeof (GFC_REAL_10));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_r16.c b/libgfortran/generated/in_pack_r16.c
index 4e8e9ca5fbf..c495a46155f 100644
--- a/libgfortran/generated/in_pack_r16.c
+++ b/libgfortran/generated/in_pack_r16.c
@@ -76,7 +76,7 @@ internal_pack_r16 (gfc_array_r16 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_REAL_16 *)internal_malloc_size (ssize * sizeof (GFC_REAL_16));
+  destptr = (GFC_REAL_16 *)xmalloc (ssize * sizeof (GFC_REAL_16));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_r4.c b/libgfortran/generated/in_pack_r4.c
index b234719a48b..d8c742c50c9 100644
--- a/libgfortran/generated/in_pack_r4.c
+++ b/libgfortran/generated/in_pack_r4.c
@@ -76,7 +76,7 @@ internal_pack_r4 (gfc_array_r4 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_REAL_4 *)internal_malloc_size (ssize * sizeof (GFC_REAL_4));
+  destptr = (GFC_REAL_4 *)xmalloc (ssize * sizeof (GFC_REAL_4));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/in_pack_r8.c b/libgfortran/generated/in_pack_r8.c
index 4477b5b98ba..fcb449dfb83 100644
--- a/libgfortran/generated/in_pack_r8.c
+++ b/libgfortran/generated/in_pack_r8.c
@@ -76,7 +76,7 @@ internal_pack_r8 (gfc_array_r8 * source)
     return source->base_addr;
 
   /* Allocate storage for the destination.  */
-  destptr = (GFC_REAL_8 *)internal_malloc_size (ssize * sizeof (GFC_REAL_8));
+  destptr = (GFC_REAL_8 *)xmalloc (ssize * sizeof (GFC_REAL_8));
   dest = destptr;
   src = source->base_addr;
   stride0 = stride[0];
diff --git a/libgfortran/generated/iparity_i1.c b/libgfortran/generated/iparity_i1.c
index 6603f7bdbf9..f12eee92041 100644
--- a/libgfortran/generated/iparity_i1.c
+++ b/libgfortran/generated/iparity_i1.c
@@ -100,7 +100,7 @@ iparity_i1 (gfc_array_i1 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miparity_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siparity_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iparity_i16.c b/libgfortran/generated/iparity_i16.c
index d1bfe725b78..b4986d263d5 100644
--- a/libgfortran/generated/iparity_i16.c
+++ b/libgfortran/generated/iparity_i16.c
@@ -100,7 +100,7 @@ iparity_i16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miparity_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siparity_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iparity_i2.c b/libgfortran/generated/iparity_i2.c
index acca495d604..5ff64e0ecc0 100644
--- a/libgfortran/generated/iparity_i2.c
+++ b/libgfortran/generated/iparity_i2.c
@@ -100,7 +100,7 @@ iparity_i2 (gfc_array_i2 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miparity_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siparity_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iparity_i4.c b/libgfortran/generated/iparity_i4.c
index d62c99abbfd..7ed2b712d96 100644
--- a/libgfortran/generated/iparity_i4.c
+++ b/libgfortran/generated/iparity_i4.c
@@ -100,7 +100,7 @@ iparity_i4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miparity_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siparity_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/iparity_i8.c b/libgfortran/generated/iparity_i8.c
index e0ffff2cb40..c85551f5858 100644
--- a/libgfortran/generated/iparity_i8.c
+++ b/libgfortran/generated/iparity_i8.c
@@ -100,7 +100,7 @@ iparity_i8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ miparity_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ siparity_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/matmul_c10.c b/libgfortran/generated/matmul_c10.c
index d78d0c8e6ad..7d3137612ec 100644
--- a/libgfortran/generated/matmul_c10.c
+++ b/libgfortran/generated/matmul_c10.c
@@ -125,7 +125,7 @@ matmul_c10 (gfc_array_c10 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_c16.c b/libgfortran/generated/matmul_c16.c
index cfe49488340..e7872866df1 100644
--- a/libgfortran/generated/matmul_c16.c
+++ b/libgfortran/generated/matmul_c16.c
@@ -125,7 +125,7 @@ matmul_c16 (gfc_array_c16 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_c4.c b/libgfortran/generated/matmul_c4.c
index 6577eaf9155..f6f684b9b72 100644
--- a/libgfortran/generated/matmul_c4.c
+++ b/libgfortran/generated/matmul_c4.c
@@ -125,7 +125,7 @@ matmul_c4 (gfc_array_c4 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_c8.c b/libgfortran/generated/matmul_c8.c
index 333ab9114b0..0fa3d2b15b6 100644
--- a/libgfortran/generated/matmul_c8.c
+++ b/libgfortran/generated/matmul_c8.c
@@ -125,7 +125,7 @@ matmul_c8 (gfc_array_c8 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_i1.c b/libgfortran/generated/matmul_i1.c
index 8df0516b1d3..0db09db2f4a 100644
--- a/libgfortran/generated/matmul_i1.c
+++ b/libgfortran/generated/matmul_i1.c
@@ -125,7 +125,7 @@ matmul_i1 (gfc_array_i1 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_INTEGER_1) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_INTEGER_1) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_i16.c b/libgfortran/generated/matmul_i16.c
index 2a825b71be7..e2f3d275f75 100644
--- a/libgfortran/generated/matmul_i16.c
+++ b/libgfortran/generated/matmul_i16.c
@@ -125,7 +125,7 @@ matmul_i16 (gfc_array_i16 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_INTEGER_16) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_INTEGER_16) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_i2.c b/libgfortran/generated/matmul_i2.c
index 36f72e7135f..36d1ec9f92c 100644
--- a/libgfortran/generated/matmul_i2.c
+++ b/libgfortran/generated/matmul_i2.c
@@ -125,7 +125,7 @@ matmul_i2 (gfc_array_i2 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_INTEGER_2) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_INTEGER_2) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_i4.c b/libgfortran/generated/matmul_i4.c
index 60916ba2f92..d461b7baad1 100644
--- a/libgfortran/generated/matmul_i4.c
+++ b/libgfortran/generated/matmul_i4.c
@@ -125,7 +125,7 @@ matmul_i4 (gfc_array_i4 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_INTEGER_4) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_INTEGER_4) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_i8.c b/libgfortran/generated/matmul_i8.c
index 09bcb20a490..dae541cc618 100644
--- a/libgfortran/generated/matmul_i8.c
+++ b/libgfortran/generated/matmul_i8.c
@@ -125,7 +125,7 @@ matmul_i8 (gfc_array_i8 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_INTEGER_8) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_INTEGER_8) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_l16.c b/libgfortran/generated/matmul_l16.c
index d4757d12ec8..27a703c6a03 100644
--- a/libgfortran/generated/matmul_l16.c
+++ b/libgfortran/generated/matmul_l16.c
@@ -89,7 +89,7 @@ matmul_l16 (gfc_array_l16 * const restrict retarray,
         }
           
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_LOGICAL_16) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_LOGICAL_16) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_l4.c b/libgfortran/generated/matmul_l4.c
index d8ed7c142a7..37a0e4e208f 100644
--- a/libgfortran/generated/matmul_l4.c
+++ b/libgfortran/generated/matmul_l4.c
@@ -89,7 +89,7 @@ matmul_l4 (gfc_array_l4 * const restrict retarray,
         }
           
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_LOGICAL_4) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_LOGICAL_4) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_l8.c b/libgfortran/generated/matmul_l8.c
index 8faf6d7640b..955ffa290a6 100644
--- a/libgfortran/generated/matmul_l8.c
+++ b/libgfortran/generated/matmul_l8.c
@@ -89,7 +89,7 @@ matmul_l8 (gfc_array_l8 * const restrict retarray,
         }
           
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_LOGICAL_8) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_LOGICAL_8) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_r10.c b/libgfortran/generated/matmul_r10.c
index 23313b0ede3..a034660b561 100644
--- a/libgfortran/generated/matmul_r10.c
+++ b/libgfortran/generated/matmul_r10.c
@@ -125,7 +125,7 @@ matmul_r10 (gfc_array_r10 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_REAL_10) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_REAL_10) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_r16.c b/libgfortran/generated/matmul_r16.c
index 5d0aaf3efd6..d30a8aad28f 100644
--- a/libgfortran/generated/matmul_r16.c
+++ b/libgfortran/generated/matmul_r16.c
@@ -125,7 +125,7 @@ matmul_r16 (gfc_array_r16 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_REAL_16) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_REAL_16) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_r4.c b/libgfortran/generated/matmul_r4.c
index 992335fe91c..cdf2c9188e7 100644
--- a/libgfortran/generated/matmul_r4.c
+++ b/libgfortran/generated/matmul_r4.c
@@ -125,7 +125,7 @@ matmul_r4 (gfc_array_r4 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_REAL_4) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_REAL_4) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/matmul_r8.c b/libgfortran/generated/matmul_r8.c
index 221dedadcea..88f00603513 100644
--- a/libgfortran/generated/matmul_r8.c
+++ b/libgfortran/generated/matmul_r8.c
@@ -125,7 +125,7 @@ matmul_r8 (gfc_array_r8 * const restrict retarray,
         }
 
       retarray->base_addr
-	= internal_malloc_size (sizeof (GFC_REAL_8) * size0 ((array_t *) retarray));
+	= xmalloc (sizeof (GFC_REAL_8) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
     else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/generated/maxloc0_16_i1.c b/libgfortran/generated/maxloc0_16_i1.c
index 6bc7854179a..58c3916d7a4 100644
--- a/libgfortran/generated/maxloc0_16_i1.c
+++ b/libgfortran/generated/maxloc0_16_i1.c
@@ -58,7 +58,7 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_16_i16.c b/libgfortran/generated/maxloc0_16_i16.c
index 58b67df7321..c3b4a516e62 100644
--- a/libgfortran/generated/maxloc0_16_i16.c
+++ b/libgfortran/generated/maxloc0_16_i16.c
@@ -58,7 +58,7 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_16_i2.c b/libgfortran/generated/maxloc0_16_i2.c
index e6234917e95..42160f7ab15 100644
--- a/libgfortran/generated/maxloc0_16_i2.c
+++ b/libgfortran/generated/maxloc0_16_i2.c
@@ -58,7 +58,7 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_16_i4.c b/libgfortran/generated/maxloc0_16_i4.c
index b67229e1c3e..1d3b65c0c7b 100644
--- a/libgfortran/generated/maxloc0_16_i4.c
+++ b/libgfortran/generated/maxloc0_16_i4.c
@@ -58,7 +58,7 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_16_i8.c b/libgfortran/generated/maxloc0_16_i8.c
index 9fbc1d7138b..4082eb52e94 100644
--- a/libgfortran/generated/maxloc0_16_i8.c
+++ b/libgfortran/generated/maxloc0_16_i8.c
@@ -58,7 +58,7 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_16_r10.c b/libgfortran/generated/maxloc0_16_r10.c
index d4eddf0ac2c..b3985a97585 100644
--- a/libgfortran/generated/maxloc0_16_r10.c
+++ b/libgfortran/generated/maxloc0_16_r10.c
@@ -58,7 +58,7 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_16_r16.c b/libgfortran/generated/maxloc0_16_r16.c
index 84b36f1a95c..fe0f7e29ab8 100644
--- a/libgfortran/generated/maxloc0_16_r16.c
+++ b/libgfortran/generated/maxloc0_16_r16.c
@@ -58,7 +58,7 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_16_r4.c b/libgfortran/generated/maxloc0_16_r4.c
index 4556819d010..bb4cee938db 100644
--- a/libgfortran/generated/maxloc0_16_r4.c
+++ b/libgfortran/generated/maxloc0_16_r4.c
@@ -58,7 +58,7 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_16_r8.c b/libgfortran/generated/maxloc0_16_r8.c
index e9935660403..211b43c1fa5 100644
--- a/libgfortran/generated/maxloc0_16_r8.c
+++ b/libgfortran/generated/maxloc0_16_r8.c
@@ -58,7 +58,7 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_4_i1.c b/libgfortran/generated/maxloc0_4_i1.c
index 9e85770987c..1862ef6f98e 100644
--- a/libgfortran/generated/maxloc0_4_i1.c
+++ b/libgfortran/generated/maxloc0_4_i1.c
@@ -58,7 +58,7 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_4_i16.c b/libgfortran/generated/maxloc0_4_i16.c
index 896559582d6..9f41b3ba408 100644
--- a/libgfortran/generated/maxloc0_4_i16.c
+++ b/libgfortran/generated/maxloc0_4_i16.c
@@ -58,7 +58,7 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_4_i2.c b/libgfortran/generated/maxloc0_4_i2.c
index 8fc7a38198c..a5febd7ac83 100644
--- a/libgfortran/generated/maxloc0_4_i2.c
+++ b/libgfortran/generated/maxloc0_4_i2.c
@@ -58,7 +58,7 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_4_i4.c b/libgfortran/generated/maxloc0_4_i4.c
index 423aca348ae..a23332d207c 100644
--- a/libgfortran/generated/maxloc0_4_i4.c
+++ b/libgfortran/generated/maxloc0_4_i4.c
@@ -58,7 +58,7 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_4_i8.c b/libgfortran/generated/maxloc0_4_i8.c
index f3bc9249875..102810cc563 100644
--- a/libgfortran/generated/maxloc0_4_i8.c
+++ b/libgfortran/generated/maxloc0_4_i8.c
@@ -58,7 +58,7 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_4_r10.c b/libgfortran/generated/maxloc0_4_r10.c
index 61437422021..ec7a489292a 100644
--- a/libgfortran/generated/maxloc0_4_r10.c
+++ b/libgfortran/generated/maxloc0_4_r10.c
@@ -58,7 +58,7 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_4_r16.c b/libgfortran/generated/maxloc0_4_r16.c
index 2cbc2a046ee..5aef471033d 100644
--- a/libgfortran/generated/maxloc0_4_r16.c
+++ b/libgfortran/generated/maxloc0_4_r16.c
@@ -58,7 +58,7 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_4_r4.c b/libgfortran/generated/maxloc0_4_r4.c
index e68de4df565..8631b29642b 100644
--- a/libgfortran/generated/maxloc0_4_r4.c
+++ b/libgfortran/generated/maxloc0_4_r4.c
@@ -58,7 +58,7 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_4_r8.c b/libgfortran/generated/maxloc0_4_r8.c
index f493afc356c..4f61cf9ce21 100644
--- a/libgfortran/generated/maxloc0_4_r8.c
+++ b/libgfortran/generated/maxloc0_4_r8.c
@@ -58,7 +58,7 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_8_i1.c b/libgfortran/generated/maxloc0_8_i1.c
index 4550ae24ed6..42f036b2294 100644
--- a/libgfortran/generated/maxloc0_8_i1.c
+++ b/libgfortran/generated/maxloc0_8_i1.c
@@ -58,7 +58,7 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_8_i16.c b/libgfortran/generated/maxloc0_8_i16.c
index b2c37117d86..e19cc8b372d 100644
--- a/libgfortran/generated/maxloc0_8_i16.c
+++ b/libgfortran/generated/maxloc0_8_i16.c
@@ -58,7 +58,7 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_8_i2.c b/libgfortran/generated/maxloc0_8_i2.c
index ec3c4d16815..8511437d67f 100644
--- a/libgfortran/generated/maxloc0_8_i2.c
+++ b/libgfortran/generated/maxloc0_8_i2.c
@@ -58,7 +58,7 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_8_i4.c b/libgfortran/generated/maxloc0_8_i4.c
index 09bc2470948..99bd3d29ede 100644
--- a/libgfortran/generated/maxloc0_8_i4.c
+++ b/libgfortran/generated/maxloc0_8_i4.c
@@ -58,7 +58,7 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_8_i8.c b/libgfortran/generated/maxloc0_8_i8.c
index 7507a5718ed..33907a9e68f 100644
--- a/libgfortran/generated/maxloc0_8_i8.c
+++ b/libgfortran/generated/maxloc0_8_i8.c
@@ -58,7 +58,7 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_8_r10.c b/libgfortran/generated/maxloc0_8_r10.c
index 6824cf2c279..f070e1fa0b7 100644
--- a/libgfortran/generated/maxloc0_8_r10.c
+++ b/libgfortran/generated/maxloc0_8_r10.c
@@ -58,7 +58,7 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_8_r16.c b/libgfortran/generated/maxloc0_8_r16.c
index fb0c30374d1..c065440bbc7 100644
--- a/libgfortran/generated/maxloc0_8_r16.c
+++ b/libgfortran/generated/maxloc0_8_r16.c
@@ -58,7 +58,7 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_8_r4.c b/libgfortran/generated/maxloc0_8_r4.c
index 96429bdd1a2..bba23199a95 100644
--- a/libgfortran/generated/maxloc0_8_r4.c
+++ b/libgfortran/generated/maxloc0_8_r4.c
@@ -58,7 +58,7 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc0_8_r8.c b/libgfortran/generated/maxloc0_8_r8.c
index 88aaff78630..ded662d98bb 100644
--- a/libgfortran/generated/maxloc0_8_r8.c
+++ b/libgfortran/generated/maxloc0_8_r8.c
@@ -58,7 +58,7 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/maxloc1_16_i1.c b/libgfortran/generated/maxloc1_16_i1.c
index 13c986f2e1c..dc97afe6cb4 100644
--- a/libgfortran/generated/maxloc1_16_i1.c
+++ b/libgfortran/generated/maxloc1_16_i1.c
@@ -101,7 +101,7 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c
index 6bd76e95417..f606a9f07b6 100644
--- a/libgfortran/generated/maxloc1_16_i16.c
+++ b/libgfortran/generated/maxloc1_16_i16.c
@@ -101,7 +101,7 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_16_i2.c b/libgfortran/generated/maxloc1_16_i2.c
index b670bb26e89..564ca654b9e 100644
--- a/libgfortran/generated/maxloc1_16_i2.c
+++ b/libgfortran/generated/maxloc1_16_i2.c
@@ -101,7 +101,7 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c
index 80359d5476c..5370dd65d75 100644
--- a/libgfortran/generated/maxloc1_16_i4.c
+++ b/libgfortran/generated/maxloc1_16_i4.c
@@ -101,7 +101,7 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_16_i8.c b/libgfortran/generated/maxloc1_16_i8.c
index fc49056f43b..3ffa61b950a 100644
--- a/libgfortran/generated/maxloc1_16_i8.c
+++ b/libgfortran/generated/maxloc1_16_i8.c
@@ -101,7 +101,7 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c
index 389e2517c9d..4dbaf3d8d64 100644
--- a/libgfortran/generated/maxloc1_16_r10.c
+++ b/libgfortran/generated/maxloc1_16_r10.c
@@ -101,7 +101,7 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c
index 9e0b088d510..5fe479d6eee 100644
--- a/libgfortran/generated/maxloc1_16_r16.c
+++ b/libgfortran/generated/maxloc1_16_r16.c
@@ -101,7 +101,7 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c
index e6fc39e469a..65cd4b076ba 100644
--- a/libgfortran/generated/maxloc1_16_r4.c
+++ b/libgfortran/generated/maxloc1_16_r4.c
@@ -101,7 +101,7 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c
index 62a652fef83..d6f0bcfe433 100644
--- a/libgfortran/generated/maxloc1_16_r8.c
+++ b/libgfortran/generated/maxloc1_16_r8.c
@@ -101,7 +101,7 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_4_i1.c b/libgfortran/generated/maxloc1_4_i1.c
index b61b9d7dcb2..a42858ef372 100644
--- a/libgfortran/generated/maxloc1_4_i1.c
+++ b/libgfortran/generated/maxloc1_4_i1.c
@@ -101,7 +101,7 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_4_i16.c b/libgfortran/generated/maxloc1_4_i16.c
index 91a521c04c6..4ee918f5b92 100644
--- a/libgfortran/generated/maxloc1_4_i16.c
+++ b/libgfortran/generated/maxloc1_4_i16.c
@@ -101,7 +101,7 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_4_i2.c b/libgfortran/generated/maxloc1_4_i2.c
index d38b40245fc..bb734e10c44 100644
--- a/libgfortran/generated/maxloc1_4_i2.c
+++ b/libgfortran/generated/maxloc1_4_i2.c
@@ -101,7 +101,7 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c
index 67933e497c9..26ff86203a5 100644
--- a/libgfortran/generated/maxloc1_4_i4.c
+++ b/libgfortran/generated/maxloc1_4_i4.c
@@ -101,7 +101,7 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_4_i8.c b/libgfortran/generated/maxloc1_4_i8.c
index 4a80a017b43..42f7445e24b 100644
--- a/libgfortran/generated/maxloc1_4_i8.c
+++ b/libgfortran/generated/maxloc1_4_i8.c
@@ -101,7 +101,7 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c
index 59666697953..8ea0c7a59bb 100644
--- a/libgfortran/generated/maxloc1_4_r10.c
+++ b/libgfortran/generated/maxloc1_4_r10.c
@@ -101,7 +101,7 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c
index 83ebc27b2ae..7227a75af1a 100644
--- a/libgfortran/generated/maxloc1_4_r16.c
+++ b/libgfortran/generated/maxloc1_4_r16.c
@@ -101,7 +101,7 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c
index e974a56167c..40bae8d7605 100644
--- a/libgfortran/generated/maxloc1_4_r4.c
+++ b/libgfortran/generated/maxloc1_4_r4.c
@@ -101,7 +101,7 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c
index f416fe0bfc8..60679033129 100644
--- a/libgfortran/generated/maxloc1_4_r8.c
+++ b/libgfortran/generated/maxloc1_4_r8.c
@@ -101,7 +101,7 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_8_i1.c b/libgfortran/generated/maxloc1_8_i1.c
index ef5f3f4850a..32a79407220 100644
--- a/libgfortran/generated/maxloc1_8_i1.c
+++ b/libgfortran/generated/maxloc1_8_i1.c
@@ -101,7 +101,7 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_8_i16.c b/libgfortran/generated/maxloc1_8_i16.c
index 1e30a8a4a3e..d4e5a621461 100644
--- a/libgfortran/generated/maxloc1_8_i16.c
+++ b/libgfortran/generated/maxloc1_8_i16.c
@@ -101,7 +101,7 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_8_i2.c b/libgfortran/generated/maxloc1_8_i2.c
index ecc43e92670..0265895b579 100644
--- a/libgfortran/generated/maxloc1_8_i2.c
+++ b/libgfortran/generated/maxloc1_8_i2.c
@@ -101,7 +101,7 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c
index c8dff07bee4..f9f9953491e 100644
--- a/libgfortran/generated/maxloc1_8_i4.c
+++ b/libgfortran/generated/maxloc1_8_i4.c
@@ -101,7 +101,7 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_8_i8.c b/libgfortran/generated/maxloc1_8_i8.c
index 3b94b0b2ab2..6086a08d5a0 100644
--- a/libgfortran/generated/maxloc1_8_i8.c
+++ b/libgfortran/generated/maxloc1_8_i8.c
@@ -101,7 +101,7 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c
index 9dfedb2dc5a..29a8f3162ee 100644
--- a/libgfortran/generated/maxloc1_8_r10.c
+++ b/libgfortran/generated/maxloc1_8_r10.c
@@ -101,7 +101,7 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c
index 16a3bef5622..4b85d0c5e29 100644
--- a/libgfortran/generated/maxloc1_8_r16.c
+++ b/libgfortran/generated/maxloc1_8_r16.c
@@ -101,7 +101,7 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c
index 2cff0252050..dc0f75f6a97 100644
--- a/libgfortran/generated/maxloc1_8_r4.c
+++ b/libgfortran/generated/maxloc1_8_r4.c
@@ -101,7 +101,7 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c
index b003f2ffc63..6ca9640844c 100644
--- a/libgfortran/generated/maxloc1_8_r8.c
+++ b/libgfortran/generated/maxloc1_8_r8.c
@@ -101,7 +101,7 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxval_i1.c b/libgfortran/generated/maxval_i1.c
index 4ef4a59ed20..94298a0473f 100644
--- a/libgfortran/generated/maxval_i1.c
+++ b/libgfortran/generated/maxval_i1.c
@@ -100,7 +100,7 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c
index 480e6c1aa81..24f7abc578e 100644
--- a/libgfortran/generated/maxval_i16.c
+++ b/libgfortran/generated/maxval_i16.c
@@ -100,7 +100,7 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxval_i2.c b/libgfortran/generated/maxval_i2.c
index 6080d186768..27695b9b2eb 100644
--- a/libgfortran/generated/maxval_i2.c
+++ b/libgfortran/generated/maxval_i2.c
@@ -100,7 +100,7 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c
index 6e857c99317..eb195926f11 100644
--- a/libgfortran/generated/maxval_i4.c
+++ b/libgfortran/generated/maxval_i4.c
@@ -100,7 +100,7 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c
index c92b3cadd67..4277c6f4842 100644
--- a/libgfortran/generated/maxval_i8.c
+++ b/libgfortran/generated/maxval_i8.c
@@ -100,7 +100,7 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c
index 1e4e6fa4fcf..f465dcaea56 100644
--- a/libgfortran/generated/maxval_r10.c
+++ b/libgfortran/generated/maxval_r10.c
@@ -100,7 +100,7 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c
index 66025e4b3ce..eb9b3137742 100644
--- a/libgfortran/generated/maxval_r16.c
+++ b/libgfortran/generated/maxval_r16.c
@@ -100,7 +100,7 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c
index 088ee0495ee..76e534276be 100644
--- a/libgfortran/generated/maxval_r4.c
+++ b/libgfortran/generated/maxval_r4.c
@@ -100,7 +100,7 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c
index 6b2885c1fa4..39590ff3b5c 100644
--- a/libgfortran/generated/maxval_r8.c
+++ b/libgfortran/generated/maxval_r8.c
@@ -100,7 +100,7 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc0_16_i1.c b/libgfortran/generated/minloc0_16_i1.c
index 074502e0f4a..c1e68a45d63 100644
--- a/libgfortran/generated/minloc0_16_i1.c
+++ b/libgfortran/generated/minloc0_16_i1.c
@@ -58,7 +58,7 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_16_i16.c b/libgfortran/generated/minloc0_16_i16.c
index 9ca67e623bd..ac3feec915e 100644
--- a/libgfortran/generated/minloc0_16_i16.c
+++ b/libgfortran/generated/minloc0_16_i16.c
@@ -58,7 +58,7 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_16_i2.c b/libgfortran/generated/minloc0_16_i2.c
index d09d11ff10d..1c055d538ab 100644
--- a/libgfortran/generated/minloc0_16_i2.c
+++ b/libgfortran/generated/minloc0_16_i2.c
@@ -58,7 +58,7 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_16_i4.c b/libgfortran/generated/minloc0_16_i4.c
index b77cfdfa155..0e38b5abf36 100644
--- a/libgfortran/generated/minloc0_16_i4.c
+++ b/libgfortran/generated/minloc0_16_i4.c
@@ -58,7 +58,7 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_16_i8.c b/libgfortran/generated/minloc0_16_i8.c
index bec28aec737..6bb37914d0b 100644
--- a/libgfortran/generated/minloc0_16_i8.c
+++ b/libgfortran/generated/minloc0_16_i8.c
@@ -58,7 +58,7 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_16_r10.c b/libgfortran/generated/minloc0_16_r10.c
index 04318d193fa..51ea9d2ba0a 100644
--- a/libgfortran/generated/minloc0_16_r10.c
+++ b/libgfortran/generated/minloc0_16_r10.c
@@ -58,7 +58,7 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_16_r16.c b/libgfortran/generated/minloc0_16_r16.c
index 6f188057cb9..add77463831 100644
--- a/libgfortran/generated/minloc0_16_r16.c
+++ b/libgfortran/generated/minloc0_16_r16.c
@@ -58,7 +58,7 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_16_r4.c b/libgfortran/generated/minloc0_16_r4.c
index 85f5691be07..984b5c9a2b1 100644
--- a/libgfortran/generated/minloc0_16_r4.c
+++ b/libgfortran/generated/minloc0_16_r4.c
@@ -58,7 +58,7 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_16_r8.c b/libgfortran/generated/minloc0_16_r8.c
index bb1b82fd6d2..55ff7da3675 100644
--- a/libgfortran/generated/minloc0_16_r8.c
+++ b/libgfortran/generated/minloc0_16_r8.c
@@ -58,7 +58,7 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_4_i1.c b/libgfortran/generated/minloc0_4_i1.c
index d077afbb9c8..3e1d013e406 100644
--- a/libgfortran/generated/minloc0_4_i1.c
+++ b/libgfortran/generated/minloc0_4_i1.c
@@ -58,7 +58,7 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_4_i16.c b/libgfortran/generated/minloc0_4_i16.c
index 1f1d609d653..6ad1fd07a37 100644
--- a/libgfortran/generated/minloc0_4_i16.c
+++ b/libgfortran/generated/minloc0_4_i16.c
@@ -58,7 +58,7 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_4_i2.c b/libgfortran/generated/minloc0_4_i2.c
index cd26a60c446..4d18b6fb657 100644
--- a/libgfortran/generated/minloc0_4_i2.c
+++ b/libgfortran/generated/minloc0_4_i2.c
@@ -58,7 +58,7 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_4_i4.c b/libgfortran/generated/minloc0_4_i4.c
index 57a6a595985..b1df66c8fad 100644
--- a/libgfortran/generated/minloc0_4_i4.c
+++ b/libgfortran/generated/minloc0_4_i4.c
@@ -58,7 +58,7 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_4_i8.c b/libgfortran/generated/minloc0_4_i8.c
index 21df8a32f03..907d4c6de3b 100644
--- a/libgfortran/generated/minloc0_4_i8.c
+++ b/libgfortran/generated/minloc0_4_i8.c
@@ -58,7 +58,7 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_4_r10.c b/libgfortran/generated/minloc0_4_r10.c
index e3b84c8cf68..3d257c5e043 100644
--- a/libgfortran/generated/minloc0_4_r10.c
+++ b/libgfortran/generated/minloc0_4_r10.c
@@ -58,7 +58,7 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_4_r16.c b/libgfortran/generated/minloc0_4_r16.c
index bc40dc7be6f..b9fc3b270b0 100644
--- a/libgfortran/generated/minloc0_4_r16.c
+++ b/libgfortran/generated/minloc0_4_r16.c
@@ -58,7 +58,7 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_4_r4.c b/libgfortran/generated/minloc0_4_r4.c
index 32b3344d7f5..2718346de9a 100644
--- a/libgfortran/generated/minloc0_4_r4.c
+++ b/libgfortran/generated/minloc0_4_r4.c
@@ -58,7 +58,7 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_4_r8.c b/libgfortran/generated/minloc0_4_r8.c
index 59c4a1eb68e..512822219da 100644
--- a/libgfortran/generated/minloc0_4_r8.c
+++ b/libgfortran/generated/minloc0_4_r8.c
@@ -58,7 +58,7 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_8_i1.c b/libgfortran/generated/minloc0_8_i1.c
index 000ccadbcc9..34e6391ccea 100644
--- a/libgfortran/generated/minloc0_8_i1.c
+++ b/libgfortran/generated/minloc0_8_i1.c
@@ -58,7 +58,7 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_8_i16.c b/libgfortran/generated/minloc0_8_i16.c
index e794eefcee4..60b2e7eff94 100644
--- a/libgfortran/generated/minloc0_8_i16.c
+++ b/libgfortran/generated/minloc0_8_i16.c
@@ -58,7 +58,7 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_8_i2.c b/libgfortran/generated/minloc0_8_i2.c
index 7e48051bcb6..a9187a53209 100644
--- a/libgfortran/generated/minloc0_8_i2.c
+++ b/libgfortran/generated/minloc0_8_i2.c
@@ -58,7 +58,7 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_8_i4.c b/libgfortran/generated/minloc0_8_i4.c
index 8597ef4cc11..643c2b77242 100644
--- a/libgfortran/generated/minloc0_8_i4.c
+++ b/libgfortran/generated/minloc0_8_i4.c
@@ -58,7 +58,7 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_8_i8.c b/libgfortran/generated/minloc0_8_i8.c
index e38b737acb6..e8f1ad5664b 100644
--- a/libgfortran/generated/minloc0_8_i8.c
+++ b/libgfortran/generated/minloc0_8_i8.c
@@ -58,7 +58,7 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_8_r10.c b/libgfortran/generated/minloc0_8_r10.c
index 935819ab31e..02bacc2d7cc 100644
--- a/libgfortran/generated/minloc0_8_r10.c
+++ b/libgfortran/generated/minloc0_8_r10.c
@@ -58,7 +58,7 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_8_r16.c b/libgfortran/generated/minloc0_8_r16.c
index eb09b3ab26e..f8d72c7364f 100644
--- a/libgfortran/generated/minloc0_8_r16.c
+++ b/libgfortran/generated/minloc0_8_r16.c
@@ -58,7 +58,7 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_8_r4.c b/libgfortran/generated/minloc0_8_r4.c
index b6d632d336f..6ef98deb22b 100644
--- a/libgfortran/generated/minloc0_8_r4.c
+++ b/libgfortran/generated/minloc0_8_r4.c
@@ -58,7 +58,7 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc0_8_r8.c b/libgfortran/generated/minloc0_8_r8.c
index 4b4f596c042..0ff3a291f9e 100644
--- a/libgfortran/generated/minloc0_8_r8.c
+++ b/libgfortran/generated/minloc0_8_r8.c
@@ -58,7 +58,7 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -199,7 +199,7 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -367,7 +367,7 @@ sminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
       GFC_DIMENSION_SET (retarray->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/minloc1_16_i1.c b/libgfortran/generated/minloc1_16_i1.c
index 51b272f270a..afbdbf39ca4 100644
--- a/libgfortran/generated/minloc1_16_i1.c
+++ b/libgfortran/generated/minloc1_16_i1.c
@@ -101,7 +101,7 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c
index c9795e3930c..b5d1a00a63e 100644
--- a/libgfortran/generated/minloc1_16_i16.c
+++ b/libgfortran/generated/minloc1_16_i16.c
@@ -101,7 +101,7 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_16_i2.c b/libgfortran/generated/minloc1_16_i2.c
index a1a08d71912..5ec6c65d4fc 100644
--- a/libgfortran/generated/minloc1_16_i2.c
+++ b/libgfortran/generated/minloc1_16_i2.c
@@ -101,7 +101,7 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c
index 9dcc85bf7c8..7d25a499c8f 100644
--- a/libgfortran/generated/minloc1_16_i4.c
+++ b/libgfortran/generated/minloc1_16_i4.c
@@ -101,7 +101,7 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c
index ea5d5228a8c..8d265d9cb39 100644
--- a/libgfortran/generated/minloc1_16_i8.c
+++ b/libgfortran/generated/minloc1_16_i8.c
@@ -101,7 +101,7 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c
index 5ecf36143b2..f56d057c74a 100644
--- a/libgfortran/generated/minloc1_16_r10.c
+++ b/libgfortran/generated/minloc1_16_r10.c
@@ -101,7 +101,7 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c
index d5c1b95a225..a5a4775599f 100644
--- a/libgfortran/generated/minloc1_16_r16.c
+++ b/libgfortran/generated/minloc1_16_r16.c
@@ -101,7 +101,7 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c
index 5d9bd1c0b2b..73e8768fca5 100644
--- a/libgfortran/generated/minloc1_16_r4.c
+++ b/libgfortran/generated/minloc1_16_r4.c
@@ -101,7 +101,7 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c
index e18a487d6d1..fbf01ceb758 100644
--- a/libgfortran/generated/minloc1_16_r8.c
+++ b/libgfortran/generated/minloc1_16_r8.c
@@ -101,7 +101,7 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_4_i1.c b/libgfortran/generated/minloc1_4_i1.c
index df9e73e194d..04a127ec479 100644
--- a/libgfortran/generated/minloc1_4_i1.c
+++ b/libgfortran/generated/minloc1_4_i1.c
@@ -101,7 +101,7 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c
index 65eaf6647e6..116aaab0770 100644
--- a/libgfortran/generated/minloc1_4_i16.c
+++ b/libgfortran/generated/minloc1_4_i16.c
@@ -101,7 +101,7 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_4_i2.c b/libgfortran/generated/minloc1_4_i2.c
index e015e55f7fd..ad320ddc823 100644
--- a/libgfortran/generated/minloc1_4_i2.c
+++ b/libgfortran/generated/minloc1_4_i2.c
@@ -101,7 +101,7 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c
index 8499c06d1b3..5b461fea5a3 100644
--- a/libgfortran/generated/minloc1_4_i4.c
+++ b/libgfortran/generated/minloc1_4_i4.c
@@ -101,7 +101,7 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c
index 0e732e1caff..48be8aeba1d 100644
--- a/libgfortran/generated/minloc1_4_i8.c
+++ b/libgfortran/generated/minloc1_4_i8.c
@@ -101,7 +101,7 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c
index 1d7752f1132..dd302243968 100644
--- a/libgfortran/generated/minloc1_4_r10.c
+++ b/libgfortran/generated/minloc1_4_r10.c
@@ -101,7 +101,7 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c
index f1180979310..57b8e8444dc 100644
--- a/libgfortran/generated/minloc1_4_r16.c
+++ b/libgfortran/generated/minloc1_4_r16.c
@@ -101,7 +101,7 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c
index 212da6e7d9c..94d0fd6b9de 100644
--- a/libgfortran/generated/minloc1_4_r4.c
+++ b/libgfortran/generated/minloc1_4_r4.c
@@ -101,7 +101,7 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c
index 810b9813fbd..344dd0c3929 100644
--- a/libgfortran/generated/minloc1_4_r8.c
+++ b/libgfortran/generated/minloc1_4_r8.c
@@ -101,7 +101,7 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_8_i1.c b/libgfortran/generated/minloc1_8_i1.c
index 2c11a5558e7..30155b2184a 100644
--- a/libgfortran/generated/minloc1_8_i1.c
+++ b/libgfortran/generated/minloc1_8_i1.c
@@ -101,7 +101,7 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c
index 5f363df3472..802a6287e47 100644
--- a/libgfortran/generated/minloc1_8_i16.c
+++ b/libgfortran/generated/minloc1_8_i16.c
@@ -101,7 +101,7 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_8_i2.c b/libgfortran/generated/minloc1_8_i2.c
index 9c6dcf9e78f..d65d72d08b2 100644
--- a/libgfortran/generated/minloc1_8_i2.c
+++ b/libgfortran/generated/minloc1_8_i2.c
@@ -101,7 +101,7 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c
index 96f8525465d..adee1a3af50 100644
--- a/libgfortran/generated/minloc1_8_i4.c
+++ b/libgfortran/generated/minloc1_8_i4.c
@@ -101,7 +101,7 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c
index 3a17cfea668..585c692a30e 100644
--- a/libgfortran/generated/minloc1_8_i8.c
+++ b/libgfortran/generated/minloc1_8_i8.c
@@ -101,7 +101,7 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c
index 07ff21e6930..527c39fb836 100644
--- a/libgfortran/generated/minloc1_8_r10.c
+++ b/libgfortran/generated/minloc1_8_r10.c
@@ -101,7 +101,7 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c
index c4a419cf484..1393b40967b 100644
--- a/libgfortran/generated/minloc1_8_r16.c
+++ b/libgfortran/generated/minloc1_8_r16.c
@@ -101,7 +101,7 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c
index 66df4552587..b68d162bf7c 100644
--- a/libgfortran/generated/minloc1_8_r4.c
+++ b/libgfortran/generated/minloc1_8_r4.c
@@ -101,7 +101,7 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c
index 9c2809ca0aa..8217791e6fd 100644
--- a/libgfortran/generated/minloc1_8_r8.c
+++ b/libgfortran/generated/minloc1_8_r8.c
@@ -101,7 +101,7 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -307,7 +307,7 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -499,7 +499,7 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minval_i1.c b/libgfortran/generated/minval_i1.c
index c0ead7d3ba1..930ce9c5a1f 100644
--- a/libgfortran/generated/minval_i1.c
+++ b/libgfortran/generated/minval_i1.c
@@ -100,7 +100,7 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ sminval_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c
index aa08d582e0f..623015a9ad1 100644
--- a/libgfortran/generated/minval_i16.c
+++ b/libgfortran/generated/minval_i16.c
@@ -100,7 +100,7 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ sminval_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minval_i2.c b/libgfortran/generated/minval_i2.c
index 6a697e64dfe..16279a4c88e 100644
--- a/libgfortran/generated/minval_i2.c
+++ b/libgfortran/generated/minval_i2.c
@@ -100,7 +100,7 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ sminval_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c
index 2877d12808a..573970aaf46 100644
--- a/libgfortran/generated/minval_i4.c
+++ b/libgfortran/generated/minval_i4.c
@@ -100,7 +100,7 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ sminval_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c
index 28b3f496eb0..2656bbaa204 100644
--- a/libgfortran/generated/minval_i8.c
+++ b/libgfortran/generated/minval_i8.c
@@ -100,7 +100,7 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ sminval_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minval_r10.c b/libgfortran/generated/minval_r10.c
index 3dc89135b24..a1338ca0f6b 100644
--- a/libgfortran/generated/minval_r10.c
+++ b/libgfortran/generated/minval_r10.c
@@ -100,7 +100,7 @@ minval_r10 (gfc_array_r10 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ sminval_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minval_r16.c b/libgfortran/generated/minval_r16.c
index 063fd6a5f5a..ac33d566436 100644
--- a/libgfortran/generated/minval_r16.c
+++ b/libgfortran/generated/minval_r16.c
@@ -100,7 +100,7 @@ minval_r16 (gfc_array_r16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ sminval_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minval_r4.c b/libgfortran/generated/minval_r4.c
index 9565f69e9aa..f2c5b78cd17 100644
--- a/libgfortran/generated/minval_r4.c
+++ b/libgfortran/generated/minval_r4.c
@@ -100,7 +100,7 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ sminval_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/minval_r8.c b/libgfortran/generated/minval_r8.c
index a0c021e3837..7ffa643b336 100644
--- a/libgfortran/generated/minval_r8.c
+++ b/libgfortran/generated/minval_r8.c
@@ -100,7 +100,7 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -299,7 +299,7 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -486,7 +486,7 @@ sminval_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/norm2_r10.c b/libgfortran/generated/norm2_r10.c
index 64ac3769bed..63755f1887c 100644
--- a/libgfortran/generated/norm2_r10.c
+++ b/libgfortran/generated/norm2_r10.c
@@ -104,7 +104,7 @@ norm2_r10 (gfc_array_r10 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
diff --git a/libgfortran/generated/norm2_r16.c b/libgfortran/generated/norm2_r16.c
index b1ac9b287c8..c6643124d1a 100644
--- a/libgfortran/generated/norm2_r16.c
+++ b/libgfortran/generated/norm2_r16.c
@@ -108,7 +108,7 @@ norm2_r16 (gfc_array_r16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
diff --git a/libgfortran/generated/norm2_r4.c b/libgfortran/generated/norm2_r4.c
index d856d7a235d..83c5d325580 100644
--- a/libgfortran/generated/norm2_r4.c
+++ b/libgfortran/generated/norm2_r4.c
@@ -104,7 +104,7 @@ norm2_r4 (gfc_array_r4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
diff --git a/libgfortran/generated/norm2_r8.c b/libgfortran/generated/norm2_r8.c
index 7199975ecea..f4f889d1819 100644
--- a/libgfortran/generated/norm2_r8.c
+++ b/libgfortran/generated/norm2_r8.c
@@ -104,7 +104,7 @@ norm2_r8 (gfc_array_r8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
diff --git a/libgfortran/generated/pack_c10.c b/libgfortran/generated/pack_c10.c
index 97c81af70af..31f676a2398 100644
--- a/libgfortran/generated/pack_c10.c
+++ b/libgfortran/generated/pack_c10.c
@@ -168,8 +168,8 @@ pack_c10 (gfc_array_c10 *ret, const gfc_array_c10 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_10) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_10) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_c16.c b/libgfortran/generated/pack_c16.c
index 831ecf10873..d859df2f94e 100644
--- a/libgfortran/generated/pack_c16.c
+++ b/libgfortran/generated/pack_c16.c
@@ -168,8 +168,8 @@ pack_c16 (gfc_array_c16 *ret, const gfc_array_c16 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_16) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_16) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_c4.c b/libgfortran/generated/pack_c4.c
index 8368bc51817..b238ccba1be 100644
--- a/libgfortran/generated/pack_c4.c
+++ b/libgfortran/generated/pack_c4.c
@@ -168,8 +168,8 @@ pack_c4 (gfc_array_c4 *ret, const gfc_array_c4 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_4) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_4) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_c8.c b/libgfortran/generated/pack_c8.c
index 41b1ca9515f..ec007d29b50 100644
--- a/libgfortran/generated/pack_c8.c
+++ b/libgfortran/generated/pack_c8.c
@@ -168,8 +168,8 @@ pack_c8 (gfc_array_c8 *ret, const gfc_array_c8 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_8) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_8) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_i1.c b/libgfortran/generated/pack_i1.c
index 5a8376be139..7d7be0ef637 100644
--- a/libgfortran/generated/pack_i1.c
+++ b/libgfortran/generated/pack_i1.c
@@ -168,8 +168,8 @@ pack_i1 (gfc_array_i1 *ret, const gfc_array_i1 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_1) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_INTEGER_1) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_i16.c b/libgfortran/generated/pack_i16.c
index e55961a853d..bd06a52a1e5 100644
--- a/libgfortran/generated/pack_i16.c
+++ b/libgfortran/generated/pack_i16.c
@@ -168,8 +168,8 @@ pack_i16 (gfc_array_i16 *ret, const gfc_array_i16 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_i2.c b/libgfortran/generated/pack_i2.c
index 56af5ce4861..a0dd79e7ec9 100644
--- a/libgfortran/generated/pack_i2.c
+++ b/libgfortran/generated/pack_i2.c
@@ -168,8 +168,8 @@ pack_i2 (gfc_array_i2 *ret, const gfc_array_i2 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_2) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_INTEGER_2) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_i4.c b/libgfortran/generated/pack_i4.c
index 3ef0e1a6347..b3ce4f60e78 100644
--- a/libgfortran/generated/pack_i4.c
+++ b/libgfortran/generated/pack_i4.c
@@ -168,8 +168,8 @@ pack_i4 (gfc_array_i4 *ret, const gfc_array_i4 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_i8.c b/libgfortran/generated/pack_i8.c
index 916faf09ca3..75c41cb69f7 100644
--- a/libgfortran/generated/pack_i8.c
+++ b/libgfortran/generated/pack_i8.c
@@ -168,8 +168,8 @@ pack_i8 (gfc_array_i8 *ret, const gfc_array_i8 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_r10.c b/libgfortran/generated/pack_r10.c
index 5d8da498c38..24de6394e7b 100644
--- a/libgfortran/generated/pack_r10.c
+++ b/libgfortran/generated/pack_r10.c
@@ -168,8 +168,8 @@ pack_r10 (gfc_array_r10 *ret, const gfc_array_r10 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_REAL_10) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_r16.c b/libgfortran/generated/pack_r16.c
index db8d2e028c2..34ac1301226 100644
--- a/libgfortran/generated/pack_r16.c
+++ b/libgfortran/generated/pack_r16.c
@@ -168,8 +168,8 @@ pack_r16 (gfc_array_r16 *ret, const gfc_array_r16 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_REAL_16) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_r4.c b/libgfortran/generated/pack_r4.c
index b0b4752e161..856c166e759 100644
--- a/libgfortran/generated/pack_r4.c
+++ b/libgfortran/generated/pack_r4.c
@@ -168,8 +168,8 @@ pack_r4 (gfc_array_r4 *ret, const gfc_array_r4 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_REAL_4) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/pack_r8.c b/libgfortran/generated/pack_r8.c
index 15e2d4fef54..781d112b455 100644
--- a/libgfortran/generated/pack_r8.c
+++ b/libgfortran/generated/pack_r8.c
@@ -168,8 +168,8 @@ pack_r8 (gfc_array_r8 *ret, const gfc_array_r8 *array,
 
 	  ret->offset = 0;
 
-	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * total);
+	  /* xmalloc allocates a single byte for zero size.  */
+	  ret->base_addr = xmalloc (sizeof (GFC_REAL_8) * total);
 
 	  if (total == 0)
 	    return;
diff --git a/libgfortran/generated/parity_l1.c b/libgfortran/generated/parity_l1.c
index abf5a827436..d34b652a98c 100644
--- a/libgfortran/generated/parity_l1.c
+++ b/libgfortran/generated/parity_l1.c
@@ -1,5 +1,5 @@
-/* Implementation of the NORM2 intrinsic
-   Copyright 2010 Free Software Foundation, Inc.
+/* Implementation of the PARITY intrinsic
+   Copyright 2010, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Burnus  <burnus@net-b.de>
 
 This file is part of the GNU Fortran runtime library (libgfortran).
@@ -101,7 +101,7 @@ parity_l1 (gfc_array_l1 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
diff --git a/libgfortran/generated/parity_l16.c b/libgfortran/generated/parity_l16.c
index 3004a5f894e..7652e1c397f 100644
--- a/libgfortran/generated/parity_l16.c
+++ b/libgfortran/generated/parity_l16.c
@@ -1,5 +1,5 @@
-/* Implementation of the NORM2 intrinsic
-   Copyright 2010 Free Software Foundation, Inc.
+/* Implementation of the PARITY intrinsic
+   Copyright 2010, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Burnus  <burnus@net-b.de>
 
 This file is part of the GNU Fortran runtime library (libgfortran).
@@ -101,7 +101,7 @@ parity_l16 (gfc_array_l16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
diff --git a/libgfortran/generated/parity_l2.c b/libgfortran/generated/parity_l2.c
index 14dacad9df6..db04eedd078 100644
--- a/libgfortran/generated/parity_l2.c
+++ b/libgfortran/generated/parity_l2.c
@@ -1,5 +1,5 @@
-/* Implementation of the NORM2 intrinsic
-   Copyright 2010 Free Software Foundation, Inc.
+/* Implementation of the PARITY intrinsic
+   Copyright 2010, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Burnus  <burnus@net-b.de>
 
 This file is part of the GNU Fortran runtime library (libgfortran).
@@ -101,7 +101,7 @@ parity_l2 (gfc_array_l2 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
diff --git a/libgfortran/generated/parity_l4.c b/libgfortran/generated/parity_l4.c
index e6ee81d491e..633649cf3f4 100644
--- a/libgfortran/generated/parity_l4.c
+++ b/libgfortran/generated/parity_l4.c
@@ -1,5 +1,5 @@
-/* Implementation of the NORM2 intrinsic
-   Copyright 2010 Free Software Foundation, Inc.
+/* Implementation of the PARITY intrinsic
+   Copyright 2010, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Burnus  <burnus@net-b.de>
 
 This file is part of the GNU Fortran runtime library (libgfortran).
@@ -101,7 +101,7 @@ parity_l4 (gfc_array_l4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
diff --git a/libgfortran/generated/parity_l8.c b/libgfortran/generated/parity_l8.c
index 28724feb241..5ceb71ec37a 100644
--- a/libgfortran/generated/parity_l8.c
+++ b/libgfortran/generated/parity_l8.c
@@ -1,5 +1,5 @@
-/* Implementation of the NORM2 intrinsic
-   Copyright 2010 Free Software Foundation, Inc.
+/* Implementation of the PARITY intrinsic
+   Copyright 2010, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Burnus  <burnus@net-b.de>
 
 This file is part of the GNU Fortran runtime library (libgfortran).
@@ -101,7 +101,7 @@ parity_l8 (gfc_array_l8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
diff --git a/libgfortran/generated/product_c10.c b/libgfortran/generated/product_c10.c
index d7017edf4b9..ddc43d70e0e 100644
--- a/libgfortran/generated/product_c10.c
+++ b/libgfortran/generated/product_c10.c
@@ -100,7 +100,7 @@ product_c10 (gfc_array_c10 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_c16.c b/libgfortran/generated/product_c16.c
index 3c87e114d8c..1998811b426 100644
--- a/libgfortran/generated/product_c16.c
+++ b/libgfortran/generated/product_c16.c
@@ -100,7 +100,7 @@ product_c16 (gfc_array_c16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_c4.c b/libgfortran/generated/product_c4.c
index 5b18a4b3308..8183e960cf9 100644
--- a/libgfortran/generated/product_c4.c
+++ b/libgfortran/generated/product_c4.c
@@ -100,7 +100,7 @@ product_c4 (gfc_array_c4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_c8.c b/libgfortran/generated/product_c8.c
index a488f8b619a..6b499b5b44b 100644
--- a/libgfortran/generated/product_c8.c
+++ b/libgfortran/generated/product_c8.c
@@ -100,7 +100,7 @@ product_c8 (gfc_array_c8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_i1.c b/libgfortran/generated/product_i1.c
index de58feb3bcc..3066d6bef44 100644
--- a/libgfortran/generated/product_i1.c
+++ b/libgfortran/generated/product_i1.c
@@ -100,7 +100,7 @@ product_i1 (gfc_array_i1 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_i16.c b/libgfortran/generated/product_i16.c
index ecee33fcd31..b05223c0ea4 100644
--- a/libgfortran/generated/product_i16.c
+++ b/libgfortran/generated/product_i16.c
@@ -100,7 +100,7 @@ product_i16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_i2.c b/libgfortran/generated/product_i2.c
index 17699230daa..939b0f89fdd 100644
--- a/libgfortran/generated/product_i2.c
+++ b/libgfortran/generated/product_i2.c
@@ -100,7 +100,7 @@ product_i2 (gfc_array_i2 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_i4.c b/libgfortran/generated/product_i4.c
index e0009726b54..2a9fac0c521 100644
--- a/libgfortran/generated/product_i4.c
+++ b/libgfortran/generated/product_i4.c
@@ -100,7 +100,7 @@ product_i4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_i8.c b/libgfortran/generated/product_i8.c
index 2730322cf55..e1912cc543d 100644
--- a/libgfortran/generated/product_i8.c
+++ b/libgfortran/generated/product_i8.c
@@ -100,7 +100,7 @@ product_i8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_r10.c b/libgfortran/generated/product_r10.c
index 48b7a76ed4b..e426bf1c39d 100644
--- a/libgfortran/generated/product_r10.c
+++ b/libgfortran/generated/product_r10.c
@@ -100,7 +100,7 @@ product_r10 (gfc_array_r10 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_r16.c b/libgfortran/generated/product_r16.c
index cbc15d39f01..3868434ace3 100644
--- a/libgfortran/generated/product_r16.c
+++ b/libgfortran/generated/product_r16.c
@@ -100,7 +100,7 @@ product_r16 (gfc_array_r16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_r4.c b/libgfortran/generated/product_r4.c
index 4770965ee51..91b0134dd0c 100644
--- a/libgfortran/generated/product_r4.c
+++ b/libgfortran/generated/product_r4.c
@@ -100,7 +100,7 @@ product_r4 (gfc_array_r4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/product_r8.c b/libgfortran/generated/product_r8.c
index af6a410b340..d4d395e13af 100644
--- a/libgfortran/generated/product_r8.c
+++ b/libgfortran/generated/product_r8.c
@@ -100,7 +100,7 @@ product_r8 (gfc_array_r8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/reshape_c10.c b/libgfortran/generated/reshape_c10.c
index b914c42e98d..bdc4a3f3802 100644
--- a/libgfortran/generated/reshape_c10.c
+++ b/libgfortran/generated/reshape_c10.c
@@ -115,7 +115,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/reshape_c16.c b/libgfortran/generated/reshape_c16.c
index 0d7a8774561..71b0e6d6064 100644
--- a/libgfortran/generated/reshape_c16.c
+++ b/libgfortran/generated/reshape_c16.c
@@ -115,7 +115,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/reshape_c4.c b/libgfortran/generated/reshape_c4.c
index 262e0b44ac0..3ed105b40fb 100644
--- a/libgfortran/generated/reshape_c4.c
+++ b/libgfortran/generated/reshape_c4.c
@@ -115,7 +115,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/reshape_c8.c b/libgfortran/generated/reshape_c8.c
index 923b2c913b3..9df5cd8953b 100644
--- a/libgfortran/generated/reshape_c8.c
+++ b/libgfortran/generated/reshape_c8.c
@@ -115,7 +115,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/reshape_i16.c b/libgfortran/generated/reshape_i16.c
index 3e41ded560c..77feef416e4 100644
--- a/libgfortran/generated/reshape_i16.c
+++ b/libgfortran/generated/reshape_i16.c
@@ -115,7 +115,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/reshape_i4.c b/libgfortran/generated/reshape_i4.c
index 7f704a4e103..68ae131f86c 100644
--- a/libgfortran/generated/reshape_i4.c
+++ b/libgfortran/generated/reshape_i4.c
@@ -115,7 +115,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/reshape_i8.c b/libgfortran/generated/reshape_i8.c
index 912d49f33e1..d90a7e3a20f 100644
--- a/libgfortran/generated/reshape_i8.c
+++ b/libgfortran/generated/reshape_i8.c
@@ -115,7 +115,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/reshape_r10.c b/libgfortran/generated/reshape_r10.c
index 26d8cfe8608..50e45914ab6 100644
--- a/libgfortran/generated/reshape_r10.c
+++ b/libgfortran/generated/reshape_r10.c
@@ -115,7 +115,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/reshape_r16.c b/libgfortran/generated/reshape_r16.c
index 33a41875e1a..63f50e75825 100644
--- a/libgfortran/generated/reshape_r16.c
+++ b/libgfortran/generated/reshape_r16.c
@@ -115,7 +115,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/reshape_r4.c b/libgfortran/generated/reshape_r4.c
index b83e91ca5e5..e89204d0f0d 100644
--- a/libgfortran/generated/reshape_r4.c
+++ b/libgfortran/generated/reshape_r4.c
@@ -115,7 +115,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/reshape_r8.c b/libgfortran/generated/reshape_r8.c
index c9091fed8ea..17568ea984f 100644
--- a/libgfortran/generated/reshape_r8.c
+++ b/libgfortran/generated/reshape_r8.c
@@ -115,7 +115,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
       else
         alloc_size = rs;
 
-      ret->base_addr = internal_malloc_size (alloc_size);
+      ret->base_addr = xmalloc (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
diff --git a/libgfortran/generated/shape_i16.c b/libgfortran/generated/shape_i16.c
index e1e8262f943..72086585e91 100644
--- a/libgfortran/generated/shape_i16.c
+++ b/libgfortran/generated/shape_i16.c
@@ -49,7 +49,7 @@ shape_16 (gfc_array_i16 * const restrict ret,
     {
       GFC_DIMENSION_SET(ret->dim[0], 0, rank, sizeof (GFC_INTEGER_16));
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      ret->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * rank);
     }
 
   stride = GFC_DESCRIPTOR_STRIDE_TYPEKNOWN(ret,0);
diff --git a/libgfortran/generated/shape_i4.c b/libgfortran/generated/shape_i4.c
index 621f4b2906d..0dd1901e7fa 100644
--- a/libgfortran/generated/shape_i4.c
+++ b/libgfortran/generated/shape_i4.c
@@ -49,7 +49,7 @@ shape_4 (gfc_array_i4 * const restrict ret,
     {
       GFC_DIMENSION_SET(ret->dim[0], 0, rank, sizeof (GFC_INTEGER_4));
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      ret->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * rank);
     }
 
   stride = GFC_DESCRIPTOR_STRIDE_TYPEKNOWN(ret,0);
diff --git a/libgfortran/generated/shape_i8.c b/libgfortran/generated/shape_i8.c
index 2833ebec9e2..929b1579c4a 100644
--- a/libgfortran/generated/shape_i8.c
+++ b/libgfortran/generated/shape_i8.c
@@ -49,7 +49,7 @@ shape_8 (gfc_array_i8 * const restrict ret,
     {
       GFC_DIMENSION_SET(ret->dim[0], 0, rank, sizeof (GFC_INTEGER_8));
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      ret->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * rank);
     }
 
   stride = GFC_DESCRIPTOR_STRIDE_TYPEKNOWN(ret,0);
diff --git a/libgfortran/generated/spread_c10.c b/libgfortran/generated/spread_c10.c
index 21823ecec16..b308a61f62a 100644
--- a/libgfortran/generated/spread_c10.c
+++ b/libgfortran/generated/spread_c10.c
@@ -101,8 +101,8 @@ spread_c10 (gfc_array_c10 *ret, const gfc_array_c10 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_10));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_COMPLEX_10));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_c10 (gfc_array_c10 *ret, const GFC_COMPLEX_10 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_10));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_COMPLEX_10));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_COMPLEX_10));
     }
diff --git a/libgfortran/generated/spread_c16.c b/libgfortran/generated/spread_c16.c
index 963108be3bb..d2ebb26f91d 100644
--- a/libgfortran/generated/spread_c16.c
+++ b/libgfortran/generated/spread_c16.c
@@ -101,8 +101,8 @@ spread_c16 (gfc_array_c16 *ret, const gfc_array_c16 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_16));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_COMPLEX_16));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_c16 (gfc_array_c16 *ret, const GFC_COMPLEX_16 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_16));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_COMPLEX_16));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_COMPLEX_16));
     }
diff --git a/libgfortran/generated/spread_c4.c b/libgfortran/generated/spread_c4.c
index fac99d5a252..c820f388405 100644
--- a/libgfortran/generated/spread_c4.c
+++ b/libgfortran/generated/spread_c4.c
@@ -101,8 +101,8 @@ spread_c4 (gfc_array_c4 *ret, const gfc_array_c4 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_4));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_COMPLEX_4));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_c4 (gfc_array_c4 *ret, const GFC_COMPLEX_4 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_4));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_COMPLEX_4));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_COMPLEX_4));
     }
diff --git a/libgfortran/generated/spread_c8.c b/libgfortran/generated/spread_c8.c
index 5516c8522b0..b8c016b137e 100644
--- a/libgfortran/generated/spread_c8.c
+++ b/libgfortran/generated/spread_c8.c
@@ -101,8 +101,8 @@ spread_c8 (gfc_array_c8 *ret, const gfc_array_c8 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_8));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_COMPLEX_8));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_c8 (gfc_array_c8 *ret, const GFC_COMPLEX_8 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_8));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_COMPLEX_8));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_COMPLEX_8));
     }
diff --git a/libgfortran/generated/spread_i1.c b/libgfortran/generated/spread_i1.c
index 816561ef05e..3c3a5e177af 100644
--- a/libgfortran/generated/spread_i1.c
+++ b/libgfortran/generated/spread_i1.c
@@ -101,8 +101,8 @@ spread_i1 (gfc_array_i1 *ret, const gfc_array_i1 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_1));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_INTEGER_1));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_i1 (gfc_array_i1 *ret, const GFC_INTEGER_1 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_1));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_INTEGER_1));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_INTEGER_1));
     }
diff --git a/libgfortran/generated/spread_i16.c b/libgfortran/generated/spread_i16.c
index b112f6621fb..5854f89db48 100644
--- a/libgfortran/generated/spread_i16.c
+++ b/libgfortran/generated/spread_i16.c
@@ -101,8 +101,8 @@ spread_i16 (gfc_array_i16 *ret, const gfc_array_i16 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_16));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_INTEGER_16));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_i16 (gfc_array_i16 *ret, const GFC_INTEGER_16 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_16));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_INTEGER_16));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_INTEGER_16));
     }
diff --git a/libgfortran/generated/spread_i2.c b/libgfortran/generated/spread_i2.c
index ea6dd4ec298..20ffa099b89 100644
--- a/libgfortran/generated/spread_i2.c
+++ b/libgfortran/generated/spread_i2.c
@@ -101,8 +101,8 @@ spread_i2 (gfc_array_i2 *ret, const gfc_array_i2 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_2));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_INTEGER_2));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_i2 (gfc_array_i2 *ret, const GFC_INTEGER_2 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_2));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_INTEGER_2));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_INTEGER_2));
     }
diff --git a/libgfortran/generated/spread_i4.c b/libgfortran/generated/spread_i4.c
index 13a08923430..8d5a5653dda 100644
--- a/libgfortran/generated/spread_i4.c
+++ b/libgfortran/generated/spread_i4.c
@@ -101,8 +101,8 @@ spread_i4 (gfc_array_i4 *ret, const gfc_array_i4 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_4));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_INTEGER_4));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_i4 (gfc_array_i4 *ret, const GFC_INTEGER_4 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_4));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_INTEGER_4));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_INTEGER_4));
     }
diff --git a/libgfortran/generated/spread_i8.c b/libgfortran/generated/spread_i8.c
index ec4748471e1..3e50db66ed6 100644
--- a/libgfortran/generated/spread_i8.c
+++ b/libgfortran/generated/spread_i8.c
@@ -101,8 +101,8 @@ spread_i8 (gfc_array_i8 *ret, const gfc_array_i8 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_8));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_INTEGER_8));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_i8 (gfc_array_i8 *ret, const GFC_INTEGER_8 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_8));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_INTEGER_8));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_INTEGER_8));
     }
diff --git a/libgfortran/generated/spread_r10.c b/libgfortran/generated/spread_r10.c
index 42cac657825..f924f004161 100644
--- a/libgfortran/generated/spread_r10.c
+++ b/libgfortran/generated/spread_r10.c
@@ -101,8 +101,8 @@ spread_r10 (gfc_array_r10 *ret, const gfc_array_r10 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_10));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_REAL_10));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_r10 (gfc_array_r10 *ret, const GFC_REAL_10 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_10));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_REAL_10));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_REAL_10));
     }
diff --git a/libgfortran/generated/spread_r16.c b/libgfortran/generated/spread_r16.c
index 6078e0b9791..439540cc3d1 100644
--- a/libgfortran/generated/spread_r16.c
+++ b/libgfortran/generated/spread_r16.c
@@ -101,8 +101,8 @@ spread_r16 (gfc_array_r16 *ret, const gfc_array_r16 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_16));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_REAL_16));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_r16 (gfc_array_r16 *ret, const GFC_REAL_16 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_16));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_REAL_16));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_REAL_16));
     }
diff --git a/libgfortran/generated/spread_r4.c b/libgfortran/generated/spread_r4.c
index d9b8a68de6c..b6ecf1d1a76 100644
--- a/libgfortran/generated/spread_r4.c
+++ b/libgfortran/generated/spread_r4.c
@@ -101,8 +101,8 @@ spread_r4 (gfc_array_r4 *ret, const gfc_array_r4 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_4));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_REAL_4));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_r4 (gfc_array_r4 *ret, const GFC_REAL_4 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_4));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_REAL_4));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_REAL_4));
     }
diff --git a/libgfortran/generated/spread_r8.c b/libgfortran/generated/spread_r8.c
index 6a2c896dfdc..3d38fd6b1cd 100644
--- a/libgfortran/generated/spread_r8.c
+++ b/libgfortran/generated/spread_r8.c
@@ -101,8 +101,8 @@ spread_r8 (gfc_array_r8 *ret, const gfc_array_r8 *source,
 	}
       ret->offset = 0;
 
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_8));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof(GFC_REAL_8));
       if (rs <= 0)
         return;
     }
@@ -244,7 +244,7 @@ spread_scalar_r8 (gfc_array_r8 *ret, const GFC_REAL_8 *source,
 
   if (ret->base_addr == NULL)
     {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_8));
+      ret->base_addr = xmalloc (ncopies * sizeof (GFC_REAL_8));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies, sizeof (GFC_REAL_8));
     }
diff --git a/libgfortran/generated/sum_c10.c b/libgfortran/generated/sum_c10.c
index 716f12d3e40..ce58249507f 100644
--- a/libgfortran/generated/sum_c10.c
+++ b/libgfortran/generated/sum_c10.c
@@ -100,7 +100,7 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_c10 (gfc_array_c10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_c16.c b/libgfortran/generated/sum_c16.c
index 6a1611ac7ab..ab77e4a485f 100644
--- a/libgfortran/generated/sum_c16.c
+++ b/libgfortran/generated/sum_c16.c
@@ -100,7 +100,7 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_c16 (gfc_array_c16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_c4.c b/libgfortran/generated/sum_c4.c
index b7f956f0c50..79a43b9d8ae 100644
--- a/libgfortran/generated/sum_c4.c
+++ b/libgfortran/generated/sum_c4.c
@@ -100,7 +100,7 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_c4 (gfc_array_c4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_c8.c b/libgfortran/generated/sum_c8.c
index 9b4692143fa..83aa8fb2345 100644
--- a/libgfortran/generated/sum_c8.c
+++ b/libgfortran/generated/sum_c8.c
@@ -100,7 +100,7 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_c8 (gfc_array_c8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_i1.c b/libgfortran/generated/sum_i1.c
index 33ae652b85d..97c132d188d 100644
--- a/libgfortran/generated/sum_i1.c
+++ b/libgfortran/generated/sum_i1.c
@@ -100,7 +100,7 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_i16.c b/libgfortran/generated/sum_i16.c
index eea7d338fcf..2ebc872791b 100644
--- a/libgfortran/generated/sum_i16.c
+++ b/libgfortran/generated/sum_i16.c
@@ -100,7 +100,7 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_i2.c b/libgfortran/generated/sum_i2.c
index 5ce76d0791b..e46cc4096aa 100644
--- a/libgfortran/generated/sum_i2.c
+++ b/libgfortran/generated/sum_i2.c
@@ -100,7 +100,7 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_i4.c b/libgfortran/generated/sum_i4.c
index 5e5c6809cc8..03227d31191 100644
--- a/libgfortran/generated/sum_i4.c
+++ b/libgfortran/generated/sum_i4.c
@@ -100,7 +100,7 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_i8.c b/libgfortran/generated/sum_i8.c
index 43d2b86259b..2d58028f653 100644
--- a/libgfortran/generated/sum_i8.c
+++ b/libgfortran/generated/sum_i8.c
@@ -100,7 +100,7 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_r10.c b/libgfortran/generated/sum_r10.c
index c3e3c9a73e0..afa96ff2cae 100644
--- a/libgfortran/generated/sum_r10.c
+++ b/libgfortran/generated/sum_r10.c
@@ -100,7 +100,7 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_r16.c b/libgfortran/generated/sum_r16.c
index ab8a9423695..d2da8bdb844 100644
--- a/libgfortran/generated/sum_r16.c
+++ b/libgfortran/generated/sum_r16.c
@@ -100,7 +100,7 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_r4.c b/libgfortran/generated/sum_r4.c
index ab2a8b9f351..52f1755ac38 100644
--- a/libgfortran/generated/sum_r4.c
+++ b/libgfortran/generated/sum_r4.c
@@ -100,7 +100,7 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/sum_r8.c b/libgfortran/generated/sum_r8.c
index 246263fb872..ba0c68078b8 100644
--- a/libgfortran/generated/sum_r8.c
+++ b/libgfortran/generated/sum_r8.c
@@ -100,7 +100,7 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
       alloc_size = GFC_DESCRIPTOR_SM (retarray, rank-1)
     		   * extent[rank-1];
 
-      retarray->base_addr = internal_malloc_size (alloc_size);
+      retarray->base_addr = xmalloc (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -285,7 +285,7 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
 
     }
   else
@@ -444,7 +444,7 @@ ssum_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->base_addr = internal_malloc_size (alloc_size);
+	retarray->base_addr = xmalloc (alloc_size);
     }
   else
     {
diff --git a/libgfortran/generated/transpose_c10.c b/libgfortran/generated/transpose_c10.c
index 8dd03b8a309..62cff522d39 100644
--- a/libgfortran/generated/transpose_c10.c
+++ b/libgfortran/generated/transpose_c10.c
@@ -60,7 +60,7 @@ transpose_c10 (gfc_array_c10 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_COMPLEX_10));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/transpose_c16.c b/libgfortran/generated/transpose_c16.c
index ea02cbcabdb..88acfa34127 100644
--- a/libgfortran/generated/transpose_c16.c
+++ b/libgfortran/generated/transpose_c16.c
@@ -60,7 +60,7 @@ transpose_c16 (gfc_array_c16 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_COMPLEX_16));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/transpose_c4.c b/libgfortran/generated/transpose_c4.c
index e6c40ee0694..e0aaf633727 100644
--- a/libgfortran/generated/transpose_c4.c
+++ b/libgfortran/generated/transpose_c4.c
@@ -60,7 +60,7 @@ transpose_c4 (gfc_array_c4 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_COMPLEX_4));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/transpose_c8.c b/libgfortran/generated/transpose_c8.c
index 00bdde06000..bac75e7e64d 100644
--- a/libgfortran/generated/transpose_c8.c
+++ b/libgfortran/generated/transpose_c8.c
@@ -60,7 +60,7 @@ transpose_c8 (gfc_array_c8 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_COMPLEX_8));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/transpose_i16.c b/libgfortran/generated/transpose_i16.c
index d90c8b137b4..58fa53f1830 100644
--- a/libgfortran/generated/transpose_i16.c
+++ b/libgfortran/generated/transpose_i16.c
@@ -60,7 +60,7 @@ transpose_i16 (gfc_array_i16 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_INTEGER_16));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_INTEGER_16) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/transpose_i4.c b/libgfortran/generated/transpose_i4.c
index c21a2cb4a10..e9022ba2113 100644
--- a/libgfortran/generated/transpose_i4.c
+++ b/libgfortran/generated/transpose_i4.c
@@ -60,7 +60,7 @@ transpose_i4 (gfc_array_i4 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_INTEGER_4));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_INTEGER_4) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/transpose_i8.c b/libgfortran/generated/transpose_i8.c
index 46ee2264d08..a1fba54e128 100644
--- a/libgfortran/generated/transpose_i8.c
+++ b/libgfortran/generated/transpose_i8.c
@@ -60,7 +60,7 @@ transpose_i8 (gfc_array_i8 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_INTEGER_8));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_INTEGER_8) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/transpose_r10.c b/libgfortran/generated/transpose_r10.c
index 14f084c367d..018992b1ebf 100644
--- a/libgfortran/generated/transpose_r10.c
+++ b/libgfortran/generated/transpose_r10.c
@@ -60,7 +60,7 @@ transpose_r10 (gfc_array_r10 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_REAL_10));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_10) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/transpose_r16.c b/libgfortran/generated/transpose_r16.c
index fffa7865892..9a3b61d3f5b 100644
--- a/libgfortran/generated/transpose_r16.c
+++ b/libgfortran/generated/transpose_r16.c
@@ -60,7 +60,7 @@ transpose_r16 (gfc_array_r16 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_REAL_16));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_16) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/transpose_r4.c b/libgfortran/generated/transpose_r4.c
index c85b56f9ad1..89dd354396d 100644
--- a/libgfortran/generated/transpose_r4.c
+++ b/libgfortran/generated/transpose_r4.c
@@ -60,7 +60,7 @@ transpose_r4 (gfc_array_r4 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_REAL_4));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_4) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/transpose_r8.c b/libgfortran/generated/transpose_r8.c
index cfd4b71b7ee..b456052d07e 100644
--- a/libgfortran/generated/transpose_r8.c
+++ b/libgfortran/generated/transpose_r8.c
@@ -60,7 +60,7 @@ transpose_r8 (gfc_array_r8 * const restrict ret,
       GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0),
 			GFC_DESCRIPTOR_EXTENT(source, 1)*sizeof (GFC_REAL_8));
 
-      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof (GFC_REAL_8) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
diff --git a/libgfortran/generated/unpack_c10.c b/libgfortran/generated/unpack_c10.c
index e4f8ecf131d..6f88f9dec6f 100644
--- a/libgfortran/generated/unpack_c10.c
+++ b/libgfortran/generated/unpack_c10.c
@@ -100,7 +100,7 @@ unpack0_c10 (gfc_array_c10 *ret, const gfc_array_c10 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_10));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_10));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_c10 (gfc_array_c10 *ret, const gfc_array_c10 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_10));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_10));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_c16.c b/libgfortran/generated/unpack_c16.c
index 9545b52fe0f..8d2c7df0708 100644
--- a/libgfortran/generated/unpack_c16.c
+++ b/libgfortran/generated/unpack_c16.c
@@ -100,7 +100,7 @@ unpack0_c16 (gfc_array_c16 *ret, const gfc_array_c16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_16));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_16));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_c16 (gfc_array_c16 *ret, const gfc_array_c16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_16));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_16));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_c4.c b/libgfortran/generated/unpack_c4.c
index 3ac6654452d..4ad1b49b17c 100644
--- a/libgfortran/generated/unpack_c4.c
+++ b/libgfortran/generated/unpack_c4.c
@@ -100,7 +100,7 @@ unpack0_c4 (gfc_array_c4 *ret, const gfc_array_c4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_4));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_4));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_c4 (gfc_array_c4 *ret, const gfc_array_c4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_4));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_4));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_c8.c b/libgfortran/generated/unpack_c8.c
index bb3e7dc1981..2afcc394b17 100644
--- a/libgfortran/generated/unpack_c8.c
+++ b/libgfortran/generated/unpack_c8.c
@@ -100,7 +100,7 @@ unpack0_c8 (gfc_array_c8 *ret, const gfc_array_c8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_8));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_8));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_c8 (gfc_array_c8 *ret, const gfc_array_c8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_8));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_COMPLEX_8));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_i1.c b/libgfortran/generated/unpack_i1.c
index 0f442fe3487..61bed8dbf7e 100644
--- a/libgfortran/generated/unpack_i1.c
+++ b/libgfortran/generated/unpack_i1.c
@@ -100,7 +100,7 @@ unpack0_i1 (gfc_array_i1 *ret, const gfc_array_i1 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_1));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_1));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_i1 (gfc_array_i1 *ret, const gfc_array_i1 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_1));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_1));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_i16.c b/libgfortran/generated/unpack_i16.c
index 8be7ee86c0c..874e069689d 100644
--- a/libgfortran/generated/unpack_i16.c
+++ b/libgfortran/generated/unpack_i16.c
@@ -100,7 +100,7 @@ unpack0_i16 (gfc_array_i16 *ret, const gfc_array_i16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_16));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_16));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_i16 (gfc_array_i16 *ret, const gfc_array_i16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_16));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_16));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_i2.c b/libgfortran/generated/unpack_i2.c
index 8308e1a5d85..593712a6b7f 100644
--- a/libgfortran/generated/unpack_i2.c
+++ b/libgfortran/generated/unpack_i2.c
@@ -100,7 +100,7 @@ unpack0_i2 (gfc_array_i2 *ret, const gfc_array_i2 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_2));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_2));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_i2 (gfc_array_i2 *ret, const gfc_array_i2 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_2));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_2));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_i4.c b/libgfortran/generated/unpack_i4.c
index 5035a818c60..a1c7678d13e 100644
--- a/libgfortran/generated/unpack_i4.c
+++ b/libgfortran/generated/unpack_i4.c
@@ -100,7 +100,7 @@ unpack0_i4 (gfc_array_i4 *ret, const gfc_array_i4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_4));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_4));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_i4 (gfc_array_i4 *ret, const gfc_array_i4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_4));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_4));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_i8.c b/libgfortran/generated/unpack_i8.c
index 30a25627d50..2d4310ba6d3 100644
--- a/libgfortran/generated/unpack_i8.c
+++ b/libgfortran/generated/unpack_i8.c
@@ -100,7 +100,7 @@ unpack0_i8 (gfc_array_i8 *ret, const gfc_array_i8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_8));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_8));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_i8 (gfc_array_i8 *ret, const gfc_array_i8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_8));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_INTEGER_8));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_r10.c b/libgfortran/generated/unpack_r10.c
index 83c9bfd39c7..c5ff9345a6b 100644
--- a/libgfortran/generated/unpack_r10.c
+++ b/libgfortran/generated/unpack_r10.c
@@ -100,7 +100,7 @@ unpack0_r10 (gfc_array_r10 *ret, const gfc_array_r10 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_10));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_10));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_r10 (gfc_array_r10 *ret, const gfc_array_r10 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_10));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_10));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_r16.c b/libgfortran/generated/unpack_r16.c
index 393dc008075..5ceda3316ea 100644
--- a/libgfortran/generated/unpack_r16.c
+++ b/libgfortran/generated/unpack_r16.c
@@ -100,7 +100,7 @@ unpack0_r16 (gfc_array_r16 *ret, const gfc_array_r16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_16));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_16));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_r16 (gfc_array_r16 *ret, const gfc_array_r16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_16));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_16));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_r4.c b/libgfortran/generated/unpack_r4.c
index 2e6266f7ce6..e583ac8b217 100644
--- a/libgfortran/generated/unpack_r4.c
+++ b/libgfortran/generated/unpack_r4.c
@@ -100,7 +100,7 @@ unpack0_r4 (gfc_array_r4 *ret, const gfc_array_r4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_4));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_4));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_r4 (gfc_array_r4 *ret, const gfc_array_r4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_4));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_4));
     }
   else
     {
diff --git a/libgfortran/generated/unpack_r8.c b/libgfortran/generated/unpack_r8.c
index 6c57aa55f0b..fe3ef75c00b 100644
--- a/libgfortran/generated/unpack_r8.c
+++ b/libgfortran/generated/unpack_r8.c
@@ -100,7 +100,7 @@ unpack0_r8 (gfc_array_r8 *ret, const gfc_array_r8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_8));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_8));
     }
   else
     {
@@ -246,7 +246,7 @@ unpack1_r8 (gfc_array_r8 *ret, const gfc_array_r8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_8));
+      ret->base_addr = xmalloc (rs * sizeof (GFC_REAL_8));
     }
   else
     {