Combined get_mem and internal_malloc_size.

2012-03-26  Janne Blomqvist  <jb@gcc.gnu.org>

	* runtime/memory.c (get_mem): Rename to xmalloc, check for zero
	size.
	(internal_malloc_size): Remove.
	* libgfortran.h (get_mem): Rename to xmalloc.
	(internal_malloc_size): Remove prototype.
	* Makefile.am (i_iall_c): Fix dependency.
	(i_iany_c): Likewise.
	(i_iparity_c): Likewise.
	(i_norm2_c): Likewise.
	(i_parity_c): Likewise.
	* Makefile.in: Regenerated.
	* m4/parity.m4: Fix typo in comment.
	* generated/all_l1.c: Regenerated.
	* generated/all_l16.c: Regenerated.
	* generated/all_l2.c: Regenerated.
	* generated/all_l4.c: Regenerated.
	* generated/all_l8.c: Regenerated.
	* generated/any_l1.c: Regenerated.
	* generated/any_l16.c: Regenerated.
	* generated/any_l2.c: Regenerated.
	* generated/any_l4.c: Regenerated.
	* generated/any_l8.c: Regenerated.
	* generated/bessel_r10.c: Regenerated.
	* generated/bessel_r16.c: Regenerated.
	* generated/bessel_r4.c: Regenerated.
	* generated/bessel_r8.c: Regenerated.
	* generated/count_16_l.c: Regenerated.
	* generated/count_1_l.c: Regenerated.
	* generated/count_2_l.c: Regenerated.
	* generated/count_4_l.c: Regenerated.
	* generated/count_8_l.c: Regenerated.
	* generated/cshift1_16.c: Regenerated.
	* generated/cshift1_4.c: Regenerated.
	* generated/cshift1_8.c: Regenerated.
	* generated/eoshift1_16.c: Regenerated.
	* generated/eoshift1_4.c: Regenerated.
	* generated/eoshift1_8.c: Regenerated.
	* generated/eoshift3_16.c: Regenerated.
	* generated/eoshift3_4.c: Regenerated.
	* generated/eoshift3_8.c: Regenerated.
	* generated/iall_i1.c: Regenerated.
	* generated/iall_i16.c: Regenerated.
	* generated/iall_i2.c: Regenerated.
	* generated/iall_i4.c: Regenerated.
	* generated/iall_i8.c: Regenerated.
	* generated/iany_i1.c: Regenerated.
	* generated/iany_i16.c: Regenerated.
	* generated/iany_i2.c: Regenerated.
	* generated/iany_i4.c: Regenerated.
	* generated/iany_i8.c: Regenerated.
	* generated/in_pack_c10.c: Regenerated.
	* generated/in_pack_c16.c: Regenerated.
	* generated/in_pack_c4.c: Regenerated.
	* generated/in_pack_c8.c: Regenerated.
	* generated/in_pack_i1.c: Regenerated.
	* generated/in_pack_i16.c: Regenerated.
	* generated/in_pack_i2.c: Regenerated.
	* generated/in_pack_i4.c: Regenerated.
	* generated/in_pack_i8.c: Regenerated.
	* generated/in_pack_r10.c: Regenerated.
	* generated/in_pack_r16.c: Regenerated.
	* generated/in_pack_r4.c: Regenerated.
	* generated/in_pack_r8.c: Regenerated.
	* generated/iparity_i1.c: Regenerated.
	* generated/iparity_i16.c: Regenerated.
	* generated/iparity_i2.c: Regenerated.
	* generated/iparity_i4.c: Regenerated.
	* generated/iparity_i8.c: Regenerated.
	* generated/matmul_c10.c: Regenerated.
	* generated/matmul_c16.c: Regenerated.
	* generated/matmul_c4.c: Regenerated.
	* generated/matmul_c8.c: Regenerated.
	* generated/matmul_i1.c: Regenerated.
	* generated/matmul_i16.c: Regenerated.
	* generated/matmul_i2.c: Regenerated.
	* generated/matmul_i4.c: Regenerated.
	* generated/matmul_i8.c: Regenerated.
	* generated/matmul_l16.c: Regenerated.
	* generated/matmul_l4.c: Regenerated.
	* generated/matmul_l8.c: Regenerated.
	* generated/matmul_r10.c: Regenerated.
	* generated/matmul_r16.c: Regenerated.
	* generated/matmul_r4.c: Regenerated.
	* generated/matmul_r8.c: Regenerated.
	* generated/maxloc0_16_i1.c: Regenerated.
	* generated/maxloc0_16_i16.c: Regenerated.
	* generated/maxloc0_16_i2.c: Regenerated.
	* generated/maxloc0_16_i4.c: Regenerated.
	* generated/maxloc0_16_i8.c: Regenerated.
	* generated/maxloc0_16_r10.c: Regenerated.
	* generated/maxloc0_16_r16.c: Regenerated.
	* generated/maxloc0_16_r4.c: Regenerated.
	* generated/maxloc0_16_r8.c: Regenerated.
	* generated/maxloc0_4_i1.c: Regenerated.
	* generated/maxloc0_4_i16.c: Regenerated.
	* generated/maxloc0_4_i2.c: Regenerated.
	* generated/maxloc0_4_i4.c: Regenerated.
	* generated/maxloc0_4_i8.c: Regenerated.
	* generated/maxloc0_4_r10.c: Regenerated.
	* generated/maxloc0_4_r16.c: Regenerated.
	* generated/maxloc0_4_r4.c: Regenerated.
	* generated/maxloc0_4_r8.c: Regenerated.
	* generated/maxloc0_8_i1.c: Regenerated.
	* generated/maxloc0_8_i16.c: Regenerated.
	* generated/maxloc0_8_i2.c: Regenerated.
	* generated/maxloc0_8_i4.c: Regenerated.
	* generated/maxloc0_8_i8.c: Regenerated.
	* generated/maxloc0_8_r10.c: Regenerated.
	* generated/maxloc0_8_r16.c: Regenerated.
	* generated/maxloc0_8_r4.c: Regenerated.
	* generated/maxloc0_8_r8.c: Regenerated.
	* generated/maxloc1_16_i1.c: Regenerated.
	* generated/maxloc1_16_i16.c: Regenerated.
	* generated/maxloc1_16_i2.c: Regenerated.
	* generated/maxloc1_16_i4.c: Regenerated.
	* generated/maxloc1_16_i8.c: Regenerated.
	* generated/maxloc1_16_r10.c: Regenerated.
	* generated/maxloc1_16_r16.c: Regenerated.
	* generated/maxloc1_16_r4.c: Regenerated.
	* generated/maxloc1_16_r8.c: Regenerated.
	* generated/maxloc1_4_i1.c: Regenerated.
	* generated/maxloc1_4_i16.c: Regenerated.
	* generated/maxloc1_4_i2.c: Regenerated.
	* generated/maxloc1_4_i4.c: Regenerated.
	* generated/maxloc1_4_i8.c: Regenerated.
	* generated/maxloc1_4_r10.c: Regenerated.
	* generated/maxloc1_4_r16.c: Regenerated.
	* generated/maxloc1_4_r4.c: Regenerated.
	* generated/maxloc1_4_r8.c: Regenerated.
	* generated/maxloc1_8_i1.c: Regenerated.
	* generated/maxloc1_8_i16.c: Regenerated.
	* generated/maxloc1_8_i2.c: Regenerated.
	* generated/maxloc1_8_i4.c: Regenerated.
	* generated/maxloc1_8_i8.c: Regenerated.
	* generated/maxloc1_8_r10.c: Regenerated.
	* generated/maxloc1_8_r16.c: Regenerated.
	* generated/maxloc1_8_r4.c: Regenerated.
	* generated/maxloc1_8_r8.c: Regenerated.
	* generated/maxval_i1.c: Regenerated.
	* generated/maxval_i16.c: Regenerated.
	* generated/maxval_i2.c: Regenerated.
	* generated/maxval_i4.c: Regenerated.
	* generated/maxval_i8.c: Regenerated.
	* generated/maxval_r10.c: Regenerated.
	* generated/maxval_r16.c: Regenerated.
	* generated/maxval_r4.c: Regenerated.
	* generated/maxval_r8.c: Regenerated.
	* generated/minloc0_16_i1.c: Regenerated.
	* generated/minloc0_16_i16.c: Regenerated.
	* generated/minloc0_16_i2.c: Regenerated.
	* generated/minloc0_16_i4.c: Regenerated.
	* generated/minloc0_16_i8.c: Regenerated.
	* generated/minloc0_16_r10.c: Regenerated.
	* generated/minloc0_16_r16.c: Regenerated.
	* generated/minloc0_16_r4.c: Regenerated.
	* generated/minloc0_16_r8.c: Regenerated.
	* generated/minloc0_4_i1.c: Regenerated.
	* generated/minloc0_4_i16.c: Regenerated.
	* generated/minloc0_4_i2.c: Regenerated.
	* generated/minloc0_4_i4.c: Regenerated.
	* generated/minloc0_4_i8.c: Regenerated.
	* generated/minloc0_4_r10.c: Regenerated.
	* generated/minloc0_4_r16.c: Regenerated.
	* generated/minloc0_4_r4.c: Regenerated.
	* generated/minloc0_4_r8.c: Regenerated.
	* generated/minloc0_8_i1.c: Regenerated.
	* generated/minloc0_8_i16.c: Regenerated.
	* generated/minloc0_8_i2.c: Regenerated.
	* generated/minloc0_8_i4.c: Regenerated.
	* generated/minloc0_8_i8.c: Regenerated.
	* generated/minloc0_8_r10.c: Regenerated.
	* generated/minloc0_8_r16.c: Regenerated.
	* generated/minloc0_8_r4.c: Regenerated.
	* generated/minloc0_8_r8.c: Regenerated.
	* generated/minloc1_16_i1.c: Regenerated.
	* generated/minloc1_16_i16.c: Regenerated.
	* generated/minloc1_16_i2.c: Regenerated.
	* generated/minloc1_16_i4.c: Regenerated.
	* generated/minloc1_16_i8.c: Regenerated.
	* generated/minloc1_16_r10.c: Regenerated.
	* generated/minloc1_16_r16.c: Regenerated.
	* generated/minloc1_16_r4.c: Regenerated.
	* generated/minloc1_16_r8.c: Regenerated.
	* generated/minloc1_4_i1.c: Regenerated.
	* generated/minloc1_4_i16.c: Regenerated.
	* generated/minloc1_4_i2.c: Regenerated.
	* generated/minloc1_4_i4.c: Regenerated.
	* generated/minloc1_4_i8.c: Regenerated.
	* generated/minloc1_4_r10.c: Regenerated.
	* generated/minloc1_4_r16.c: Regenerated.
	* generated/minloc1_4_r4.c: Regenerated.
	* generated/minloc1_4_r8.c: Regenerated.
	* generated/minloc1_8_i1.c: Regenerated.
	* generated/minloc1_8_i16.c: Regenerated.
	* generated/minloc1_8_i2.c: Regenerated.
	* generated/minloc1_8_i4.c: Regenerated.
	* generated/minloc1_8_i8.c: Regenerated.
	* generated/minloc1_8_r10.c: Regenerated.
	* generated/minloc1_8_r16.c: Regenerated.
	* generated/minloc1_8_r4.c: Regenerated.
	* generated/minloc1_8_r8.c: Regenerated.
	* generated/minval_i1.c: Regenerated.
	* generated/minval_i16.c: Regenerated.
	* generated/minval_i2.c: Regenerated.
	* generated/minval_i4.c: Regenerated.
	* generated/minval_i8.c: Regenerated.
	* generated/minval_r10.c: Regenerated.
	* generated/minval_r16.c: Regenerated.
	* generated/minval_r4.c: Regenerated.
	* generated/minval_r8.c: Regenerated.
	* generated/norm2_r10.c: Regenerated.
	* generated/norm2_r16.c: Regenerated.
	* generated/norm2_r4.c: Regenerated.
	* generated/norm2_r8.c: Regenerated.
	* generated/pack_c10.c: Regenerated.
	* generated/pack_c16.c: Regenerated.
	* generated/pack_c4.c: Regenerated.
	* generated/pack_c8.c: Regenerated.
	* generated/pack_i1.c: Regenerated.
	* generated/pack_i16.c: Regenerated.
	* generated/pack_i2.c: Regenerated.
	* generated/pack_i4.c: Regenerated.
	* generated/pack_i8.c: Regenerated.
	* generated/pack_r10.c: Regenerated.
	* generated/pack_r16.c: Regenerated.
	* generated/pack_r4.c: Regenerated.
	* generated/pack_r8.c: Regenerated.
	* generated/parity_l1.c: Regenerated.
	* generated/parity_l16.c: Regenerated.
	* generated/parity_l2.c: Regenerated.
	* generated/parity_l4.c: Regenerated.
	* generated/parity_l8.c: Regenerated.
	* generated/product_c10.c: Regenerated.
	* generated/product_c16.c: Regenerated.
	* generated/product_c4.c: Regenerated.
	* generated/product_c8.c: Regenerated.
	* generated/product_i1.c: Regenerated.
	* generated/product_i16.c: Regenerated.
	* generated/product_i2.c: Regenerated.
	* generated/product_i4.c: Regenerated.
	* generated/product_i8.c: Regenerated.
	* generated/product_r10.c: Regenerated.
	* generated/product_r16.c: Regenerated.
	* generated/product_r4.c: Regenerated.
	* generated/product_r8.c: Regenerated.
	* generated/reshape_c10.c: Regenerated.
	* generated/reshape_c16.c: Regenerated.
	* generated/reshape_c4.c: Regenerated.
	* generated/reshape_c8.c: Regenerated.
	* generated/reshape_i16.c: Regenerated.
	* generated/reshape_i4.c: Regenerated.
	* generated/reshape_i8.c: Regenerated.
	* generated/reshape_r10.c: Regenerated.
	* generated/reshape_r16.c: Regenerated.
	* generated/reshape_r4.c: Regenerated.
	* generated/reshape_r8.c: Regenerated.
	* generated/shape_i16.c: Regenerated.
	* generated/shape_i4.c: Regenerated.
	* generated/shape_i8.c: Regenerated.
	* generated/spread_c10.c: Regenerated.
	* generated/spread_c16.c: Regenerated.
	* generated/spread_c4.c: Regenerated.
	* generated/spread_c8.c: Regenerated.
	* generated/spread_i1.c: Regenerated.
	* generated/spread_i16.c: Regenerated.
	* generated/spread_i2.c: Regenerated.
	* generated/spread_i4.c: Regenerated.
	* generated/spread_i8.c: Regenerated.
	* generated/spread_r10.c: Regenerated.
	* generated/spread_r16.c: Regenerated.
	* generated/spread_r4.c: Regenerated.
	* generated/spread_r8.c: Regenerated.
	* generated/sum_c10.c: Regenerated.
	* generated/sum_c16.c: Regenerated.
	* generated/sum_c4.c: Regenerated.
	* generated/sum_c8.c: Regenerated.
	* generated/sum_i1.c: Regenerated.
	* generated/sum_i16.c: Regenerated.
	* generated/sum_i2.c: Regenerated.
	* generated/sum_i4.c: Regenerated.
	* generated/sum_i8.c: Regenerated.
	* generated/sum_r10.c: Regenerated.
	* generated/sum_r16.c: Regenerated.
	* generated/sum_r4.c: Regenerated.
	* generated/sum_r8.c: Regenerated.
	* generated/transpose_c10.c: Regenerated.
	* generated/transpose_c16.c: Regenerated.
	* generated/transpose_c4.c: Regenerated.
	* generated/transpose_c8.c: Regenerated.
	* generated/transpose_i16.c: Regenerated.
	* generated/transpose_i4.c: Regenerated.
	* generated/transpose_i8.c: Regenerated.
	* generated/transpose_r10.c: Regenerated.
	* generated/transpose_r16.c: Regenerated.
	* generated/transpose_r4.c: Regenerated.
	* generated/transpose_r8.c: Regenerated.
	* generated/unpack_c10.c: Regenerated.
	* generated/unpack_c16.c: Regenerated.
	* generated/unpack_c4.c: Regenerated.
	* generated/unpack_c8.c: Regenerated.
	* generated/unpack_i1.c: Regenerated.
	* generated/unpack_i16.c: Regenerated.
	* generated/unpack_i2.c: Regenerated.
	* generated/unpack_i4.c: Regenerated.
	* generated/unpack_i8.c: Regenerated.
	* generated/unpack_r10.c: Regenerated.
	* generated/unpack_r16.c: Regenerated.
	* generated/unpack_r4.c: Regenerated.
	* generated/unpack_r8.c: Regenerated.
	* intrinsics/cshift0.c: Use xmalloc.
	* intrinsics/ctime.c: Likewise.
	* intrinsics/date_and_time.c: Likewise.
	* intrinsics/eoshift0.c: Likewise.
	* intrinsics/eoshift2.c: Likewise.
	* intrinsics/getlog.c: Likewise.
	* intrinsics/pack_generic.c: Likewise.
	* intrinsics/reshape_generic.c: Likewise.
	* intrinsics/spread_generic.c: Likewise.
	* intrinsics/string_intrinsics_inc.c: Likewise.
	* intrinsics/transpose_generic.c: Likewise.
	* intrinsics/unpack_generic.c: Likewise.
	* io/fbuf.c: Likewise.
	* io/format.c: Likewise.
	* io/intrinsics.c: Likewise.
	* io/list_read.c: Likewise.
	* io/open.c: Likewise.
	* io/transfer.c: Likewise.
	* io/unit.c: Likewise.
	* io/unix.c: Likewise.
	* io/write.c: Likewise.
	* m4/bessel.m4: Likewise.
	* m4/cshift1.m4: Likewise.
	* m4/eoshift1.m4: Likewise.
	* m4/eoshift3.m4: Likewise.
	* m4/iforeach.m4: Likewise.
	* m4/ifunction.m4: Likewise.
	* m4/ifunction_logical.m4: Likewise.
	* m4/in_pack.m4: Likewise.
	* m4/matmul.m4: Likewise.
	* m4/matmull.m4: Likewise.
	* m4/pack.m4: Likewise.
	* m4/reshape.m4: Likewise.
	* m4/shape.m4: Likewise.
	* m4/spread.m4: Likewise.
	* m4/transpose.m4: Likewise.
	* m4/unpack.m4: Likewise.
	* runtime/convert_char.c: Likewise.
	* runtime/environ.c: Likewise.
	* runtime/in_pack_generic.c: Likewise.



