Combined get_mem and internal_malloc_size.

author jb <jb@138bc75d-0d04-0410-961f-82ee72b054a4>

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

committer jb <jb@138bc75d-0d04-0410-961f-82ee72b054a4>

Mon, 26 Mar 2012 15:16:05 +0000 (15:16 +0000)
author jb <jb@138bc75d-0d04-0410-961f-82ee72b054a4>
Mon, 26 Mar 2012 15:16:05 +0000 (15:16 +0000)
committer jb <jb@138bc75d-0d04-0410-961f-82ee72b054a4>
Mon, 26 Mar 2012 15:16:05 +0000 (15:16 +0000)
diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog

index 5624049..e4a6b1e 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 2ff29a8..abc23cd 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 09b5064..aa23e85 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 541e725..81020f7 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 8162ac1..520de21 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 0e98cf6..8e51708 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 8571751..f78987c 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 9b9d16a..57becda 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 e8b9cab..eca125f 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 c605588..2c65db6 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 6c4afee..64ed5bb 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 b2c4cde..4cad8c8 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 86fd28c..55ffaf1 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 7d11614..6a3a139 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 ae23dbc..c1aa5e2 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 d3b0590..0f7c4cc 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 b48c04b..cc61300 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 6522440..ad5af4f 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 5b7776e..92ef819 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 8a104d1..503a07d 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 0edca41..380c005 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 e3d95dc..16c7cf3 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 41cc1ea..22d1b29 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 9652222..a0f3ab6 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 8ccd63b..ceb7409 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 2de9208..e309628 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 8a9f1aa..451a6af 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 136f546..1f056b3 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 d363d90..5384a72 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 1b623c2..6618516 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 2af1ccb..a90d87f 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 d60f7f3..dbe0fa7 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 88be6a8..02e61fd 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 14fa83b..e9c181c 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 ce5e185..8cd3b3e 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 fee269a..8e2bb1a 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 f1b0aeb..52b6f92 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 511e369..9194aa5 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 b52f551..dcad991 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 a0949e1..46a5d83 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 e365f5f..f0a2e90 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 1d6b0db..2279690 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 a627094..bc40163 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 833d7e8..532c2de 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 d86ce9f..b8e9ee4 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 2b582a5..d4449bb 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 294e3ca..9a6b5e8 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 6a95af3..fb87ea7 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 4a5a863..44b3397 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 cb7e785..f0d6dd1 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 b479001..417fc4d 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 f16fd2f..d815b2f 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 e5b09a7..f8d9990 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 12670d2..be13b82 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 5fcb29d..00eb4bc 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 aef9458..6caad71 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 22f95e3..c44f908 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 58b18b8..a7f76c8 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 78de1c4..e93389d 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 3496a83..ffd3be6 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 0140dd3..98799f5 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 fd8ce9f..d5855db 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 e71b5fb..97b6347 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 7525ea7..61ddd98 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 19b6995..01d1b85 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 7393506..2b6b99b 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 2e9e016..536c773 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 6c6c655..777c991 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 1ae8f7a..ffb6d4c 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 dfe3369..e73ff69 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 258a953..ba18cba 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 79a5771..dbe49ea 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 87bc587..6798c7b 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 4f72b6a..606c225 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 422a1f0..4733912 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 fbac3ad..0de65a8 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 e15ebf2..be8c469 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 90b2b3a..9852dcc 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 dc75d83..0f2973b 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 43879c7..fd79bf0 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 3e3bcb5..beb0fb3 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 cec3963..52790c7 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 985dcd6..eefb8a2 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 7f385d7..f536ac8 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 6d7cf61..31506d4 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 0d8bf75..e772875 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 b0c05c8..cc5a57a 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 9be7099..2d407ef 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 cb33723..3d35996 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 48abb63..200257a 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 3fae48d..f878e67 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 d2a985d..923ee4b 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 6f57fca..77f97db 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 07815cf..4a51134 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 dc5c575..a9783e8 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 f01ec69..9e329fa 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 13f32e0..6aea6bb 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 066cedf..1e5b168 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 f34984d..0bb5674 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 e28ba0f..e80946e 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 d6594ab..5ac8b42 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 2a9b754..f510bdd 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 2621faf..e2eb8e0 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 5175885..9b3563f 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 a806782..0278e99 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 85dd48c..9751c2a 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 d6a96ec..e9140e5 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 551d207..f88d254 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 d44ecd4..b1188a2 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 ffd484c..7061102 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 d03ba72..5d4d9c2 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 4c528f2..0ee6ed5 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 5c0a801..c79f0ca 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 3d35b0c..4eff28a 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 ec2f434..7c8f5e6 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 0bee414..ae63e1b 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 cfb16f9..afd935b 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 4bf9b8c..fdd4817 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 c3721d9..8360dfc 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 a756665..96f3651 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 59be8b7..a591171 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 107426e..30b946a 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 21a8dce..af32584 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 2c7d860..dc63f1e 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 0638ab0..c50965e 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 acc5689..c088686 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 1cd2a45..35f6807 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 177f06e..5d84bd0 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 35739aa..e1e80d3 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 7a4a58e..a94eeca 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 fe42c27..94059cb 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 19b233d..eb3d767 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 d4ef8ed..ef9e6c9 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 814357d..a6cd682 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 736cced..1be75f1 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 37ae298..059896d 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 0cd7319..f306f18 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 f8ac97d..ca70ca5 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 6175885..4b7b119 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 d938dd7..cd056c7 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 8f0528e..157018f 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 cf57b79..ef0fc08 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 23c7293..0742e9a 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 52c0ab7..8bd602a 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 e35ad66..93bb975 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 37e877b..ab67973 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 dbd7ad3..bfa623d 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 fa9dcf5..23f0f49 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 5a8e440..abeb209 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 d3ce2ed..9ebf23a 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 dc2d606..bd813f2 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 98da2de..b42c8bc 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 8302d23..21a0ccf 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 d8617ff..dcee2c2 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 2cdbc7d..2e60f8b 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 f8ef3a5..6da89bf 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 0d6b521..8291e87 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 37d6561..5306cd5 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 3418cee..5a9b40a 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 c36785e..629b0b7 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 817f1c1..ccd445e 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 d5a68ea..090bdff 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 c2235b8..26744c8 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 05230f5..f1c829a 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 0ec3067..fe122a1 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 7b5ae81..949fa43 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 c08cb66..b5a1681 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 3e89ba7..8879079 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 1097c3b..6a5553f 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 326b9cf..04be9c6 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 7bf30bd..a66feda 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 bc65a03..2e75ecf 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 baa2bc4..b8e9337 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 482391d..42519eb 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 73c1a23..07f0dce 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 442f518..0c20411 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 f235b09..389b1db 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 e0a54f2..5d66fe9 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 2d28829..28cd536 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 0894708..3919671 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 082d409..f796612 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 60c8f73..7f34b91 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 267bdae..21bb4cb 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 17fc399..81d6f8e 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 350d762..0a41d17 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 22b10b8..b0dac3e 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 f01ef6d..c8b42ca 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 91cbc7e..186fe5c 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 b04ebfc..582f88e 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 02f9b47..0471c27 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 bd7fb36..b144115 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 cd300bb..81916e2 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 ed9fb22..e2abc95 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 7f11f41..f2c72e3 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 18663d7..b87a072 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 f6d4803..20766fa 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 2fdf455..73e3d9b 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 590a4db..72134fe 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 ca30114..47c703c 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 8ec3c7c..58c8854 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 d03f513..c8426bd 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 d3e8c7a..19356fd 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 dc5aeac..fda5a20 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 8c7fae0..a4cfba4 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 9dcd8cf..9031b7a 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 577c68a..9c3b0a2 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 121b0a8..84340e0 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 c9ad6e8..3ba1e4b 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 d1a6941..11a8e44 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 2aa75c1..05b8ae5 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 451c8da..8ce8125 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 9b68c52..fc24cc6 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 36d1eb1..13d343d 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 8f75038..e79a438 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 b8b8135..38cce4c 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 932e190..c6576d5 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 a57daba..29e6d4b 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 9516551..0de8a97 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 84b1e96..d14b053 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 184fdf0..1f5e168 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 5906c2a..f72b459 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 b9f183a..c498225 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 651350b..9509101 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 349ab55..379f389 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 9680b76..2e91c5e 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 5e53465..c1a9534 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 5e5a911..80a6ac6 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 fd19554..ff8e76a 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 6105413..652e766 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 803bd0c..1063d6a 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 71f353e..97eab9e 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 2422ce6..8945497 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 6621f9f..4259f7a 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 846b5c2..e4ec5b2 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 2c6feff..dc3fe51 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 ddb0215..5e03477 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 13dedbc..bb0b67e 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 72aba60..7fcc97c 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 63f66ec..9362bba 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 ab64683..cb34899 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 dbf812d..7a2cef4 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 a4c83ad..6fa7b2f 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 e7288bb..a97c946 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 87216f4..47e4bbd 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 cb1f7f3..e591948 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 64f3991..9eece42 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 4b6f4c6..22cb729 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 c42aca9..496f03d 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 3f57399..e012ec0 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 49910ac..01eefc1 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 fb4efb0..ac3dc2c 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 46789ca..e7aff07 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 ef91ca5..d75d315 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 dbcc029..1786d1d 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 0e654eb..ea18032 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 4167651..76512d3 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 e65b942..b81784b 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 599da3f..3a4f946 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 ddb8163..c55013c 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 d023a27..76c1d16 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 17bffbe..163262d 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 656205f..12f46d5 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 2c77f1c..138b47d 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 2a289f4..50567b3 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 d87e086..285b444 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 7964eb9..bdaa1ad 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 2fd6782..e7a4a45 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 c746e07..7b03bd0 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 02d6cc8..71bf01a 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 5e6d3b9..1d82782 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 e199544..3e29bfa 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 68e8539..05767bc 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 42f676e..16ff425 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 ca98de1..3b2d8a6 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 863191a..5136dae 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 45de9f4..8634637 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 f863688..9402936 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 af0b43f..86e865c 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 81e1584..5819ab1 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 b523bb0..171d650 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 5f15534..22dd5f6 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 adfd0ad..a554a96 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 07b80c9..54606ba 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 8179688..53e0cc3 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 b1f7b41..7cf22ab 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 8c854cc..b14bad3 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 f60a69e..95bed28 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 150509d..879d309 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 f33830d..6b8eee5 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 2106202..f40fa95 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 c8903cf..6b7c5e1 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 517474e..0d5ec8e 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 c21a61e..1e030e6 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 d77b049..ae230bf 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 95ce538..88915e5 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 59412d3..793cdce 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 34c2262..3ba1e2a 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 c50dc71..51d6b64 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 3e022b9..a187d51 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 0d343cd..c6ad80a 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 5da73d4..b330537 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 05bf31f..d22851c 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 c785f84..5d8973e 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 8b7dd0a..f4cd424 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 cd2a827..d0d0bf1 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 f4fc0f6..92338c1 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 77d600a..4df3f93 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 b16690a..ec8ea23 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 2a478f1..40450bd 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 8335a38..b20483d 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 03fbbef..b5bae41 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 123f5e1..7f92cf5 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 353e5ae..6dacc54 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 1711a75..afa5f34 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 22150e7..576434a 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 91b345c..2024fcd 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 8f969ed..d086d2e 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 f71e96f..6dda1df 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 5fe9eb2..d5029dc 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 31fa005..278decd 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 8be3a5a..838bc0d 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 186bfbe..be5f133 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 d9e7f89..d5c602d 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 88fce1a..40d34fb 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 691edd1..637bdae 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 b5c8bb4..e1d74fe 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 86d4350..a875a2a 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 1cd3073..613fbf5 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 b36e8e0..13dd7a9 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 7cee37b..aad3dab 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 6a7ce5c..6a58cd9 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 87245ae..73c5088 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 e88e84e..bc7f3b9 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 037e96d..6ff0ad2 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 26ea7e0..b589e53 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 66445ce..8b63ade 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 52c0022..d9779bd 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 a60ca6d..f5581f1 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 0395715..7278857 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 540c2bf..aa43d97 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 6bd8886..7782cee 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 7ebebca..5360f26 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 044a115..8fa71d3 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	jb <jb@138bc75d-0d04-0410-961f-82ee72b054a4>
	Mon, 26 Mar 2012 15:16:05 +0000 (15:16 +0000)
