Combined get_mem and internal_malloc_size.

author Janne Blomqvist <jb@gcc.gnu.org>

Mon, 26 Mar 2012 15:16:05 +0000 (18:16 +0300)

committer Janne Blomqvist <jb@gcc.gnu.org>

Mon, 26 Mar 2012 15:16:05 +0000 (18:16 +0300)
author Janne Blomqvist <jb@gcc.gnu.org>
Mon, 26 Mar 2012 15:16:05 +0000 (18:16 +0300)
committer Janne Blomqvist <jb@gcc.gnu.org>
Mon, 26 Mar 2012 15:16:05 +0000 (18:16 +0300)
diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog

index 5624049d206ea3b2948199c1e89b075951e17425..e4a6b1e91fbab63254a9e4c40e71fbef9c1aa631 100644 (file)
--- a/libgfortran/ChangeLog
+++ b/libgfortran/ChangeLog
@@ -1,3 +1,355 @@
+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.
+
  2012-03-26  Tristan Gingold  <gingold@adacore.com>
  
         * configure.ac: Use GCC_CHECK_MATH_FUNC for math functions.
diff --git a/libgfortran/Makefile.am b/libgfortran/Makefile.am

index 2ff29a8f68fdc2de5a4b1ac81eaded6c76674ed5..abc23cd1eda0db69f8aeb19e16114c35aa1af1c5 100644 (file)
--- a/libgfortran/Makefile.am
+++ b/libgfortran/Makefile.am
@@ -887,13 +887,13 @@ $(i_any_c): m4/any.m4 $(I_M4_DEPS2)
  $(i_count_c): m4/count.m4 $(I_M4_DEPS2)
         $(M4) -Dfile=$@ -I$(srcdir)/m4 count.m4 > $@
  
-$(i_iall_c): m4/iall.m4 $(I_M4_DEPS)
+$(i_iall_c): m4/iall.m4 $(I_M4_DEPS1)
         $(M4) -Dfile=$@ -I$(srcdir)/m4 iall.m4 > $@
  
-$(i_iany_c): m4/iany.m4 $(I_M4_DEPS)
+$(i_iany_c): m4/iany.m4 $(I_M4_DEPS1)
         $(M4) -Dfile=$@ -I$(srcdir)/m4 iany.m4 > $@
  
-$(i_iparity_c): m4/iparity.m4 $(I_M4_DEPS)
+$(i_iparity_c): m4/iparity.m4 $(I_M4_DEPS1)
         $(M4) -Dfile=$@ -I$(srcdir)/m4 iparity.m4 > $@
  
  $(i_maxloc0_c): m4/maxloc0.m4 $(I_M4_DEPS0)
@@ -926,10 +926,10 @@ $(i_matmul_c): m4/matmul.m4 $(I_M4_DEPS)
  $(i_matmull_c): m4/matmull.m4 $(I_M4_DEPS)
         $(M4) -Dfile=$@ -I$(srcdir)/m4 matmull.m4 > $@
  
-$(i_norm2_c): m4/norm2.m4 $(I_M4_DEPS)
+$(i_norm2_c): m4/norm2.m4 $(I_M4_DEPS1)
         $(M4) -Dfile=$@ -I$(srcdir)/m4 norm2.m4 > $@
  
-$(i_parity_c): m4/parity.m4 $(I_M4_DEPS)
+$(i_parity_c): m4/parity.m4 $(I_M4_DEPS1)
         $(M4) -Dfile=$@ -I$(srcdir)/m4 parity.m4 > $@
  
  $(i_transpose_c): m4/transpose.m4 $(I_M4_DEPS)
diff --git a/libgfortran/Makefile.in b/libgfortran/Makefile.in

index 09b50642d8ef14ca1e0e8863163c95283c760864..aa23e85e37b06a3a5309efa7df32d5e96517df54 100644 (file)
--- a/libgfortran/Makefile.in
+++ b/libgfortran/Makefile.in
@@ -5936,13 +5936,13 @@ fpu-target.h: $(srcdir)/$(FPU_HOST_HEADER)
  @MAINTAINER_MODE_TRUE@$(i_count_c): m4/count.m4 $(I_M4_DEPS2)
  @MAINTAINER_MODE_TRUE@ $(M4) -Dfile=$@ -I$(srcdir)/m4 count.m4 > $@
  
-@MAINTAINER_MODE_TRUE@$(i_iall_c): m4/iall.m4 $(I_M4_DEPS)
+@MAINTAINER_MODE_TRUE@$(i_iall_c): m4/iall.m4 $(I_M4_DEPS1)
  @MAINTAINER_MODE_TRUE@ $(M4) -Dfile=$@ -I$(srcdir)/m4 iall.m4 > $@
  
-@MAINTAINER_MODE_TRUE@$(i_iany_c): m4/iany.m4 $(I_M4_DEPS)
+@MAINTAINER_MODE_TRUE@$(i_iany_c): m4/iany.m4 $(I_M4_DEPS1)
  @MAINTAINER_MODE_TRUE@ $(M4) -Dfile=$@ -I$(srcdir)/m4 iany.m4 > $@
  
-@MAINTAINER_MODE_TRUE@$(i_iparity_c): m4/iparity.m4 $(I_M4_DEPS)
+@MAINTAINER_MODE_TRUE@$(i_iparity_c): m4/iparity.m4 $(I_M4_DEPS1)
  @MAINTAINER_MODE_TRUE@ $(M4) -Dfile=$@ -I$(srcdir)/m4 iparity.m4 > $@
  
  @MAINTAINER_MODE_TRUE@$(i_maxloc0_c): m4/maxloc0.m4 $(I_M4_DEPS0)
@@ -5975,10 +5975,10 @@ fpu-target.h: $(srcdir)/$(FPU_HOST_HEADER)
  @MAINTAINER_MODE_TRUE@$(i_matmull_c): m4/matmull.m4 $(I_M4_DEPS)
  @MAINTAINER_MODE_TRUE@ $(M4) -Dfile=$@ -I$(srcdir)/m4 matmull.m4 > $@
  
-@MAINTAINER_MODE_TRUE@$(i_norm2_c): m4/norm2.m4 $(I_M4_DEPS)
+@MAINTAINER_MODE_TRUE@$(i_norm2_c): m4/norm2.m4 $(I_M4_DEPS1)
  @MAINTAINER_MODE_TRUE@ $(M4) -Dfile=$@ -I$(srcdir)/m4 norm2.m4 > $@
  
-@MAINTAINER_MODE_TRUE@$(i_parity_c): m4/parity.m4 $(I_M4_DEPS)
+@MAINTAINER_MODE_TRUE@$(i_parity_c): m4/parity.m4 $(I_M4_DEPS1)
  @MAINTAINER_MODE_TRUE@ $(M4) -Dfile=$@ -I$(srcdir)/m4 parity.m4 > $@
  
  @MAINTAINER_MODE_TRUE@$(i_transpose_c): m4/transpose.m4 $(I_M4_DEPS)
diff --git a/libgfortran/generated/all_l1.c b/libgfortran/generated/all_l1.c