git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@185806 138bc75d-0d04-0410-961f-82ee72b054a4

297 files changed, 706 insertions, 706 deletions

diff --git a/libgfortran/generated/all_l1.c b/libgfortran/generated/all_l1.c
index 541e7258516..81020f7b331 100644
--- a/libgfortran/generated/all_l1.c
+++ b/libgfortran/generated/all_l1.c
@@ -111,7 +111,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 8162ac1596e..520de21e7d7 100644
--- a/libgfortran/generated/all_l16.c
+++ b/libgfortran/generated/all_l16.c
@@ -111,7 +111,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 0e98cf64acb..8e5170807c6 100644
--- a/libgfortran/generated/all_l2.c
+++ b/libgfortran/generated/all_l2.c
@@ -111,7 +111,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 857175159a4..f78987c70f3 100644
--- a/libgfortran/generated/all_l4.c
+++ b/libgfortran/generated/all_l4.c
@@ -111,7 +111,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 9b9d16a8844..57becda58c3 100644
--- a/libgfortran/generated/all_l8.c
+++ b/libgfortran/generated/all_l8.c
@@ -111,7 +111,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 e8b9cab99e8..eca125fb256 100644
--- a/libgfortran/generated/any_l1.c
+++ b/libgfortran/generated/any_l1.c
@@ -111,7 +111,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 c6055886b41..2c65db6b7a5 100644
--- a/libgfortran/generated/any_l16.c
+++ b/libgfortran/generated/any_l16.c
@@ -111,7 +111,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 6c4afeea01b..64ed5bb6499 100644
--- a/libgfortran/generated/any_l2.c
+++ b/libgfortran/generated/any_l2.c
@@ -111,7 +111,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 b2c4cde3c3d..4cad8c88a5c 100644
--- a/libgfortran/generated/any_l4.c
+++ b/libgfortran/generated/any_l4.c
@@ -111,7 +111,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 86fd28c1462..55ffaf1e162 100644
--- a/libgfortran/generated/any_l8.c
+++ b/libgfortran/generated/any_l8.c
@@ -111,7 +111,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 7d11614b039..6a3a139fdb7 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-1, 1);
-      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-1, 1);
-      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 ae23dbced72..c1aa5e25570 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-1, 1);
-      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-1, 1);
-      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 d3b05907082..0f7c4cc4233 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-1, 1);
-      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-1, 1);
-      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 b48c04bfcc3..cc61300057a 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-1, 1);
-      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-1, 1);
-      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 652244004fe..ad5af4fb5a6 100644
--- a/libgfortran/generated/count_16_l.c
+++ b/libgfortran/generated/count_16_l.c
@@ -111,7 +111,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 5b7776eb9b3..92ef8191dcb 100644
--- a/libgfortran/generated/count_1_l.c
+++ b/libgfortran/generated/count_1_l.c
@@ -111,7 +111,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 8a104d1bdfc..503a07d4cef 100644
--- a/libgfortran/generated/count_2_l.c
+++ b/libgfortran/generated/count_2_l.c
@@ -111,7 +111,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 0edca41c492..380c0058e11 100644
--- a/libgfortran/generated/count_4_l.c
+++ b/libgfortran/generated/count_4_l.c
@@ -111,7 +111,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 e3d95dca825..16c7cf3aa0e 100644
--- a/libgfortran/generated/count_8_l.c
+++ b/libgfortran/generated/count_8_l.c
@@ -111,7 +111,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/cshift1_16.c b/libgfortran/generated/cshift1_16.c
index 41cc1ea81f5..22d1b29d0fa 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 9652222bda0..a0f3ab60050 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 8ccd63b5208..ceb74091a89 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 2de9208cf9d..e3096288b0e 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, ub, str);
 
         }