committer	jb <jb@138bc75d-0d04-0410-961f-82ee72b054a4>
	Mon, 26 Mar 2012 15:16:05 +0000 (15:16 +0000)
libgfortran/ChangeLog		patch \| blob \| history
libgfortran/Makefile.am		patch \| blob \| history
libgfortran/Makefile.in		patch \| blob \| history
libgfortran/generated/all_l1.c		patch \| blob \| history
libgfortran/generated/all_l16.c		patch \| blob \| history
libgfortran/generated/all_l2.c		patch \| blob \| history
libgfortran/generated/all_l4.c		patch \| blob \| history
libgfortran/generated/all_l8.c		patch \| blob \| history
libgfortran/generated/any_l1.c		patch \| blob \| history
libgfortran/generated/any_l16.c		patch \| blob \| history
libgfortran/generated/any_l2.c		patch \| blob \| history
libgfortran/generated/any_l4.c		patch \| blob \| history
libgfortran/generated/any_l8.c		patch \| blob \| history
libgfortran/generated/bessel_r10.c		patch \| blob \| history
libgfortran/generated/bessel_r16.c		patch \| blob \| history
libgfortran/generated/bessel_r4.c		patch \| blob \| history
libgfortran/generated/bessel_r8.c		patch \| blob \| history
libgfortran/generated/count_16_l.c		patch \| blob \| history
libgfortran/generated/count_1_l.c		patch \| blob \| history
libgfortran/generated/count_2_l.c		patch \| blob \| history
libgfortran/generated/count_4_l.c		patch \| blob \| history
libgfortran/generated/count_8_l.c		patch \| blob \| history
libgfortran/generated/cshift1_16.c		patch \| blob \| history
libgfortran/generated/cshift1_4.c		patch \| blob \| history
libgfortran/generated/cshift1_8.c		patch \| blob \| history
libgfortran/generated/eoshift1_16.c		patch \| blob \| history
libgfortran/generated/eoshift1_4.c		patch \| blob \| history
libgfortran/generated/eoshift1_8.c		patch \| blob \| history
libgfortran/generated/eoshift3_16.c		patch \| blob \| history
libgfortran/generated/eoshift3_4.c		patch \| blob \| history
libgfortran/generated/eoshift3_8.c		patch \| blob \| history
libgfortran/generated/iall_i1.c		patch \| blob \| history
libgfortran/generated/iall_i16.c		patch \| blob \| history
libgfortran/generated/iall_i2.c		patch \| blob \| history
libgfortran/generated/iall_i4.c		patch \| blob \| history
libgfortran/generated/iall_i8.c		patch \| blob \| history
libgfortran/generated/iany_i1.c		patch \| blob \| history
libgfortran/generated/iany_i16.c		patch \| blob \| history
libgfortran/generated/iany_i2.c		patch \| blob \| history
libgfortran/generated/iany_i4.c		patch \| blob \| history
libgfortran/generated/iany_i8.c		patch \| blob \| history
libgfortran/generated/in_pack_c10.c		patch \| blob \| history
libgfortran/generated/in_pack_c16.c		patch \| blob \| history
libgfortran/generated/in_pack_c4.c		patch \| blob \| history
libgfortran/generated/in_pack_c8.c		patch \| blob \| history
libgfortran/generated/in_pack_i1.c		patch \| blob \| history
libgfortran/generated/in_pack_i16.c		patch \| blob \| history
libgfortran/generated/in_pack_i2.c		patch \| blob \| history
libgfortran/generated/in_pack_i4.c		patch \| blob \| history
libgfortran/generated/in_pack_i8.c		patch \| blob \| history
libgfortran/generated/in_pack_r10.c		patch \| blob \| history
libgfortran/generated/in_pack_r16.c		patch \| blob \| history
libgfortran/generated/in_pack_r4.c		patch \| blob \| history
libgfortran/generated/in_pack_r8.c		patch \| blob \| history
libgfortran/generated/iparity_i1.c		patch \| blob \| history
libgfortran/generated/iparity_i16.c		patch \| blob \| history
libgfortran/generated/iparity_i2.c		patch \| blob \| history
libgfortran/generated/iparity_i4.c		patch \| blob \| history
libgfortran/generated/iparity_i8.c		patch \| blob \| history
libgfortran/generated/matmul_c10.c		patch \| blob \| history
libgfortran/generated/matmul_c16.c		patch \| blob \| history
libgfortran/generated/matmul_c4.c		patch \| blob \| history
libgfortran/generated/matmul_c8.c		patch \| blob \| history
libgfortran/generated/matmul_i1.c		patch \| blob \| history
libgfortran/generated/matmul_i16.c		patch \| blob \| history
libgfortran/generated/matmul_i2.c		patch \| blob \| history
libgfortran/generated/matmul_i4.c		patch \| blob \| history
libgfortran/generated/matmul_i8.c		patch \| blob \| history
libgfortran/generated/matmul_l16.c		patch \| blob \| history
libgfortran/generated/matmul_l4.c		patch \| blob \| history
libgfortran/generated/matmul_l8.c		patch \| blob \| history
libgfortran/generated/matmul_r10.c		patch \| blob \| history
libgfortran/generated/matmul_r16.c		patch \| blob \| history
libgfortran/generated/matmul_r4.c		patch \| blob \| history
libgfortran/generated/matmul_r8.c		patch \| blob \| history
libgfortran/generated/maxloc0_16_i1.c		patch \| blob \| history
libgfortran/generated/maxloc0_16_i16.c		patch \| blob \| history
libgfortran/generated/maxloc0_16_i2.c		patch \| blob \| history
libgfortran/generated/maxloc0_16_i4.c		patch \| blob \| history
libgfortran/generated/maxloc0_16_i8.c		patch \| blob \| history
libgfortran/generated/maxloc0_16_r10.c		patch \| blob \| history
libgfortran/generated/maxloc0_16_r16.c		patch \| blob \| history
libgfortran/generated/maxloc0_16_r4.c		patch \| blob \| history
libgfortran/generated/maxloc0_16_r8.c		patch \| blob \| history
libgfortran/generated/maxloc0_4_i1.c		patch \| blob \| history
libgfortran/generated/maxloc0_4_i16.c		patch \| blob \| history
libgfortran/generated/maxloc0_4_i2.c		patch \| blob \| history
libgfortran/generated/maxloc0_4_i4.c		patch \| blob \| history
libgfortran/generated/maxloc0_4_i8.c		patch \| blob \| history
libgfortran/generated/maxloc0_4_r10.c		patch \| blob \| history
libgfortran/generated/maxloc0_4_r16.c		patch \| blob \| history
libgfortran/generated/maxloc0_4_r4.c		patch \| blob \| history
libgfortran/generated/maxloc0_4_r8.c		patch \| blob \| history
libgfortran/generated/maxloc0_8_i1.c		patch \| blob \| history
libgfortran/generated/maxloc0_8_i16.c		patch \| blob \| history
libgfortran/generated/maxloc0_8_i2.c		patch \| blob \| history
libgfortran/generated/maxloc0_8_i4.c		patch \| blob \| history
libgfortran/generated/maxloc0_8_i8.c		patch \| blob \| history
libgfortran/generated/maxloc0_8_r10.c		patch \| blob \| history
libgfortran/generated/maxloc0_8_r16.c		patch \| blob \| history
libgfortran/generated/maxloc0_8_r4.c		patch \| blob \| history
libgfortran/generated/maxloc0_8_r8.c		patch \| blob \| history
libgfortran/generated/maxloc1_16_i1.c		patch \| blob \| history
libgfortran/generated/maxloc1_16_i16.c		patch \| blob \| history
libgfortran/generated/maxloc1_16_i2.c		patch \| blob \| history
libgfortran/generated/maxloc1_16_i4.c		patch \| blob \| history
libgfortran/generated/maxloc1_16_i8.c		patch \| blob \| history
libgfortran/generated/maxloc1_16_r10.c		patch \| blob \| history
libgfortran/generated/maxloc1_16_r16.c		patch \| blob \| history
libgfortran/generated/maxloc1_16_r4.c		patch \| blob \| history
libgfortran/generated/maxloc1_16_r8.c		patch \| blob \| history
libgfortran/generated/maxloc1_4_i1.c		patch \| blob \| history
libgfortran/generated/maxloc1_4_i16.c		patch \| blob \| history
libgfortran/generated/maxloc1_4_i2.c		patch \| blob \| history
libgfortran/generated/maxloc1_4_i4.c		patch \| blob \| history
libgfortran/generated/maxloc1_4_i8.c		patch \| blob \| history
libgfortran/generated/maxloc1_4_r10.c		patch \| blob \| history
libgfortran/generated/maxloc1_4_r16.c		patch \| blob \| history
libgfortran/generated/maxloc1_4_r4.c		patch \| blob \| history
libgfortran/generated/maxloc1_4_r8.c		patch \| blob \| history
libgfortran/generated/maxloc1_8_i1.c		patch \| blob \| history
libgfortran/generated/maxloc1_8_i16.c		patch \| blob \| history
libgfortran/generated/maxloc1_8_i2.c		patch \| blob \| history
libgfortran/generated/maxloc1_8_i4.c		patch \| blob \| history
libgfortran/generated/maxloc1_8_i8.c		patch \| blob \| history
libgfortran/generated/maxloc1_8_r10.c		patch \| blob \| history
libgfortran/generated/maxloc1_8_r16.c		patch \| blob \| history
libgfortran/generated/maxloc1_8_r4.c		patch \| blob \| history
libgfortran/generated/maxloc1_8_r8.c		patch \| blob \| history
libgfortran/generated/maxval_i1.c		patch \| blob \| history
libgfortran/generated/maxval_i16.c		patch \| blob \| history
libgfortran/generated/maxval_i2.c		patch \| blob \| history
libgfortran/generated/maxval_i4.c		patch \| blob \| history
libgfortran/generated/maxval_i8.c		patch \| blob \| history
libgfortran/generated/maxval_r10.c		patch \| blob \| history
libgfortran/generated/maxval_r16.c		patch \| blob \| history
libgfortran/generated/maxval_r4.c		patch \| blob \| history
libgfortran/generated/maxval_r8.c		patch \| blob \| history
libgfortran/generated/minloc0_16_i1.c		patch \| blob \| history
libgfortran/generated/minloc0_16_i16.c		patch \| blob \| history
libgfortran/generated/minloc0_16_i2.c		patch \| blob \| history
libgfortran/generated/minloc0_16_i4.c		patch \| blob \| history
libgfortran/generated/minloc0_16_i8.c		patch \| blob \| history
libgfortran/generated/minloc0_16_r10.c		patch \| blob \| history
libgfortran/generated/minloc0_16_r16.c		patch \| blob \| history
libgfortran/generated/minloc0_16_r4.c		patch \| blob \| history
libgfortran/generated/minloc0_16_r8.c		patch \| blob \| history
libgfortran/generated/minloc0_4_i1.c		patch \| blob \| history
libgfortran/generated/minloc0_4_i16.c		patch \| blob \| history
libgfortran/generated/minloc0_4_i2.c		patch \| blob \| history
libgfortran/generated/minloc0_4_i4.c		patch \| blob \| history
libgfortran/generated/minloc0_4_i8.c		patch \| blob \| history
libgfortran/generated/minloc0_4_r10.c		patch \| blob \| history
libgfortran/generated/minloc0_4_r16.c		patch \| blob \| history
libgfortran/generated/minloc0_4_r4.c		patch \| blob \| history
libgfortran/generated/minloc0_4_r8.c		patch \| blob \| history
libgfortran/generated/minloc0_8_i1.c		patch \| blob \| history
libgfortran/generated/minloc0_8_i16.c		patch \| blob \| history
libgfortran/generated/minloc0_8_i2.c		patch \| blob \| history
libgfortran/generated/minloc0_8_i4.c		patch \| blob \| history
libgfortran/generated/minloc0_8_i8.c		patch \| blob \| history
libgfortran/generated/minloc0_8_r10.c		patch \| blob \| history
libgfortran/generated/minloc0_8_r16.c		patch \| blob \| history
libgfortran/generated/minloc0_8_r4.c		patch \| blob \| history
libgfortran/generated/minloc0_8_r8.c		patch \| blob \| history
libgfortran/generated/minloc1_16_i1.c		patch \| blob \| history
libgfortran/generated/minloc1_16_i16.c		patch \| blob \| history
libgfortran/generated/minloc1_16_i2.c		patch \| blob \| history
libgfortran/generated/minloc1_16_i4.c		patch \| blob \| history
libgfortran/generated/minloc1_16_i8.c		patch \| blob \| history
libgfortran/generated/minloc1_16_r10.c		patch \| blob \| history
libgfortran/generated/minloc1_16_r16.c		patch \| blob \| history
libgfortran/generated/minloc1_16_r4.c		patch \| blob \| history
libgfortran/generated/minloc1_16_r8.c		patch \| blob \| history
libgfortran/generated/minloc1_4_i1.c		patch \| blob \| history
libgfortran/generated/minloc1_4_i16.c		patch \| blob \| history
libgfortran/generated/minloc1_4_i2.c		patch \| blob \| history
libgfortran/generated/minloc1_4_i4.c		patch \| blob \| history
libgfortran/generated/minloc1_4_i8.c		patch \| blob \| history
libgfortran/generated/minloc1_4_r10.c		patch \| blob \| history
libgfortran/generated/minloc1_4_r16.c		patch \| blob \| history
libgfortran/generated/minloc1_4_r4.c		patch \| blob \| history
libgfortran/generated/minloc1_4_r8.c		patch \| blob \| history
libgfortran/generated/minloc1_8_i1.c		patch \| blob \| history
libgfortran/generated/minloc1_8_i16.c		patch \| blob \| history
libgfortran/generated/minloc1_8_i2.c		patch \| blob \| history
libgfortran/generated/minloc1_8_i4.c		patch \| blob \| history
libgfortran/generated/minloc1_8_i8.c		patch \| blob \| history
libgfortran/generated/minloc1_8_r10.c		patch \| blob \| history
libgfortran/generated/minloc1_8_r16.c		patch \| blob \| history
libgfortran/generated/minloc1_8_r4.c		patch \| blob \| history
libgfortran/generated/minloc1_8_r8.c		patch \| blob \| history
libgfortran/generated/minval_i1.c		patch \| blob \| history
libgfortran/generated/minval_i16.c		patch \| blob \| history
libgfortran/generated/minval_i2.c		patch \| blob \| history
libgfortran/generated/minval_i4.c		patch \| blob \| history
libgfortran/generated/minval_i8.c		patch \| blob \| history
libgfortran/generated/minval_r10.c		patch \| blob \| history
libgfortran/generated/minval_r16.c		patch \| blob \| history
libgfortran/generated/minval_r4.c		patch \| blob \| history
libgfortran/generated/minval_r8.c		patch \| blob \| history
libgfortran/generated/norm2_r10.c		patch \| blob \| history
libgfortran/generated/norm2_r16.c		patch \| blob \| history
libgfortran/generated/norm2_r4.c		patch \| blob \| history
libgfortran/generated/norm2_r8.c		patch \| blob \| history
libgfortran/generated/pack_c10.c		patch \| blob \| history
libgfortran/generated/pack_c16.c		patch \| blob \| history
libgfortran/generated/pack_c4.c		patch \| blob \| history
libgfortran/generated/pack_c8.c		patch \| blob \| history
libgfortran/generated/pack_i1.c		patch \| blob \| history
libgfortran/generated/pack_i16.c		patch \| blob \| history
libgfortran/generated/pack_i2.c		patch \| blob \| history
libgfortran/generated/pack_i4.c		patch \| blob \| history
libgfortran/generated/pack_i8.c		patch \| blob \| history
libgfortran/generated/pack_r10.c		patch \| blob \| history
libgfortran/generated/pack_r16.c		patch \| blob \| history
libgfortran/generated/pack_r4.c		patch \| blob \| history
libgfortran/generated/pack_r8.c		patch \| blob \| history
libgfortran/generated/parity_l1.c		patch \| blob \| history
libgfortran/generated/parity_l16.c		patch \| blob \| history
libgfortran/generated/parity_l2.c		patch \| blob \| history
libgfortran/generated/parity_l4.c		patch \| blob \| history
libgfortran/generated/parity_l8.c		patch \| blob \| history
libgfortran/generated/product_c10.c		patch \| blob \| history
libgfortran/generated/product_c16.c		patch \| blob \| history
libgfortran/generated/product_c4.c		patch \| blob \| history
libgfortran/generated/product_c8.c		patch \| blob \| history
libgfortran/generated/product_i1.c		patch \| blob \| history
libgfortran/generated/product_i16.c		patch \| blob \| history
libgfortran/generated/product_i2.c		patch \| blob \| history
libgfortran/generated/product_i4.c		patch \| blob \| history
libgfortran/generated/product_i8.c		patch \| blob \| history
libgfortran/generated/product_r10.c		patch \| blob \| history
libgfortran/generated/product_r16.c		patch \| blob \| history
libgfortran/generated/product_r4.c		patch \| blob \| history
libgfortran/generated/product_r8.c		patch \| blob \| history
libgfortran/generated/reshape_c10.c		patch \| blob \| history
libgfortran/generated/reshape_c16.c		patch \| blob \| history
libgfortran/generated/reshape_c4.c		patch \| blob \| history
libgfortran/generated/reshape_c8.c		patch \| blob \| history
libgfortran/generated/reshape_i16.c		patch \| blob \| history
libgfortran/generated/reshape_i4.c		patch \| blob \| history
libgfortran/generated/reshape_i8.c		patch \| blob \| history
libgfortran/generated/reshape_r10.c		patch \| blob \| history
libgfortran/generated/reshape_r16.c		patch \| blob \| history
libgfortran/generated/reshape_r4.c		patch \| blob \| history
libgfortran/generated/reshape_r8.c		patch \| blob \| history
libgfortran/generated/shape_i16.c		patch \| blob \| history
libgfortran/generated/shape_i4.c		patch \| blob \| history
libgfortran/generated/shape_i8.c		patch \| blob \| history
libgfortran/generated/spread_c10.c		patch \| blob \| history
libgfortran/generated/spread_c16.c		patch \| blob \| history
libgfortran/generated/spread_c4.c		patch \| blob \| history
libgfortran/generated/spread_c8.c		patch \| blob \| history
libgfortran/generated/spread_i1.c		patch \| blob \| history
libgfortran/generated/spread_i16.c		patch \| blob \| history
libgfortran/generated/spread_i2.c		patch \| blob \| history
libgfortran/generated/spread_i4.c		patch \| blob \| history
libgfortran/generated/spread_i8.c		patch \| blob \| history
libgfortran/generated/spread_r10.c		patch \| blob \| history
libgfortran/generated/spread_r16.c		patch \| blob \| history
libgfortran/generated/spread_r4.c		patch \| blob \| history
libgfortran/generated/spread_r8.c		patch \| blob \| history
libgfortran/generated/sum_c10.c		patch \| blob \| history
libgfortran/generated/sum_c16.c		patch \| blob \| history
libgfortran/generated/sum_c4.c		patch \| blob \| history
libgfortran/generated/sum_c8.c		patch \| blob \| history
libgfortran/generated/sum_i1.c		patch \| blob \| history
libgfortran/generated/sum_i16.c		patch \| blob \| history
libgfortran/generated/sum_i2.c		patch \| blob \| history
libgfortran/generated/sum_i4.c		patch \| blob \| history
libgfortran/generated/sum_i8.c		patch \| blob \| history
libgfortran/generated/sum_r10.c		patch \| blob \| history
libgfortran/generated/sum_r16.c		patch \| blob \| history
libgfortran/generated/sum_r4.c		patch \| blob \| history
libgfortran/generated/sum_r8.c		patch \| blob \| history
libgfortran/generated/transpose_c10.c		patch \| blob \| history
libgfortran/generated/transpose_c16.c		patch \| blob \| history
libgfortran/generated/transpose_c4.c		patch \| blob \| history
libgfortran/generated/transpose_c8.c		patch \| blob \| history
libgfortran/generated/transpose_i16.c		patch \| blob \| history
libgfortran/generated/transpose_i4.c		patch \| blob \| history
libgfortran/generated/transpose_i8.c		patch \| blob \| history
libgfortran/generated/transpose_r10.c		patch \| blob \| history
libgfortran/generated/transpose_r16.c		patch \| blob \| history
libgfortran/generated/transpose_r4.c		patch \| blob \| history
libgfortran/generated/transpose_r8.c		patch \| blob \| history
libgfortran/generated/unpack_c10.c		patch \| blob \| history
libgfortran/generated/unpack_c16.c		patch \| blob \| history
libgfortran/generated/unpack_c4.c		patch \| blob \| history
libgfortran/generated/unpack_c8.c		patch \| blob \| history
libgfortran/generated/unpack_i1.c		patch \| blob \| history
libgfortran/generated/unpack_i16.c		patch \| blob \| history
libgfortran/generated/unpack_i2.c		patch \| blob \| history
libgfortran/generated/unpack_i4.c		patch \| blob \| history
libgfortran/generated/unpack_i8.c		patch \| blob \| history
libgfortran/generated/unpack_r10.c		patch \| blob \| history
libgfortran/generated/unpack_r16.c		patch \| blob \| history
libgfortran/generated/unpack_r4.c		patch \| blob \| history
libgfortran/generated/unpack_r8.c		patch \| blob \| history
libgfortran/intrinsics/cshift0.c		patch \| blob \| history
libgfortran/intrinsics/ctime.c		patch \| blob \| history
libgfortran/intrinsics/date_and_time.c		patch \| blob \| history
libgfortran/intrinsics/eoshift0.c		patch \| blob \| history
libgfortran/intrinsics/eoshift2.c		patch \| blob \| history
libgfortran/intrinsics/getlog.c		patch \| blob \| history
libgfortran/intrinsics/pack_generic.c		patch \| blob \| history
libgfortran/intrinsics/reshape_generic.c		patch \| blob \| history
libgfortran/intrinsics/spread_generic.c		patch \| blob \| history
libgfortran/intrinsics/string_intrinsics_inc.c		patch \| blob \| history
libgfortran/intrinsics/transpose_generic.c		patch \| blob \| history
libgfortran/intrinsics/unpack_generic.c		patch \| blob \| history
libgfortran/io/fbuf.c		patch \| blob \| history
libgfortran/io/format.c		patch \| blob \| history
libgfortran/io/intrinsics.c		patch \| blob \| history
libgfortran/io/list_read.c		patch \| blob \| history
libgfortran/io/open.c		patch \| blob \| history
libgfortran/io/transfer.c		patch \| blob \| history
libgfortran/io/unit.c		patch \| blob \| history
libgfortran/io/unix.c		patch \| blob \| history
libgfortran/io/write.c		patch \| blob \| history
libgfortran/libgfortran.h		patch \| blob \| history
libgfortran/m4/bessel.m4		patch \| blob \| history
libgfortran/m4/cshift1.m4		patch \| blob \| history
libgfortran/m4/eoshift1.m4		patch \| blob \| history
libgfortran/m4/eoshift3.m4		patch \| blob \| history
libgfortran/m4/iforeach.m4		patch \| blob \| history
libgfortran/m4/ifunction.m4		patch \| blob \| history
libgfortran/m4/ifunction_logical.m4		patch \| blob \| history
libgfortran/m4/in_pack.m4		patch \| blob \| history
libgfortran/m4/matmul.m4		patch \| blob \| history
libgfortran/m4/matmull.m4		patch \| blob \| history
libgfortran/m4/pack.m4		patch \| blob \| history
libgfortran/m4/parity.m4		patch \| blob \| history
libgfortran/m4/reshape.m4		patch \| blob \| history
libgfortran/m4/shape.m4		patch \| blob \| history
libgfortran/m4/spread.m4		patch \| blob \| history
libgfortran/m4/transpose.m4		patch \| blob \| history
libgfortran/m4/unpack.m4		patch \| blob \| history
libgfortran/runtime/convert_char.c		patch \| blob \| history
libgfortran/runtime/environ.c		patch \| blob \| history
libgfortran/runtime/in_pack_generic.c		patch \| blob \| history
libgfortran/runtime/memory.c		patch \| blob \| history