index 541e72585169eba67594d2c52c3fc7ad0c5a81d3..81020f7b331ee9700f3027843c709dca171db5b8 100644 (file)
--- 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 8162ac1596ee362ec694a311164fbe91c477e81c..520de21e7d7314c8e98e7e0c746080de22f79966 100644 (file)
--- 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 0e98cf64acb641eb93ad0906fc638ee491cca001..8e5170807c6af40441646b39fe40d2a34bb0b379 100644 (file)
--- 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 857175159a4f79fe35d27b045d1207690be255b7..f78987c70f34c25f489165f4cb914dc5d9729146 100644 (file)
--- 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 9b9d16a884441d9319883131779713e46bdf96fb..57becda58c343f3624d396677e8387ac506631bf 100644 (file)
--- 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 e8b9cab99e847bc6dba4ffb49f705eb4962f091c..eca125fb2565d84a99ee0a9765a71fa954948485 100644 (file)
--- 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 c6055886b4130a1fc861883d1ca91e800f71437b..2c65db6b7a529802bc77f0ef5041232b118655d7 100644 (file)
--- 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 6c4afeea01bebfed78979824127b13066478f9fb..64ed5bb6499707a5aefa6e4af4c4a17f56b8e3ea 100644 (file)
--- 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 b2c4cde3c3d15a2a760b54d35d27fa96a5c973d3..4cad8c88a5c93fe06433297e2584849e11e687c8 100644 (file)
--- 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 86fd28c1462e3cff743ee841423e359249b7db36..55ffaf1e162aa3bdf4546ba56317c63b7749ea6c 100644 (file)
--- 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 7d11614b0391d86f9a3f9af5ed8c677b6d943016..6a3a139fdb7a173a8be1abf22110501f63271eb6 100644 (file)
--- 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 ae23dbced72b9de9b35ed38abc7c1586778fdc92..c1aa5e25570eee3e17316093f50836ccd3f64284 100644 (file)
--- 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 d3b05907082b4feb8e12a5b9be85de6fa58180da..0f7c4cc423396403432b7b1582d9c02e50f76b01 100644 (file)
--- 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 b48c04bfcc34f80fecb122ae09b39ece7f16a1f3..cc61300057ae3204119ee0a4c163f55ecc41ce7f 100644 (file)
--- 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 652244004fe15679aaa752ff35ab610b5eec2f2f..ad5af4fb5a613daebbef563f2b30509f7e8db01a 100644 (file)
--- 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 5b7776eb9b39933aa0856a7dbac9fa72f477692e..92ef8191dcb47590cfd6e0758bc5662f4b0bcf4d 100644 (file)
--- 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 8a104d1bdfcb3b95b299a7e716c2651078178f96..503a07d4cefdd89dd730d4e56283d6a00774a7ae 100644 (file)
--- 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 0edca41c49255b94b93c92bfd13c13b30bb61cc5..380c0058e112ff1e8f127c886f0f0286a654c1ac 100644 (file)
--- 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 e3d95dca825bc71dc771b004ba247764806f4917..16c7cf3aa0e017c1839c7bf12eb712cf79b72059 100644 (file)
--- 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 41cc1ea81f530fc684cece3de3759258fa380b08..22d1b29d0fa7ac616e9ebf1b62854eeb4b4494d4 100644 (file)
--- 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 9652222bda067d204e652491bf90ed44f6dd788f..a0f3ab60050d856576b0843c63dbfc6318f98e36 100644 (file)
--- 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 8ccd63b52089e1c8bf97a986fcaed81704540507..ceb74091a8928ce46cd98f0c2092840f695c4f28 100644 (file)
--- 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 2de9208cf9da72a6ff48f88011d99adec5084736..e3096288b0eeacaf17860d3579a9bdf46b0c8ca6 100644 (file)
--- 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 8a9f1aaafbf8c14301a541b10a8422d883d21334..451a6af1d650c387f09582c169d6724b66181704 100644 (file)
--- 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 136f5464c1742feb9395601f95e5fb6a954a4d5f..1f056b36b98900ee1bb37776af74325ca7c7c916 100644 (file)
--- 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 d363d90ae0c54b1d18bebd157ee51ae1cf443f2e..5384a720de79499b627c66a4a256836a6169ea88 100644 (file)
--- 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 1b623c28f51c852c1082a0b5a8b6e830226ee89a..6618516818a564329351d568dbe580c16eed2d21 100644 (file)
--- 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 2af1ccb9cf561fd603703e99e02cb78ec8388bd3..a90d87fcabf175a1dfee2924f5710e9d2559dee6 100644 (file)
--- 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 d60f7f358ba854d2b824c514408d1e292572f501..dbe0fa74d70d31fbb0e75d995df23d13d7885ef4 100644 (file)
--- 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 88be6a8bad89ad7f16dacfc02c33e7a5d75c4c1b..02e61fdc4a650e7a21c61d265311999b67a80637 100644 (file)
--- 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 14fa83b1c60257ee95454872fe81411e3161513e..e9c181c53091ac9b0a98316c43d4904f188ae57f 100644 (file)
--- 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 ce5e185d6905cc69a5627c2edbef5139e5b6b621..8cd3b3e9acf6a839b4d4b92e2cc2ebfc61d4bc33 100644 (file)
--- 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 fee269a8cfed01cc50b938e15dd5d952528c49c2..8e2bb1ad46d69cf97753a839656fadc462d63d47 100644 (file)
--- 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 f1b0aebe936c0a16491d7957f5a322fb82e2b6e2..52b6f923fecf02b0f6cad03367d7c9d380066d08 100644 (file)
--- 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 511e36989e4938180e18dd3d7a43feb73efb23b8..9194aa5731563cc9fdf2ddb981704515f4d0e2c6 100644 (file)
--- 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 b52f5512cef96bf1d2dd3346e12f54ad7faebd37..dcad9910490f33d105451f0bbbda63daae220302 100644 (file)
--- 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 a0949e17ec98e1d45e068e59a1a03cea3dab13fc..46a5d83062ef8f1df41ea8d2d7467be7e1e2247d 100644 (file)
--- 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 e365f5f97b0ca8b82cbb902a0f35427ad8d3929e..f0a2e904dd9a9b52389f9694b5be5b93214fea59 100644 (file)
--- 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 1d6b0db637bc7aa00a601e28e32c4b533b95e6ea..2279690764c731ec075838793777b80d9c220027 100644 (file)
--- 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 a627094ee43c26086ad0117366a50c67eed43670..bc40163591cb2dede9920694c1a61d2de85e98ca 100644 (file)
--- 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 833d7e8d515c40692d70679e11155371f6a86012..532c2deb48fe725d2c0e14c3e306f946f70fe549 100644 (file)
--- 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 d86ce9f1b67b08d90acb752eba30d92b737bdd20..b8e9ee4333dadefab70726ae8c373cd8729ae1a5 100644 (file)
--- 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 2b582a5df6fd864b447c47321db8970c5f80199e..d4449bb6904d450e547ab22d93c8fa1779b745d0 100644 (file)
--- 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 294e3ca47ffc82ea925abd483ca6b72f57e8cb20..9a6b5e8b16292f0044eb0e1faf8bb3b89e5e3259 100644 (file)
--- 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 6a95af3b5168f24f2076ddd4c8d08ee238b1ac2b..fb87ea716ef932800b6f986efee874662aff3a8a 100644 (file)
--- 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 4a5a8637172c62e65fa1beda53749310adecd375..44b339769f929517239b87ba37a3e88307ec4365 100644 (file)
--- 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 cb7e785f06009f9bb6b4604fd26233a520301b4f..f0d6dd13e236a82c7dbe5602b51246e85fbf7d59 100644 (file)
--- 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 b479001562fa90b0765338d935c88122f4090915..417fc4d9637552abe8b27f2ad9e3a65a20dd84c9 100644 (file)
--- 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 f16fd2fea66b130812abf3974d050f6dd82f5c7e..d815b2f6a8a12225bb385db406ccbfcc833094b4 100644 (file)
--- 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 e5b09a70f1bed76434a23b8326fc5acd6654d333..f8d99900de393491bdb500d5a0c57f469134e820 100644 (file)
--- 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 12670d277240a72879c2e34e3f21c1735b4595e8..be13b82ad1402994bf908a3d6eab432b25c1b5aa 100644 (file)
--- 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 5fcb29d1af752b57091aa4122f621ed8c4753002..00eb4bcac9f82fda35b8f001295931b73aeb7494 100644 (file)
--- 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 aef94588875a02a83c57c9263d6d3447b569c405..6caad71db79b0e3ded9b6c22dbf04832ccf5684e 100644 (file)
--- 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 22f95e360dda39bad29d4733d8a68308134fb8f6..c44f908035adf8c8383b21b5d465806da2341b2e 100644 (file)
--- 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 58b18b86a0ee41512ac35df644e51bc4dabf8789..a7f76c8268d800d675b602adc9468922fce5cb0b 100644 (file)
--- 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 78de1c429e287b7b43efe95545693985bf95557d..e93389df0fef95e130b49c2425df84104426c164 100644 (file)
--- 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 3496a83eea09e96cc1b66744e70ffef6d0ed70a3..ffd3be62f97dc2059558ddcc1744774f527331fd 100644 (file)
--- 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 0140dd311cdc527051733dd64f77af88dab7df91..98799f52271b83f69fc24b96ff10866ace595525 100644 (file)
--- 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 fd8ce9f1794e84ae3f60815e48b5f615913e60a2..d5855db3060ae2a49ee1140ac6ee3f0b882db1c8 100644 (file)
--- 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 e71b5fb58ade32b18622110d5911efc7faef56ba..97b63474eda8ce616089b71dfe3ec3f9e8ca3cb6 100644 (file)
--- 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 7525ea77ab3e6ecf3d0d24c6efdf8f11367edf3b..61ddd9882f7a5ea8556bb62274c52433deb3fc9d 100644 (file)
--- 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 19b6995a3fbb1069a89b91e627d683d43a8d2549..01d1b85638fddb77c098415f0238977ca7a9077b 100644 (file)
--- 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 73935067a16d20da23fdab83aeabe6416ff4e3c5..2b6b99b735547f70d68ed897f294be489fcd83da 100644 (file)
--- 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 2e9e016816a51b81b46f523a020ec8c8d707dcd2..536c773efdc4e0207fc57893c47bce33daf7c13b 100644 (file)
--- 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 6c6c655625adc37288c7bd75423d159b03aa6221..777c991ad6887c683d75fbe4d31f538fbec75b11 100644 (file)
--- 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 1ae8f7a9cb679960b41eea538044019a0fb3c247..ffb6d4c1865f52a764d0d9f6c1fe4af66b51e0e8 100644 (file)
--- 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 dfe3369c0a752402f5539fed48ce962f7570df6d..e73ff6910aeac7e9cad36886eac13a14325396f3 100644 (file)
--- 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 258a953d023f5fc888d8faedac894c4d3d0248ef..ba18cbacf4b73b896ed0ae9be5dba96218a8b6e7 100644 (file)
--- 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 79a577129515fbf6ec51442d15f8bc781255075c..dbe49eafcf16e18c60599e208e6c2914e8e3c84c 100644 (file)
--- 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 87bc587acee461a3dd24ace143c12b0899fb3c0c..6798c7bf45149d6ab4471daec53913ac6431f850 100644 (file)
--- 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 4f72b6a4c80e675f60232c8ac4cfd10aa62a4b65..606c22554708aa9e3f894a3d369e55717bc35cce 100644 (file)
--- 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 422a1f03ea3c0473d4819bf648749222aebcc4cc..4733912d24598f1e7c7eccef77c7f80e30e11aa3 100644 (file)
--- 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 fbac3ad12ff9737115a63f6c2074a3aaaedf81a7..0de65a885c5b9bd5df25acf8f796c8d598fc09f3 100644 (file)
--- 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 e15ebf26e53b2d1bca6969f94bf223616c60a94a..be8c469f9ed0ec7a7a2b5b360f3944c8ba69f133 100644 (file)
--- 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 90b2b3a8ff7d3a8f50c17ab6b192eef4d1b227bb..9852dcc92c697cc64e181442481e643edc84842f 100644 (file)
--- 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 dc75d83e78c1e894ab38384b249b30d64bbe0d7b..0f2973b07312af1abc045e0a3f5c51ec0c795015 100644 (file)
--- 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 43879c7ddcdce0fcaa5c721aa25b4a0b3b306f29..fd79bf057ced1b375f33a1fee6583afccf3d07b9 100644 (file)
--- 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 3e3bcb5ffdde3a73bd05716b512e8f3ce9788077..beb0fb37f3eb2bd3cac0e77441de921ca9b9107a 100644 (file)
--- 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 cec39633b65eca6bdd4c2ff9e7c36285c5facb8e..52790c70808f414c71b32158ad924156898f6f8e 100644 (file)
--- 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 985dcd6bdf69abaa6b2b7d69c951466f2ab344d2..eefb8a280f1ea349744bbc45e3202fe37891892b 100644 (file)
--- 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 7f385d713f614f90b77f724be2d1c65847ab41cf..f536ac8bbed60281879250af47b7f140ffec6409 100644 (file)
--- 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 6d7cf6188b9d5578d97fae4c57da635148a2ae86..31506d41be82a9c200634b7b22e089561807d312 100644 (file)
--- 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 0d8bf75667ff279bccace6407545c6482520bffe..e7728753a0985ca480c3c16661ffd642d6b179cf 100644 (file)
--- 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 b0c05c80a2d539eb4153d2b3b976f45f7c4fa746..cc5a57afc43b3810e1dee461cb3efa16c915330e 100644 (file)
--- 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 9be7099176440a69297a2716c1042a02ffaf254a..2d407ef265c6d037a2bab48601df98fdb571679b 100644 (file)
--- 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 cb337239b2c2fcc78bc4e96d03fa861813128962..3d3599612345f68ddc2bbb388be3402c686f0794 100644 (file)
--- 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 48abb630b9c4bb3db452b515bae9e9792b0a37d4..200257a6448a1e9f5642ba6cd8ae1432901a533e 100644 (file)
--- 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 3fae48df1be34679fe9c286a4c52bd3bbda19726..f878e67d7878d5713f44887c0f5b4b1af3f335b7 100644 (file)
--- 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 d2a985d0a27fa1ff5718d0cee10003b8829bb7f3..923ee4bf1d8523722c2e6e59942190b7c5cd4772 100644 (file)
--- 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 6f57fca5aea10bbfa6871fcc12613e2104d94bf4..77f97dbca09cb662ad56ed0054987d8140dbcc4e 100644 (file)
--- 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 07815cf551837762d82bd9315ddd04350a00f708..4a51134b91a4ee0241d7c22fe239a39ad13b0e66 100644 (file)
--- 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 dc5c57503e0cdb30683a08539a776d41d4358097..a9783e8ab6e160ca8ea497d68722e61c835df15a 100644 (file)
--- 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 f01ec69905e2722d27bc55ed55294b1b92fef6e6..9e329fae5b35e2fbbfcec8ae72ef85e98aa25efe 100644 (file)
--- 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 13f32e02820ba1bc875aea7f984cb7f5a9f67c45..6aea6bb58169b41f60488003bc4ed380673b6823 100644 (file)
--- 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 066cedf61217793e92956fd1b1f635b70c5bcb38..1e5b1687b5c04d8d3e0c77ee97910ad489505cbb 100644 (file)
--- 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 f34984dcd49ccbe375e5cd284e6f5aa8e0ad2fa2..0bb567405bae3f39c735798564a7734c758be9bd 100644 (file)
--- 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 e28ba0fe89fbeb01d49266a24ca0039764345a5f..e80946ef8b0681737fbb6af4df8403e3c9173bf1 100644 (file)
--- 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 d6594ab3004efd2636eb0eea12c2e93358c642a6..5ac8b423728b6b6f200f25f51eac49df6c5471ce 100644 (file)
--- 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 2a9b7546da94663980d2e9a9c07c0087a1cd5682..f510bdd15945065e24c2f80936297f6130eb2364 100644 (file)
--- 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 2621fafe625ac50688d899b1d6472918c99d2efe..e2eb8e0a7b0fcb690e6b69e654d0d9330ad5b78a 100644 (file)
--- 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 51758850181ed2852ccae249db1151b03514f954..9b3563f9677d54c03a31a9d773540abe405f2b64 100644 (file)
--- 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 a8067821b127f197bd848bb4de28230b6b17f7d3..0278e99dc8b7bb81db1481f22b1fcbb058ddc97d 100644 (file)
--- 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 85dd48c7c5c1d5fa64365157aa704d3f0fd8dec9..9751c2afec28011fc5229079d9791d7513f752cd 100644 (file)
--- 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 d6a96ec4bf71097da8c139974a25c0d485c50dbb..e9140e5f86834283de274e104ff30d86f0e7ee4f 100644 (file)
--- 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 551d207212b894c5b05e393f76ce668533bf06f1..f88d254b29573e948aa6e027be0ee79623cc9cb0 100644 (file)
--- 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 d44ecd44fce33fb79aad1acbcafdbfa7798d2083..b1188a2c795edc50fe2a9fd934ca53dde849ffaf 100644 (file)
--- 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 ffd484ca6785652d9e26be7ba896debef0d33f81..70611027985fd7ce2ad53fd24d773b4a2e98349b 100644 (file)
--- 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 d03ba72a2c43228d25e219ea3ab0c36da848ff25..5d4d9c27c9f84e616ca2a7c97bd8d73e9f33910a 100644 (file)
--- 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 4c528f27d5b6bfcbaeb7fb4c488bf789545f5aaf..0ee6ed5489874cfaec964db42a7e3d0870ebabe7 100644 (file)
--- 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 5c0a8017f7850c65c3662070d794d8610d74c35f..c79f0ca07176a9ff752c2ae4882ec4d3f2b8fce7 100644 (file)
--- 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 3d35b0c46c4489da6ec653451cebabe66c534b33..4eff28acb147fa6a1465f0523f690f74bfac6fb2 100644 (file)
--- 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 ec2f43422dc8a18eb18956a140c3c3ac599b4ca9..7c8f5e6e534c01c0386a2400a07bf88c91d74bf0 100644 (file)
--- 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 0bee414b6815e7b68d9600c849f7372e582bd3fa..ae63e1b1b38d0404d2859a46387aafedc266767c 100644 (file)
--- 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 cfb16f96716783c289213bd019a32aa7faaaa889..afd935b39ab9179802f6a7a0a3da9f267efb8e9a 100644 (file)
--- 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 4bf9b8c03789748a51a6c5b2609bd6890cb6f4b6..fdd481722345846f782e346c51a10811b901d38a 100644 (file)
--- 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 c3721d9e51a636971171d7d375bcb2d70b8cc95d..8360dfcdbca081618bba6c0748951ca8671ff73e 100644 (file)
--- 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 a756665a53a4ea49bce29774e0dbfbced1a5ce69..96f36511dc0c592eb1031acded5883401221cf3c 100644 (file)
--- 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 59be8b71f127e96a7e5b8550f197405a78f84889..a591171894225b034ec2bd1e2c3deb3f9e1c66b1 100644 (file)
--- 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 107426e96c7277771034d2d9c3e027186432caab..30b946ae36be1f9ddddc17366063df7ebfc38cdd 100644 (file)
--- 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 21a8dceaab8267ee56512f5ddeabe717f892aad0..af32584ccf855ea476c06b4e1bed66e9843bec4c 100644 (file)
--- 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 2c7d860bc62837e3f657c2a68234bec4149dd2b7..dc63f1e71a29783ac125baf8d66a4cb880434e18 100644 (file)
--- 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 0638ab03332869d6129c4735de36df000d6c3cb4..c50965edae4d307c6cc14aeda6aacd5cd3ae8883 100644 (file)
--- 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 acc5689a0f682ac47d8bd8f0a53efd2da143a0ad..c088686b5648397384fbf6f924b97f9a662eac56 100644 (file)
--- 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 1cd2a45c45986e353e73cac560b0a8de62973b51..35f68071ca39dd3c1fe1c0d2966ae721ff8e42eb 100644 (file)
--- 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 177f06e4d9702c448f8db5ae04947e20ef0ae447..5d84bd077e050b0c80e2ef36bc70210a37e8a17c 100644 (file)
--- 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 35739aa8159e5b7cf3110d4852d911714d73fbb7..e1e80d3298d73ecd35cec1af4f82a1fc87f54c09 100644 (file)
--- 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 7a4a58e711bbf89cf5586c4e7f225a4dae0198ec..a94eecae000efde90de60fea5c0796a4f6925abe 100644 (file)
--- 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 fe42c27a6e8d914cc93da2eed21ae9947d3b529f..94059cb1a0288f7708a8de8dfd03ee6e9debf25f 100644 (file)
--- 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 19b233d80ec6a72e06aca966303bcae4094dab87..eb3d767e31a2a487d48d1341e7da2056fd3faeb2 100644 (file)
--- 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 d4ef8ed2c6a2eec8e8e4bd488a88f69983c9693d..ef9e6c91826b31697e9ae8838f658c2e4ba78d16 100644 (file)
--- 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 814357d457733dc4d3730c40b0f6f92e7709464c..a6cd6829a3f6397b2f267ad0188cdd506a0cd22a 100644 (file)
--- 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 736cced85a6684094688fe811bf8a8eb4968ed01..1be75f1fe2f3723bd99cf9f11963a3f0a3412d14 100644 (file)
--- 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 37ae298a6b942ff7755a9119e0a0f10e21d4b44e..059896daf6bcb0fe3d3cc2a748b9e6eccd49c89c 100644 (file)
--- 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 0cd7319476311a43fa6b842940281f0c4cddf4b6..f306f181f52719e984f783283ba208e391d6a400 100644 (file)
--- 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 f8ac97d08f292faba73fcc6dd70ba58ae036ae18..ca70ca5a9e5c8e0728874b7a6ff42de03865c4c4 100644 (file)
--- 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 617588528d3bb8b4c866ebbd9135f8690f90afde..4b7b11973337f4be60ab9494797331b07d04af34 100644 (file)
--- 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 d938dd7b90d5109dfb17be17a1a5779a42d6f6cb..cd056c73c8f2b4a9d3ef7e65206ba2b7d6e2d081 100644 (file)
--- 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 8f0528e8cc3a444f0b949aa1a4bb906f8731547c..157018f6d71c5b67c71c7373696d6ee0a45a22c3 100644 (file)
--- 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 cf57b7936d8379bd46d15fcf831e4050a16d1dda..ef0fc0868a574aebaf8e77ac15f21a5d0e5de956 100644 (file)
--- 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 23c72931570e9b43faee089d7c20d74fd3e42e55..0742e9a553cbe29fc441aa2aa45ef506c8737206 100644 (file)
--- 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 52c0ab74c90638691b9bbecb3cccb92dc4c9cd2e..8bd602af3dcb769adc8671a7a7c502773eb9bf88 100644 (file)
--- 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 e35ad66d4bec85c7c4d8a1109804e9e04a86f64f..93bb9755a880a61b4639af298150981fb02575ca 100644 (file)
--- 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 37e877b8c1ee366d831fe34b88ecbe560a4dfc9f..ab6797369971582b8965c0344faa461d85050d0c 100644 (file)
--- 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 dbd7ad37b113ae6c52b5b359d334d1f879a80926..bfa623df1ca058950000c7c5aec7be204e90ee5c 100644 (file)
--- 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 fa9dcf5941687bc7cd7ea381cea92e3cfde661a9..23f0f490034309260e4d80374aa96726e3e9df26 100644 (file)
--- 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 5a8e4401a638526445a7a5a4bb4dca6a7ca58d91..abeb209ac53e12eb04746cd4d47718cc41535834 100644 (file)
--- 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 d3ce2ede03270b9472fa4d7850131623e0863592..9ebf23a8d9443d568d49a9351e191952c35944af 100644 (file)
--- 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 dc2d60692a444a3199de696dfd7c5258e165d40c..bd813f28c8e6c4ca2457af056deef42e467da77e 100644 (file)
--- 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 98da2decf9206fa0c22b6c711274a7d51baaa530..b42c8bc4c953bbc49d28b86d8d823a6d8d01adda 100644 (file)
--- 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 8302d23518d64e845aeaff9dcea76164a0610261..21a0ccff0cfe5164e486a64ac783e59fa8bd941b 100644 (file)
--- 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 d8617ff948334b858725a7ffe14850760fc8b810..dcee2c2fa0d20f5c24254ef342585ae26964755d 100644 (file)
--- 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 2cdbc7dafcacbb757c7d39d5ec8f57f62a9bf4b9..2e60f8bad274fdd5523c59c96a6965dba9a52482 100644 (file)
--- 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 f8ef3a55c117e8b76e3c78bcb7ae8b24b00a40fd..6da89bfbeee71d00b32a4148f56cd741390b491b 100644 (file)
--- 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 0d6b52194fed1ffc95f396e890da06c6ce037e85..8291e87b6f092fa532058e7c9388b6b83652b5e2 100644 (file)
--- 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 37d6561a8d25d39ae46cf8d555838834b3e0657d..5306cd528bd8ac4215ef192455b44e7c775fb7fb 100644 (file)
--- 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 3418ceee2f67b74ccd159fc76408499f2919bd7d..5a9b40a8dc50afa4fc68082f8b3a20445ced720e 100644 (file)
--- 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 c36785e67f5e665c8b6c34185439e8fe6709f0d3..629b0b77dbcffb3a6b607ff04dc4fd452fd72a62 100644 (file)
--- 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 817f1c17ee89c1ed00cd3344f3b677baaa9ddbfa..ccd445edc77d4ed9b2bbb4d921c32c5228ac5111 100644 (file)
--- 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 d5a68eae6356ebcf7f736d9616adbb5d345d9bac..090bdff69ab8c1bdd5844ac2af83a1f810a53066 100644 (file)
--- 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 c2235b8f3b2bea087d63ab924fb802bfa0036cbc..26744c8ca5e699e2a9e73165cb7d77a0a322dd09 100644 (file)
--- 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 05230f516b3e371dea25ac05f514884408ae6ba3..f1c829aafe953500133b98745f13d85bdd8bc7ea 100644 (file)
--- 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 0ec3067f4bc26766da6e86484304e306c1701653..fe122a1a6a49868aa30e422cb8549dbe8bf7c760 100644 (file)
--- 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 7b5ae81ff966e038d21792a9cc62fc409ed93bed..949fa434c1e9148a36d26ce4f8d7e124923be8fa 100644 (file)
--- 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 c08cb66e238d7923e575b372919d5c806fa71f34..b5a1681836552c3cbb5a6cf041f3783440e128b5 100644 (file)
--- 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 3e89ba7cf2829295f0007264860e86954855c084..887907995d70543c54fa21311a8e809596242a39 100644 (file)
--- 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 1097c3b11315b4ba158400f8c21b81fc95e8bd69..6a5553fd405041102585ba3ab5a07002b1ede950 100644 (file)
--- 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 326b9cfd799d9154ace37fced738735e78dde391..04be9c60b95bc5de265014447a327508cc349618 100644 (file)
--- 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 7bf30bd4d1ea504ab50059aff51eb6478a72f918..a66feda39d5a1772005a204140ae15af6264ad4b 100644 (file)
--- 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 bc65a036f5955cdccab07b26593e436a8bf13a28..2e75ecf46d2f072f6d43d1749229b40db2383b20 100644 (file)
--- 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 baa2bc42dae7d4ce088cb0eacdc1778b21613dcc..b8e9337e8e29f26fc0dcd7db135e811a6ba2011b 100644 (file)
--- 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 482391dfb0243083318709239c5cda9b2f7e0498..42519eb3380afa9f0481db37e99c4fa2fe8f51a6 100644 (file)
--- 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 73c1a235c439cd8bd316017d513c64ef6dde40a4..07f0dceb55ea4d158e55b45b5801b1c4cbfcb4e8 100644 (file)
--- 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 442f518c5210147ca650aeeb03f79bce7b8ba37c..0c2041115d5125b7daece559a47959eff3da7e53 100644 (file)
--- 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 f235b0931be2dbbd975a7e229ba95e0cc58f791a..389b1dbddfdb3837680d41cee2008a9406f3bd33 100644 (file)
--- 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 e0a54f2f8b1b05f45ba31cff659fbefb903b8541..5d66fe9afcbfac6e403979d580f6b6d7e3827529 100644 (file)
--- 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 2d2882954d7a45c723a5dfea3d11f5a317ae4b1b..28cd536fa4a3b52b8b7bc0505a5ff9e57ad19a8e 100644 (file)
--- 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 08947086bd5ae1df6fe5699c3301d2cf50c9f35d..39196711e322aa1474528b32dc000afb9cae2829 100644 (file)
--- 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 082d4097e3242c04c3e9f7e3acc63b5fb7c9cba3..f7966123128b27fb1f03c0edb4c38aba95a46366 100644 (file)
--- 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 60c8f731a331c8785e3a86990d58aff36dd2c83d..7f34b91381346158481211b93decb7cd21744633 100644 (file)
--- 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 267bdae40450aad822d0da0c98393c32417997a9..21bb4cbcc776a31be9dfe79f6b98f568abb45507 100644 (file)
--- 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 17fc399b0c54dd91c514ee68f0438683d6d1116d..81d6f8e42e14bae1dfe0302c5d0c59c1575be723 100644 (file)
--- 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 350d762fc2a424e78d27241c26e0f39122037df4..0a41d1700620d9f53492f52485ee401c8f4fb71c 100644 (file)
--- 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 22b10b8828b0bad244aaf4799efe305cb42cf839..b0dac3e0404cd0e0128f6077d06dceee05d14bd1 100644 (file)
--- 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 f01ef6dc3708a7c9b8d7ff406e45fdb59efe1311..c8b42cac5e21e5a20198dd78e6f1abe4ca181177 100644 (file)
--- 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 91cbc7e6a2614657f92ba6dd53ca44e7c1c435ed..186fe5ceacf15e121e0c2899b98b568a4bcaa16d 100644 (file)
--- 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 b04ebfcbd09edc88143bfa04c9a86019eefcad6c..582f88e1034c5d8ae219c34d3306ee47410fedca 100644 (file)
--- 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 02f9b477f4fe73f358cd8a8c7fe4cd70d0a12550..0471c2750fb4cc735906a22b73bcc6b9af1422e5 100644 (file)
--- 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 bd7fb36ee6fca97ccbd3b47b8e46dd54f8efe26f..b144115c0bcbb605c6dd3acde9b2ca5406b1c936 100644 (file)
--- 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 cd300bbe218c90e61b3955825d07b0dada4ef190..81916e2890a07d58e23facc032a980ba6098b2bb 100644 (file)
--- 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 ed9fb22ae349fcac8174ee691ea7c84ca0a7d6ab..e2abc9587f0442df12c21d246b13dcf587a555fa 100644 (file)
--- 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 7f11f411230b6fa2d19a54b1a37fc6e439e1b925..f2c72e3e9de333e8f36d4002a56ec0b52ee937c8 100644 (file)
--- 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 18663d7664dcf72335b9da969b9a4dd7f74f7ded..b87a0722744e39c584723d920edc02ecbd1f2dad 100644 (file)
--- 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 f6d4803506940cadde226c74624432c2ea86434e..20766fa62b161570c50f15bb19a255f0cf73ad0c 100644 (file)
--- 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 2fdf455b02b4d0e9018e9f32ad93640d971af37c..73e3d9bba8f110ae34141f5e38bf063a09f94eb8 100644 (file)
--- 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 590a4dba8d386bb68c1b306d9a4e1482fb41eb30..72134fe7013180f3a050a2c9bda69ac1bfe465b8 100644 (file)
--- 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 ca30114a585b281f1eb24100780e5114d270b6ad..47c703ccc8596936166d3596b8be3a9afc367b2e 100644 (file)
--- 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 8ec3c7c24a02b88af8687357eb5ccebef06eec39..58c8854a537f63772b84a6fe45cbe03e04fc64b3 100644 (file)
--- 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 d03f5135339d6d1151ac070bde9c65f5048ef449..c8426bd905a7b18b8d24a9063f88199a719d82d9 100644 (file)
--- 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 d3e8c7a9306d5a4d6425af980f0a588caeb50c3e..19356fdeea07b29786c1b5bc8225481e34bd266f 100644 (file)
--- 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 dc5aeac43cec7e2142a86b51aea0a7be0cd51233..fda5a205559025f6533a611de352ef9c6179e367 100644 (file)
--- 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 8c7fae0902542491693933bb759cdd4972a746c2..a4cfba45bb41be53474a2406dbe0f521d039edee 100644 (file)
--- 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 9dcd8cfa6f962d91f18d7f30f558815b613c47a7..9031b7a4699449c7bee4ca19966cae8ebad5d0ec 100644 (file)
--- 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 577c68a4476278ab44aef6d8109bfe00e6e256a0..9c3b0a20d22e11fd02f6e17b460cfc2670554eb0 100644 (file)
--- 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 121b0a86b475caf323a25ff4e49e994cd7ad327b..84340e0ea652ff545449fc3ec3b689a8187f31c4 100644 (file)
--- 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 c9ad6e80e2f21082be9fea2005a5f98b504c9b98..3ba1e4b5001db965f9f808574f6510e04df5e4a6 100644 (file)
--- 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 d1a6941a9400ad4102024bbf26ed80bff7ad3d69..11a8e44f093c390a909adf6e471c137dac81f989 100644 (file)
--- 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 2aa75c19debe64bef15f732d76fa4e3fd04520a5..05b8ae5e35c971873b1b2706b5f47db0b3f29cd9 100644 (file)
--- 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 451c8da6c95f36a05ea0abe2c286ffd1972d1417..8ce8125eca9eeeffb62b333248af06acdb4041c1 100644 (file)
--- 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 9b68c5207f599ed3be3af424fae72f6a883dcd1e..fc24cc6133333f88b160b0b726a44d959c88c54a 100644 (file)
--- 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 36d1eb149e139acc7812ef13cd8996e2e7d3bebf..13d343d93b7d4501f80d09d49a91b59725a5d6bf 100644 (file)
--- 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 8f75038efb0f3ba7c0853ead0fdd90fd93f6f9f5..e79a43892a1e1aeca83750b859d3648f94b1c49f 100644 (file)
--- 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 b8b81359030510f5088885d96f92cf0509173c3f..38cce4c4085df9894c61075ab01b633ea61ed1e8 100644 (file)
--- 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 932e190aebaad2d34547f8bc5617e5f6030e3613..c6576d5a20e14f2cc12b6dc47fe8fd475c4bf4b9 100644 (file)
--- 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 a57daba216bbd7b3887f64c1a9c837a9b41babd2..29e6d4bbd1500b46fdcb2e8db9003ff65ba0bc2a 100644 (file)
--- 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 9516551b443c24a4ea3deecd0605961403c5b427..0de8a970bc0991996dfaa5dccbefd16d814a41cb 100644 (file)
--- 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 84b1e9676d0a08521a80f88abe65de27989b13f7..d14b0539e224918c4c1f4306165e7865c006ed91 100644 (file)
--- 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 184fdf0f8ed10443943b2fa4ba64c092dffe6787..1f5e1684c87985e7ff1441bf3b6e0eb26216ff4b 100644 (file)
--- 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 5906c2a8c9557ccab51057bbc718f0776a930a39..f72b4597fb7035825353dc4c260a0fe3b0fd4470 100644 (file)
--- 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 b9f183a5b163be1ca969517c83f7b2f92f9ce938..c498225952d2323827a3583d32905fa800b23245 100644 (file)
--- 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 651350b62e045e7a4a38bf006cb83e26f5a0fc62..950910122542ac39719e35b8c68d572d5d8b5b68 100644 (file)
--- 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 349ab55bf8a7d465c7412cc21010836ee7ae4a11..379f3892be6e1d2075095c94da3f3dbbe204c35a 100644 (file)
--- 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 9680b76f347c3a7ac526706f12ef3caeedf4941f..2e91c5e9cdd6862ddc587534006ef36db7973ea7 100644 (file)
--- 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 5e5346518bec4a152b34e8abc84363a95021c703..c1a9534cb41f5598c6f089528afe3ce23b0ef66f 100644 (file)
--- 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 5e5a9116ff41a510bdcd3d7f6ac8f9e376627c76..80a6ac62789865bd8c85f3ee6649e538bac8819b 100644 (file)
--- 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 fd19554b36264811bdaa0e81ac3c3484c5b68cab..ff8e76a7b07594d1c17d4d2dbd39a8a0fa6f82f1 100644 (file)
--- 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 6105413dadc6f684bc6a03f57522b9fa8aea5137..652e766b5080361d8756903435387a9d3897ff3f 100644 (file)
--- 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 803bd0cd7e81981f140b7b3aee13e82a7bde83b2..1063d6acf9841593e43230f7318fe97c1424f1ee 100644 (file)
--- 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 71f353eb2fb50b179503cbbdfe09226e67c42f1c..97eab9e4766b26930dabb4484c68c019f5043652 100644 (file)
--- 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 2422ce62b1c9965b4561480cf70fb18be0de31ac..89454971dd8cff5e407394454f60191ea6c58911 100644 (file)
--- 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 6621f9f394831fd992dd539e79e34f23b94e0858..4259f7acb0cf3490c1a88a0cde61d4d1fa407ea4 100644 (file)
--- 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 846b5c226b1b899f674d91d158a27e6797cd5cb9..e4ec5b27268141ee237b76c3986cf3091750627d 100644 (file)
--- 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 2c6feffc4582b4b0c01dd1a498e8e6233682a48f..dc3fe513e9004c556a43e96057ae9881e8375a6d 100644 (file)
--- 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 ddb021564c498aa54e7b6825a351b2126f4ab5ab..5e03477710cbabed90fa2837cf63883392e47383 100644 (file)
--- 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 13dedbcc5ad86ff97a140ec608ccf289f84a7223..bb0b67e93ef2f619605d29821a63e33fb34cbd90 100644 (file)
--- 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 72aba60fb4be2edcf5beed3d8cedc6ae96299fb0..7fcc97c18706fe64bdabb299d0d56aa1fe043a53 100644 (file)
--- 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 63f66ecdd7b7a4dc67e2963c127c464e3ee3a03b..9362bbad2381e9de7e29d8a85304977a86515709 100644 (file)
--- 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 ab646834825bdef33b9ef3f8d5a7b9ccc7782370..cb34899e09baf9e0e64335115ff143afb0718b6d 100644 (file)
--- 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 dbf812d8e36b1248107ee21a8ec9d6491fdf9e9a..7a2cef4a73369dc37a1a8c80cf2f4c46c22044d0 100644 (file)
--- 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 a4c83adc3868e85f9de4c375a8bc29494d0493c8..6fa7b2f819d272cc10575d696a342c0e6633d5b9 100644 (file)
--- 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 e7288bb20d6238a4fd543e4d7bba18af648f8892..a97c94673274a3c66fe490cb01b591b06cbe2805 100644 (file)
--- 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 87216f49936440dc3037938206c684f5e26c5a12..47e4bbd3b36a632302ef1349940ea484a6eb1568 100644 (file)
--- 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 cb1f7f34993dd7af79d82cd310ea77aa5703e99f..e5919482548a90f3facba4cfdaa01361149c1090 100644 (file)
--- 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 64f3991e363fb200f4b66d4680c3d26defc08cc6..9eece42a67119304a107cefe50fdb567fd96253c 100644 (file)
--- 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 4b6f4c67dd4d1824fb50cc8be4092f07c2856c65..22cb72959c9812493b4e360a9c254dcf11cbbb27 100644 (file)
--- 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 c42aca9d63d46271a604bdc338449c849b77bf34..496f03dee7fadc40a084d2f3f87b3b7e1ab35c97 100644 (file)
--- 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 3f5739996292c2d44062adabcfc0a12d28fdec6c..e012ec0e8455058f30a35d62473e106c32e1c05b 100644 (file)
--- 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 49910ac7e4c03adac75841793928def1da88945d..01eefc16618ac6987f9fc7dbdc16570dc7a16906 100644 (file)
--- 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 fb4efb0fa24ededcabc82a14b509e1bf09e46de9..ac3dc2c1b56cca114f74328cd194b62d33fd4706 100644 (file)
--- 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 46789ca8adcbfcc8667aa82bac6257d07800015d..e7aff077f2b739d532f82f0ec618887fc2ce25d3 100644 (file)
--- 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 ef91ca55bc8b0a45cea95085b44fae02238ce796..d75d315ff9882571b871c5ae19051282f8e6487f 100644 (file)
--- 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 dbcc0293a21741aecc9aec00dc8bd0044066d784..1786d1dde5b7d5aeef41fba44fe0fde39f10d2b3 100644 (file)
--- 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 0e654eb75b80dd6804963fb21ffe7668e1ea83e9..ea18032deaa2574d4b4abf91fd0d58aa195c042f 100644 (file)
--- 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 41676510f8860ca3509fbe1e07f4f601b3b95f92..76512d3a934780f3f0acf80cd1ddbf1eec01be27 100644 (file)
--- 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 e65b942bd27389bbb79f264140b41927e695236f..b81784b2770745a568629156e27f67eb4dc0f31a 100644 (file)
--- 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 599da3fe129671db4835d115c64ca8b94d30830f..3a4f946807773bbd6164bad0581f5ed35790df90 100644 (file)
--- 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 ddb8163d5a5956ed4446c0ee4935517ba1ec9a99..c55013c96f74403080e335e6b4968a058ed19552 100644 (file)
--- 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 d023a2774f120da8e82cbd33f58164c87c14fad0..76c1d1608bb338f4ff06b8dda566c5bceccf2a5f 100644 (file)
--- 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 17bffbe5d0b7034b1072d453468cb8b60bfba17a..163262d9a54f380a71db6fa0d53b79256c77cc94 100644 (file)
--- 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 656205fc153cf0e9739b9064cb9f5a3677346b6a..12f46d57f7ce41a58a464949515d2f72cf308ae6 100644 (file)
--- 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 2c77f1cf2b3bdc0e8a66a14981363743f5ef3ef0..138b47d52cd1d1455131c2ae7f906837bdbc55dc 100644 (file)
--- 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 2a289f4ee409b32e75f28cb3879c8f856658789a..50567b3a27045649b34f376e36a29efe4655983b 100644 (file)
--- 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 d87e086bfed60a6afeb71f7fe15fdfae44c39b4c..285b4449e775578e5f4b022b44eeea97d061c8ad 100644 (file)
--- 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 7964eb912764ddc8df2badd799fdbff1b21f2377..bdaa1adc7275c4f3d1fc068062ecb6bcc4bedb5a 100644 (file)
--- 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 2fd67828d95b939b9a44dfaff49ca3fab98e7424..e7a4a45aa03c45e76307e826aa678c6bdbe28917 100644 (file)
--- 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 c746e073f76c35b0acdf95468a040fca565a13d5..7b03bd0596598863cdd11ba905882673a7161e18 100644 (file)
--- 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 02d6cc86b1b8831ef83cfc1e3e53d29430b1937e..71bf01a209c232d34a7546c44781fcc67ff56eab 100644 (file)
--- 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 5e6d3b98df3e5f5b05cbe6abeb9239cbcffd147c..1d82782bef14dd5067558bc8ebcffd83c4f9fd84 100644 (file)
--- 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 e199544f193f55b510ebe0ac88264cbd08b20db9..3e29bfa498a8c73f2e6589698cd0fa3fd17ca676 100644 (file)
--- 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 68e8539a7850eb60d2520d2d65f0b1cc696f681c..05767bc59c736157d1399d0c155c14aed9a0b7f7 100644 (file)
--- 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 42f676eaf9253b025d7877997cd3c33e70b852ae..16ff425a617bbd376cb0cd0e7116d697973ab2e3 100644 (file)
--- 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 ca98de1bfe12936425bb5b7560e6b4b0fc856adf..3b2d8a60729b7ed6b4db12a751d3b73eb75c2cea 100644 (file)
--- 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 863191af478080012fb11b7914012c2df691e2d7..5136dae2c80da64e5e591ce38ede95b4bbbcb006 100644 (file)
--- 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 45de9f4f649b3d957ff713611933fbdd6f85c1bb..8634637434dac35ef44da02d62bd6313ab936db9 100644 (file)
--- 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 f86368801b6dceff21b070a4a90e8c6d94e8acea..9402936f3cff5b6113fd83c9ba8f7014abb8b80f 100644 (file)
--- 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 af0b43f2e97ccf3eceadba80c6ffecc83438c14f..86e865c71f47ce14d2e4af1f4342f1de583a60fc 100644 (file)
--- 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 81e1584a9cfbcd9b9f3f8c617cc0756270e27aa5..5819ab1633575877e39f9be4f417d4e879de1d5f 100644 (file)
--- 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 b523bb067ec1e6eb47c1640b43d1972e1da30970..171d6500789130de62c08bd8bdd0824c22e8f037 100644 (file)
--- 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 5f15534f777b73bd4e9e077a6f201dc2a83be9b3..22dd5f60c79afe283eb0151ddc2bfda1739d53a5 100644 (file)
--- 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 adfd0adf70f52b0a4f4b102a11517ed9a7aa6b33..a554a966fd19d04a3f7e4ca439e9d4a4fe105227 100644 (file)
--- 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 07b80c9d6849673145993dc91a25f59e8593d391..54606bab53794adbcefcd4826072df3a4e06f016 100644 (file)
--- 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 817968881bf248cf085779c24dfa0223fdcdff2a..53e0cc359be66357ea731afbc8d0abe593d1aa92 100644 (file)
--- 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 b1f7b41b53ed9d01efa7bcfad1386b9e88c8a082..7cf22ab778416438272a3fdf7a24bcd483821cde 100644 (file)
--- 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 8c854cc2fb63f8f765b5e412f9e2305cf51fb302..b14bad33293e0570dc769f2e7894a11b81903d58 100644 (file)
--- 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 f60a69e248c29410bff8c2d98ccdfaaf938aeeb7..95bed284fe083da9568179283b0daaa191613c99 100644 (file)
--- 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 150509deaba29bb4961c7ac624392c8ad937f10f..879d3092d55853ecca4ca01991beedd3b5133223 100644 (file)
--- 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 f33830d43ae5ac2c56a9a38608c1321b96f4e555..6b8eee5eed6301d745af6ad97e846f0e715449e8 100644 (file)
--- 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 2106202b57cdb34d1f3999857e93e0337d98f6cf..f40fa959ce77241389bf5df15e5aa990a99b1b1c 100644 (file)
--- 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 c8903cf3e9239ece1a0c6a5c0f191a777644243d..6b7c5e1f6a69ffe252cbbb02c6923798e0532256 100644 (file)
--- 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 517474ef86d6e203cd0bcd46567694b43c3eae8d..0d5ec8ef292f85990a8bc86fb0f0edbdcbd28ec0 100644 (file)
--- 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 c21a61e08959c392416322bde478460d6c99ed85..1e030e66b5cead777377971903e40da551530f54 100644 (file)
--- 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 d77b049db4f678321440860f6392612d2646fab2..ae230bf773c545586eb93b6ff3b94cb4d199f3e5 100644 (file)
--- 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 95ce538cc4319ad0ad144112e2d6f8e8ec02f42e..88915e5087749a14ce568e99a4c8874ef1692ba9 100644 (file)
--- 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 59412d3906cdfeceacb60f1f32a7517dadc4e326..793cdceb71bc5bc2f3c5e6ab7468f59ec55f0015 100644 (file)
--- 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 34c226254c4d70a76f0a986868e0134c3b14e622..3ba1e2a35498b32c2cdcc01cb9c6eac674e35142 100644 (file)
--- 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 c50dc71c6a9a0fe945e463d4795155998d3bb5e0..51d6b64d260a22873bf714e01b4a1c7c1aa26b15 100644 (file)
--- 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 3e022b98672e11d03294a23d36a91d41693d621d..a187d51dcd89ee3691be55c724882ac0908f8583 100644 (file)
--- 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 0d343cde7fc3494642c045e336b41821fe939245..c6ad80a1fa1e311e1cca7811db14a66b31d7f3b5 100644 (file)
--- 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
      {
diff --git a/libgfortran/intrinsics/cshift0.c b/libgfortran/intrinsics/cshift0.c

index 5da73d4e17078fc469b47031265a3e23e6aca535..b3305375f79c6aaa789a0b47c5663e13291ca1ed 100644 (file)
--- a/libgfortran/intrinsics/cshift0.c
+++ b/libgfortran/intrinsics/cshift0.c
@@ -79,8 +79,8 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
           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/intrinsics/ctime.c b/libgfortran/intrinsics/ctime.c

index 05bf31fc779d77859646400a3e63ea23348aac4e..d22851c918ea8cc7b756dda8809573246f243654 100644 (file)
--- a/libgfortran/intrinsics/ctime.c
+++ b/libgfortran/intrinsics/ctime.c
@@ -1,5 +1,5 @@
  /* Implementation of the CTIME and FDATE g77 intrinsics.
-   Copyright (C) 2005, 2007, 2009, 2011 Free Software Foundation, Inc.
+   Copyright (C) 2005, 2007, 2009, 2011, 2012 Free Software Foundation, Inc.
     Contributed by François-Xavier Coudert <coudert@clipper.ens.fr>
  
  This file is part of the GNU Fortran runtime library (libgfortran).
@@ -64,7 +64,7 @@ void
  fdate (char ** date, gfc_charlen_type * date_len)
  {
    time_t now = time(NULL);
-  *date = get_mem (CSZ);
+  *date = xmalloc (CSZ);
    *date_len = strctime (*date, CSZ, &now);
  }
  
@@ -76,7 +76,7 @@ void
  fdate_sub (char * date, gfc_charlen_type date_len)
  {
    time_t now = time(NULL);
-  char *s = get_mem (date_len + 1);
+  char *s = xmalloc (date_len + 1);
    size_t n = strctime (s, date_len + 1, &now);
    fstrcpy (date, date_len, s, n);
    free (s);
@@ -91,7 +91,7 @@ void
  PREFIX(ctime) (char ** date, gfc_charlen_type * date_len, GFC_INTEGER_8 t)
  {
    time_t now = t;
-  *date = get_mem (CSZ);
+  *date = xmalloc (CSZ);
    *date_len = strctime (*date, CSZ, &now);
  }
  
@@ -103,7 +103,7 @@ void
  ctime_sub (GFC_INTEGER_8 * t, char * date, gfc_charlen_type date_len)
  {
    time_t now = *t;
-  char *s = get_mem (date_len + 1);
+  char *s = xmalloc (date_len + 1);
    size_t n = strctime (s, date_len + 1, &now);
    fstrcpy (date, date_len, s, n);
    free (s);
diff --git a/libgfortran/intrinsics/date_and_time.c b/libgfortran/intrinsics/date_and_time.c

index c785f84c0d925c9a432c8c6e6922693750f63b9c..5d8973ec444cc7af950d30866a05a2a6118cc2fc 100644 (file)
--- a/libgfortran/intrinsics/date_and_time.c
+++ b/libgfortran/intrinsics/date_and_time.c
@@ -270,7 +270,7 @@ secnds (GFC_REAL_4 *x)
    GFC_REAL_4 temp1, temp2;
  
    /* Make the INTEGER*4 array for passing to date_and_time.  */
-  gfc_array_i4 *avalues = internal_malloc_size (sizeof (gfc_array_i4));
+  gfc_array_i4 *avalues = xmalloc (sizeof (gfc_array_i4));
    avalues->base_addr = &values[0];
    GFC_DESCRIPTOR_DTYPE (avalues) = ((BT_REAL << GFC_DTYPE_TYPE_SHIFT)
                                         & GFC_DTYPE_TYPE_MASK) +
diff --git a/libgfortran/intrinsics/eoshift0.c b/libgfortran/intrinsics/eoshift0.c

index 8b7dd0a641f667e2c6c0d6670e81ee86f1bf6a44..f4cd424f06199ebbf0a8783464816f943a2b349c 100644 (file)
--- a/libgfortran/intrinsics/eoshift0.c
+++ b/libgfortran/intrinsics/eoshift0.c
@@ -86,8 +86,8 @@ eoshift0 (gfc_array_char * ret, const gfc_array_char * array,
  
          }
  
-      /* 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/intrinsics/eoshift2.c b/libgfortran/intrinsics/eoshift2.c

index cd2a827fbfce45fd480b9b4cfad2486da72c2647..d0d0bf14e046690666c1d3e693ec3777c4305c56 100644 (file)
--- a/libgfortran/intrinsics/eoshift2.c
+++ b/libgfortran/intrinsics/eoshift2.c
@@ -91,8 +91,8 @@ eoshift2 (gfc_array_char *ret, const gfc_array_char *array,
  
           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);
  
          }
      }
diff --git a/libgfortran/intrinsics/getlog.c b/libgfortran/intrinsics/getlog.c

index f4fc0f6e5ef344e7722d88984203ce06ac6f66e8..92338c1fb8d2b1ddea72b0b6049ddccf6377856b 100644 (file)
--- a/libgfortran/intrinsics/getlog.c
+++ b/libgfortran/intrinsics/getlog.c
@@ -1,5 +1,5 @@
  /* Implementation of the GETLOG g77 intrinsic.
-   Copyright (C) 2005, 2007, 2009, 2011 Free Software Foundation, Inc.
+   Copyright (C) 2005, 2007, 2009, 2011, 2012 Free Software Foundation, Inc.
     Contributed by François-Xavier Coudert <coudert@clipper.ens.fr>
  
  This file is part of the GNU Fortran runtime library (libgfortran).
@@ -86,7 +86,7 @@ PREFIX(getlog) (char * login, gfc_charlen_type login_len)
       targets; we do something simple in case the target doesn't
       support sysconf.  */
    static const size_t buflen = 1024;
-  buf = get_mem (buflen);
+  buf = xmalloc (buflen);
    err = getpwuid_r (geteuid (), &pwd, buf, buflen, &result);
    if (err != 0 || result == NULL)
      goto cleanup;
diff --git a/libgfortran/intrinsics/pack_generic.c b/libgfortran/intrinsics/pack_generic.c

index 77d600a5ecc471eb1492931cba0bd5c0c13be411..4df3f93a7c5f169bc57d6fa46b5c78eb459d6661 100644 (file)
--- a/libgfortran/intrinsics/pack_generic.c
+++ b/libgfortran/intrinsics/pack_generic.c
@@ -153,8 +153,8 @@ pack_internal (gfc_array_char *ret, const gfc_array_char *array,
           GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
  
           ret->offset = 0;
-         /* internal_malloc_size allocates a single byte for zero size.  */
-         ret->base_addr = internal_malloc_size (size * total);
+         /* xmalloc allocates a single byte for zero size.  */
+         ret->base_addr = xmalloc (size * total);
  
           if (total == 0)
             return;      /* In this case, nothing remains to be done.  */
@@ -520,7 +520,7 @@ pack_s_internal (gfc_array_char *ret, const gfc_array_char *array,
  
        ret->offset = 0;
  
-      ret->base_addr = internal_malloc_size (size * total);
+      ret->base_addr = xmalloc (size * total);
  
        if (total == 0)
         return;
diff --git a/libgfortran/intrinsics/reshape_generic.c b/libgfortran/intrinsics/reshape_generic.c

index b16690ac1fc498fa9fd8e3402d04a83fb43df0fa..ec8ea23976f4f6bd1da0b544c82e3998d7b39e6d 100644 (file)
--- a/libgfortran/intrinsics/reshape_generic.c
+++ b/libgfortran/intrinsics/reshape_generic.c
@@ -103,7 +103,7 @@ reshape_internal (parray *ret, parray *source, shape_type *shape,
        else
         alloc_size = rs * size;
  
-      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/intrinsics/spread_generic.c b/libgfortran/intrinsics/spread_generic.c

index 2a478f1889955cb3cb4073601aa0880d4bb015a9..40450bd7f6fd5a3fe462f0b6e657fe59dbaf0263 100644 (file)
--- a/libgfortran/intrinsics/spread_generic.c
+++ b/libgfortran/intrinsics/spread_generic.c
@@ -1,5 +1,6 @@
  /* Generic implementation of the SPREAD intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2010, 2012 
+   Free Software Foundation, Inc.
     Contributed by Paul Brook <paul@nowt.org>
  
  This file is part of the GNU Fortran runtime library (libgfortran).
@@ -100,7 +101,7 @@ spread_internal (gfc_array_char *ret, const gfc_array_char *source,
           GFC_DIMENSION_SET(ret->dim[n], 0, ub, stride);
         }
        ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * size);
+      ret->base_addr = xmalloc (rs * size);
  
        if (rs <= 0)
         return;
@@ -245,7 +246,7 @@ spread_internal_scalar (gfc_array_char *ret, const char *source,
  
    if (ret->base_addr == NULL)
      {
-      ret->base_addr = internal_malloc_size (ncopies * size);
+      ret->base_addr = xmalloc (ncopies * size);
        ret->offset = 0;
        GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
      }
diff --git a/libgfortran/intrinsics/string_intrinsics_inc.c b/libgfortran/intrinsics/string_intrinsics_inc.c

index 8335a38d949143bfb61f1af123f7a6cbc27b494e..b20483da2c4b30079680b749e6f6ac6198260153 100644 (file)
--- a/libgfortran/intrinsics/string_intrinsics_inc.c
+++ b/libgfortran/intrinsics/string_intrinsics_inc.c
@@ -1,5 +1,5 @@
  /* String intrinsics helper functions.
-   Copyright 2002, 2005, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2008, 2009, 2012 Free Software Foundation, Inc.
  
  This file is part of the GNU Fortran runtime library (libgfortran).
  
@@ -167,7 +167,7 @@ string_trim (gfc_charlen_type *len, CHARTYPE **dest, gfc_charlen_type slen,
    else
      {
        /* Allocate space for result string.  */
-      *dest = internal_malloc_size (*len * sizeof (CHARTYPE));
+      *dest = xmalloc (*len * sizeof (CHARTYPE));
  
        /* Copy string if necessary.  */
        memcpy (*dest, src, *len * sizeof (CHARTYPE));
@@ -445,7 +445,7 @@ string_minmax (gfc_charlen_type *rlen, CHARTYPE **dest, int op, int nargs, ...)
      *dest = &zero_length_string;
    else
      {
-      CHARTYPE *tmp = internal_malloc_size (*rlen * sizeof (CHARTYPE));
+      CHARTYPE *tmp = xmalloc (*rlen * sizeof (CHARTYPE));
        memcpy (tmp, res, reslen * sizeof (CHARTYPE));
        MEMSET (&tmp[reslen], ' ', *rlen - reslen);
        *dest = tmp;
diff --git a/libgfortran/intrinsics/transpose_generic.c b/libgfortran/intrinsics/transpose_generic.c

index 03fbbef24edaf1ab81fc67be012a7220c5e4e121..b5bae415681b11e0149f0c890e5e8822068dbcfd 100644 (file)
--- a/libgfortran/intrinsics/transpose_generic.c
+++ b/libgfortran/intrinsics/transpose_generic.c
@@ -60,7 +60,7 @@ transpose_internal (gfc_array_char *ret, gfc_array_char *source)
        GFC_DIMENSION_SET(ret->dim[1], 0, GFC_DESCRIPTOR_EXTENT(source,0) - 1,
                         GFC_DESCRIPTOR_EXTENT(source, 1));
  
-      ret->base_addr = internal_malloc_size (size * size0 ((array_t*)ret));
+      ret->base_addr = xmalloc (size * size0 ((array_t*)ret));
        ret->offset = 0;
      }
    else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/intrinsics/unpack_generic.c b/libgfortran/intrinsics/unpack_generic.c

index 123f5e1980fd40fd4289b66dd4c1400a300649fe..7f92cf52b19f80e1f4df04dc5812b9067dd79c1f 100644 (file)
--- a/libgfortran/intrinsics/unpack_generic.c
+++ b/libgfortran/intrinsics/unpack_generic.c
@@ -126,7 +126,7 @@ unpack_internal (gfc_array_char *ret, const gfc_array_char *vector,
           rs *= extent[n];
         }
        ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * size);
+      ret->base_addr = xmalloc (rs * size);
      }
    else
      {
diff --git a/libgfortran/io/fbuf.c b/libgfortran/io/fbuf.c

index 353e5aec9d31749b1e8003412a67e127ea887cb4..6dacc5455effdb32757bf8e29398c9ca3884ecb9 100644 (file)
--- a/libgfortran/io/fbuf.c
+++ b/libgfortran/io/fbuf.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2008, 2009, 2010 Free Software Foundation, Inc.
+/* Copyright (C) 2008, 2009, 2010, 2012 Free Software Foundation, Inc.
     Contributed by Janne Blomqvist
  
  This file is part of the GNU Fortran runtime library (libgfortran).
@@ -39,8 +39,8 @@ fbuf_init (gfc_unit * u, int len)
    if (len == 0)
      len = 512;                 /* Default size.  */
  
-  u->fbuf = get_mem (sizeof (struct fbuf));
-  u->fbuf->buf = get_mem (len);
+  u->fbuf = xmalloc (sizeof (struct fbuf));
+  u->fbuf->buf = xmalloc (len);
    u->fbuf->len = len;
    u->fbuf->act = u->fbuf->pos = 0;
  }
diff --git a/libgfortran/io/format.c b/libgfortran/io/format.c

index 1711a75dd0a5f492282ab3481e051a57cd40c2cf..afa5f34b9370844422a4e2f8be397a05e6bbb6a4 100644 (file)
--- a/libgfortran/io/format.c
+++ b/libgfortran/io/format.c
@@ -1,4 +1,5 @@
-/* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+/* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 
+   2012
     Free Software Foundation, Inc.
     Contributed by Andy Vaught
     F2003 I/O support contributed by Jerry DeLisle
@@ -150,7 +151,7 @@ save_parsed_format (st_parameter_dt *dtp)
    u->format_hash_table[hash].hashed_fmt = NULL;
  
    free (u->format_hash_table[hash].key);
-  u->format_hash_table[hash].key = get_mem (dtp->format_len);
+  u->format_hash_table[hash].key = xmalloc (dtp->format_len);
    memcpy (u->format_hash_table[hash].key, dtp->format, dtp->format_len);
  
    u->format_hash_table[hash].key_len = dtp->format_len;
@@ -223,7 +224,7 @@ get_fnode (format_data *fmt, fnode **head, fnode **tail, format_token t)
  
    if (fmt->avail == &fmt->last->array[FARRAY_SIZE])
      {
-      fmt->last->next = get_mem (sizeof (fnode_array));
+      fmt->last->next = xmalloc (sizeof (fnode_array));
        fmt->last = fmt->last->next;
        fmt->last->next = NULL;
        fmt->avail = &fmt->last->array[0];
@@ -1225,7 +1226,7 @@ parse_format (st_parameter_dt *dtp)
  
    /* Not found so proceed as follows.  */
  
-  dtp->u.p.fmt = fmt = get_mem (sizeof (format_data));
+  dtp->u.p.fmt = fmt = xmalloc (sizeof (format_data));
    fmt->format_string = dtp->format;
    fmt->format_string_len = dtp->format_len;
  
diff --git a/libgfortran/io/intrinsics.c b/libgfortran/io/intrinsics.c

index 22150e70ce98de66f5745edeb76e22f813b3dcf8..576434a8e4c0cf44d96d51817ae43b3d5f854f73 100644 (file)
--- a/libgfortran/io/intrinsics.c
+++ b/libgfortran/io/intrinsics.c
@@ -1,6 +1,6 @@
  /* Implementation of the FGET, FGETC, FPUT, FPUTC, FLUSH 
     FTELL, TTYNAM and ISATTY intrinsics.
-   Copyright (C) 2005, 2007, 2009, 2010, 2011 Free Software
+   Copyright (C) 2005, 2007, 2009, 2010, 2011, 2012 Free Software
     Foundation, Inc.
  
  This file is part of the GNU Fortran runtime library (libgfortran).
@@ -380,7 +380,7 @@ ttynam (char ** name, gfc_charlen_type * name_len, int unit)
    u = find_unit (unit);
    if (u != NULL)
      {
-      *name = get_mem (TTY_NAME_MAX);
+      *name = xmalloc (TTY_NAME_MAX);
        int err = stream_ttyname (u->s, *name, TTY_NAME_MAX);
        if (err == 0)
         {
diff --git a/libgfortran/io/list_read.c b/libgfortran/io/list_read.c

index 91b345cb930b589b289792c613442762625a4040..2024fcd9b6cf8fc6d331e90e931395303565840f 100644 (file)
--- a/libgfortran/io/list_read.c
+++ b/libgfortran/io/list_read.c
@@ -2282,7 +2282,7 @@ nml_touch_nodes (namelist_info * nl)
  {
    index_type len = strlen (nl->var_name) + 1;
    int dim;
-  char * ext_name = (char*)get_mem (len + 1);
+  char * ext_name = (char*)xmalloc (len + 1);
    memcpy (ext_name, nl->var_name, len-1);
    memcpy (ext_name + len - 1, "%", 2);
    for (nl = nl->next; nl; nl = nl->next)
@@ -2540,7 +2540,7 @@ nml_read_obj (st_parameter_dt *dtp, namelist_info * nl, index_type offset,
  
           case BT_DERIVED:
             obj_name_len = strlen (nl->var_name) + 1;
-           obj_name = get_mem (obj_name_len+1);
+           obj_name = xmalloc (obj_name_len+1);
             memcpy (obj_name, nl->var_name, obj_name_len-1);
             memcpy (obj_name + obj_name_len - 1, "%", 2);
  
diff --git a/libgfortran/io/open.c b/libgfortran/io/open.c

index 8f969edb5e131a23c8c696c26920b31243d18540..d086d2edfef9406ee8669c7159726ec7d4e592ac 100644 (file)
--- a/libgfortran/io/open.c
+++ b/libgfortran/io/open.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011
+/* Copyright (C) 2002, 2003, 2004, 2005, 2007, 2008, 2009, 2010, 2011, 2012
     Free Software Foundation, Inc.
     Contributed by Andy Vaught
     F2003 I/O support contributed by Jerry DeLisle
@@ -538,7 +538,7 @@ new_unit (st_parameter_open *opp, gfc_unit *u, unit_flags * flags)
  
    /* Create the unit structure.  */
  
-  u->file = get_mem (opp->file_len);
+  u->file = xmalloc (opp->file_len);
    if (u->unit_number != opp->common.unit)
      internal_error (&opp->common, "Unit number changed");
    u->s = s;
diff --git a/libgfortran/io/transfer.c b/libgfortran/io/transfer.c

index f71e96f75de9f0456419bc027b83f4d981d882fd..6dda1df8a1306079dd1d9781e90d0277d4d34a21 100644 (file)
--- a/libgfortran/io/transfer.c
+++ b/libgfortran/io/transfer.c
@@ -3650,11 +3650,11 @@ st_set_nml_var (st_parameter_dt *dtp, void * var_addr, char * var_name,
    namelist_info *nml;
    size_t var_name_len = strlen (var_name);
  
-  nml = (namelist_info*) get_mem (sizeof (namelist_info));
+  nml = (namelist_info*) xmalloc (sizeof (namelist_info));
  
    nml->mem_pos = var_addr;
  
-  nml->var_name = (char*) get_mem (var_name_len + 1);
+  nml->var_name = (char*) xmalloc (var_name_len + 1);
    memcpy (nml->var_name, var_name, var_name_len);
    nml->var_name[var_name_len] = '\0';
  
@@ -3668,9 +3668,9 @@ st_set_nml_var (st_parameter_dt *dtp, void * var_addr, char * var_name,
    if (nml->var_rank > 0)
      {
        nml->dim = (descriptor_dimension*)
-                  get_mem (nml->var_rank * sizeof (descriptor_dimension));
+                  xmalloc (nml->var_rank * sizeof (descriptor_dimension));
        nml->ls = (array_loop_spec*)
-                 get_mem (nml->var_rank * sizeof (array_loop_spec));
+                 xmalloc (nml->var_rank * sizeof (array_loop_spec));
      }
    else
      {
diff --git a/libgfortran/io/unit.c b/libgfortran/io/unit.c

index 5fe9eb2b52299849251e7427f15163717e6e261b..d5029dcac2782964194cc12046caf9daa42581bc 100644 (file)
--- a/libgfortran/io/unit.c
+++ b/libgfortran/io/unit.c
@@ -409,7 +409,7 @@ get_internal_unit (st_parameter_dt *dtp)
      {
        iunit->rank = GFC_DESCRIPTOR_RANK (dtp->internal_unit_desc);
        iunit->ls = (array_loop_spec *)
-       get_mem (iunit->rank * sizeof (array_loop_spec));
+       xmalloc (iunit->rank * sizeof (array_loop_spec));
        dtp->internal_unit_len *=
         init_loop_spec (dtp->internal_unit_desc, iunit->ls, &start_record);
  
@@ -542,7 +542,7 @@ init_units (void)
        u->endfile = NO_ENDFILE;
  
        u->file_len = strlen (stdin_name);
-      u->file = get_mem (u->file_len);
+      u->file = xmalloc (u->file_len);
        memmove (u->file, stdin_name, u->file_len);
  
        fbuf_init (u, 0);
@@ -572,7 +572,7 @@ init_units (void)
        u->endfile = AT_ENDFILE;
      
        u->file_len = strlen (stdout_name);
-      u->file = get_mem (u->file_len);
+      u->file = xmalloc (u->file_len);
        memmove (u->file, stdout_name, u->file_len);
        
        fbuf_init (u, 0);
@@ -602,7 +602,7 @@ init_units (void)
        u->endfile = AT_ENDFILE;
  
        u->file_len = strlen (stderr_name);
-      u->file = get_mem (u->file_len);
+      u->file = xmalloc (u->file_len);
        memmove (u->file, stderr_name, u->file_len);
        
        fbuf_init (u, 256);  /* 256 bytes should be enough, probably not doing
@@ -759,7 +759,7 @@ filename_from_unit (int n)
    /* Get the filename.  */
    if (u != NULL)
      {
-      filename = (char *) get_mem (u->file_len + 1);
+      filename = (char *) xmalloc (u->file_len + 1);
        unpack_filename (filename, u->file, u->file_len);
        return filename;
      }
diff --git a/libgfortran/io/unix.c b/libgfortran/io/unix.c

index 31fa0059c9cf78fee68cc008c793bf091a5b7398..278decd6775937bc69059ddf8af9f03ccfb70960 100644 (file)
--- a/libgfortran/io/unix.c
+++ b/libgfortran/io/unix.c
@@ -639,7 +639,7 @@ buf_init (unix_stream * s)
  {
    s->st.vptr = &buf_vtable;
  
-  s->buffer = get_mem (BUFFER_SIZE);
+  s->buffer = xmalloc (BUFFER_SIZE);
    return 0;
  }
  
@@ -1082,7 +1082,7 @@ tempfile (st_parameter_open *opp)
      slash = "";
  
    // Take care that the template is longer in the mktemp() branch.
-  template = get_mem (tempdirlen + 23);
+  template = xmalloc (tempdirlen + 23);
  
  #ifdef HAVE_MKSTEMP
    snprintf (template, tempdirlen + 23, "%s%sgfortrantmpXXXXXX", 
diff --git a/libgfortran/io/write.c b/libgfortran/io/write.c

index 8be3a5a72bf5322a05d9cde0e54c8410700a8651..838bc0d6688fb15aa54520ef9751aa090d3b707f 100644 (file)
--- a/libgfortran/io/write.c
+++ b/libgfortran/io/write.c
@@ -1,4 +1,5 @@
-/* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
+/* Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 
+   2012
     Free Software Foundation, Inc.
     Contributed by Andy Vaught
     Namelist output contributed by Paul Thomas
@@ -1864,7 +1865,7 @@ nml_write_obj (st_parameter_dt *dtp, namelist_info * obj, index_type offset,
               base_var_name_len = base ? strlen (base->var_name) : 0;
               ext_name_len = base_name_len + base_var_name_len 
                 + strlen (obj->var_name) + obj->var_rank * NML_DIGITS + 1;
-             ext_name = (char*)get_mem (ext_name_len);
+             ext_name = (char*)xmalloc (ext_name_len);
  
               memcpy (ext_name, base_name, base_name_len);
               clen = strlen (obj->var_name + base_var_name_len);
@@ -1893,7 +1894,7 @@ nml_write_obj (st_parameter_dt *dtp, namelist_info * obj, index_type offset,
               /* Now obj_name.  */
  
               obj_name_len = strlen (obj->var_name) + 1;
-             obj_name = get_mem (obj_name_len+1);
+             obj_name = xmalloc (obj_name_len+1);
               memcpy (obj_name, obj->var_name, obj_name_len-1);
               memcpy (obj_name + obj_name_len-1, "%", 2);
  
diff --git a/libgfortran/libgfortran.h b/libgfortran/libgfortran.h

index 186bfbe9864ebd6887e8cb07d530e2aae5852506..be5f133bb836f9949bb2ef6ff7fd6ae83be1afcd 100644 (file)
--- a/libgfortran/libgfortran.h
+++ b/libgfortran/libgfortran.h
@@ -753,11 +753,8 @@ internal_proto(set_fpu);
  
  /* memory.c */
  
-extern void *get_mem (size_t) __attribute__ ((malloc));
-internal_proto(get_mem);
-
-extern void *internal_malloc_size (size_t) __attribute__ ((malloc));
-internal_proto(internal_malloc_size);
+extern void *xmalloc (size_t) __attribute__ ((malloc));
+internal_proto(xmalloc);
  
  extern void *xcalloc (size_t, size_t) __attribute__ ((malloc));
  internal_proto(xcalloc);
diff --git a/libgfortran/m4/bessel.m4 b/libgfortran/m4/bessel.m4

index d9e7f893f8ecdafbf012eed33e5f3d752244af83..d5c602dbf4c62f454d04984793fb0d0557db2078 100644 (file)
--- a/libgfortran/m4/bessel.m4
+++ b/libgfortran/m4/bessel.m4
@@ -56,7 +56,7 @@ bessel_jn_r'rtype_kind` ('rtype` * const restrict ret, int n1, int n2, 'rtype_na
      {
        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 ('rtype_name`) * size);
+      ret->base_addr = xmalloc (sizeof ('rtype_name`) * size);
        ret->offset = 0;
      }
  
@@ -123,7 +123,7 @@ bessel_yn_r'rtype_kind` ('rtype` * 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 ('rtype_name`) * size);
+      ret->base_addr = xmalloc (sizeof ('rtype_name`) * size);
        ret->offset = 0;
      }
  
diff --git a/libgfortran/m4/cshift1.m4 b/libgfortran/m4/cshift1.m4

index 88fce1aa9b7d15c6604c61a633a127f6c43fb05d..40d34fb14a763df6cfcd138ab457905f80a22fae 100644 (file)
--- a/libgfortran/m4/cshift1.m4
+++ b/libgfortran/m4/cshift1.m4
@@ -81,7 +81,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/m4/eoshift1.m4 b/libgfortran/m4/eoshift1.m4

index 691edd1733c065e9545d672051ca7da8de31dda2..637bdaea1a096926ce9adbce2fc17ddb7504352b 100644 (file)
--- a/libgfortran/m4/eoshift1.m4
+++ b/libgfortran/m4/eoshift1.m4
@@ -106,8 +106,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/m4/eoshift3.m4 b/libgfortran/m4/eoshift3.m4

index b5c8bb4ff43935fe7d4f7f9b331fe64caed41d3d..e1d74fe377edb49a12791952476d947b7b105f21 100644 (file)
--- a/libgfortran/m4/eoshift3.m4
+++ b/libgfortran/m4/eoshift3.m4
@@ -90,7 +90,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++)
@@ -108,8 +108,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/m4/iforeach.m4 b/libgfortran/m4/iforeach.m4

index 86d43506c6accb7965a6a5caef1915bce3dfa733..a875a2ac2731d8183203b48a71c796132aaaca41 100644 (file)
--- a/libgfortran/m4/iforeach.m4
+++ b/libgfortran/m4/iforeach.m4
@@ -30,7 +30,7 @@ name`'rtype_qual`_'atype_code (rtype * 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 (rtype_name) * rank);
+      retarray->base_addr = xmalloc (sizeof (rtype_name) * rank);
      }
    else
      {
@@ -133,7 +133,7 @@ void
        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 (rtype_name) * rank);
+      retarray->base_addr = xmalloc (sizeof (rtype_name) * rank);
      }
    else
      {
@@ -264,7 +264,7 @@ void
        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 (rtype_name) * rank);
+      retarray->base_addr = xmalloc (sizeof (rtype_name) * rank);
      }
    else if (unlikely (compile_options.bounds_check))
      {
diff --git a/libgfortran/m4/ifunction.m4 b/libgfortran/m4/ifunction.m4

index 1cd30739cd5b520df8d09b1f5040986218abb6f9..613fbf5dad5f0fdeb6ceffce553533dd1f875ee3 100644 (file)
--- a/libgfortran/m4/ifunction.m4
+++ b/libgfortran/m4/ifunction.m4
@@ -88,7 +88,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
        alloc_size = sizeof (rtype_name) * 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.  */
@@ -273,7 +273,7 @@ void
           return;
         }
        else
-       retarray->base_addr = internal_malloc_size (alloc_size);
+       retarray->base_addr = xmalloc (alloc_size);
  
      }
    else