-      /* 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 8a9f1aaafbf..451a6af1d65 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, ub, str);
 
         }
-      /* 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 136f5464c17..1f056b36b98 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, ub, str);
 
         }
-      /* 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 d363d90ae0c..5384a720de7 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, ub, str);
 
         }
-      /* 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 1b623c28f51..6618516818a 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, ub, str);
 
         }
-      /* 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 2af1ccb9cf5..a90d87fcabf 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, ub, str);
 
         }
-      /* 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 d60f7f358ba..dbe0fa74d70 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 = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 88be6a8bad8..02e61fdc4a6 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 14fa83b1c60..e9c181c5309 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 = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 ce5e185d690..8cd3b3e9acf 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 fee269a8cfe..8e2bb1ad46d 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 f1b0aebe936..52b6f923fec 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 = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 511e36989e4..9194aa57315 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 b52f5512cef..dcad9910490 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 = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 a0949e17ec9..46a5d83062e 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 e365f5f97b0..f0a2e904dd9 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 1d6b0db637b..2279690764c 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 a627094ee43..bc40163591c 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 833d7e8d515..532c2deb48f 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 d86ce9f1b67..b8e9ee4333d 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 2b582a5df6f..d4449bb6904 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 294e3ca47ff..9a6b5e8b162 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 6a95af3b516..fb87ea716ef 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 4a5a8637172..44b339769f9 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 cb7e785f060..f0d6dd13e23 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 b479001562f..417fc4d9637 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 f16fd2fea66..d815b2f6a8a 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 e5b09a70f1b..f8d99900de3 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 12670d27724..be13b82ad14 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 5fcb29d1af7..00eb4bcac9f 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 = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 aef94588875..6caad71db79 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 22f95e360dd..c44f908035a 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 = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 58b18b86a0e..a7f76c8268d 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 78de1c429e2..e93389df0fe 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 3496a83eea0..ffd3be62f97 100644
--- a/libgfortran/generated/matmul_c10.c
+++ b/libgfortran/generated/matmul_c10.c
@@ -124,7 +124,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 0140dd311cd..98799f52271 100644
--- a/libgfortran/generated/matmul_c16.c
+++ b/libgfortran/generated/matmul_c16.c
@@ -124,7 +124,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 fd8ce9f1794..d5855db3060 100644
--- a/libgfortran/generated/matmul_c4.c
+++ b/libgfortran/generated/matmul_c4.c
@@ -124,7 +124,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 e71b5fb58ad..97b63474eda 100644
--- a/libgfortran/generated/matmul_c8.c
+++ b/libgfortran/generated/matmul_c8.c
@@ -124,7 +124,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 7525ea77ab3..61ddd9882f7 100644
--- a/libgfortran/generated/matmul_i1.c
+++ b/libgfortran/generated/matmul_i1.c
@@ -124,7 +124,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 19b6995a3fb..01d1b85638f 100644
--- a/libgfortran/generated/matmul_i16.c
+++ b/libgfortran/generated/matmul_i16.c
@@ -124,7 +124,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 73935067a16..2b6b99b7355 100644
--- a/libgfortran/generated/matmul_i2.c
+++ b/libgfortran/generated/matmul_i2.c
@@ -124,7 +124,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 2e9e016816a..536c773efdc 100644
--- a/libgfortran/generated/matmul_i4.c
+++ b/libgfortran/generated/matmul_i4.c
@@ -124,7 +124,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 6c6c655625a..777c991ad68 100644
--- a/libgfortran/generated/matmul_i8.c
+++ b/libgfortran/generated/matmul_i8.c
@@ -124,7 +124,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 1ae8f7a9cb6..ffb6d4c1865 100644
--- a/libgfortran/generated/matmul_l16.c
+++ b/libgfortran/generated/matmul_l16.c
@@ -88,7 +88,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 dfe3369c0a7..e73ff6910ae 100644
--- a/libgfortran/generated/matmul_l4.c
+++ b/libgfortran/generated/matmul_l4.c
@@ -88,7 +88,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 258a953d023..ba18cbacf4b 100644
--- a/libgfortran/generated/matmul_l8.c
+++ b/libgfortran/generated/matmul_l8.c
@@ -88,7 +88,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 79a57712951..dbe49eafcf1 100644
--- a/libgfortran/generated/matmul_r10.c
+++ b/libgfortran/generated/matmul_r10.c
@@ -124,7 +124,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 87bc587acee..6798c7bf451 100644
--- a/libgfortran/generated/matmul_r16.c
+++ b/libgfortran/generated/matmul_r16.c
@@ -124,7 +124,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 4f72b6a4c80..606c2255470 100644
--- a/libgfortran/generated/matmul_r4.c
+++ b/libgfortran/generated/matmul_r4.c
@@ -124,7 +124,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 422a1f03ea3..4733912d245 100644
--- a/libgfortran/generated/matmul_r8.c
+++ b/libgfortran/generated/matmul_r8.c
@@ -124,7 +124,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 fbac3ad12ff..0de65a885c5 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 e15ebf26e53..be8c469f9ed 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 90b2b3a8ff7..9852dcc92c6 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 dc75d83e78c..0f2973b0731 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 43879c7ddcd..fd79bf057ce 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 3e3bcb5ffdd..beb0fb37f3e 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 cec39633b65..52790c70808 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 985dcd6bdf6..eefb8a280f1 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 7f385d713f6..f536ac8bbed 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 6d7cf6188b9..31506d41be8 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 0d8bf75667f..e7728753a09 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 b0c05c80a2d..cc5a57afc43 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 9be70991764..2d407ef265c 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 cb337239b2c..3d359961234 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 48abb630b9c..200257a6448 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 3fae48df1be..f878e67d787 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 d2a985d0a27..923ee4bf1d8 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 6f57fca5aea..77f97dbca09 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 07815cf5518..4a51134b91a 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 dc5c57503e0..a9783e8ab6e 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 f01ec69905e..9e329fae5b3 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 13f32e02820..6aea6bb5816 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 066cedf6121..1e5b1687b5c 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 f34984dcd49..0bb567405ba 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 e28ba0fe89f..e80946ef8b0 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 d6594ab3004..5ac8b423728 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 2a9b7546da9..f510bdd1594 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 2621fafe625..e2eb8e0a7b0 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 51758850181..9b3563f9677 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 a8067821b12..0278e99dc8b 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 85dd48c7c5c..9751c2afec2 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 d6a96ec4bf7..e9140e5f868 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 551d207212b..f88d254b295 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 d44ecd44fce..b1188a2c795 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 ffd484ca678..70611027985 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 d03ba72a2c4..5d4d9c27c9f 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 4c528f27d5b..0ee6ed54898 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 5c0a8017f78..c79f0ca0717 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 3d35b0c46c4..4eff28acb14 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 ec2f43422dc..7c8f5e6e534 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 0bee414b681..ae63e1b1b38 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 cfb16f96716..afd935b39ab 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 4bf9b8c0378..fdd48172234 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 c3721d9e51a..8360dfcdbca 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 a756665a53a..96f36511dc0 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 59be8b71f12..a5911718942 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 107426e96c7..30b946ae36b 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 21a8dceaab8..af32584ccf8 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 2c7d860bc62..dc63f1e71a2 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 0638ab03332..c50965edae4 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 acc5689a0f6..c088686b564 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 1cd2a45c459..35f68071ca3 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 177f06e4d97..5d84bd077e0 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 35739aa8159..e1e80d3298d 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 7a4a58e711b..a94eecae000 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 = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 fe42c27a6e8..94059cb1a02 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 19b233d80ec..eb3d767e31a 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 = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 d4ef8ed2c6a..ef9e6c91826 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 814357d4577..a6cd6829a3f 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 736cced85a6..1be75f1fe2f 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 = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 37ae298a6b9..059896daf6b 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 = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 0cd73194763..f306f181f52 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 = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 f8ac97d08f2..ca70ca5a9e5 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 = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 617588528d3..4b7b1197333 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 d938dd7b90d..cd056c73c8f 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 8f0528e8cc3..157018f6d71 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 cf57b7936d8..ef0fc0868a5 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 23c72931570..0742e9a553c 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 52c0ab74c90..8bd602af3dc 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 e35ad66d4be..93bb9755a88 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 37e877b8c1e..ab679736997 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 dbd7ad37b11..bfa623df1ca 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 fa9dcf59416..23f0f490034 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 5a8e4401a63..abeb209ac53 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 d3ce2ede032..9ebf23a8d94 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 dc2d60692a4..bd813f28c8e 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 98da2decf92..b42c8bc4c95 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 8302d23518d..21a0ccff0cf 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 d8617ff9483..dcee2c2fa0d 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 2cdbc7dafca..2e60f8bad27 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 f8ef3a55c11..6da89bfbeee 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 0d6b52194fe..8291e87b6f0 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 37d6561a8d2..5306cd528bd 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 3418ceee2f6..5a9b40a8dc5 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 c36785e67f5..629b0b77dbc 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 817f1c17ee8..ccd445edc77 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 d5a68eae635..090bdff69ab 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 c2235b8f3b2..26744c8ca5e 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 05230f516b3..f1c829aafe9 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 0ec3067f4bc..fe122a1a6a4 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-1, 1);
       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 - 1, 1);
       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-1, 1);
       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 7b5ae81ff96..949fa434c1e 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 c08cb66e238..b5a16818365 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 3e89ba7cf28..887907995d7 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 1097c3b1131..6a5553fd405 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 326b9cfd799..04be9c60b95 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 7bf30bd4d1e..a66feda39d5 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 bc65a036f59..2e75ecf46d2 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 baa2bc42dae..b8e9337e8e2 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 482391dfb02..42519eb3380 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 73c1a235c43..07f0dceb55e 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 442f518c521..0c2041115d5 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 f235b0931be..389b1dbddfd 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 e0a54f2f8b1..5d66fe9afcb 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 2d2882954d7..28cd536fa4a 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 08947086bd5..39196711e32 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 082d4097e32..f7966123128 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 60c8f731a33..7f34b913813 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 267bdae4045..21bb4cbcc77 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 17fc399b0c5..81d6f8e42e1 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 350d762fc2a..0a41d170062 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 22b10b8828b..b0dac3e0404 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 f01ef6dc370..c8b42cac5e2 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 91cbc7e6a26..186fe5ceacf 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 b04ebfcbd09..582f88e1034 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 02f9b477f4f..0471c2750fb 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 bd7fb36ee6f..b144115c0bc 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 cd300bbe218..81916e2890a 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -500,7 +500,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 ed9fb22ae34..e2abc9587f0 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 = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 7f11f411230..f2c72e3e9de 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 18663d7664d..b87a0722744 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 = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 f6d48035069..20766fa62b1 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 2fdf455b02b..73e3d9bba8f 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 590a4dba8d3..72134fe7013 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 = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 ca30114a585..47c703ccc85 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 = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 8ec3c7c24a0..58c8854a537 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 = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 d03f5135339..c8426bd905a 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 = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -487,7 +487,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 d3e8c7a9306..19356fdeea0 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 = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(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 dc5aeac43ce..fda5a205559 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 = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(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 8c7fae09025..a4cfba45bb4 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 = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(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 9dcd8cfa6f9..9031b7a4699 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 = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(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 577c68a4476..9c3b0a20d22 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 121b0a86b47..84340e0ea65 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 c9ad6e80e2f..3ba1e4b5001 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 d1a6941a940..11a8e44f093 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 2aa75c19deb..05b8ae5e35c 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 451c8da6c95..8ce8125eca9 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 9b68c5207f5..fc24cc61333 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 36d1eb149e1..13d343d93b7 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 8f75038efb0..e79a43892a1 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 b8b81359030..38cce4c4085 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 932e190aeba..c6576d5a20e 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 a57daba216b..29e6d4bbd15 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 9516551b443..0de8a970bc0 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 84b1e9676d0..d14b0539e22 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 = sizeof (GFC_LOGICAL_1) * GFC_DESCRIPTOR_STRIDE(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 184fdf0f8ed..1f5e1684c87 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 = sizeof (GFC_LOGICAL_16) * GFC_DESCRIPTOR_STRIDE(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 5906c2a8c95..f72b4597fb7 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 = sizeof (GFC_LOGICAL_2) * GFC_DESCRIPTOR_STRIDE(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 b9f183a5b16..c498225952d 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 = sizeof (GFC_LOGICAL_4) * GFC_DESCRIPTOR_STRIDE(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 651350b62e0..95091012254 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 = sizeof (GFC_LOGICAL_8) * GFC_DESCRIPTOR_STRIDE(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 349ab55bf8a..379f3892be6 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 = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 9680b76f347..2e91c5e9cdd 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 = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 5e5346518be..c1a9534cb41 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 = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 5e5a9116ff4..80a6ac62789 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 = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 fd19554b362..ff8e76a7b07 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 = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 6105413dadc..652e766b508 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 803bd0cd7e8..1063d6acf98 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 = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 71f353eb2fb..97eab9e4766 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 2422ce62b1c..89454971dd8 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 6621f9f3948..4259f7acb0c 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 = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 846b5c226b1..e4ec5b27268 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 = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 2c6feffc458..dc3fe513e90 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 = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 ddb021564c4..5e03477710c 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 = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 13dedbcc5ad..bb0b67e93ef 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 * sizeof (GFC_COMPLEX_10);
 
-      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 72aba60fb4b..7fcc97c1870 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 * sizeof (GFC_COMPLEX_16);
 
-      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 63f66ecdd7b..9362bbad238 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 * sizeof (GFC_COMPLEX_4);
 
-      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 ab646834825..cb34899e09b 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 * sizeof (GFC_COMPLEX_8);
 
-      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 dbf812d8e36..7a2cef4a733 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 * sizeof (GFC_INTEGER_16);
 
-      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 a4c83adc386..6fa7b2f819d 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 * sizeof (GFC_INTEGER_4);
 
-      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 e7288bb20d6..a97c9467327 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 * sizeof (GFC_INTEGER_8);
 
-      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 87216f49936..47e4bbd3b36 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 * sizeof (GFC_REAL_10);
 
-      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 cb1f7f34993..e5919482548 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 * sizeof (GFC_REAL_16);
 
-      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 64f3991e363..9eece42a671 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 * sizeof (GFC_REAL_4);
 
-      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 4b6f4c67dd4..22cb72959c9 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 * sizeof (GFC_REAL_8);
 
-      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 c42aca9d63d..496f03dee7f 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 - 1, 1);
       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(ret,0);
diff --git a/libgfortran/generated/shape_i4.c b/libgfortran/generated/shape_i4.c
index 3f573999629..e012ec0e845 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 - 1, 1);
       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(ret,0);
diff --git a/libgfortran/generated/shape_i8.c b/libgfortran/generated/shape_i8.c
index 49910ac7e4c..01eefc16618 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 - 1, 1);
       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(ret,0);
diff --git a/libgfortran/generated/spread_c10.c b/libgfortran/generated/spread_c10.c
index fb4efb0fa24..ac3dc2c1b56 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_c16.c b/libgfortran/generated/spread_c16.c
index 46789ca8adc..e7aff077f2b 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_c4.c b/libgfortran/generated/spread_c4.c
index ef91ca55bc8..d75d315ff98 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_c8.c b/libgfortran/generated/spread_c8.c
index dbcc0293a21..1786d1dde5b 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_i1.c b/libgfortran/generated/spread_i1.c
index 0e654eb75b8..ea18032deaa 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_i16.c b/libgfortran/generated/spread_i16.c
index 41676510f88..76512d3a934 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_i2.c b/libgfortran/generated/spread_i2.c
index e65b942bd27..b81784b2770 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_i4.c b/libgfortran/generated/spread_i4.c
index 599da3fe129..3a4f9468077 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_i8.c b/libgfortran/generated/spread_i8.c
index ddb8163d5a5..c55013c96f7 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_r10.c b/libgfortran/generated/spread_r10.c
index d023a2774f1..76c1d1608bb 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_r16.c b/libgfortran/generated/spread_r16.c
index 17bffbe5d0b..163262d9a54 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_r4.c b/libgfortran/generated/spread_r4.c
index 656205fc153..12f46d57f7c 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 - 1, 1);
     }
diff --git a/libgfortran/generated/spread_r8.c b/libgfortran/generated/spread_r8.c
index 2c77f1cf2b3..138b47d52cd 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 - 1, 1);
     }
diff --git a/libgfortran/generated/sum_c10.c b/libgfortran/generated/sum_c10.c
index 2a289f4ee40..50567b3a270 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 = sizeof (GFC_COMPLEX_10) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 d87e086bfed..285b4449e77 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 = sizeof (GFC_COMPLEX_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 7964eb91276..bdaa1adc727 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 = sizeof (GFC_COMPLEX_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 2fd67828d95..e7a4a45aa03 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 = sizeof (GFC_COMPLEX_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 c746e073f76..7b03bd05965 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 = sizeof (GFC_INTEGER_1) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 02d6cc86b1b..71bf01a209c 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 = sizeof (GFC_INTEGER_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 5e6d3b98df3..1d82782bef1 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 = sizeof (GFC_INTEGER_2) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 e199544f193..3e29bfa498a 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 = sizeof (GFC_INTEGER_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 68e8539a785..05767bc59c7 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 = sizeof (GFC_INTEGER_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 42f676eaf92..16ff425a617 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 = sizeof (GFC_REAL_10) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 ca98de1bfe1..3b2d8a60729 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 = sizeof (GFC_REAL_16) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 863191af478..5136dae2c80 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 = sizeof (GFC_REAL_4) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 45de9f4f649..8634637434d 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 = sizeof (GFC_REAL_8) * GFC_DESCRIPTOR_STRIDE(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
@@ -445,7 +445,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 f86368801b6..9402936f3cf 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 af0b43f2e97..86e865c71f4 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 81e1584a9cf..5819ab16335 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 b523bb067ec..171d6500789 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 5f15534f777..22dd5f60c79 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 adfd0adf70f..a554a966fd1 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 07b80c9d684..54606bab537 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 817968881bf..53e0cc359be 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 b1f7b41b53e..7cf22ab7784 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 8c854cc2fb6..b14bad33293 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 f60a69e248c..95bed284fe0 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) - 1,
 			GFC_DESCRIPTOR_EXTENT(source, 1));
 
-      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 150509deaba..879d3092d55 100644
--- a/libgfortran/generated/unpack_c10.c
+++ b/libgfortran/generated/unpack_c10.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 f33830d43ae..6b8eee5eed6 100644
--- a/libgfortran/generated/unpack_c16.c
+++ b/libgfortran/generated/unpack_c16.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 2106202b57c..f40fa959ce7 100644
--- a/libgfortran/generated/unpack_c4.c
+++ b/libgfortran/generated/unpack_c4.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 c8903cf3e92..6b7c5e1f6a6 100644
--- a/libgfortran/generated/unpack_c8.c
+++ b/libgfortran/generated/unpack_c8.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 517474ef86d..0d5ec8ef292 100644
--- a/libgfortran/generated/unpack_i1.c
+++ b/libgfortran/generated/unpack_i1.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 c21a61e0895..1e030e66b5c 100644
--- a/libgfortran/generated/unpack_i16.c
+++ b/libgfortran/generated/unpack_i16.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 d77b049db4f..ae230bf773c 100644
--- a/libgfortran/generated/unpack_i2.c
+++ b/libgfortran/generated/unpack_i2.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 95ce538cc43..88915e50877 100644
--- a/libgfortran/generated/unpack_i4.c
+++ b/libgfortran/generated/unpack_i4.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 59412d3906c..793cdceb71b 100644
--- a/libgfortran/generated/unpack_i8.c
+++ b/libgfortran/generated/unpack_i8.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 34c226254c4..3ba1e2a3549 100644
--- a/libgfortran/generated/unpack_r10.c
+++ b/libgfortran/generated/unpack_r10.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 c50dc71c6a9..51d6b64d260 100644
--- a/libgfortran/generated/unpack_r16.c
+++ b/libgfortran/generated/unpack_r16.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 3e022b98672..a187d51dcd8 100644
--- a/libgfortran/generated/unpack_r4.c
+++ b/libgfortran/generated/unpack_r4.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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 0d343cde7fc..c6ad80a1fa1 100644
--- a/libgfortran/generated/unpack_r8.c
+++ b/libgfortran/generated/unpack_r8.c
@@ -99,7 +99,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
     {
@@ -244,7 +244,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
     {