@@ -432,7 +432,7 @@ void
           return;
         }
        else
-       retarray->base_addr = internal_malloc_size (alloc_size);
+       retarray->base_addr = xmalloc (alloc_size);
      }
    else
      {
diff --git a/libgfortran/m4/ifunction_logical.m4 b/libgfortran/m4/ifunction_logical.m4

index b36e8e04ae308059fe537c363289ea71e7c489a8..13dd7a928f30590373480cf76c5cdd2466e696e2 100644 (file)
--- a/libgfortran/m4/ifunction_logical.m4
+++ b/libgfortran/m4/ifunction_logical.m4
@@ -99,7 +99,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
           return;
         }
        else
-       retarray->base_addr = internal_malloc_size (alloc_size);
+       retarray->base_addr = xmalloc (alloc_size);
      }
    else
      {
diff --git a/libgfortran/m4/in_pack.m4 b/libgfortran/m4/in_pack.m4

index 7cee37bd6477714f76a31494435538f46449643f..aad3dab77667e2d4e5dc116aba34d21a09b211fc 100644 (file)
--- a/libgfortran/m4/in_pack.m4
+++ b/libgfortran/m4/in_pack.m4
@@ -79,7 +79,7 @@ internal_pack_'rtype_ccode` ('rtype` * source)
      return source->base_addr;
  
    /* Allocate storage for the destination.  */
-  destptr = ('rtype_name` *)internal_malloc_size (ssize * sizeof ('rtype_name`));
+  destptr = ('rtype_name` *)xmalloc (ssize * sizeof ('rtype_name`));
    dest = destptr;
    src = source->base_addr;
    stride0 = stride[0];
diff --git a/libgfortran/m4/matmul.m4 b/libgfortran/m4/matmul.m4

index 6a7ce5c49ef2d48ec989fdf6167e4108febf6f0c..6a58cd91adbe93dd0a8bf58b4d3f91642e7408e1 100644 (file)
--- a/libgfortran/m4/matmul.m4
+++ b/libgfortran/m4/matmul.m4
@@ -125,7 +125,7 @@ matmul_'rtype_code` ('rtype` * const restrict retarray,
          }
  
        retarray->base_addr
-       = internal_malloc_size (sizeof ('rtype_name`) * size0 ((array_t *) retarray));
+       = xmalloc (sizeof ('rtype_name`) * size0 ((array_t *) retarray));
        retarray->offset = 0;
      }
      else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/m4/matmull.m4 b/libgfortran/m4/matmull.m4

index 87245ae04a297e78543d551c9ea2442486af1a1e..73c508828c47b5b06164df09588b0e98c531fbe8 100644 (file)
--- a/libgfortran/m4/matmull.m4
+++ b/libgfortran/m4/matmull.m4
@@ -89,7 +89,7 @@ matmul_'rtype_code` ('rtype` * const restrict retarray,
          }
            
        retarray->base_addr
-       = internal_malloc_size (sizeof ('rtype_name`) * size0 ((array_t *) retarray));
+       = xmalloc (sizeof ('rtype_name`) * size0 ((array_t *) retarray));
        retarray->offset = 0;
      }
      else if (unlikely (compile_options.bounds_check))
diff --git a/libgfortran/m4/pack.m4 b/libgfortran/m4/pack.m4

index e88e84e0adce2eb948d431e35b0477c5079bf3b2..bc7f3b92f75ba9a9b671225254d4ea76da2194c3 100644 (file)
--- a/libgfortran/m4/pack.m4
+++ b/libgfortran/m4/pack.m4
@@ -169,8 +169,8 @@ pack_'rtype_code` ('rtype` *ret, const 'rtype` *array,
  
           ret->offset = 0;
  
-         /* internal_malloc_size allocates a single byte for zero size.  */
-         ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * total);
+         /* xmalloc allocates a single byte for zero size.  */
+         ret->base_addr = xmalloc (sizeof ('rtype_name`) * total);
  
           if (total == 0)
             return;
diff --git a/libgfortran/m4/parity.m4 b/libgfortran/m4/parity.m4

index 037e96db913deae53553c82070d0f84231f83247..6ff0ad2e8175a0b91621d8e8dc84cbae21fe1b54 100644 (file)
--- a/libgfortran/m4/parity.m4
+++ b/libgfortran/m4/parity.m4
@@ -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).
diff --git a/libgfortran/m4/reshape.m4 b/libgfortran/m4/reshape.m4

index 26ea7e0d875e1c7b0d48297db682dfee94f1e59a..b589e53a41444842eb16a6f6de0020ec91edda63 100644 (file)
--- a/libgfortran/m4/reshape.m4
+++ b/libgfortran/m4/reshape.m4
@@ -119,7 +119,7 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
        else
          alloc_size = rs * sizeof ('rtype_name`);
  
-      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/m4/shape.m4 b/libgfortran/m4/shape.m4

index 66445ce8301f4eadb6cc61cf2e4c5cb8a5ce1065..8b63ade9526e95fc76c7b9f5c739d6e04180d7cd 100644 (file)
--- a/libgfortran/m4/shape.m4
+++ b/libgfortran/m4/shape.m4
@@ -50,7 +50,7 @@ shape_'rtype_kind` ('rtype` * const restrict ret,
      {
        GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1);
        ret->offset = 0;
-      ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * rank);
+      ret->base_addr = xmalloc (sizeof ('rtype_name`) * rank);
      }
  
    stride = GFC_DESCRIPTOR_STRIDE(ret,0);
diff --git a/libgfortran/m4/spread.m4 b/libgfortran/m4/spread.m4

index 52c0022f43ece0adb00948be59ebb1432671e6f2..d9779bdc6f9946c772f09cf29437e6702edc3e0f 100644 (file)
--- a/libgfortran/m4/spread.m4
+++ b/libgfortran/m4/spread.m4
@@ -102,8 +102,8 @@ spread_'rtype_code` ('rtype` *ret, const 'rtype` *source,
         }
        ret->offset = 0;
  
-      /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->base_addr = internal_malloc_size (rs * sizeof('rtype_name`));
+      /* xmalloc allocates a single byte for zero size.  */
+      ret->base_addr = xmalloc (rs * sizeof('rtype_name`));
        if (rs <= 0)
          return;
      }
@@ -245,7 +245,7 @@ spread_scalar_'rtype_code` ('rtype` *ret, const 'rtype_name` *source,
  
    if (ret->base_addr == NULL)
      {
-      ret->base_addr = internal_malloc_size (ncopies * sizeof ('rtype_name`));
+      ret->base_addr = xmalloc (ncopies * sizeof ('rtype_name`));
        ret->offset = 0;
        GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
      }
diff --git a/libgfortran/m4/transpose.m4 b/libgfortran/m4/transpose.m4

index a60ca6d27ccaf8f73de977a3a70976294d3fb84f..f5581f1b8e6a907f445f569bba5e6a9a42c8b258 100644 (file)
--- a/libgfortran/m4/transpose.m4
+++ b/libgfortran/m4/transpose.m4
@@ -61,7 +61,7 @@ transpose_'rtype_code` ('rtype` * 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 ('rtype_name`) * size0 ((array_t *) ret));
+      ret->base_addr = xmalloc (sizeof ('rtype_name`) * size0 ((array_t *) ret));
        ret->offset = 0;
      } else if (unlikely (compile_options.bounds_check))
      {
diff --git a/libgfortran/m4/unpack.m4 b/libgfortran/m4/unpack.m4

index 0395715a0c19094cd0942c88c6b901c56032abcc..727885739006bb6605e96ce89bad67c5ac4d260f 100644 (file)
--- a/libgfortran/m4/unpack.m4
+++ b/libgfortran/m4/unpack.m4
@@ -100,7 +100,7 @@ unpack0_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
           rs *= extent[n];
         }
        ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof ('rtype_name`));
+      ret->base_addr = xmalloc (rs * sizeof ('rtype_name`));
      }
    else
      {
@@ -245,7 +245,7 @@ unpack1_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
           rs *= extent[n];
         }
        ret->offset = 0;
-      ret->base_addr = internal_malloc_size (rs * sizeof ('rtype_name`));
+      ret->base_addr = xmalloc (rs * sizeof ('rtype_name`));
      }
    else
      {
diff --git a/libgfortran/runtime/convert_char.c b/libgfortran/runtime/convert_char.c

index 540c2bfdb652065fa76c45a8496f0df896040979..aa43d9796a31d33c2c8e6b187e20a3ea0ca00de8 100644 (file)
--- a/libgfortran/runtime/convert_char.c
+++ b/libgfortran/runtime/convert_char.c
@@ -1,5 +1,5 @@
  /* Runtime conversion of strings from one character kind to another.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
  
  This file is part of the GNU Fortran runtime library (libgfortran).
  
@@ -44,7 +44,7 @@ convert_char1_to_char4 (gfc_char4_t **dst, gfc_charlen_type len,
    gfc_charlen_type i, l;
  
    l = len > 0 ? len : 0;
-  *dst = get_mem ((l + 1) * sizeof (gfc_char4_t));
+  *dst = xmalloc ((l + 1) * sizeof (gfc_char4_t));
  
    for (i = 0; i < l; i++)
      (*dst)[i] = src[i];
@@ -60,7 +60,7 @@ convert_char4_to_char1 (unsigned char **dst, gfc_charlen_type len,
    gfc_charlen_type i, l;
  
    l = len > 0 ? len : 0;
-  *dst = get_mem ((l + 1) * sizeof (unsigned char));
+  *dst = xmalloc ((l + 1) * sizeof (unsigned char));
  
    for (i = 0; i < l; i++)
      (*dst)[i] = src[i];
diff --git a/libgfortran/runtime/environ.c b/libgfortran/runtime/environ.c

index 6bd88865d89b47d320aeecd7b0d1ef62275009f6..7782cee044c09675171fd08d3f386f4620e44f05 100644 (file)
--- a/libgfortran/runtime/environ.c
+++ b/libgfortran/runtime/environ.c
@@ -1,7 +1,8 @@
-/* Copyright (C) 2002, 2003, 2005, 2007, 2009 Free Software Foundation, Inc.
+/* Copyright (C) 2002, 2003, 2005, 2007, 2009, 2012 
+   Free Software Foundation, Inc.
     Contributed by Andy Vaught
  
-This file is part of the GNU Fortran 95 runtime library (libgfortran).
+This file is part of the GNU Fortran runtime library (libgfortran).
  
  Libgfortran is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
@@ -807,7 +808,7 @@ void init_unformatted (variable * v)
      }
    else
      {
-      elist = get_mem (unit_count * sizeof (exception_t));
+      elist = xmalloc (unit_count * sizeof (exception_t));
        do_count = 0;
        p = val;
        do_parse ();
diff --git a/libgfortran/runtime/in_pack_generic.c b/libgfortran/runtime/in_pack_generic.c

index 7ebebcad16a702600cf99a8e48d1d858b3d2d73d..5360f26746ed320261230818c287b6d081282de5 100644 (file)
--- a/libgfortran/runtime/in_pack_generic.c
+++ b/libgfortran/runtime/in_pack_generic.c
@@ -178,7 +178,7 @@ internal_pack (gfc_array_char * source)
      return source->base_addr;
  
     /* Allocate storage for the destination.  */
-  destptr = internal_malloc_size (ssize * size);
+  destptr = xmalloc (ssize * size);
    dest = (char *)destptr;
    src = source->base_addr;
    stride0 = stride[0] * size;
diff --git a/libgfortran/runtime/memory.c b/libgfortran/runtime/memory.c

index 044a115c1f5b2781a4acc7197cd96c0b04e88f57..8fa71d360f79b77355629e80597e1b3dc288ef0e 100644 (file)
--- a/libgfortran/runtime/memory.c
+++ b/libgfortran/runtime/memory.c
@@ -27,22 +27,17 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  #include "libgfortran.h"
  #include <stdlib.h>
  
-/* If GFC_CLEAR_MEMORY is defined, the memory allocation routines will
-   return memory that is guaranteed to be set to zero.  This can have
-   a severe efficiency penalty, so it should never be set if good
-   performance is desired, but it can help when you're debugging code.  */
-/* #define GFC_CLEAR_MEMORY */
  
  void *
-get_mem (size_t n)
+xmalloc (size_t n)
  {
    void *p;
  
-#ifdef GFC_CLEAR_MEMORY
-  p = (void *) calloc (1, n);
-#else
-  p = (void *) malloc (n);
-#endif
+  if (n == 0)
+    n = 1;
+
+  p = malloc (n);
+
    if (p == NULL)
      os_error ("Memory allocation failed");
  
@@ -50,18 +45,6 @@ get_mem (size_t n)
  }
  
  
-/* Allocate memory for internal (compiler generated) use.  */
-
-void *
-internal_malloc_size (size_t size)
-{
-  if (unlikely (size == 0))
-    size = 1;
-
-  return get_mem (size);
-}
-
-
  /* calloc wrapper that aborts on error.  */
  
  void *
author	Janne Blomqvist <jb@gcc.gnu.org>
	Mon, 26 Mar 2012 15:16:05 +0000 (18:16 +0300)
committer	Janne Blomqvist <jb@gcc.gnu.org>
	Mon, 26 Mar 2012 15:16:05 +0000 (18:16 +0300)