libgfortran.h (descriptor_dimension, [...]): Rename _lbound to lower_bound and data to base_addr.

2012-03-10  Tobias Burnus  <burnus@net-b.de>

        * libgfortran.h (descriptor_dimension, GFC_DIMENSION_LBOUND,
        GFC_DIMENSION_EXTENT, GFC_DIMENSION_SET, GFC_DESCRIPTOR_DATA,
        GFC_ARRAY_DESCRIPTOR): Rename _lbound to lower_bound and
        data to base_addr.
        * intrinsics/cshift0.c (size0, cshift0): Handle data to
        base_addr rename.
        * intrinsics/date_and_time.c (date_and_time, secnds, itime_i4,
        itime_i8, gmtime_i4, gmtime_i8, ltime_i4, ltime_i8): Ditto.
        * intrinsics/dtime.c (dtime_sub): Ditto.
        * intrinsics/eoshift0.c (eoshift0): Ditto.
        * intrinsics/eoshift2.c (eoshift2): Ditto.
        * intrinsics/etime.c (etime_sub): Ditto.
        * intrinsics/iso_c_binding.c (c_f_pointer_u0): Ditto.
        * intrinsics/move_alloc.c (move_alloc): Ditto.
        * intrinsics/pack_generic.c (pack_internal, pack,
        pack_s_internal): Ditto.
        * intrinsics/random.c (arandom_r4, arandom_r8, arandom_r10,
        arandom_r16, random_seed_i4, random_seed_i8): Ditto.
        * intrinsics/reshape_generic.c (reshape_internal): Ditto.
        * intrinsics/spread_generic.c (spread_internal,
        spread_internal_scalar, spread, spread_scalar): Ditto.
        * intrinsics/stat.c (stat_i4_sub_0, stat_i8_sub_0, fstat_i4_sub,
        fstat_i8_sub): Ditto.
        * intrinsics/transpose_generic.c (transpose_internal): Ditto.
        * intrinsics/unpack_generic.c (unpack_bounds, unpack_internal,
        unpack1, unpack0, unpack0_char4): Ditto.
        * m4/bessel.m4 (bessel_jn_r'rtype_kind`,
        * bessel_yn_r'rtype_kind`):
        Ditto.
        * m4/cshift0.m4 (cshift0_'rtype_code`): Ditto.
        * m4/cshift1.m4 (cshift1): Ditto.
        * m4/eoshift1.m4 (eoshift1): Ditto.
        * m4/eoshift3.m4 (eoshift3): Ditto.
        * m4/iforeach.m4 (name`'rtype_qual`_'atype_code): Ditto.
        * m4/ifunction.m4 (name`'rtype_qual`_'atype_code): Ditto.
        * m4/ifunction_logical.m4 (name`'rtype_qual`_'atype_code):
        * Ditto.
        * m4/in_pack.m4 (internal_pack_'rtype_ccode`): Ditto.
        * m4/in_unpack.m4 (internal_unpack_'rtype_ccode`): Ditto.
        * m4/matmul.m4 (matmul_'rtype_code`): Ditto.
        * m4/matmull.m4 (matmul_'rtype_code`): Ditto.
        * m4/pack.m4 (pack_'rtype_code`): Ditto.
        * m4/reshape.m4 (reshape_'rtype_ccode`): Ditto.
        * m4/shape.m4 (shape_'rtype_kind`): Ditto.
        * m4/spread.m4 (spread_'rtype_code`): Ditto.
        * m4/transpose.m4 (transpose_'rtype_code`): Ditto.
        * m4/unpack.m4 (unpack0_'rtype_code`, unpack1_'rtype_code`):
        * Ditto.
        * runtime/bounds.c (count_0): Ditto.
        * runtime/in_pack_generic.c (internal_pack): Ditto.
        * runtime/in_unpack_generic.c (internal_unpack): Ditto.
        * generated/cshift0_r4.c: Regenerated.
        * generated/unpack_r8.c: Regenerated.
        * generated/cshift0_c10.c: Regenerated.
        * generated/in_unpack_i1.c: Regenerated.
        * generated/eoshift1_16.c: Regenerated.
        * generated/iany_i16.c: Regenerated.
        * generated/reshape_i4.c: Regenerated.
        * generated/parity_l16.c: Regenerated.
        * generated/in_unpack_r16.c: Regenerated.
        * generated/iparity_i1.c: Regenerated.
        * generated/minloc0_16_r10.c: Regenerated.
        * generated/minloc1_16_i8.c: Regenerated.
        * generated/bessel_r8.c: Regenerated.
        * generated/maxloc0_4_i8.c: Regenerated.
        * generated/maxloc1_8_i1.c: Regenerated.
        * generated/sum_c10.c: Regenerated.
        * generated/maxloc0_8_r10.c: Regenerated.
        * generated/unpack_r16.c: Regenerated.
        * generated/maxloc1_16_i1.c: Regenerated.
        * generated/minloc1_4_i1.c: Regenerated.
        * generated/unpack_i4.c: Regenerated.
        * generated/in_pack_i1.c: Regenerated.
        * generated/cshift0_i1.c: Regenerated.
        * generated/minloc0_16_i4.c: Regenerated.
        * generated/minloc1_8_r8.c: Regenerated.
        * generated/maxval_r8.c: Regenerated.
        * generated/unpack_i2.c: Regenerated.
        * generated/matmul_r16.c: Regenerated.
        * generated/maxloc0_16_r8.c: Regenerated.
        * generated/maxloc1_8_i16.c: Regenerated.
        * generated/maxloc0_4_r4.c: Regenerated.
        * generated/pack_c10.c: Regenerated.
        * generated/in_unpack_c8.c: Regenerated.
        * generated/maxloc1_8_i8.c: Regenerated.
        * generated/in_pack_c16.c: Regenerated.
        * generated/parity_l1.c: Regenerated.
        * generated/in_pack_i2.c: Regenerated.
        * generated/maxloc0_4_r8.c: Regenerated.
        * generated/pack_r4.c: Regenerated.
        * generated/matmul_r8.c: Regenerated.
        * generated/pack_i1.c: Regenerated.
        * generated/minloc0_16_r16.c: Regenerated.
        * generated/cshift0_c8.c: Regenerated.
        * generated/minloc1_4_i16.c: Regenerated.
        * generated/minloc0_4_r4.c: Regenerated.
        * generated/product_i2.c: Regenerated.
        * generated/maxval_r10.c: Regenerated.
        * generated/minloc0_16_r8.c: Regenerated.
        * generated/in_pack_i8.c: Regenerated.
        * generated/all_l8.c: Regenerated.
        * generated/minloc0_8_i16.c: Regenerated.
        * generated/minloc1_8_i2.c: Regenerated.
        * generated/matmul_l8.c: Regenerated.
        * generated/spread_r10.c: Regenerated.
        * generated/product_c4.c: Regenerated.
        * generated/reshape_r16.c: Regenerated.
        * generated/cshift0_i16.c: Regenerated.
        * generated/minloc1_8_r10.c: Regenerated.
        * generated/iparity_i8.c: Regenerated.
        * generated/minloc0_16_i8.c: Regenerated.
        * generated/minloc1_8_i1.c: Regenerated.
        * generated/maxloc0_16_r10.c: Regenerated.
        * generated/maxloc1_8_i4.c: Regenerated.
        * generated/maxloc0_16_i8.c: Regenerated.
        * generated/maxloc1_16_i16.c: Regenerated.
        * generated/reshape_i8.c: Regenerated.
        * generated/all_l16.c: Regenerated.
        * generated/cshift1_8.c: Regenerated.
        * generated/matmul_c10.c: Regenerated.
        * generated/pack_r16.c: Regenerated.
        * generated/transpose_r10.c: Regenerated.
        * generated/maxloc1_16_i2.c: Regenerated.
        * generated/minloc1_4_r4.c: Regenerated.
        * generated/reshape_r8.c: Regenerated.
        * generated/product_r10.c: Regenerated.
        * generated/spread_c10.c: Regenerated.
        * generated/reshape_r4.c: Regenerated.
        * generated/in_unpack_i4.c: Regenerated.
        * generated/minval_r4.c: Regenerated.
        * generated/minloc1_16_r16.c: Regenerated.
        * generated/norm2_r8.c: Regenerated.
        * generated/iany_i2.c: Regenerated.
        * generated/eoshift3_8.c: Regenerated.
        * generated/maxloc1_16_r8.c: Regenerated.
        * generated/maxloc0_16_r16.c: Regenerated.
        * generated/cshift0_i8.c: Regenerated.
        * generated/all_l1.c: Regenerated.
        * generated/minloc1_16_r10.c: Regenerated.
        * generated/spread_i16.c: Regenerated.
        * generated/minloc1_8_r16.c: Regenerated.
        * generated/spread_r16.c: Regenerated.
        * generated/matmul_c8.c: Regenerated.
        * generated/pack_r10.c: Regenerated.
        * generated/reshape_r10.c: Regenerated.
        * generated/sum_r10.c: Regenerated.
        * generated/count_8_l.c: Regenerated.
        * generated/minloc1_16_i16.c: Regenerated.
        * generated/maxloc0_16_i2.c: Regenerated.
        * generated/count_1_l.c: Regenerated.
        * generated/unpack_c16.c: Regenerated.
        * generated/any_l8.c: Regenerated.
        * generated/minloc1_16_i1.c: Regenerated.
        * generated/sum_r4.c: Regenerated.
        * generated/in_unpack_r8.c: Regenerated.
        * generated/product_r8.c: Regenerated.
        * generated/in_unpack_r4.c: Regenerated.
        * generated/unpack_i1.c: Regenerated.
        * generated/cshift0_r8.c: Regenerated.
        * generated/spread_i2.c: Regenerated.
        * generated/minloc1_4_r10.c: Regenerated.
        * generated/minloc1_16_i2.c: Regenerated.
        * generated/minloc0_16_i2.c: Regenerated.
        * generated/eoshift3_16.c: Regenerated.
        * generated/maxloc0_8_i4.c: Regenerated.
        * generated/maxloc1_16_r10.c: Regenerated.
        * generated/maxloc1_4_i16.c: Regenerated.
        * generated/maxloc1_4_r8.c: Regenerated.
        * generated/parity_l2.c: Regenerated.
        * generated/maxloc0_16_i16.c: Regenerated.
        * generated/product_r4.c: Regenerated.
        * generated/in_unpack_r10.c: Regenerated.
        * generated/maxloc1_8_i2.c: Regenerated.
        * generated/iparity_i2.c: Regenerated.
        * generated/maxloc1_8_r4.c: Regenerated.
        * generated/maxloc1_8_r8.c: Regenerated.
        * generated/iall_i4.c: Regenerated.
        * generated/maxloc0_4_i16.c: Regenerated.
        * generated/cshift0_i4.c: Regenerated.
        * generated/in_unpack_c10.c: Regenerated.
        * generated/unpack_c8.c: Regenerated.
        * generated/transpose_c8.c: Regenerated.
        * generated/in_unpack_c16.c: Regenerated.
        * generated/product_c16.c: Regenerated.
        * generated/minval_r8.c: Regenerated.
        * generated/minloc0_4_i1.c: Regenerated.
        * generated/minloc0_8_r16.c: Regenerated.
        * generated/in_unpack_i16.c: Regenerated.
        * generated/reshape_c16.c: Regenerated.
        * generated/pack_i4.c: Regenerated.
        * generated/minval_r10.c: Regenerated.
        * generated/maxloc0_4_r10.c: Regenerated.
        * generated/unpack_i8.c: Regenerated.
        * generated/minloc1_16_r8.c: Regenerated.
        * generated/pack_c16.c: Regenerated.
        * generated/maxval_r4.c: Regenerated.
        * generated/spread_r8.c: Regenerated.
        * generated/minloc0_16_r4.c: Regenerated.
        * generated/maxval_i4.c: Regenerated.
        * generated/matmul_r4.c: Regenerated.
        * generated/product_c8.c: Regenerated.
        * generated/maxloc1_4_i4.c: Regenerated.
        * generated/any_l4.c: Regenerated.
        * generated/cshift0_r16.c: Regenerated.
        * generated/maxloc1_16_r4.c: Regenerated.
        * generated/in_pack_r10.c: Regenerated.
        * generated/iall_i1.c: Regenerated.
        * generated/product_i1.c: Regenerated.
        * generated/maxloc0_4_i1.c: Regenerated.
        * generated/maxloc0_8_r16.c: Regenerated.
        * generated/minloc1_8_i16.c: Regenerated.
        * generated/reshape_c10.c: Regenerated.
        * generated/matmul_l4.c: Regenerated.
        * generated/cshift0_c16.c: Regenerated.
        * generated/spread_r4.c: Regenerated.
        * generated/sum_r16.c: Regenerated.
        * generated/in_unpack_c4.c: Regenerated.
        * generated/maxval_i8.c: Regenerated.
        * generated/maxloc0_8_r8.c: Regenerated.
        * generated/unpack_i16.c: Regenerated.
        * generated/norm2_r4.c: Regenerated.
        * generated/maxloc1_4_r16.c: Regenerated.
        * generated/in_pack_r4.c: Regenerated.
        * generated/sum_c8.c: Regenerated.
        * generated/parity_l8.c: Regenerated.
        * generated/minval_i2.c: Regenerated.
        * generated/transpose_c10.c: Regenerated.
        * generated/cshift0_r10.c: Regenerated.
        * generated/cshift0_i2.c: Regenerated.
        * generated/spread_c4.c: Regenerated.
        * generated/maxval_r16.c: Regenerated.
        * generated/unpack_c10.c: Regenerated.
        * generated/bessel_r4.c: Regenerated.
        * generated/minloc0_8_i1.c: Regenerated.
        * generated/product_c10.c: Regenerated.
        * generated/minloc1_4_i4.c: Regenerated.
        * generated/minloc1_4_i2.c: Regenerated.
        * generated/transpose_c4.c: Regenerated.
        * generated/in_pack_c8.c: Regenerated.
        * generated/minval_i8.c: Regenerated.
        * generated/maxloc1_4_i2.c: Regenerated.
        * generated/maxloc1_4_i1.c: Regenerated.
        * generated/iall_i8.c: Regenerated.
        * generated/iany_i8.c: Regenerated.
        * generated/sum_c16.c: Regenerated.
        * generated/spread_i8.c: Regenerated.
        * generated/sum_i8.c: Regenerated.
        * generated/pack_i2.c: Regenerated.
        * generated/unpack_r10.c: Regenerated.
        * generated/minloc0_4_i4.c: Regenerated.
        * generated/iany_i4.c: Regenerated.
        * generated/maxloc0_4_i4.c: Regenerated.
        * generated/in_pack_r8.c: Regenerated.
        * generated/spread_i1.c: Regenerated.
        * generated/maxval_i16.c: Regenerated.
        * generated/pack_c8.c: Regenerated.
        * generated/iparity_i16.c: Regenerated.
        * generated/matmul_c16.c: Regenerated.
        * generated/eoshift1_8.c: Regenerated.
        * generated/any_l16.c: Regenerated.
        * generated/maxloc1_4_i8.c: Regenerated.
        * generated/minloc0_8_r4.c: Regenerated.
        * generated/transpose_c16.c: Regenerated.
        * generated/reshape_c4.c: Regenerated.
        * generated/minloc0_8_r8.c: Regenerated.
        * generated/count_16_l.c: Regenerated.
        * generated/minloc0_16_i1.c: Regenerated.
        * generated/minloc1_16_r4.c: Regenerated.
        * generated/maxloc0_8_i1.c: Regenerated.
        * generated/matmul_i1.c: Regenerated.
        * generated/sum_i2.c: Regenerated.
        * generated/cshift1_4.c: Regenerated.
        * generated/minloc0_4_i2.c: Regenerated.
        * generated/bessel_r10.c: Regenerated.
        * generated/matmul_c4.c: Regenerated.
        * generated/parity_l4.c: Regenerated.
        * generated/in_unpack_i2.c: Regenerated.
        * generated/product_i16.c: Regenerated.
        * generated/maxloc0_16_i4.c: Regenerated.
        * generated/minloc0_4_r10.c: Regenerated.
        * generated/transpose_i16.c: Regenerated.
        * generated/matmul_l16.c: Regenerated.
        * generated/any_l1.c: Regenerated.
        * generated/minval_r16.c: Regenerated.
        * generated/shape_i16.c: Regenerated.
        * generated/in_pack_c4.c: Regenerated.
        * generated/minloc1_8_r4.c: Regenerated.
        * generated/iany_i1.c: Regenerated.
        * generated/matmul_i16.c: Regenerated.
        * generated/maxloc0_16_r4.c: Regenerated.
        * generated/spread_c8.c: Regenerated.
        * generated/product_i8.c: Regenerated.
        * generated/minloc1_8_i4.c: Regenerated.
        * generated/product_i4.c: Regenerated.
        * generated/minval_i16.c: Regenerated.
        * generated/pack_r8.c: Regenerated.
        * generated/matmul_r10.c: Regenerated.
        * generated/shape_i8.c: Regenerated.
        * generated/eoshift1_4.c: Regenerated.
        * generated/minloc1_16_i4.c: Regenerated.
        * generated/transpose_r16.c: Regenerated.
        * generated/spread_c16.c: Regenerated.
        * generated/maxloc0_8_i16.c: Regenerated.
        * generated/minval_i1.c: Regenerated.
        * generated/sum_i4.c: Regenerated.
        * generated/in_pack_r16.c: Regenerated.
        * generated/iall_i16.c: Regenerated.
        * generated/minloc0_8_r10.c: Regenerated.
        * generated/maxloc0_8_i8.c: Regenerated.
        * generated/transpose_i4.c: Regenerated.
        * generated/maxloc0_4_i2.c: Regenerated.
        * generated/iall_i2.c: Regenerated.
        * generated/maxloc0_8_r4.c: Regenerated.
        * generated/minloc0_4_r16.c: Regenerated.
        * generated/minloc1_4_r8.c: Regenerated.
        * generated/minloc0_4_i8.c: Regenerated.
        * generated/minval_i4.c: Regenerated.
        * generated/minloc1_8_i8.c: Regenerated.
        * generated/in_pack_i16.c: Regenerated.
        * generated/spread_i4.c: Regenerated.
        * generated/cshift0_c4.c: Regenerated.
        * generated/minloc0_4_i16.c: Regenerated.
        * generated/sum_r8.c: Regenerated.
        * generated/minloc0_16_i16.c: Regenerated.
        * generated/sum_i1.c: Regenerated.
        * generated/all_l2.c: Regenerated.
        * generated/sum_c4.c: Regenerated.
        * generated/shape_i4.c: Regenerated.
        * generated/maxval_i1.c: Regenerated.
        * generated/norm2_r10.c: Regenerated.
        * generated/unpack_c4.c: Regenerated.
        * generated/maxloc0_16_i1.c: Regenerated.
        * generated/all_l4.c: Regenerated.
        * generated/maxloc1_16_i8.c: Regenerated.
        * generated/sum_i16.c: Regenerated.
        * generated/maxloc1_8_r16.c: Regenerated.
        * generated/minloc1_4_r16.c: Regenerated.
        * generated/maxloc1_16_r16.c: Regenerated.
        * generated/transpose_i8.c: Regenerated.
        * generated/minloc0_8_i2.c: Regenerated.
        * generated/product_r16.c: Regenerated.
        * generated/in_pack_c10.c: Regenerated.
        * generated/maxloc0_4_r16.c: Regenerated.
        * generated/pack_c4.c: Regenerated.
        * generated/bessel_r16.c: Regenerated.
        * generated/norm2_r16.c: Regenerated.
        * generated/in_unpack_i8.c: Regenerated.
        * generated/maxloc1_16_i4.c: Regenerated.
        * generated/minloc1_4_i8.c: Regenerated.
        * generated/eoshift3_4.c: Regenerated.
        * generated/maxloc1_8_r10.c: Regenerated.
        * generated/matmul_i8.c: Regenerated.
        * generated/matmul_i4.c: Regenerated.
        * generated/reshape_i16.c: Regenerated.
        * generated/matmul_i2.c: Regenerated.
        * generated/transpose_r8.c: Regenerated.
        * generated/transpose_r4.c: Regenerated.
        * generated/cshift1_16.c: Regenerated.
        * generated/maxloc1_4_r10.c: Regenerated.
        * generated/iparity_i4.c: Regenerated.
        * generated/in_pack_i4.c: Regenerated.
        * generated/maxloc0_8_i2.c: Regenerated.
        * generated/unpack_r4.c: Regenerated.
        * generated/count_4_l.c: Regenerated.
        * generated/maxloc1_4_r4.c: Regenerated.
        * generated/minloc0_8_i8.c: Regenerated.
        * generated/any_l2.c: Regenerated.
        * generated/minloc0_8_i4.c: Regenerated.
        * generated/pack_i8.c: Regenerated.
        * generated/count_2_l.c: Regenerated.
        * generated/reshape_c8.c: Regenerated.
        * generated/maxval_i2.c: Regenerated.
        * generated/minloc0_4_r8.c: Regenerated.

From-SVN: r185177

361 files changed, 3909 insertions, 3544 deletions

diff --git a/libgfortran/ChangeLog b/libgfortran/ChangeLog
index 49b4681..a509435 100644
--- a/libgfortran/ChangeLog
+++ b/libgfortran/ChangeLog
@@ -1,3 +1,376 @@
+2012-03-10  Tobias Burnus  <burnus@net-b.de>
+
+	* libgfortran.h (descriptor_dimension, GFC_DIMENSION_LBOUND,
+	GFC_DIMENSION_EXTENT, GFC_DIMENSION_SET, GFC_DESCRIPTOR_DATA,
+	GFC_ARRAY_DESCRIPTOR): Rename _lbound to lower_bound and
+	data to base_addr.
+	* intrinsics/cshift0.c (size0, cshift0): Handle data to
+	base_addr rename.
+	* intrinsics/date_and_time.c (date_and_time, secnds, itime_i4,
+	itime_i8, gmtime_i4, gmtime_i8, ltime_i4, ltime_i8): Ditto.
+	* intrinsics/dtime.c (dtime_sub): Ditto.
+	* intrinsics/eoshift0.c (eoshift0): Ditto.
+	* intrinsics/eoshift2.c (eoshift2): Ditto.
+	* intrinsics/etime.c (etime_sub): Ditto.
+	* intrinsics/iso_c_binding.c (c_f_pointer_u0): Ditto.
+	* intrinsics/move_alloc.c (move_alloc): Ditto.
+	* intrinsics/pack_generic.c (pack_internal, pack,
+	pack_s_internal): Ditto.
+	* intrinsics/random.c (arandom_r4, arandom_r8, arandom_r10,
+	arandom_r16, random_seed_i4, random_seed_i8): Ditto.
+	* intrinsics/reshape_generic.c (reshape_internal): Ditto.
+	* intrinsics/spread_generic.c (spread_internal,
+	spread_internal_scalar, spread, spread_scalar): Ditto.
+	* intrinsics/stat.c (stat_i4_sub_0, stat_i8_sub_0, fstat_i4_sub,
+	fstat_i8_sub): Ditto.
+	* intrinsics/transpose_generic.c (transpose_internal): Ditto.
+	* intrinsics/unpack_generic.c (unpack_bounds, unpack_internal,
+	unpack1, unpack0, unpack0_char4): Ditto.
+	* m4/bessel.m4 (bessel_jn_r'rtype_kind`, bessel_yn_r'rtype_kind`):
+	Ditto.
+	* m4/cshift0.m4 (cshift0_'rtype_code`): Ditto.
+	* m4/cshift1.m4 (cshift1): Ditto.
+	* m4/eoshift1.m4 (eoshift1): Ditto.
+	* m4/eoshift3.m4 (eoshift3): Ditto.
+	* m4/iforeach.m4 (name`'rtype_qual`_'atype_code): Ditto.
+	* m4/ifunction.m4 (name`'rtype_qual`_'atype_code): Ditto.
+	* m4/ifunction_logical.m4 (name`'rtype_qual`_'atype_code): Ditto.
+	* m4/in_pack.m4 (internal_pack_'rtype_ccode`): Ditto.
+	* m4/in_unpack.m4 (internal_unpack_'rtype_ccode`): Ditto.
+	* m4/matmul.m4 (matmul_'rtype_code`): Ditto.
+	* m4/matmull.m4 (matmul_'rtype_code`): Ditto.
+	* m4/pack.m4 (pack_'rtype_code`): Ditto.
+	* m4/reshape.m4 (reshape_'rtype_ccode`): Ditto.
+	* m4/shape.m4 (shape_'rtype_kind`): Ditto.
+	* m4/spread.m4 (spread_'rtype_code`): Ditto.
+	* m4/transpose.m4 (transpose_'rtype_code`): Ditto.
+	* m4/unpack.m4 (unpack0_'rtype_code`, unpack1_'rtype_code`): Ditto.
+	* runtime/bounds.c (count_0): Ditto.
+	* runtime/in_pack_generic.c (internal_pack): Ditto.
+	* runtime/in_unpack_generic.c (internal_unpack): Ditto.
+	* generated/cshift0_r4.c: Regenerated.
+	* generated/unpack_r8.c: Regenerated.
+	* generated/cshift0_c10.c: Regenerated.
+	* generated/in_unpack_i1.c: Regenerated.
+	* generated/eoshift1_16.c: Regenerated.
+	* generated/iany_i16.c: Regenerated.
+	* generated/reshape_i4.c: Regenerated.
+	* generated/parity_l16.c: Regenerated.
+	* generated/in_unpack_r16.c: Regenerated.
+	* generated/iparity_i1.c: Regenerated.
+	* generated/minloc0_16_r10.c: Regenerated.
+	* generated/minloc1_16_i8.c: Regenerated.
+	* generated/bessel_r8.c: Regenerated.
+	* generated/maxloc0_4_i8.c: Regenerated.
+	* generated/maxloc1_8_i1.c: Regenerated.
+	* generated/sum_c10.c: Regenerated.
+	* generated/maxloc0_8_r10.c: Regenerated.
+	* generated/unpack_r16.c: Regenerated.
+	* generated/maxloc1_16_i1.c: Regenerated.
+	* generated/minloc1_4_i1.c: Regenerated.
+	* generated/unpack_i4.c: Regenerated.
+	* generated/in_pack_i1.c: Regenerated.
+	* generated/cshift0_i1.c: Regenerated.
+	* generated/minloc0_16_i4.c: Regenerated.
+	* generated/minloc1_8_r8.c: Regenerated.
+	* generated/maxval_r8.c: Regenerated.
+	* generated/unpack_i2.c: Regenerated.
+	* generated/matmul_r16.c: Regenerated.
+	* generated/maxloc0_16_r8.c: Regenerated.
+	* generated/maxloc1_8_i16.c: Regenerated.
+	* generated/maxloc0_4_r4.c: Regenerated.
+	* generated/pack_c10.c: Regenerated.
+	* generated/in_unpack_c8.c: Regenerated.
+	* generated/maxloc1_8_i8.c: Regenerated.
+	* generated/in_pack_c16.c: Regenerated.
+	* generated/parity_l1.c: Regenerated.
+	* generated/in_pack_i2.c: Regenerated.
+	* generated/maxloc0_4_r8.c: Regenerated.
+	* generated/pack_r4.c: Regenerated.
+	* generated/matmul_r8.c: Regenerated.
+	* generated/pack_i1.c: Regenerated.
+	* generated/minloc0_16_r16.c: Regenerated.
+	* generated/cshift0_c8.c: Regenerated.
+	* generated/minloc1_4_i16.c: Regenerated.
+	* generated/minloc0_4_r4.c: Regenerated.
+	* generated/product_i2.c: Regenerated.
+	* generated/maxval_r10.c: Regenerated.
+	* generated/minloc0_16_r8.c: Regenerated.
+	* generated/in_pack_i8.c: Regenerated.
+	* generated/all_l8.c: Regenerated.
+	* generated/minloc0_8_i16.c: Regenerated.
+	* generated/minloc1_8_i2.c: Regenerated.
+	* generated/matmul_l8.c: Regenerated.
+	* generated/spread_r10.c: Regenerated.
+	* generated/product_c4.c: Regenerated.
+	* generated/reshape_r16.c: Regenerated.
+	* generated/cshift0_i16.c: Regenerated.
+	* generated/minloc1_8_r10.c: Regenerated.
+	* generated/iparity_i8.c: Regenerated.
+	* generated/minloc0_16_i8.c: Regenerated.
+	* generated/minloc1_8_i1.c: Regenerated.
+	* generated/maxloc0_16_r10.c: Regenerated.
+	* generated/maxloc1_8_i4.c: Regenerated.
+	* generated/maxloc0_16_i8.c: Regenerated.
+	* generated/maxloc1_16_i16.c: Regenerated.
+	* generated/reshape_i8.c: Regenerated.
+	* generated/all_l16.c: Regenerated.
+	* generated/cshift1_8.c: Regenerated.
+	* generated/matmul_c10.c: Regenerated.
+	* generated/pack_r16.c: Regenerated.
+	* generated/transpose_r10.c: Regenerated.
+	* generated/maxloc1_16_i2.c: Regenerated.
+	* generated/minloc1_4_r4.c: Regenerated.
+	* generated/reshape_r8.c: Regenerated.
+	* generated/product_r10.c: Regenerated.
+	* generated/spread_c10.c: Regenerated.
+	* generated/reshape_r4.c: Regenerated.
+	* generated/in_unpack_i4.c: Regenerated.
+	* generated/minval_r4.c: Regenerated.
+	* generated/minloc1_16_r16.c: Regenerated.
+	* generated/norm2_r8.c: Regenerated.
+	* generated/iany_i2.c: Regenerated.
+	* generated/eoshift3_8.c: Regenerated.
+	* generated/maxloc1_16_r8.c: Regenerated.
+	* generated/maxloc0_16_r16.c: Regenerated.
+	* generated/cshift0_i8.c: Regenerated.
+	* generated/all_l1.c: Regenerated.
+	* generated/minloc1_16_r10.c: Regenerated.
+	* generated/spread_i16.c: Regenerated.
+	* generated/minloc1_8_r16.c: Regenerated.
+	* generated/spread_r16.c: Regenerated.
+	* generated/matmul_c8.c: Regenerated.
+	* generated/pack_r10.c: Regenerated.
+	* generated/reshape_r10.c: Regenerated.
+	* generated/sum_r10.c: Regenerated.
+	* generated/count_8_l.c: Regenerated.
+	* generated/minloc1_16_i16.c: Regenerated.
+	* generated/maxloc0_16_i2.c: Regenerated.
+	* generated/count_1_l.c: Regenerated.
+	* generated/unpack_c16.c: Regenerated.
+	* generated/any_l8.c: Regenerated.
+	* generated/minloc1_16_i1.c: Regenerated.
+	* generated/sum_r4.c: Regenerated.
+	* generated/in_unpack_r8.c: Regenerated.
+	* generated/product_r8.c: Regenerated.
+	* generated/in_unpack_r4.c: Regenerated.
+	* generated/unpack_i1.c: Regenerated.
+	* generated/cshift0_r8.c: Regenerated.
+	* generated/spread_i2.c: Regenerated.
+	* generated/minloc1_4_r10.c: Regenerated.
+	* generated/minloc1_16_i2.c: Regenerated.
+	* generated/minloc0_16_i2.c: Regenerated.
+	* generated/eoshift3_16.c: Regenerated.
+	* generated/maxloc0_8_i4.c: Regenerated.
+	* generated/maxloc1_16_r10.c: Regenerated.
+	* generated/maxloc1_4_i16.c: Regenerated.
+	* generated/maxloc1_4_r8.c: Regenerated.
+	* generated/parity_l2.c: Regenerated.
+	* generated/maxloc0_16_i16.c: Regenerated.
+	* generated/product_r4.c: Regenerated.
+	* generated/in_unpack_r10.c: Regenerated.
+	* generated/maxloc1_8_i2.c: Regenerated.
+	* generated/iparity_i2.c: Regenerated.
+	* generated/maxloc1_8_r4.c: Regenerated.
+	* generated/maxloc1_8_r8.c: Regenerated.
+	* generated/iall_i4.c: Regenerated.
+	* generated/maxloc0_4_i16.c: Regenerated.
+	* generated/cshift0_i4.c: Regenerated.
+	* generated/in_unpack_c10.c: Regenerated.
+	* generated/unpack_c8.c: Regenerated.
+	* generated/transpose_c8.c: Regenerated.
+	* generated/in_unpack_c16.c: Regenerated.
+	* generated/product_c16.c: Regenerated.
+	* generated/minval_r8.c: Regenerated.
+	* generated/minloc0_4_i1.c: Regenerated.
+	* generated/minloc0_8_r16.c: Regenerated.
+	* generated/in_unpack_i16.c: Regenerated.
+	* generated/reshape_c16.c: Regenerated.
+	* generated/pack_i4.c: Regenerated.
+	* generated/minval_r10.c: Regenerated.
+	* generated/maxloc0_4_r10.c: Regenerated.
+	* generated/unpack_i8.c: Regenerated.
+	* generated/minloc1_16_r8.c: Regenerated.
+	* generated/pack_c16.c: Regenerated.
+	* generated/maxval_r4.c: Regenerated.
+	* generated/spread_r8.c: Regenerated.
+	* generated/minloc0_16_r4.c: Regenerated.
+	* generated/maxval_i4.c: Regenerated.
+	* generated/matmul_r4.c: Regenerated.
+	* generated/product_c8.c: Regenerated.
+	* generated/maxloc1_4_i4.c: Regenerated.
+	* generated/any_l4.c: Regenerated.
+	* generated/cshift0_r16.c: Regenerated.
+	* generated/maxloc1_16_r4.c: Regenerated.
+	* generated/in_pack_r10.c: Regenerated.
+	* generated/iall_i1.c: Regenerated.
+	* generated/product_i1.c: Regenerated.
+	* generated/maxloc0_4_i1.c: Regenerated.
+	* generated/maxloc0_8_r16.c: Regenerated.
+	* generated/minloc1_8_i16.c: Regenerated.
+	* generated/reshape_c10.c: Regenerated.
+	* generated/matmul_l4.c: Regenerated.
+	* generated/cshift0_c16.c: Regenerated.
+	* generated/spread_r4.c: Regenerated.
+	* generated/sum_r16.c: Regenerated.
+	* generated/in_unpack_c4.c: Regenerated.
+	* generated/maxval_i8.c: Regenerated.
+	* generated/maxloc0_8_r8.c: Regenerated.
+	* generated/unpack_i16.c: Regenerated.
+	* generated/norm2_r4.c: Regenerated.
+	* generated/maxloc1_4_r16.c: Regenerated.
+	* generated/in_pack_r4.c: Regenerated.
+	* generated/sum_c8.c: Regenerated.
+	* generated/parity_l8.c: Regenerated.
+	* generated/minval_i2.c: Regenerated.
+	* generated/transpose_c10.c: Regenerated.
+	* generated/cshift0_r10.c: Regenerated.
+	* generated/cshift0_i2.c: Regenerated.
+	* generated/spread_c4.c: Regenerated.
+	* generated/maxval_r16.c: Regenerated.
+	* generated/unpack_c10.c: Regenerated.
+	* generated/bessel_r4.c: Regenerated.
+	* generated/minloc0_8_i1.c: Regenerated.
+	* generated/product_c10.c: Regenerated.
+	* generated/minloc1_4_i4.c: Regenerated.
+	* generated/minloc1_4_i2.c: Regenerated.
+	* generated/transpose_c4.c: Regenerated.
+	* generated/in_pack_c8.c: Regenerated.
+	* generated/minval_i8.c: Regenerated.
+	* generated/maxloc1_4_i2.c: Regenerated.
+	* generated/maxloc1_4_i1.c: Regenerated.
+	* generated/iall_i8.c: Regenerated.
+	* generated/iany_i8.c: Regenerated.
+	* generated/sum_c16.c: Regenerated.
+	* generated/spread_i8.c: Regenerated.
+	* generated/sum_i8.c: Regenerated.
+	* generated/pack_i2.c: Regenerated.
+	* generated/unpack_r10.c: Regenerated.
+	* generated/minloc0_4_i4.c: Regenerated.
+	* generated/iany_i4.c: Regenerated.
+	* generated/maxloc0_4_i4.c: Regenerated.
+	* generated/in_pack_r8.c: Regenerated.
+	* generated/spread_i1.c: Regenerated.
+	* generated/maxval_i16.c: Regenerated.
+	* generated/pack_c8.c: Regenerated.
+	* generated/iparity_i16.c: Regenerated.
+	* generated/matmul_c16.c: Regenerated.
+	* generated/eoshift1_8.c: Regenerated.
+	* generated/any_l16.c: Regenerated.
+	* generated/maxloc1_4_i8.c: Regenerated.
+	* generated/minloc0_8_r4.c: Regenerated.
+	* generated/transpose_c16.c: Regenerated.
+	* generated/reshape_c4.c: Regenerated.
+	* generated/minloc0_8_r8.c: Regenerated.
+	* generated/count_16_l.c: Regenerated.
+	* generated/minloc0_16_i1.c: Regenerated.
+	* generated/minloc1_16_r4.c: Regenerated.
+	* generated/maxloc0_8_i1.c: Regenerated.
+	* generated/matmul_i1.c: Regenerated.
+	* generated/sum_i2.c: Regenerated.
+	* generated/cshift1_4.c: Regenerated.
+	* generated/minloc0_4_i2.c: Regenerated.
+	* generated/bessel_r10.c: Regenerated.
+	* generated/matmul_c4.c: Regenerated.
+	* generated/parity_l4.c: Regenerated.
+	* generated/in_unpack_i2.c: Regenerated.
+	* generated/product_i16.c: Regenerated.
+	* generated/maxloc0_16_i4.c: Regenerated.
+	* generated/minloc0_4_r10.c: Regenerated.
+	* generated/transpose_i16.c: Regenerated.
+	* generated/matmul_l16.c: Regenerated.
+	* generated/any_l1.c: Regenerated.
+	* generated/minval_r16.c: Regenerated.
+	* generated/shape_i16.c: Regenerated.
+	* generated/in_pack_c4.c: Regenerated.
+	* generated/minloc1_8_r4.c: Regenerated.
+	* generated/iany_i1.c: Regenerated.
+	* generated/matmul_i16.c: Regenerated.
+	* generated/maxloc0_16_r4.c: Regenerated.
+	* generated/spread_c8.c: Regenerated.
+	* generated/product_i8.c: Regenerated.
+	* generated/minloc1_8_i4.c: Regenerated.
+	* generated/product_i4.c: Regenerated.
+	* generated/minval_i16.c: Regenerated.
+	* generated/pack_r8.c: Regenerated.
+	* generated/matmul_r10.c: Regenerated.
+	* generated/shape_i8.c: Regenerated.
+	* generated/eoshift1_4.c: Regenerated.
+	* generated/minloc1_16_i4.c: Regenerated.
+	* generated/transpose_r16.c: Regenerated.
+	* generated/spread_c16.c: Regenerated.
+	* generated/maxloc0_8_i16.c: Regenerated.
+	* generated/minval_i1.c: Regenerated.
+	* generated/sum_i4.c: Regenerated.
+	* generated/in_pack_r16.c: Regenerated.
+	* generated/iall_i16.c: Regenerated.
+	* generated/minloc0_8_r10.c: Regenerated.
+	* generated/maxloc0_8_i8.c: Regenerated.
+	* generated/transpose_i4.c: Regenerated.
+	* generated/maxloc0_4_i2.c: Regenerated.
+	* generated/iall_i2.c: Regenerated.
+	* generated/maxloc0_8_r4.c: Regenerated.
+	* generated/minloc0_4_r16.c: Regenerated.
+	* generated/minloc1_4_r8.c: Regenerated.
+	* generated/minloc0_4_i8.c: Regenerated.
+	* generated/minval_i4.c: Regenerated.
+	* generated/minloc1_8_i8.c: Regenerated.
+	* generated/in_pack_i16.c: Regenerated.
+	* generated/spread_i4.c: Regenerated.
+	* generated/cshift0_c4.c: Regenerated.
+	* generated/minloc0_4_i16.c: Regenerated.
+	* generated/sum_r8.c: Regenerated.
+	* generated/minloc0_16_i16.c: Regenerated.
+	* generated/sum_i1.c: Regenerated.
+	* generated/all_l2.c: Regenerated.
+	* generated/sum_c4.c: Regenerated.
+	* generated/shape_i4.c: Regenerated.
+	* generated/maxval_i1.c: Regenerated.
+	* generated/norm2_r10.c: Regenerated.
+	* generated/unpack_c4.c: Regenerated.
+	* generated/maxloc0_16_i1.c: Regenerated.
+	* generated/all_l4.c: Regenerated.
+	* generated/maxloc1_16_i8.c: Regenerated.
+	* generated/sum_i16.c: Regenerated.
+	* generated/maxloc1_8_r16.c: Regenerated.
+	* generated/minloc1_4_r16.c: Regenerated.
+	* generated/maxloc1_16_r16.c: Regenerated.
+	* generated/transpose_i8.c: Regenerated.
+	* generated/minloc0_8_i2.c: Regenerated.
+	* generated/product_r16.c: Regenerated.
+	* generated/in_pack_c10.c: Regenerated.
+	* generated/maxloc0_4_r16.c: Regenerated.
+	* generated/pack_c4.c: Regenerated.
+	* generated/bessel_r16.c: Regenerated.
+	* generated/norm2_r16.c: Regenerated.
+	* generated/in_unpack_i8.c: Regenerated.
+	* generated/maxloc1_16_i4.c: Regenerated.
+	* generated/minloc1_4_i8.c: Regenerated.
+	* generated/eoshift3_4.c: Regenerated.
+	* generated/maxloc1_8_r10.c: Regenerated.
+	* generated/matmul_i8.c: Regenerated.
+	* generated/matmul_i4.c: Regenerated.
+	* generated/reshape_i16.c: Regenerated.
+	* generated/matmul_i2.c: Regenerated.
+	* generated/transpose_r8.c: Regenerated.
+	* generated/transpose_r4.c: Regenerated.
+	* generated/cshift1_16.c: Regenerated.
+	* generated/maxloc1_4_r10.c: Regenerated.
+	* generated/iparity_i4.c: Regenerated.
+	* generated/in_pack_i4.c: Regenerated.
+	* generated/maxloc0_8_i2.c: Regenerated.
+	* generated/unpack_r4.c: Regenerated.
+	* generated/count_4_l.c: Regenerated.
+	* generated/maxloc1_4_r4.c: Regenerated.
+	* generated/minloc0_8_i8.c: Regenerated.
+	* generated/any_l2.c: Regenerated.
+	* generated/minloc0_8_i4.c: Regenerated.
+	* generated/pack_i8.c: Regenerated.
+	* generated/count_2_l.c: Regenerated.
+	* generated/reshape_c8.c: Regenerated.
+	* generated/maxval_i2.c: Regenerated.
+	* generated/minloc0_4_r8.c: Regenerated.
+
 2012-01-20  Tobias Burnus  <burnus@net-b.de>
 
 	PR libgfortran/51899
diff --git a/libgfortran/generated/all_l1.c b/libgfortran/generated/all_l1.c
index edf9818..541e7258 100644
--- a/libgfortran/generated/all_l1.c
+++ b/libgfortran/generated/all_l1.c
@@ -83,7 +83,7 @@ all_l1 (gfc_array_l1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ all_l1 (gfc_array_l1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ all_l1 (gfc_array_l1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ all_l1 (gfc_array_l1 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in ALL intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/all_l16.c b/libgfortran/generated/all_l16.c
index d5cde25..8162ac1 100644
--- a/libgfortran/generated/all_l16.c
+++ b/libgfortran/generated/all_l16.c
@@ -83,7 +83,7 @@ all_l16 (gfc_array_l16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ all_l16 (gfc_array_l16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ all_l16 (gfc_array_l16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ all_l16 (gfc_array_l16 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in ALL intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/all_l2.c b/libgfortran/generated/all_l2.c
index 1128ada..0e98cf6 100644
--- a/libgfortran/generated/all_l2.c
+++ b/libgfortran/generated/all_l2.c
@@ -83,7 +83,7 @@ all_l2 (gfc_array_l2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ all_l2 (gfc_array_l2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ all_l2 (gfc_array_l2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ all_l2 (gfc_array_l2 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in ALL intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/all_l4.c b/libgfortran/generated/all_l4.c
index 97ad5a4..8571751 100644
--- a/libgfortran/generated/all_l4.c
+++ b/libgfortran/generated/all_l4.c
@@ -83,7 +83,7 @@ all_l4 (gfc_array_l4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ all_l4 (gfc_array_l4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ all_l4 (gfc_array_l4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ all_l4 (gfc_array_l4 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in ALL intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/all_l8.c b/libgfortran/generated/all_l8.c
index 8846d34..9b9d16a 100644
--- a/libgfortran/generated/all_l8.c
+++ b/libgfortran/generated/all_l8.c
@@ -83,7 +83,7 @@ all_l8 (gfc_array_l8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ all_l8 (gfc_array_l8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ all_l8 (gfc_array_l8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ all_l8 (gfc_array_l8 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in ALL intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/any_l1.c b/libgfortran/generated/any_l1.c
index 8f52b51..e8b9cab 100644
--- a/libgfortran/generated/any_l1.c
+++ b/libgfortran/generated/any_l1.c
@@ -83,7 +83,7 @@ any_l1 (gfc_array_l1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ any_l1 (gfc_array_l1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ any_l1 (gfc_array_l1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ any_l1 (gfc_array_l1 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in ANY intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/any_l16.c b/libgfortran/generated/any_l16.c
index 7f3f69e..c605588 100644
--- a/libgfortran/generated/any_l16.c
+++ b/libgfortran/generated/any_l16.c
@@ -83,7 +83,7 @@ any_l16 (gfc_array_l16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ any_l16 (gfc_array_l16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ any_l16 (gfc_array_l16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ any_l16 (gfc_array_l16 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in ANY intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/any_l2.c b/libgfortran/generated/any_l2.c
index d2c4dbe..6c4afee 100644
--- a/libgfortran/generated/any_l2.c
+++ b/libgfortran/generated/any_l2.c
@@ -83,7 +83,7 @@ any_l2 (gfc_array_l2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ any_l2 (gfc_array_l2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ any_l2 (gfc_array_l2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ any_l2 (gfc_array_l2 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in ANY intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/any_l4.c b/libgfortran/generated/any_l4.c
index f9d5637..b2c4cde 100644
--- a/libgfortran/generated/any_l4.c
+++ b/libgfortran/generated/any_l4.c
@@ -83,7 +83,7 @@ any_l4 (gfc_array_l4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ any_l4 (gfc_array_l4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ any_l4 (gfc_array_l4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ any_l4 (gfc_array_l4 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in ANY intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/any_l8.c b/libgfortran/generated/any_l8.c
index f595826..86fd28c 100644
--- a/libgfortran/generated/any_l8.c
+++ b/libgfortran/generated/any_l8.c
@@ -83,7 +83,7 @@ any_l8 (gfc_array_l8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ any_l8 (gfc_array_l8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ any_l8 (gfc_array_l8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ any_l8 (gfc_array_l8 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in ANY intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/bessel_r10.c b/libgfortran/generated/bessel_r10.c
index 93d08d6..7d11614 100644
--- a/libgfortran/generated/bessel_r10.c
+++ b/libgfortran/generated/bessel_r10.c
@@ -1,6 +1,6 @@
 /* Implementation of the BESSEL_JN and BESSEL_YN transformational
    function using a recurrence algorithm.
-   Copyright 2010 Free Software Foundation, Inc.
+   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).
@@ -51,11 +51,11 @@ bessel_jn_r10 (gfc_array_r10 * const restrict ret, int n1, int n2, GFC_REAL_10 x
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
-      ret->data = internal_malloc_size (sizeof (GFC_REAL_10) * size);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * size);
       ret->offset = 0;
     }
 
@@ -72,21 +72,20 @@ bessel_jn_r10 (gfc_array_r10 * const restrict ret, int n1, int n2, GFC_REAL_10 x
 
   if (unlikely (x == 0))
     {
-      ret->data[0] = 1;
+      ret->base_addr[0] = 1;
       for (i = 1; i <= n2-n1; i++)
-        ret->data[i*stride] = 0;
+        ret->base_addr[i*stride] = 0;
       return;
     }
 
-  ret->data = ret->data;
   last1 = MATHFUNC(jn) (n2, x);
-  ret->data[(n2-n1)*stride] = last1;
+  ret->base_addr[(n2-n1)*stride] = last1;
 
   if (n1 == n2)
     return;
 
   last2 = MATHFUNC(jn) (n2 - 1, x);
-  ret->data[(n2-n1-1)*stride] = last2;
+  ret->base_addr[(n2-n1-1)*stride] = last2;
 
   if (n1 + 1 == n2)
     return;
@@ -95,9 +94,9 @@ bessel_jn_r10 (gfc_array_r10 * const restrict ret, int n1, int n2, GFC_REAL_10 x
 
   for (i = n2-n1-2; i >= 0; i--)
     {
-      ret->data[i*stride] = x2rev * (i+1+n1) * last2 - last1;
+      ret->base_addr[i*stride] = x2rev * (i+1+n1) * last2 - last1;
       last1 = last2;
-      last2 = ret->data[i*stride];
+      last2 = ret->base_addr[i*stride];
     }
 }
 
@@ -119,11 +118,11 @@ bessel_yn_r10 (gfc_array_r10 * const restrict ret, int n1, int n2,
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
-      ret->data = internal_malloc_size (sizeof (GFC_REAL_10) * size);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * size);
       ret->offset = 0;
     }
 
@@ -142,22 +141,22 @@ bessel_yn_r10 (gfc_array_r10 * const restrict ret, int n1, int n2,
     {
       for (i = 0; i <= n2-n1; i++)
 #if defined(GFC_REAL_10_INFINITY)
-        ret->data[i*stride] = -GFC_REAL_10_INFINITY;
+        ret->base_addr[i*stride] = -GFC_REAL_10_INFINITY;
 #else
-        ret->data[i*stride] = -GFC_REAL_10_HUGE;
+        ret->base_addr[i*stride] = -GFC_REAL_10_HUGE;
 #endif
       return;
     }
 
-  ret->data = ret->data;
+  ret->base_addr = ret->base_addr;
   last1 = MATHFUNC(yn) (n1, x);
-  ret->data[0] = last1;
+  ret->base_addr[0] = last1;
 
   if (n1 == n2)
     return;
 
   last2 = MATHFUNC(yn) (n1 + 1, x);
-  ret->data[1*stride] = last2;
+  ret->base_addr[1*stride] = last2;
 
   if (n1 + 1 == n2)
     return;
@@ -169,14 +168,14 @@ bessel_yn_r10 (gfc_array_r10 * const restrict ret, int n1, int n2,
 #if defined(GFC_REAL_10_INFINITY)
       if (unlikely (last2 == -GFC_REAL_10_INFINITY))
 	{
-	  ret->data[i*stride] = -GFC_REAL_10_INFINITY;
+	  ret->base_addr[i*stride] = -GFC_REAL_10_INFINITY;
 	}
       else
 #endif
 	{
-	  ret->data[i*stride] = x2rev * (i-1+n1) * last2 - last1;
+	  ret->base_addr[i*stride] = x2rev * (i-1+n1) * last2 - last1;
 	  last1 = last2;
-	  last2 = ret->data[i*stride];
+	  last2 = ret->base_addr[i*stride];
 	}
     }
 }
diff --git a/libgfortran/generated/bessel_r16.c b/libgfortran/generated/bessel_r16.c
index 28c35c1..ae23dbc 100644
--- a/libgfortran/generated/bessel_r16.c
+++ b/libgfortran/generated/bessel_r16.c
@@ -1,6 +1,6 @@
 /* Implementation of the BESSEL_JN and BESSEL_YN transformational
    function using a recurrence algorithm.
-   Copyright 2010 Free Software Foundation, Inc.
+   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).
@@ -55,11 +55,11 @@ bessel_jn_r16 (gfc_array_r16 * const restrict ret, int n1, int n2, GFC_REAL_16 x
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
-      ret->data = internal_malloc_size (sizeof (GFC_REAL_16) * size);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * size);
       ret->offset = 0;
     }
 
@@ -76,21 +76,20 @@ bessel_jn_r16 (gfc_array_r16 * const restrict ret, int n1, int n2, GFC_REAL_16 x
 
   if (unlikely (x == 0))
     {
-      ret->data[0] = 1;
+      ret->base_addr[0] = 1;
       for (i = 1; i <= n2-n1; i++)
-        ret->data[i*stride] = 0;
+        ret->base_addr[i*stride] = 0;
       return;
     }
 
-  ret->data = ret->data;
   last1 = MATHFUNC(jn) (n2, x);
-  ret->data[(n2-n1)*stride] = last1;
+  ret->base_addr[(n2-n1)*stride] = last1;
 
   if (n1 == n2)
     return;
 
   last2 = MATHFUNC(jn) (n2 - 1, x);
-  ret->data[(n2-n1-1)*stride] = last2;
+  ret->base_addr[(n2-n1-1)*stride] = last2;
 
   if (n1 + 1 == n2)
     return;
@@ -99,9 +98,9 @@ bessel_jn_r16 (gfc_array_r16 * const restrict ret, int n1, int n2, GFC_REAL_16 x
 
   for (i = n2-n1-2; i >= 0; i--)
     {
-      ret->data[i*stride] = x2rev * (i+1+n1) * last2 - last1;
+      ret->base_addr[i*stride] = x2rev * (i+1+n1) * last2 - last1;
       last1 = last2;
-      last2 = ret->data[i*stride];
+      last2 = ret->base_addr[i*stride];
     }
 }
 
@@ -123,11 +122,11 @@ bessel_yn_r16 (gfc_array_r16 * const restrict ret, int n1, int n2,
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
-      ret->data = internal_malloc_size (sizeof (GFC_REAL_16) * size);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * size);
       ret->offset = 0;
     }
 
@@ -146,22 +145,22 @@ bessel_yn_r16 (gfc_array_r16 * const restrict ret, int n1, int n2,
     {
       for (i = 0; i <= n2-n1; i++)
 #if defined(GFC_REAL_16_INFINITY)
-        ret->data[i*stride] = -GFC_REAL_16_INFINITY;
+        ret->base_addr[i*stride] = -GFC_REAL_16_INFINITY;
 #else
-        ret->data[i*stride] = -GFC_REAL_16_HUGE;
+        ret->base_addr[i*stride] = -GFC_REAL_16_HUGE;
 #endif
       return;
     }
 
-  ret->data = ret->data;
+  ret->base_addr = ret->base_addr;
   last1 = MATHFUNC(yn) (n1, x);
-  ret->data[0] = last1;
+  ret->base_addr[0] = last1;
 
   if (n1 == n2)
     return;
 
   last2 = MATHFUNC(yn) (n1 + 1, x);
-  ret->data[1*stride] = last2;
+  ret->base_addr[1*stride] = last2;
 
   if (n1 + 1 == n2)
     return;
@@ -173,14 +172,14 @@ bessel_yn_r16 (gfc_array_r16 * const restrict ret, int n1, int n2,
 #if defined(GFC_REAL_16_INFINITY)
       if (unlikely (last2 == -GFC_REAL_16_INFINITY))
 	{
-	  ret->data[i*stride] = -GFC_REAL_16_INFINITY;
+	  ret->base_addr[i*stride] = -GFC_REAL_16_INFINITY;
 	}
       else
 #endif
 	{
-	  ret->data[i*stride] = x2rev * (i-1+n1) * last2 - last1;
+	  ret->base_addr[i*stride] = x2rev * (i-1+n1) * last2 - last1;
 	  last1 = last2;
-	  last2 = ret->data[i*stride];
+	  last2 = ret->base_addr[i*stride];
 	}
     }
 }
diff --git a/libgfortran/generated/bessel_r4.c b/libgfortran/generated/bessel_r4.c
index 3d6e3ca..d3b0590 100644
--- a/libgfortran/generated/bessel_r4.c
+++ b/libgfortran/generated/bessel_r4.c
@@ -1,6 +1,6 @@
 /* Implementation of the BESSEL_JN and BESSEL_YN transformational
    function using a recurrence algorithm.
-   Copyright 2010 Free Software Foundation, Inc.
+   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).
@@ -51,11 +51,11 @@ bessel_jn_r4 (gfc_array_r4 * const restrict ret, int n1, int n2, GFC_REAL_4 x)
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
-      ret->data = internal_malloc_size (sizeof (GFC_REAL_4) * size);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * size);
       ret->offset = 0;
     }
 
@@ -72,21 +72,20 @@ bessel_jn_r4 (gfc_array_r4 * const restrict ret, int n1, int n2, GFC_REAL_4 x)
 
   if (unlikely (x == 0))
     {
-      ret->data[0] = 1;
+      ret->base_addr[0] = 1;
       for (i = 1; i <= n2-n1; i++)
-        ret->data[i*stride] = 0;
+        ret->base_addr[i*stride] = 0;
       return;
     }
 
-  ret->data = ret->data;
   last1 = MATHFUNC(jn) (n2, x);
-  ret->data[(n2-n1)*stride] = last1;
+  ret->base_addr[(n2-n1)*stride] = last1;
 
   if (n1 == n2)
     return;
 
   last2 = MATHFUNC(jn) (n2 - 1, x);
-  ret->data[(n2-n1-1)*stride] = last2;
+  ret->base_addr[(n2-n1-1)*stride] = last2;
 
   if (n1 + 1 == n2)
     return;
@@ -95,9 +94,9 @@ bessel_jn_r4 (gfc_array_r4 * const restrict ret, int n1, int n2, GFC_REAL_4 x)
 
   for (i = n2-n1-2; i >= 0; i--)
     {
-      ret->data[i*stride] = x2rev * (i+1+n1) * last2 - last1;
+      ret->base_addr[i*stride] = x2rev * (i+1+n1) * last2 - last1;
       last1 = last2;
-      last2 = ret->data[i*stride];
+      last2 = ret->base_addr[i*stride];
     }
 }
 
@@ -119,11 +118,11 @@ bessel_yn_r4 (gfc_array_r4 * const restrict ret, int n1, int n2,
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
-      ret->data = internal_malloc_size (sizeof (GFC_REAL_4) * size);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * size);
       ret->offset = 0;
     }
 
@@ -142,22 +141,22 @@ bessel_yn_r4 (gfc_array_r4 * const restrict ret, int n1, int n2,
     {
       for (i = 0; i <= n2-n1; i++)
 #if defined(GFC_REAL_4_INFINITY)
-        ret->data[i*stride] = -GFC_REAL_4_INFINITY;
+        ret->base_addr[i*stride] = -GFC_REAL_4_INFINITY;
 #else
-        ret->data[i*stride] = -GFC_REAL_4_HUGE;
+        ret->base_addr[i*stride] = -GFC_REAL_4_HUGE;
 #endif
       return;
     }
 
-  ret->data = ret->data;
+  ret->base_addr = ret->base_addr;
   last1 = MATHFUNC(yn) (n1, x);
-  ret->data[0] = last1;
+  ret->base_addr[0] = last1;
 
   if (n1 == n2)
     return;
 
   last2 = MATHFUNC(yn) (n1 + 1, x);
-  ret->data[1*stride] = last2;
+  ret->base_addr[1*stride] = last2;
 
   if (n1 + 1 == n2)
     return;
@@ -169,14 +168,14 @@ bessel_yn_r4 (gfc_array_r4 * const restrict ret, int n1, int n2,
 #if defined(GFC_REAL_4_INFINITY)
       if (unlikely (last2 == -GFC_REAL_4_INFINITY))
 	{
-	  ret->data[i*stride] = -GFC_REAL_4_INFINITY;
+	  ret->base_addr[i*stride] = -GFC_REAL_4_INFINITY;
 	}
       else
 #endif
 	{
-	  ret->data[i*stride] = x2rev * (i-1+n1) * last2 - last1;
+	  ret->base_addr[i*stride] = x2rev * (i-1+n1) * last2 - last1;
 	  last1 = last2;
-	  last2 = ret->data[i*stride];
+	  last2 = ret->base_addr[i*stride];
 	}
     }
 }
diff --git a/libgfortran/generated/bessel_r8.c b/libgfortran/generated/bessel_r8.c
index 7e3bcab..b48c04b 100644
--- a/libgfortran/generated/bessel_r8.c
+++ b/libgfortran/generated/bessel_r8.c
@@ -1,6 +1,6 @@
 /* Implementation of the BESSEL_JN and BESSEL_YN transformational
    function using a recurrence algorithm.
-   Copyright 2010 Free Software Foundation, Inc.
+   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).
@@ -51,11 +51,11 @@ bessel_jn_r8 (gfc_array_r8 * const restrict ret, int n1, int n2, GFC_REAL_8 x)
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
-      ret->data = internal_malloc_size (sizeof (GFC_REAL_8) * size);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * size);
       ret->offset = 0;
     }
 
@@ -72,21 +72,20 @@ bessel_jn_r8 (gfc_array_r8 * const restrict ret, int n1, int n2, GFC_REAL_8 x)
 
   if (unlikely (x == 0))
     {
-      ret->data[0] = 1;
+      ret->base_addr[0] = 1;
       for (i = 1; i <= n2-n1; i++)
-        ret->data[i*stride] = 0;
+        ret->base_addr[i*stride] = 0;
       return;
     }
 
-  ret->data = ret->data;
   last1 = MATHFUNC(jn) (n2, x);
-  ret->data[(n2-n1)*stride] = last1;
+  ret->base_addr[(n2-n1)*stride] = last1;
 
   if (n1 == n2)
     return;
 
   last2 = MATHFUNC(jn) (n2 - 1, x);
-  ret->data[(n2-n1-1)*stride] = last2;
+  ret->base_addr[(n2-n1-1)*stride] = last2;
 
   if (n1 + 1 == n2)
     return;
@@ -95,9 +94,9 @@ bessel_jn_r8 (gfc_array_r8 * const restrict ret, int n1, int n2, GFC_REAL_8 x)
 
   for (i = n2-n1-2; i >= 0; i--)
     {
-      ret->data[i*stride] = x2rev * (i+1+n1) * last2 - last1;
+      ret->base_addr[i*stride] = x2rev * (i+1+n1) * last2 - last1;
       last1 = last2;
-      last2 = ret->data[i*stride];
+      last2 = ret->base_addr[i*stride];
     }
 }
 
@@ -119,11 +118,11 @@ bessel_yn_r8 (gfc_array_r8 * const restrict ret, int n1, int n2,
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
-      ret->data = internal_malloc_size (sizeof (GFC_REAL_8) * size);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * size);
       ret->offset = 0;
     }
 
@@ -142,22 +141,22 @@ bessel_yn_r8 (gfc_array_r8 * const restrict ret, int n1, int n2,
     {
       for (i = 0; i <= n2-n1; i++)
 #if defined(GFC_REAL_8_INFINITY)
-        ret->data[i*stride] = -GFC_REAL_8_INFINITY;
+        ret->base_addr[i*stride] = -GFC_REAL_8_INFINITY;
 #else
-        ret->data[i*stride] = -GFC_REAL_8_HUGE;
+        ret->base_addr[i*stride] = -GFC_REAL_8_HUGE;
 #endif
       return;
     }
 
-  ret->data = ret->data;
+  ret->base_addr = ret->base_addr;
   last1 = MATHFUNC(yn) (n1, x);
-  ret->data[0] = last1;
+  ret->base_addr[0] = last1;
 
   if (n1 == n2)
     return;
 
   last2 = MATHFUNC(yn) (n1 + 1, x);
-  ret->data[1*stride] = last2;
+  ret->base_addr[1*stride] = last2;
 
   if (n1 + 1 == n2)
     return;
@@ -169,14 +168,14 @@ bessel_yn_r8 (gfc_array_r8 * const restrict ret, int n1, int n2,
 #if defined(GFC_REAL_8_INFINITY)
       if (unlikely (last2 == -GFC_REAL_8_INFINITY))
 	{
-	  ret->data[i*stride] = -GFC_REAL_8_INFINITY;
+	  ret->base_addr[i*stride] = -GFC_REAL_8_INFINITY;
 	}
       else
 #endif
 	{
-	  ret->data[i*stride] = x2rev * (i-1+n1) * last2 - last1;
+	  ret->base_addr[i*stride] = x2rev * (i-1+n1) * last2 - last1;
 	  last1 = last2;
-	  last2 = ret->data[i*stride];
+	  last2 = ret->base_addr[i*stride];
 	}
     }
 }
diff --git a/libgfortran/generated/count_16_l.c b/libgfortran/generated/count_16_l.c
index e894e56..6522440 100644
--- a/libgfortran/generated/count_16_l.c
+++ b/libgfortran/generated/count_16_l.c
@@ -83,7 +83,7 @@ count_16_l (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ count_16_l (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ count_16_l (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ count_16_l (gfc_array_i16 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in COUNT intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/count_1_l.c b/libgfortran/generated/count_1_l.c
index 894ad0c..5b7776e 100644
--- a/libgfortran/generated/count_1_l.c
+++ b/libgfortran/generated/count_1_l.c
@@ -83,7 +83,7 @@ count_1_l (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ count_1_l (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ count_1_l (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ count_1_l (gfc_array_i1 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in COUNT intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/count_2_l.c b/libgfortran/generated/count_2_l.c
index d0e5ee4..8a104d1 100644
--- a/libgfortran/generated/count_2_l.c
+++ b/libgfortran/generated/count_2_l.c
@@ -83,7 +83,7 @@ count_2_l (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ count_2_l (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ count_2_l (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ count_2_l (gfc_array_i2 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in COUNT intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/count_4_l.c b/libgfortran/generated/count_4_l.c
index 43af56b..0edca41 100644
--- a/libgfortran/generated/count_4_l.c
+++ b/libgfortran/generated/count_4_l.c
@@ -83,7 +83,7 @@ count_4_l (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ count_4_l (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ count_4_l (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ count_4_l (gfc_array_i4 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in COUNT intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/count_8_l.c b/libgfortran/generated/count_8_l.c
index 6ddd701..e3d95dc 100644
--- a/libgfortran/generated/count_8_l.c
+++ b/libgfortran/generated/count_8_l.c
@@ -83,7 +83,7 @@ count_8_l (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -111,7 +111,7 @@ count_8_l (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -145,7 +145,7 @@ count_8_l (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -159,7 +159,7 @@ count_8_l (gfc_array_i8 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in COUNT intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/cshift0_c10.c b/libgfortran/generated/cshift0_c10.c
index ec4bb8a..43e173b 100644
--- a/libgfortran/generated/cshift0_c10.c
+++ b/libgfortran/generated/cshift0_c10.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_c10 (gfc_array_c10 *ret, const gfc_array_c10 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_c16.c b/libgfortran/generated/cshift0_c16.c
index ac7e8b7..f1f2539 100644
--- a/libgfortran/generated/cshift0_c16.c
+++ b/libgfortran/generated/cshift0_c16.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_c16 (gfc_array_c16 *ret, const gfc_array_c16 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_c4.c b/libgfortran/generated/cshift0_c4.c
index 482af77..bf8554e 100644
--- a/libgfortran/generated/cshift0_c4.c
+++ b/libgfortran/generated/cshift0_c4.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_c4 (gfc_array_c4 *ret, const gfc_array_c4 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_c8.c b/libgfortran/generated/cshift0_c8.c
index 2b3a69e..e3fd5b6 100644
--- a/libgfortran/generated/cshift0_c8.c
+++ b/libgfortran/generated/cshift0_c8.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_c8 (gfc_array_c8 *ret, const gfc_array_c8 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_i1.c b/libgfortran/generated/cshift0_i1.c
index 65173e3..f2315de 100644
--- a/libgfortran/generated/cshift0_i1.c
+++ b/libgfortran/generated/cshift0_i1.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_i1 (gfc_array_i1 *ret, const gfc_array_i1 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_i16.c b/libgfortran/generated/cshift0_i16.c
index 4374c45..7566042 100644
--- a/libgfortran/generated/cshift0_i16.c
+++ b/libgfortran/generated/cshift0_i16.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_i16 (gfc_array_i16 *ret, const gfc_array_i16 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_i2.c b/libgfortran/generated/cshift0_i2.c
index 1a39632..4a8154c 100644
--- a/libgfortran/generated/cshift0_i2.c
+++ b/libgfortran/generated/cshift0_i2.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_i2 (gfc_array_i2 *ret, const gfc_array_i2 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_i4.c b/libgfortran/generated/cshift0_i4.c
index 9d22363..7d25b7b 100644
--- a/libgfortran/generated/cshift0_i4.c
+++ b/libgfortran/generated/cshift0_i4.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_i4 (gfc_array_i4 *ret, const gfc_array_i4 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_i8.c b/libgfortran/generated/cshift0_i8.c
index 43358aa..2f565ca 100644
--- a/libgfortran/generated/cshift0_i8.c
+++ b/libgfortran/generated/cshift0_i8.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_i8 (gfc_array_i8 *ret, const gfc_array_i8 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_r10.c b/libgfortran/generated/cshift0_r10.c
index bf469fd..b7f21ca 100644
--- a/libgfortran/generated/cshift0_r10.c
+++ b/libgfortran/generated/cshift0_r10.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_r10 (gfc_array_r10 *ret, const gfc_array_r10 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_r16.c b/libgfortran/generated/cshift0_r16.c
index b9e19ff..320b705 100644
--- a/libgfortran/generated/cshift0_r16.c
+++ b/libgfortran/generated/cshift0_r16.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_r16 (gfc_array_r16 *ret, const gfc_array_r16 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_r4.c b/libgfortran/generated/cshift0_r4.c
index 9bd0214..93ccf52 100644
--- a/libgfortran/generated/cshift0_r4.c
+++ b/libgfortran/generated/cshift0_r4.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_r4 (gfc_array_r4 *ret, const gfc_array_r4 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift0_r8.c b/libgfortran/generated/cshift0_r8.c
index 1f99135..a3f7479 100644
--- a/libgfortran/generated/cshift0_r8.c
+++ b/libgfortran/generated/cshift0_r8.c
@@ -1,8 +1,8 @@
 /* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -94,8 +94,8 @@ cshift0_r8 (gfc_array_r8 *ret, const gfc_array_r8 *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/generated/cshift1_16.c b/libgfortran/generated/cshift1_16.c
index b2cb7f1..41cc1ea 100644
--- a/libgfortran/generated/cshift1_16.c
+++ b/libgfortran/generated/cshift1_16.c
@@ -1,8 +1,8 @@
 /* Implementation of the CSHIFT intrinsic
-   Copyright 2003, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Feng Wang <wf_cs@yahoo.com>
 
-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
@@ -76,11 +76,11 @@ cshift1 (gfc_array_char * const restrict ret,
 
   arraysize = size0 ((array_t *)array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -156,9 +156,9 @@ cshift1 (gfc_array_char * const restrict ret,
   rstride0 = rstride[0];
   sstride0 = sstride[0];
   hstride0 = hstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift1_4.c b/libgfortran/generated/cshift1_4.c
index 30f3d99..9652222 100644
--- a/libgfortran/generated/cshift1_4.c
+++ b/libgfortran/generated/cshift1_4.c
@@ -1,8 +1,8 @@
 /* Implementation of the CSHIFT intrinsic
-   Copyright 2003, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Feng Wang <wf_cs@yahoo.com>
 
-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
@@ -76,11 +76,11 @@ cshift1 (gfc_array_char * const restrict ret,
 
   arraysize = size0 ((array_t *)array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -156,9 +156,9 @@ cshift1 (gfc_array_char * const restrict ret,
   rstride0 = rstride[0];
   sstride0 = sstride[0];
   hstride0 = hstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/cshift1_8.c b/libgfortran/generated/cshift1_8.c
index c3bf473..8ccd63b 100644
--- a/libgfortran/generated/cshift1_8.c
+++ b/libgfortran/generated/cshift1_8.c
@@ -1,8 +1,8 @@
 /* Implementation of the CSHIFT intrinsic
-   Copyright 2003, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Feng Wang <wf_cs@yahoo.com>
 
-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
@@ -76,11 +76,11 @@ cshift1 (gfc_array_char * const restrict ret,
 
   arraysize = size0 ((array_t *)array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -156,9 +156,9 @@ cshift1 (gfc_array_char * const restrict ret,
   rstride0 = rstride[0];
   sstride0 = sstride[0];
   hstride0 = hstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/eoshift1_16.c b/libgfortran/generated/eoshift1_16.c
index eb3a27a..2de9208c 100644
--- a/libgfortran/generated/eoshift1_16.c
+++ b/libgfortran/generated/eoshift1_16.c
@@ -1,8 +1,8 @@
 /* Implementation of the EOSHIFT intrinsic
-   Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -84,7 +84,7 @@ eoshift1 (gfc_array_char * const restrict ret,
   count[0] = 0;
 
   arraysize = size0 ((array_t *) array);
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
@@ -106,7 +106,7 @@ eoshift1 (gfc_array_char * const restrict ret,
 
         }
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
@@ -159,9 +159,9 @@ eoshift1 (gfc_array_char * const restrict ret,
   rstride0 = rstride[0];
   sstride0 = sstride[0];
   hstride0 = hstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/eoshift1_4.c b/libgfortran/generated/eoshift1_4.c
index d3776b9..8a9f1aa 100644
--- a/libgfortran/generated/eoshift1_4.c
+++ b/libgfortran/generated/eoshift1_4.c
@@ -1,8 +1,8 @@
 /* Implementation of the EOSHIFT intrinsic
-   Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -84,7 +84,7 @@ eoshift1 (gfc_array_char * const restrict ret,
   count[0] = 0;
 
   arraysize = size0 ((array_t *) array);
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
@@ -106,7 +106,7 @@ eoshift1 (gfc_array_char * const restrict ret,
 
         }
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
@@ -159,9 +159,9 @@ eoshift1 (gfc_array_char * const restrict ret,
   rstride0 = rstride[0];
   sstride0 = sstride[0];
   hstride0 = hstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/eoshift1_8.c b/libgfortran/generated/eoshift1_8.c
index 5f026ac..136f546 100644
--- a/libgfortran/generated/eoshift1_8.c
+++ b/libgfortran/generated/eoshift1_8.c
@@ -1,8 +1,8 @@
 /* Implementation of the EOSHIFT intrinsic
-   Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -84,7 +84,7 @@ eoshift1 (gfc_array_char * const restrict ret,
   count[0] = 0;
 
   arraysize = size0 ((array_t *) array);
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
@@ -106,7 +106,7 @@ eoshift1 (gfc_array_char * const restrict ret,
 
         }
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
@@ -159,9 +159,9 @@ eoshift1 (gfc_array_char * const restrict ret,
   rstride0 = rstride[0];
   sstride0 = sstride[0];
   hstride0 = hstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/eoshift3_16.c b/libgfortran/generated/eoshift3_16.c
index 1cf2167..d363d90 100644
--- a/libgfortran/generated/eoshift3_16.c
+++ b/libgfortran/generated/eoshift3_16.c
@@ -1,8 +1,8 @@
 /* Implementation of the EOSHIFT intrinsic
-   Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -85,11 +85,11 @@ eoshift3 (gfc_array_char * const restrict ret,
   else
     which = 0;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -108,7 +108,7 @@ eoshift3 (gfc_array_char * const restrict ret,
 
         }
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
@@ -170,11 +170,11 @@ eoshift3 (gfc_array_char * const restrict ret,
   sstride0 = sstride[0];
   hstride0 = hstride[0];
   bstride0 = bstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
   if (bound)
-    bptr = bound->data;
+    bptr = bound->base_addr;
   else
     bptr = NULL;
 
diff --git a/libgfortran/generated/eoshift3_4.c b/libgfortran/generated/eoshift3_4.c
index c6033d0..1b623c2 100644
--- a/libgfortran/generated/eoshift3_4.c
+++ b/libgfortran/generated/eoshift3_4.c
@@ -1,8 +1,8 @@
 /* Implementation of the EOSHIFT intrinsic
-   Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -85,11 +85,11 @@ eoshift3 (gfc_array_char * const restrict ret,
   else
     which = 0;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -108,7 +108,7 @@ eoshift3 (gfc_array_char * const restrict ret,
 
         }
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
@@ -170,11 +170,11 @@ eoshift3 (gfc_array_char * const restrict ret,
   sstride0 = sstride[0];
   hstride0 = hstride[0];
   bstride0 = bstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
   if (bound)
-    bptr = bound->data;
+    bptr = bound->base_addr;
   else
     bptr = NULL;
 
diff --git a/libgfortran/generated/eoshift3_8.c b/libgfortran/generated/eoshift3_8.c
index 7a7b196..2af1ccb 100644
--- a/libgfortran/generated/eoshift3_8.c
+++ b/libgfortran/generated/eoshift3_8.c
@@ -1,8 +1,8 @@
 /* Implementation of the EOSHIFT intrinsic
-   Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -85,11 +85,11 @@ eoshift3 (gfc_array_char * const restrict ret,
   else
     which = 0;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -108,7 +108,7 @@ eoshift3 (gfc_array_char * const restrict ret,
 
         }
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
@@ -170,11 +170,11 @@ eoshift3 (gfc_array_char * const restrict ret,
   sstride0 = sstride[0];
   hstride0 = hstride[0];
   bstride0 = bstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
   if (bound)
-    bptr = bound->data;
+    bptr = bound->base_addr;
   else
     bptr = NULL;
 
diff --git a/libgfortran/generated/iall_i1.c b/libgfortran/generated/iall_i1.c
index 23a8f4f..d60f7f3 100644
--- a/libgfortran/generated/iall_i1.c
+++ b/libgfortran/generated/iall_i1.c
@@ -79,7 +79,7 @@ iall_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iall_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iall_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miall_i1 (gfc_array_i1 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miall_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miall_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miall_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siall_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siall_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siall_i1 (gfc_array_i1 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iall_i16.c b/libgfortran/generated/iall_i16.c
index d16c182..88be6a8 100644
--- a/libgfortran/generated/iall_i16.c
+++ b/libgfortran/generated/iall_i16.c
@@ -79,7 +79,7 @@ iall_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iall_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iall_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miall_i16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miall_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miall_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miall_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siall_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siall_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siall_i16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iall_i2.c b/libgfortran/generated/iall_i2.c
index ef45da5..14fa83b 100644
--- a/libgfortran/generated/iall_i2.c
+++ b/libgfortran/generated/iall_i2.c
@@ -79,7 +79,7 @@ iall_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iall_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iall_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miall_i2 (gfc_array_i2 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miall_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miall_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miall_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siall_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siall_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siall_i2 (gfc_array_i2 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iall_i4.c b/libgfortran/generated/iall_i4.c
index f2c10bf..ce5e185 100644
--- a/libgfortran/generated/iall_i4.c
+++ b/libgfortran/generated/iall_i4.c
@@ -79,7 +79,7 @@ iall_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iall_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iall_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miall_i4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miall_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miall_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miall_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siall_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siall_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siall_i4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iall_i8.c b/libgfortran/generated/iall_i8.c
index 2c5aa09..fee269a 100644
--- a/libgfortran/generated/iall_i8.c
+++ b/libgfortran/generated/iall_i8.c
@@ -79,7 +79,7 @@ iall_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iall_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iall_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miall_i8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miall_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miall_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miall_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siall_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siall_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siall_i8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iany_i1.c b/libgfortran/generated/iany_i1.c
index 1f9f91c..f1b0aeb 100644
--- a/libgfortran/generated/iany_i1.c
+++ b/libgfortran/generated/iany_i1.c
@@ -79,7 +79,7 @@ iany_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iany_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iany_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miany_i1 (gfc_array_i1 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miany_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miany_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miany_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siany_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siany_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siany_i1 (gfc_array_i1 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iany_i16.c b/libgfortran/generated/iany_i16.c
index 55f3840..511e369 100644
--- a/libgfortran/generated/iany_i16.c
+++ b/libgfortran/generated/iany_i16.c
@@ -79,7 +79,7 @@ iany_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iany_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iany_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miany_i16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miany_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miany_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miany_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siany_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siany_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siany_i16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iany_i2.c b/libgfortran/generated/iany_i2.c
index aabb992..b52f551 100644
--- a/libgfortran/generated/iany_i2.c
+++ b/libgfortran/generated/iany_i2.c
@@ -79,7 +79,7 @@ iany_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iany_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iany_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miany_i2 (gfc_array_i2 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miany_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miany_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miany_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siany_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siany_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siany_i2 (gfc_array_i2 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iany_i4.c b/libgfortran/generated/iany_i4.c
index de7b66e..a0949e1 100644
--- a/libgfortran/generated/iany_i4.c
+++ b/libgfortran/generated/iany_i4.c
@@ -79,7 +79,7 @@ iany_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iany_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iany_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miany_i4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miany_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miany_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miany_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siany_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siany_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siany_i4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iany_i8.c b/libgfortran/generated/iany_i8.c
index 71569e0..e365f5f 100644
--- a/libgfortran/generated/iany_i8.c
+++ b/libgfortran/generated/iany_i8.c
@@ -79,7 +79,7 @@ iany_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iany_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iany_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miany_i8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miany_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miany_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miany_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siany_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siany_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siany_i8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/in_pack_c10.c b/libgfortran/generated/in_pack_c10.c
index 97ce9d1..1d6b0db 100644
--- a/libgfortran/generated/in_pack_c10.c
+++ b/libgfortran/generated/in_pack_c10.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_c10 (gfc_array_c10 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_COMPLEX_10 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_10));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_c16.c b/libgfortran/generated/in_pack_c16.c
index 74e3cb6..a627094 100644
--- a/libgfortran/generated/in_pack_c16.c
+++ b/libgfortran/generated/in_pack_c16.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_c16 (gfc_array_c16 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_COMPLEX_16 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_16));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_c4.c b/libgfortran/generated/in_pack_c4.c
index ae52bc6..833d7e8 100644
--- a/libgfortran/generated/in_pack_c4.c
+++ b/libgfortran/generated/in_pack_c4.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_c4 (gfc_array_c4 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_COMPLEX_4 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_4));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_c8.c b/libgfortran/generated/in_pack_c8.c
index 142ad99..d86ce9f 100644
--- a/libgfortran/generated/in_pack_c8.c
+++ b/libgfortran/generated/in_pack_c8.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_c8 (gfc_array_c8 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_COMPLEX_8 *)internal_malloc_size (ssize * sizeof (GFC_COMPLEX_8));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_i1.c b/libgfortran/generated/in_pack_i1.c
index dc26c1a..2b582a5 100644
--- a/libgfortran/generated/in_pack_i1.c
+++ b/libgfortran/generated/in_pack_i1.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_1 (gfc_array_i1 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_INTEGER_1 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_1));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_i16.c b/libgfortran/generated/in_pack_i16.c
index 32ce3a4..294e3ca 100644
--- a/libgfortran/generated/in_pack_i16.c
+++ b/libgfortran/generated/in_pack_i16.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_16 (gfc_array_i16 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_INTEGER_16 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_16));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_i2.c b/libgfortran/generated/in_pack_i2.c
index 3c39f8e..6a95af3 100644
--- a/libgfortran/generated/in_pack_i2.c
+++ b/libgfortran/generated/in_pack_i2.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_2 (gfc_array_i2 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_INTEGER_2 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_2));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_i4.c b/libgfortran/generated/in_pack_i4.c
index 4cd7dba..4a5a863 100644
--- a/libgfortran/generated/in_pack_i4.c
+++ b/libgfortran/generated/in_pack_i4.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_4 (gfc_array_i4 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_INTEGER_4 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_4));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_i8.c b/libgfortran/generated/in_pack_i8.c
index 17acc68..cb7e785 100644
--- a/libgfortran/generated/in_pack_i8.c
+++ b/libgfortran/generated/in_pack_i8.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_8 (gfc_array_i8 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_INTEGER_8 *)internal_malloc_size (ssize * sizeof (GFC_INTEGER_8));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_r10.c b/libgfortran/generated/in_pack_r10.c
index 557ccc2..b479001 100644
--- a/libgfortran/generated/in_pack_r10.c
+++ b/libgfortran/generated/in_pack_r10.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_r10 (gfc_array_r10 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_REAL_10 *)internal_malloc_size (ssize * sizeof (GFC_REAL_10));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_r16.c b/libgfortran/generated/in_pack_r16.c
index b737cc7..f16fd2f 100644
--- a/libgfortran/generated/in_pack_r16.c
+++ b/libgfortran/generated/in_pack_r16.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_r16 (gfc_array_r16 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_REAL_16 *)internal_malloc_size (ssize * sizeof (GFC_REAL_16));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_r4.c b/libgfortran/generated/in_pack_r4.c
index 68a7e5a..e5b09a7 100644
--- a/libgfortran/generated/in_pack_r4.c
+++ b/libgfortran/generated/in_pack_r4.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_r4 (gfc_array_r4 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_REAL_4 *)internal_malloc_size (ssize * sizeof (GFC_REAL_4));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_pack_r8.c b/libgfortran/generated/in_pack_r8.c
index 1453f86..12670d2 100644
--- a/libgfortran/generated/in_pack_r8.c
+++ b/libgfortran/generated/in_pack_r8.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -73,12 +73,12 @@ internal_pack_r8 (gfc_array_r8 * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = (GFC_REAL_8 *)internal_malloc_size (ssize * sizeof (GFC_REAL_8));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/generated/in_unpack_c10.c b/libgfortran/generated/in_unpack_c10.c
index bcac6e7..1afa876 100644
--- a/libgfortran/generated/in_unpack_c10.c
+++ b/libgfortran/generated/in_unpack_c10.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_c10 (gfc_array_c10 * d, const GFC_COMPLEX_10 * src)
   GFC_COMPLEX_10 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_c16.c b/libgfortran/generated/in_unpack_c16.c
index 1d09a80..11c6127 100644
--- a/libgfortran/generated/in_unpack_c16.c
+++ b/libgfortran/generated/in_unpack_c16.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_c16 (gfc_array_c16 * d, const GFC_COMPLEX_16 * src)
   GFC_COMPLEX_16 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_c4.c b/libgfortran/generated/in_unpack_c4.c
index 9ad8a33..558f3b1 100644
--- a/libgfortran/generated/in_unpack_c4.c
+++ b/libgfortran/generated/in_unpack_c4.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_c4 (gfc_array_c4 * d, const GFC_COMPLEX_4 * src)
   GFC_COMPLEX_4 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_c8.c b/libgfortran/generated/in_unpack_c8.c
index 6adae64..72b00d8 100644
--- a/libgfortran/generated/in_unpack_c8.c
+++ b/libgfortran/generated/in_unpack_c8.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_c8 (gfc_array_c8 * d, const GFC_COMPLEX_8 * src)
   GFC_COMPLEX_8 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_i1.c b/libgfortran/generated/in_unpack_i1.c
index e632816..d045c92 100644
--- a/libgfortran/generated/in_unpack_i1.c
+++ b/libgfortran/generated/in_unpack_i1.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_1 (gfc_array_i1 * d, const GFC_INTEGER_1 * src)
   GFC_INTEGER_1 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_i16.c b/libgfortran/generated/in_unpack_i16.c
index c719920..612e7d8 100644
--- a/libgfortran/generated/in_unpack_i16.c
+++ b/libgfortran/generated/in_unpack_i16.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_16 (gfc_array_i16 * d, const GFC_INTEGER_16 * src)
   GFC_INTEGER_16 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_i2.c b/libgfortran/generated/in_unpack_i2.c
index ec0c1c3..e9a0807 100644
--- a/libgfortran/generated/in_unpack_i2.c
+++ b/libgfortran/generated/in_unpack_i2.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_2 (gfc_array_i2 * d, const GFC_INTEGER_2 * src)
   GFC_INTEGER_2 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_i4.c b/libgfortran/generated/in_unpack_i4.c
index ce5d29d..6fc836b 100644
--- a/libgfortran/generated/in_unpack_i4.c
+++ b/libgfortran/generated/in_unpack_i4.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_4 (gfc_array_i4 * d, const GFC_INTEGER_4 * src)
   GFC_INTEGER_4 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_i8.c b/libgfortran/generated/in_unpack_i8.c
index 347f011..d7bd811 100644
--- a/libgfortran/generated/in_unpack_i8.c
+++ b/libgfortran/generated/in_unpack_i8.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_8 (gfc_array_i8 * d, const GFC_INTEGER_8 * src)
   GFC_INTEGER_8 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_r10.c b/libgfortran/generated/in_unpack_r10.c
index aa5f08e..afc8e2d 100644
--- a/libgfortran/generated/in_unpack_r10.c
+++ b/libgfortran/generated/in_unpack_r10.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_r10 (gfc_array_r10 * d, const GFC_REAL_10 * src)
   GFC_REAL_10 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_r16.c b/libgfortran/generated/in_unpack_r16.c
index 0b08228..57fcb17 100644
--- a/libgfortran/generated/in_unpack_r16.c
+++ b/libgfortran/generated/in_unpack_r16.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_r16 (gfc_array_r16 * d, const GFC_REAL_16 * src)
   GFC_REAL_16 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_r4.c b/libgfortran/generated/in_unpack_r4.c
index f436c8a..9e1d69f 100644
--- a/libgfortran/generated/in_unpack_r4.c
+++ b/libgfortran/generated/in_unpack_r4.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_r4 (gfc_array_r4 * d, const GFC_REAL_4 * src)
   GFC_REAL_4 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/in_unpack_r8.c b/libgfortran/generated/in_unpack_r8.c
index 76aff2e..4a5ccb2 100644
--- a/libgfortran/generated/in_unpack_r8.c
+++ b/libgfortran/generated/in_unpack_r8.c
@@ -1,8 +1,8 @@
 /* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -43,7 +43,7 @@ internal_unpack_r8 (gfc_array_r8 * d, const GFC_REAL_8 * src)
   GFC_REAL_8 * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/generated/iparity_i1.c b/libgfortran/generated/iparity_i1.c
index e2b40c2..5fcb29d 100644
--- a/libgfortran/generated/iparity_i1.c
+++ b/libgfortran/generated/iparity_i1.c
@@ -79,7 +79,7 @@ iparity_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iparity_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iparity_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miparity_i1 (gfc_array_i1 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miparity_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miparity_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miparity_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siparity_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siparity_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siparity_i1 (gfc_array_i1 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iparity_i16.c b/libgfortran/generated/iparity_i16.c
index 5ebdabb..aef9458 100644
--- a/libgfortran/generated/iparity_i16.c
+++ b/libgfortran/generated/iparity_i16.c
@@ -79,7 +79,7 @@ iparity_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iparity_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iparity_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miparity_i16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miparity_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miparity_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miparity_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siparity_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siparity_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siparity_i16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iparity_i2.c b/libgfortran/generated/iparity_i2.c
index f908a7a..22f95e3 100644
--- a/libgfortran/generated/iparity_i2.c
+++ b/libgfortran/generated/iparity_i2.c
@@ -79,7 +79,7 @@ iparity_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iparity_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iparity_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miparity_i2 (gfc_array_i2 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miparity_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miparity_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miparity_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siparity_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siparity_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siparity_i2 (gfc_array_i2 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iparity_i4.c b/libgfortran/generated/iparity_i4.c
index 2e5811b..58b18b8 100644
--- a/libgfortran/generated/iparity_i4.c
+++ b/libgfortran/generated/iparity_i4.c
@@ -79,7 +79,7 @@ iparity_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iparity_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iparity_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miparity_i4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miparity_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miparity_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miparity_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siparity_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siparity_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siparity_i4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/iparity_i8.c b/libgfortran/generated/iparity_i8.c
index c443275..78de1c4 100644
--- a/libgfortran/generated/iparity_i8.c
+++ b/libgfortran/generated/iparity_i8.c
@@ -79,7 +79,7 @@ iparity_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -100,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -107,8 +108,6 @@ iparity_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -131,8 +130,8 @@ iparity_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -222,7 +221,7 @@ miparity_i8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -258,7 +257,7 @@ miparity_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -286,7 +285,7 @@ miparity_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -311,8 +310,8 @@ miparity_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -418,7 +417,7 @@ siparity_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -446,7 +445,7 @@ siparity_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -478,7 +477,7 @@ siparity_i8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/matmul_c10.c b/libgfortran/generated/matmul_c10.c
index c54c78e..3496a83 100644
--- a/libgfortran/generated/matmul_c10.c
+++ b/libgfortran/generated/matmul_c10.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_c10 (gfc_array_c10 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_c10 (gfc_array_c10 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_c10 (gfc_array_c10 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_c16.c b/libgfortran/generated/matmul_c16.c
index 880c0e1..0140dd3 100644
--- a/libgfortran/generated/matmul_c16.c
+++ b/libgfortran/generated/matmul_c16.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_c16 (gfc_array_c16 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_c16 (gfc_array_c16 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_c16 (gfc_array_c16 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_c4.c b/libgfortran/generated/matmul_c4.c
index 020033a..fd8ce9f 100644
--- a/libgfortran/generated/matmul_c4.c
+++ b/libgfortran/generated/matmul_c4.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_c4 (gfc_array_c4 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_c4 (gfc_array_c4 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_c4 (gfc_array_c4 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_c8.c b/libgfortran/generated/matmul_c8.c
index 1522dcd..e71b5fb 100644
--- a/libgfortran/generated/matmul_c8.c
+++ b/libgfortran/generated/matmul_c8.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_c8 (gfc_array_c8 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_c8 (gfc_array_c8 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_c8 (gfc_array_c8 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_i1.c b/libgfortran/generated/matmul_i1.c
index db56678..7525ea7 100644
--- a/libgfortran/generated/matmul_i1.c
+++ b/libgfortran/generated/matmul_i1.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_i1 (gfc_array_i1 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_i1 (gfc_array_i1 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_INTEGER_1) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_i1 (gfc_array_i1 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_i16.c b/libgfortran/generated/matmul_i16.c
index f607e27..19b6995 100644
--- a/libgfortran/generated/matmul_i16.c
+++ b/libgfortran/generated/matmul_i16.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_i16 (gfc_array_i16 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_i16 (gfc_array_i16 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_INTEGER_16) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_i16 (gfc_array_i16 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_i2.c b/libgfortran/generated/matmul_i2.c
index 58e340b..7393506 100644
--- a/libgfortran/generated/matmul_i2.c
+++ b/libgfortran/generated/matmul_i2.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_i2 (gfc_array_i2 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_i2 (gfc_array_i2 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_INTEGER_2) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_i2 (gfc_array_i2 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_i4.c b/libgfortran/generated/matmul_i4.c
index 46ed493..2e9e016 100644
--- a/libgfortran/generated/matmul_i4.c
+++ b/libgfortran/generated/matmul_i4.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_i4 (gfc_array_i4 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_i4 (gfc_array_i4 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_INTEGER_4) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_i4 (gfc_array_i4 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_i8.c b/libgfortran/generated/matmul_i8.c
index 54ffe62..6c6c655 100644
--- a/libgfortran/generated/matmul_i8.c
+++ b/libgfortran/generated/matmul_i8.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_i8 (gfc_array_i8 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_i8 (gfc_array_i8 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_INTEGER_8) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_i8 (gfc_array_i8 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_l16.c b/libgfortran/generated/matmul_l16.c
index 5fbeeb7..1ae8f7a 100644
--- a/libgfortran/generated/matmul_l16.c
+++ b/libgfortran/generated/matmul_l16.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -65,7 +65,7 @@ matmul_l16 (gfc_array_l16 * const restrict retarray,
   assert (GFC_DESCRIPTOR_RANK (a) == 2
           || GFC_DESCRIPTOR_RANK (b) == 2);
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -87,7 +87,7 @@ matmul_l16 (gfc_array_l16 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
           
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_LOGICAL_16) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -133,7 +133,7 @@ matmul_l16 (gfc_array_l16 * const restrict retarray,
 	  }
       }
 
-  abase = a->data;
+  abase = a->base_addr;
   a_kind = GFC_DESCRIPTOR_SIZE (a);
 
   if (a_kind == 1 || a_kind == 2 || a_kind == 4 || a_kind == 8
@@ -145,7 +145,7 @@ matmul_l16 (gfc_array_l16 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array");
 
-  bbase = b->data;
+  bbase = b->base_addr;
   b_kind = GFC_DESCRIPTOR_SIZE (b);
 
   if (b_kind == 1 || b_kind == 2 || b_kind == 4 || b_kind == 8
@@ -157,7 +157,7 @@ matmul_l16 (gfc_array_l16 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
 
   if (GFC_DESCRIPTOR_RANK (retarray) == 1)
diff --git a/libgfortran/generated/matmul_l4.c b/libgfortran/generated/matmul_l4.c
index 19ca9f1..dfe3369 100644
--- a/libgfortran/generated/matmul_l4.c
+++ b/libgfortran/generated/matmul_l4.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -65,7 +65,7 @@ matmul_l4 (gfc_array_l4 * const restrict retarray,
   assert (GFC_DESCRIPTOR_RANK (a) == 2
           || GFC_DESCRIPTOR_RANK (b) == 2);
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -87,7 +87,7 @@ matmul_l4 (gfc_array_l4 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
           
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_LOGICAL_4) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -133,7 +133,7 @@ matmul_l4 (gfc_array_l4 * const restrict retarray,
 	  }
       }
 
-  abase = a->data;
+  abase = a->base_addr;
   a_kind = GFC_DESCRIPTOR_SIZE (a);
 
   if (a_kind == 1 || a_kind == 2 || a_kind == 4 || a_kind == 8
@@ -145,7 +145,7 @@ matmul_l4 (gfc_array_l4 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array");
 
-  bbase = b->data;
+  bbase = b->base_addr;
   b_kind = GFC_DESCRIPTOR_SIZE (b);
 
   if (b_kind == 1 || b_kind == 2 || b_kind == 4 || b_kind == 8
@@ -157,7 +157,7 @@ matmul_l4 (gfc_array_l4 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
 
   if (GFC_DESCRIPTOR_RANK (retarray) == 1)
diff --git a/libgfortran/generated/matmul_l8.c b/libgfortran/generated/matmul_l8.c
index 558ed25..258a953 100644
--- a/libgfortran/generated/matmul_l8.c
+++ b/libgfortran/generated/matmul_l8.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -65,7 +65,7 @@ matmul_l8 (gfc_array_l8 * const restrict retarray,
   assert (GFC_DESCRIPTOR_RANK (a) == 2
           || GFC_DESCRIPTOR_RANK (b) == 2);
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -87,7 +87,7 @@ matmul_l8 (gfc_array_l8 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
           
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_LOGICAL_8) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -133,7 +133,7 @@ matmul_l8 (gfc_array_l8 * const restrict retarray,
 	  }
       }
 
-  abase = a->data;
+  abase = a->base_addr;
   a_kind = GFC_DESCRIPTOR_SIZE (a);
 
   if (a_kind == 1 || a_kind == 2 || a_kind == 4 || a_kind == 8
@@ -145,7 +145,7 @@ matmul_l8 (gfc_array_l8 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array");
 
-  bbase = b->data;
+  bbase = b->base_addr;
   b_kind = GFC_DESCRIPTOR_SIZE (b);
 
   if (b_kind == 1 || b_kind == 2 || b_kind == 4 || b_kind == 8
@@ -157,7 +157,7 @@ matmul_l8 (gfc_array_l8 * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
 
   if (GFC_DESCRIPTOR_RANK (retarray) == 1)
diff --git a/libgfortran/generated/matmul_r10.c b/libgfortran/generated/matmul_r10.c
index 8e32554..79a5771 100644
--- a/libgfortran/generated/matmul_r10.c
+++ b/libgfortran/generated/matmul_r10.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_r10 (gfc_array_r10 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_r10 (gfc_array_r10 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_REAL_10) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_r10 (gfc_array_r10 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_r16.c b/libgfortran/generated/matmul_r16.c
index c115531..87bc587 100644
--- a/libgfortran/generated/matmul_r16.c
+++ b/libgfortran/generated/matmul_r16.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_r16 (gfc_array_r16 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_r16 (gfc_array_r16 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_REAL_16) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_r16 (gfc_array_r16 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_r4.c b/libgfortran/generated/matmul_r4.c
index 5420872..4f72b6a 100644
--- a/libgfortran/generated/matmul_r4.c
+++ b/libgfortran/generated/matmul_r4.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_r4 (gfc_array_r4 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_r4 (gfc_array_r4 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_REAL_4) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_r4 (gfc_array_r4 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/matmul_r8.c b/libgfortran/generated/matmul_r8.c
index 72ad1fd..422a1f0 100644
--- a/libgfortran/generated/matmul_r8.c
+++ b/libgfortran/generated/matmul_r8.c
@@ -1,8 +1,8 @@
 /* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -101,7 +101,7 @@ matmul_r8 (gfc_array_r8 * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -123,7 +123,7 @@ matmul_r8 (gfc_array_r8 * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof (GFC_REAL_8) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -226,9 +226,9 @@ matmul_r8 (gfc_array_r8 * const restrict retarray,
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we're performing the multiplication
diff --git a/libgfortran/generated/maxloc0_16_i1.c b/libgfortran/generated/maxloc0_16_i1.c
index 5649018..fbac3ad 100644
--- a/libgfortran/generated/maxloc0_16_i1.c
+++ b/libgfortran/generated/maxloc0_16_i1.c
@@ -53,12 +53,12 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_16_i16.c b/libgfortran/generated/maxloc0_16_i16.c
index 1ff74f6..e15ebf2 100644
--- a/libgfortran/generated/maxloc0_16_i16.c
+++ b/libgfortran/generated/maxloc0_16_i16.c
@@ -53,12 +53,12 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_16_i2.c b/libgfortran/generated/maxloc0_16_i2.c
index 8ca75b9..90b2b3a 100644
--- a/libgfortran/generated/maxloc0_16_i2.c
+++ b/libgfortran/generated/maxloc0_16_i2.c
@@ -53,12 +53,12 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_16_i4.c b/libgfortran/generated/maxloc0_16_i4.c
index 18feabb..dc75d83 100644
--- a/libgfortran/generated/maxloc0_16_i4.c
+++ b/libgfortran/generated/maxloc0_16_i4.c
@@ -53,12 +53,12 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_16_i8.c b/libgfortran/generated/maxloc0_16_i8.c
index bc5a3b3..43879c7 100644
--- a/libgfortran/generated/maxloc0_16_i8.c
+++ b/libgfortran/generated/maxloc0_16_i8.c
@@ -53,12 +53,12 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_16_r10.c b/libgfortran/generated/maxloc0_16_r10.c
index ee0052f..3e3bcb5 100644
--- a/libgfortran/generated/maxloc0_16_r10.c
+++ b/libgfortran/generated/maxloc0_16_r10.c
@@ -53,12 +53,12 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_16_r16.c b/libgfortran/generated/maxloc0_16_r16.c
index 3c28d19..cec3963 100644
--- a/libgfortran/generated/maxloc0_16_r16.c
+++ b/libgfortran/generated/maxloc0_16_r16.c
@@ -53,12 +53,12 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_16_r4.c b/libgfortran/generated/maxloc0_16_r4.c
index 616ec7a..985dcd6 100644
--- a/libgfortran/generated/maxloc0_16_r4.c
+++ b/libgfortran/generated/maxloc0_16_r4.c
@@ -53,12 +53,12 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_16_r8.c b/libgfortran/generated/maxloc0_16_r8.c
index 8bb5f0d..7f385d7 100644
--- a/libgfortran/generated/maxloc0_16_r8.c
+++ b/libgfortran/generated/maxloc0_16_r8.c
@@ -53,12 +53,12 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_4_i1.c b/libgfortran/generated/maxloc0_4_i1.c
index 5fb626b..6d7cf61 100644
--- a/libgfortran/generated/maxloc0_4_i1.c
+++ b/libgfortran/generated/maxloc0_4_i1.c
@@ -53,12 +53,12 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_4_i16.c b/libgfortran/generated/maxloc0_4_i16.c
index e4d252d..0d8bf75 100644
--- a/libgfortran/generated/maxloc0_4_i16.c
+++ b/libgfortran/generated/maxloc0_4_i16.c
@@ -53,12 +53,12 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_4_i2.c b/libgfortran/generated/maxloc0_4_i2.c
index a3866e4..b0c05c8 100644
--- a/libgfortran/generated/maxloc0_4_i2.c
+++ b/libgfortran/generated/maxloc0_4_i2.c
@@ -53,12 +53,12 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_4_i4.c b/libgfortran/generated/maxloc0_4_i4.c
index 0a4a5bd..9be7099 100644
--- a/libgfortran/generated/maxloc0_4_i4.c
+++ b/libgfortran/generated/maxloc0_4_i4.c
@@ -53,12 +53,12 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_4_i8.c b/libgfortran/generated/maxloc0_4_i8.c
index 435123b..cb33723 100644
--- a/libgfortran/generated/maxloc0_4_i8.c
+++ b/libgfortran/generated/maxloc0_4_i8.c
@@ -53,12 +53,12 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_4_r10.c b/libgfortran/generated/maxloc0_4_r10.c
index 4b99bbe..48abb63 100644
--- a/libgfortran/generated/maxloc0_4_r10.c
+++ b/libgfortran/generated/maxloc0_4_r10.c
@@ -53,12 +53,12 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_4_r16.c b/libgfortran/generated/maxloc0_4_r16.c
index 1290355..3fae48d 100644
--- a/libgfortran/generated/maxloc0_4_r16.c
+++ b/libgfortran/generated/maxloc0_4_r16.c
@@ -53,12 +53,12 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_4_r4.c b/libgfortran/generated/maxloc0_4_r4.c
index 5483fda..d2a985d 100644
--- a/libgfortran/generated/maxloc0_4_r4.c
+++ b/libgfortran/generated/maxloc0_4_r4.c
@@ -53,12 +53,12 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_4_r8.c b/libgfortran/generated/maxloc0_4_r8.c
index e4631db..6f57fca 100644
--- a/libgfortran/generated/maxloc0_4_r8.c
+++ b/libgfortran/generated/maxloc0_4_r8.c
@@ -53,12 +53,12 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_8_i1.c b/libgfortran/generated/maxloc0_8_i1.c
index ddfc4df..07815cf 100644
--- a/libgfortran/generated/maxloc0_8_i1.c
+++ b/libgfortran/generated/maxloc0_8_i1.c
@@ -53,12 +53,12 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_8_i16.c b/libgfortran/generated/maxloc0_8_i16.c
index ce324b5..dc5c575 100644
--- a/libgfortran/generated/maxloc0_8_i16.c
+++ b/libgfortran/generated/maxloc0_8_i16.c
@@ -53,12 +53,12 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_8_i2.c b/libgfortran/generated/maxloc0_8_i2.c
index 1b59bb6..f01ec69 100644
--- a/libgfortran/generated/maxloc0_8_i2.c
+++ b/libgfortran/generated/maxloc0_8_i2.c
@@ -53,12 +53,12 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_8_i4.c b/libgfortran/generated/maxloc0_8_i4.c
index f1071d1..13f32e0 100644
--- a/libgfortran/generated/maxloc0_8_i4.c
+++ b/libgfortran/generated/maxloc0_8_i4.c
@@ -53,12 +53,12 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_8_i8.c b/libgfortran/generated/maxloc0_8_i8.c
index 2774558..066cedf 100644
--- a/libgfortran/generated/maxloc0_8_i8.c
+++ b/libgfortran/generated/maxloc0_8_i8.c
@@ -53,12 +53,12 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_8_r10.c b/libgfortran/generated/maxloc0_8_r10.c
index 0d5183c..f34984d 100644
--- a/libgfortran/generated/maxloc0_8_r10.c
+++ b/libgfortran/generated/maxloc0_8_r10.c
@@ -53,12 +53,12 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_8_r16.c b/libgfortran/generated/maxloc0_8_r16.c
index 51bc7b3..e28ba0f 100644
--- a/libgfortran/generated/maxloc0_8_r16.c
+++ b/libgfortran/generated/maxloc0_8_r16.c
@@ -53,12 +53,12 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_8_r4.c b/libgfortran/generated/maxloc0_8_r4.c
index cebe571..d6594ab 100644
--- a/libgfortran/generated/maxloc0_8_r4.c
+++ b/libgfortran/generated/maxloc0_8_r4.c
@@ -53,12 +53,12 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc0_8_r8.c b/libgfortran/generated/maxloc0_8_r8.c
index d332995..2a9b754 100644
--- a/libgfortran/generated/maxloc0_8_r8.c
+++ b/libgfortran/generated/maxloc0_8_r8.c
@@ -53,12 +53,12 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ maxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mmaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ smaxloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/maxloc1_16_i1.c b/libgfortran/generated/maxloc1_16_i1.c
index 3e42463..2621faf 100644
--- a/libgfortran/generated/maxloc1_16_i1.c
+++ b/libgfortran/generated/maxloc1_16_i1.c
@@ -80,7 +80,7 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_16_i1 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_16_i16.c b/libgfortran/generated/maxloc1_16_i16.c
index d6819aa..5175885 100644
--- a/libgfortran/generated/maxloc1_16_i16.c
+++ b/libgfortran/generated/maxloc1_16_i16.c
@@ -80,7 +80,7 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_16_i16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_16_i2.c b/libgfortran/generated/maxloc1_16_i2.c
index 691d034..a806782 100644
--- a/libgfortran/generated/maxloc1_16_i2.c
+++ b/libgfortran/generated/maxloc1_16_i2.c
@@ -80,7 +80,7 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_16_i2 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_16_i4.c b/libgfortran/generated/maxloc1_16_i4.c
index 1e5b87c..85dd48c 100644
--- a/libgfortran/generated/maxloc1_16_i4.c
+++ b/libgfortran/generated/maxloc1_16_i4.c
@@ -80,7 +80,7 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_16_i4 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_16_i8.c b/libgfortran/generated/maxloc1_16_i8.c
index c6a73d8..d6a96ec 100644
--- a/libgfortran/generated/maxloc1_16_i8.c
+++ b/libgfortran/generated/maxloc1_16_i8.c
@@ -80,7 +80,7 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_16_i8 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_16_r10.c b/libgfortran/generated/maxloc1_16_r10.c
index d954000..551d207 100644
--- a/libgfortran/generated/maxloc1_16_r10.c
+++ b/libgfortran/generated/maxloc1_16_r10.c
@@ -80,7 +80,7 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_16_r10 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_16_r16.c b/libgfortran/generated/maxloc1_16_r16.c
index 4ecb784..d44ecd4 100644
--- a/libgfortran/generated/maxloc1_16_r16.c
+++ b/libgfortran/generated/maxloc1_16_r16.c
@@ -80,7 +80,7 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_16_r16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_16_r4.c b/libgfortran/generated/maxloc1_16_r4.c
index e5cd291..ffd484c 100644
--- a/libgfortran/generated/maxloc1_16_r4.c
+++ b/libgfortran/generated/maxloc1_16_r4.c
@@ -80,7 +80,7 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_16_r4 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_16_r8.c b/libgfortran/generated/maxloc1_16_r8.c
index 2d209d7..d03ba72 100644
--- a/libgfortran/generated/maxloc1_16_r8.c
+++ b/libgfortran/generated/maxloc1_16_r8.c
@@ -80,7 +80,7 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_16_r8 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_4_i1.c b/libgfortran/generated/maxloc1_4_i1.c
index efd6958..4c528f2 100644
--- a/libgfortran/generated/maxloc1_4_i1.c
+++ b/libgfortran/generated/maxloc1_4_i1.c
@@ -80,7 +80,7 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_4_i1 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_4_i16.c b/libgfortran/generated/maxloc1_4_i16.c
index 71850fc..5c0a801 100644
--- a/libgfortran/generated/maxloc1_4_i16.c
+++ b/libgfortran/generated/maxloc1_4_i16.c
@@ -80,7 +80,7 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_4_i16 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_4_i2.c b/libgfortran/generated/maxloc1_4_i2.c
index d825039..3d35b0c 100644
--- a/libgfortran/generated/maxloc1_4_i2.c
+++ b/libgfortran/generated/maxloc1_4_i2.c
@@ -80,7 +80,7 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_4_i2 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_4_i4.c b/libgfortran/generated/maxloc1_4_i4.c
index f70b5aa..ec2f434 100644
--- a/libgfortran/generated/maxloc1_4_i4.c
+++ b/libgfortran/generated/maxloc1_4_i4.c
@@ -80,7 +80,7 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_4_i4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_4_i8.c b/libgfortran/generated/maxloc1_4_i8.c
index cda4a99..0bee414 100644
--- a/libgfortran/generated/maxloc1_4_i8.c
+++ b/libgfortran/generated/maxloc1_4_i8.c
@@ -80,7 +80,7 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_4_i8 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_4_r10.c b/libgfortran/generated/maxloc1_4_r10.c
index 7901a4b..cfb16f9 100644
--- a/libgfortran/generated/maxloc1_4_r10.c
+++ b/libgfortran/generated/maxloc1_4_r10.c
@@ -80,7 +80,7 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_4_r10 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_4_r16.c b/libgfortran/generated/maxloc1_4_r16.c
index f06d7b2..4bf9b8c 100644
--- a/libgfortran/generated/maxloc1_4_r16.c
+++ b/libgfortran/generated/maxloc1_4_r16.c
@@ -80,7 +80,7 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_4_r16 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_4_r4.c b/libgfortran/generated/maxloc1_4_r4.c
index e6837aa..c3721d9 100644
--- a/libgfortran/generated/maxloc1_4_r4.c
+++ b/libgfortran/generated/maxloc1_4_r4.c
@@ -80,7 +80,7 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_4_r4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_4_r8.c b/libgfortran/generated/maxloc1_4_r8.c
index 26c10c7..a756665 100644
--- a/libgfortran/generated/maxloc1_4_r8.c
+++ b/libgfortran/generated/maxloc1_4_r8.c
@@ -80,7 +80,7 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_4_r8 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_8_i1.c b/libgfortran/generated/maxloc1_8_i1.c
index c9dc610..59be8b7 100644
--- a/libgfortran/generated/maxloc1_8_i1.c
+++ b/libgfortran/generated/maxloc1_8_i1.c
@@ -80,7 +80,7 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_8_i1 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_8_i16.c b/libgfortran/generated/maxloc1_8_i16.c
index 7cd62ac..107426e 100644
--- a/libgfortran/generated/maxloc1_8_i16.c
+++ b/libgfortran/generated/maxloc1_8_i16.c
@@ -80,7 +80,7 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_8_i16 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_8_i2.c b/libgfortran/generated/maxloc1_8_i2.c
index fd0cc21..21a8dce 100644
--- a/libgfortran/generated/maxloc1_8_i2.c
+++ b/libgfortran/generated/maxloc1_8_i2.c
@@ -80,7 +80,7 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_8_i2 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_8_i4.c b/libgfortran/generated/maxloc1_8_i4.c
index 97cd54b..2c7d860 100644
--- a/libgfortran/generated/maxloc1_8_i4.c
+++ b/libgfortran/generated/maxloc1_8_i4.c
@@ -80,7 +80,7 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_8_i4 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_8_i8.c b/libgfortran/generated/maxloc1_8_i8.c
index f9c455c..0638ab0 100644
--- a/libgfortran/generated/maxloc1_8_i8.c
+++ b/libgfortran/generated/maxloc1_8_i8.c
@@ -80,7 +80,7 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_8_i8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_8_r10.c b/libgfortran/generated/maxloc1_8_r10.c
index ab1173c..acc5689 100644
--- a/libgfortran/generated/maxloc1_8_r10.c
+++ b/libgfortran/generated/maxloc1_8_r10.c
@@ -80,7 +80,7 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_8_r10 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_8_r16.c b/libgfortran/generated/maxloc1_8_r16.c
index 9a02e12..1cd2a45 100644
--- a/libgfortran/generated/maxloc1_8_r16.c
+++ b/libgfortran/generated/maxloc1_8_r16.c
@@ -80,7 +80,7 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_8_r16 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_8_r4.c b/libgfortran/generated/maxloc1_8_r4.c
index 584bdb8..177f06e 100644
--- a/libgfortran/generated/maxloc1_8_r4.c
+++ b/libgfortran/generated/maxloc1_8_r4.c
@@ -80,7 +80,7 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_8_r4 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxloc1_8_r8.c b/libgfortran/generated/maxloc1_8_r8.c
index c6f3efd..35739aa 100644
--- a/libgfortran/generated/maxloc1_8_r8.c
+++ b/libgfortran/generated/maxloc1_8_r8.c
@@ -80,7 +80,7 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ maxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mmaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ smaxloc1_8_r8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxval_i1.c b/libgfortran/generated/maxval_i1.c
index 5b67682..7a4a58e 100644
--- a/libgfortran/generated/maxval_i1.c
+++ b/libgfortran/generated/maxval_i1.c
@@ -79,7 +79,7 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ maxval_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mmaxval_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ smaxval_i1 (gfc_array_i1 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxval_i16.c b/libgfortran/generated/maxval_i16.c
index 148319d..fe42c27 100644
--- a/libgfortran/generated/maxval_i16.c
+++ b/libgfortran/generated/maxval_i16.c
@@ -79,7 +79,7 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ maxval_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mmaxval_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ smaxval_i16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxval_i2.c b/libgfortran/generated/maxval_i2.c
index f87f3ed..19b233d 100644
--- a/libgfortran/generated/maxval_i2.c
+++ b/libgfortran/generated/maxval_i2.c
@@ -79,7 +79,7 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ maxval_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mmaxval_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ smaxval_i2 (gfc_array_i2 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxval_i4.c b/libgfortran/generated/maxval_i4.c
index 51f2511..d4ef8ed 100644
--- a/libgfortran/generated/maxval_i4.c
+++ b/libgfortran/generated/maxval_i4.c
@@ -79,7 +79,7 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ maxval_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mmaxval_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ smaxval_i4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxval_i8.c b/libgfortran/generated/maxval_i8.c
index 74aca03..814357d 100644
--- a/libgfortran/generated/maxval_i8.c
+++ b/libgfortran/generated/maxval_i8.c
@@ -79,7 +79,7 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ maxval_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mmaxval_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ smaxval_i8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxval_r10.c b/libgfortran/generated/maxval_r10.c
index 3eaaa4c..736cced 100644
--- a/libgfortran/generated/maxval_r10.c
+++ b/libgfortran/generated/maxval_r10.c
@@ -79,7 +79,7 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ maxval_r10 (gfc_array_r10 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mmaxval_r10 (gfc_array_r10 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ smaxval_r10 (gfc_array_r10 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxval_r16.c b/libgfortran/generated/maxval_r16.c
index bc4cf27..37ae298 100644
--- a/libgfortran/generated/maxval_r16.c
+++ b/libgfortran/generated/maxval_r16.c
@@ -79,7 +79,7 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ maxval_r16 (gfc_array_r16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mmaxval_r16 (gfc_array_r16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ smaxval_r16 (gfc_array_r16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxval_r4.c b/libgfortran/generated/maxval_r4.c
index d7e25ee..0cd7319 100644
--- a/libgfortran/generated/maxval_r4.c
+++ b/libgfortran/generated/maxval_r4.c
@@ -79,7 +79,7 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ maxval_r4 (gfc_array_r4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mmaxval_r4 (gfc_array_r4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ smaxval_r4 (gfc_array_r4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/maxval_r8.c b/libgfortran/generated/maxval_r8.c
index 21c08e9..f8ac97d 100644
--- a/libgfortran/generated/maxval_r8.c
+++ b/libgfortran/generated/maxval_r8.c
@@ -79,7 +79,7 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ maxval_r8 (gfc_array_r8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mmaxval_r8 (gfc_array_r8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ smaxval_r8 (gfc_array_r8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc0_16_i1.c b/libgfortran/generated/minloc0_16_i1.c
index 2fbd760..61758852 100644
--- a/libgfortran/generated/minloc0_16_i1.c
+++ b/libgfortran/generated/minloc0_16_i1.c
@@ -53,12 +53,12 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_16_i1 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_16_i16.c b/libgfortran/generated/minloc0_16_i16.c
index 613ad48..d938dd7 100644
--- a/libgfortran/generated/minloc0_16_i16.c
+++ b/libgfortran/generated/minloc0_16_i16.c
@@ -53,12 +53,12 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_16_i16 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_16_i2.c b/libgfortran/generated/minloc0_16_i2.c
index 7591cd5..8f0528e 100644
--- a/libgfortran/generated/minloc0_16_i2.c
+++ b/libgfortran/generated/minloc0_16_i2.c
@@ -53,12 +53,12 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_16_i2 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_16_i4.c b/libgfortran/generated/minloc0_16_i4.c
index 85601fb..cf57b79 100644
--- a/libgfortran/generated/minloc0_16_i4.c
+++ b/libgfortran/generated/minloc0_16_i4.c
@@ -53,12 +53,12 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_16_i4 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_16_i8.c b/libgfortran/generated/minloc0_16_i8.c
index 88e1ee8..23c7293 100644
--- a/libgfortran/generated/minloc0_16_i8.c
+++ b/libgfortran/generated/minloc0_16_i8.c
@@ -53,12 +53,12 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_16_i8 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_16_r10.c b/libgfortran/generated/minloc0_16_r10.c
index 7bfc7a7..52c0ab7 100644
--- a/libgfortran/generated/minloc0_16_r10.c
+++ b/libgfortran/generated/minloc0_16_r10.c
@@ -53,12 +53,12 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_16_r10 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_16_r16.c b/libgfortran/generated/minloc0_16_r16.c
index d408854..e35ad66 100644
--- a/libgfortran/generated/minloc0_16_r16.c
+++ b/libgfortran/generated/minloc0_16_r16.c
@@ -53,12 +53,12 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_16_r16 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_16_r4.c b/libgfortran/generated/minloc0_16_r4.c
index 6b35a7a..37e877b 100644
--- a/libgfortran/generated/minloc0_16_r4.c
+++ b/libgfortran/generated/minloc0_16_r4.c
@@ -53,12 +53,12 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_16_r4 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_16_r8.c b/libgfortran/generated/minloc0_16_r8.c
index c9ee9bf..dbd7ad3 100644
--- a/libgfortran/generated/minloc0_16_r8.c
+++ b/libgfortran/generated/minloc0_16_r8.c
@@ -53,12 +53,12 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_16_r8 (gfc_array_i16 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_4_i1.c b/libgfortran/generated/minloc0_4_i1.c
index 0187a3d..fa9dcf5 100644
--- a/libgfortran/generated/minloc0_4_i1.c
+++ b/libgfortran/generated/minloc0_4_i1.c
@@ -53,12 +53,12 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_4_i1 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_4_i16.c b/libgfortran/generated/minloc0_4_i16.c
index ce3cd27..5a8e440 100644
--- a/libgfortran/generated/minloc0_4_i16.c
+++ b/libgfortran/generated/minloc0_4_i16.c
@@ -53,12 +53,12 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_4_i16 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_4_i2.c b/libgfortran/generated/minloc0_4_i2.c
index cedfbf3..d3ce2ed 100644
--- a/libgfortran/generated/minloc0_4_i2.c
+++ b/libgfortran/generated/minloc0_4_i2.c
@@ -53,12 +53,12 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_4_i2 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_4_i4.c b/libgfortran/generated/minloc0_4_i4.c
index 42211a9..dc2d606 100644
--- a/libgfortran/generated/minloc0_4_i4.c
+++ b/libgfortran/generated/minloc0_4_i4.c
@@ -53,12 +53,12 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_4_i4 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_4_i8.c b/libgfortran/generated/minloc0_4_i8.c
index 39cc14d..98da2de 100644
--- a/libgfortran/generated/minloc0_4_i8.c
+++ b/libgfortran/generated/minloc0_4_i8.c
@@ -53,12 +53,12 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_4_i8 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_4_r10.c b/libgfortran/generated/minloc0_4_r10.c
index 9edd105..8302d23 100644
--- a/libgfortran/generated/minloc0_4_r10.c
+++ b/libgfortran/generated/minloc0_4_r10.c
@@ -53,12 +53,12 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_4_r10 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_4_r16.c b/libgfortran/generated/minloc0_4_r16.c
index 0cb3ee0..d8617ff 100644
--- a/libgfortran/generated/minloc0_4_r16.c
+++ b/libgfortran/generated/minloc0_4_r16.c
@@ -53,12 +53,12 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_4_r16 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_4_r4.c b/libgfortran/generated/minloc0_4_r4.c
index 817e61e..2cdbc7d 100644
--- a/libgfortran/generated/minloc0_4_r4.c
+++ b/libgfortran/generated/minloc0_4_r4.c
@@ -53,12 +53,12 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_4_r4 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_4_r8.c b/libgfortran/generated/minloc0_4_r8.c
index 84c219b..f8ef3a5 100644
--- a/libgfortran/generated/minloc0_4_r8.c
+++ b/libgfortran/generated/minloc0_4_r8.c
@@ -53,12 +53,12 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_4_r8 (gfc_array_i4 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_8_i1.c b/libgfortran/generated/minloc0_8_i1.c
index 52f4f50..0d6b521 100644
--- a/libgfortran/generated/minloc0_8_i1.c
+++ b/libgfortran/generated/minloc0_8_i1.c
@@ -53,12 +53,12 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_8_i1 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_8_i16.c b/libgfortran/generated/minloc0_8_i16.c
index 980cd7e..37d6561 100644
--- a/libgfortran/generated/minloc0_8_i16.c
+++ b/libgfortran/generated/minloc0_8_i16.c
@@ -53,12 +53,12 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_8_i16 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_8_i2.c b/libgfortran/generated/minloc0_8_i2.c
index 26f79d4..3418cee 100644
--- a/libgfortran/generated/minloc0_8_i2.c
+++ b/libgfortran/generated/minloc0_8_i2.c
@@ -53,12 +53,12 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_8_i2 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_8_i4.c b/libgfortran/generated/minloc0_8_i4.c
index 87f1927..c36785e 100644
--- a/libgfortran/generated/minloc0_8_i4.c
+++ b/libgfortran/generated/minloc0_8_i4.c
@@ -53,12 +53,12 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_8_i4 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_8_i8.c b/libgfortran/generated/minloc0_8_i8.c
index 7305962..817f1c1 100644
--- a/libgfortran/generated/minloc0_8_i8.c
+++ b/libgfortran/generated/minloc0_8_i8.c
@@ -53,12 +53,12 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_8_i8 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_8_r10.c b/libgfortran/generated/minloc0_8_r10.c
index 38ba7f0..d5a68ea 100644
--- a/libgfortran/generated/minloc0_8_r10.c
+++ b/libgfortran/generated/minloc0_8_r10.c
@@ -53,12 +53,12 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_8_r10 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_8_r16.c b/libgfortran/generated/minloc0_8_r16.c
index 29b37f4..c2235b8 100644
--- a/libgfortran/generated/minloc0_8_r16.c
+++ b/libgfortran/generated/minloc0_8_r16.c
@@ -53,12 +53,12 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_8_r16 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_8_r4.c b/libgfortran/generated/minloc0_8_r4.c
index cf4c3b6..05230f5 100644
--- a/libgfortran/generated/minloc0_8_r4.c
+++ b/libgfortran/generated/minloc0_8_r4.c
@@ -53,12 +53,12 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_8_r4 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc0_8_r8.c b/libgfortran/generated/minloc0_8_r8.c
index 3c5d338..0ec3067 100644
--- a/libgfortran/generated/minloc0_8_r8.c
+++ b/libgfortran/generated/minloc0_8_r8.c
@@ -53,12 +53,12 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -68,7 +68,7 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -83,7 +83,7 @@ minloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -194,12 +194,12 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else
     {
@@ -215,7 +215,7 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -227,7 +227,7 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -243,7 +243,7 @@ mminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -362,12 +362,12 @@ sminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -376,7 +376,7 @@ sminloc0_8_r8 (gfc_array_i8 * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = 0 ;
 }
diff --git a/libgfortran/generated/minloc1_16_i1.c b/libgfortran/generated/minloc1_16_i1.c
index 8b4b53f..7b5ae81 100644
--- a/libgfortran/generated/minloc1_16_i1.c
+++ b/libgfortran/generated/minloc1_16_i1.c
@@ -80,7 +80,7 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_16_i1 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_16_i16.c b/libgfortran/generated/minloc1_16_i16.c
index 3a18e8c..c08cb66 100644
--- a/libgfortran/generated/minloc1_16_i16.c
+++ b/libgfortran/generated/minloc1_16_i16.c
@@ -80,7 +80,7 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_16_i16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_16_i2.c b/libgfortran/generated/minloc1_16_i2.c
index bc13bee..3e89ba7 100644
--- a/libgfortran/generated/minloc1_16_i2.c
+++ b/libgfortran/generated/minloc1_16_i2.c
@@ -80,7 +80,7 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_16_i2 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_16_i4.c b/libgfortran/generated/minloc1_16_i4.c
index 84d131a..1097c3b 100644
--- a/libgfortran/generated/minloc1_16_i4.c
+++ b/libgfortran/generated/minloc1_16_i4.c
@@ -80,7 +80,7 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_16_i4 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_16_i8.c b/libgfortran/generated/minloc1_16_i8.c
index 1f3e054..326b9cf 100644
--- a/libgfortran/generated/minloc1_16_i8.c
+++ b/libgfortran/generated/minloc1_16_i8.c
@@ -80,7 +80,7 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_16_i8 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_16_r10.c b/libgfortran/generated/minloc1_16_r10.c
index 6bda151..7bf30bd 100644
--- a/libgfortran/generated/minloc1_16_r10.c
+++ b/libgfortran/generated/minloc1_16_r10.c
@@ -80,7 +80,7 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_16_r10 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_16_r16.c b/libgfortran/generated/minloc1_16_r16.c
index c31cf4b..bc65a03 100644
--- a/libgfortran/generated/minloc1_16_r16.c
+++ b/libgfortran/generated/minloc1_16_r16.c
@@ -80,7 +80,7 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_16_r16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_16_r4.c b/libgfortran/generated/minloc1_16_r4.c
index 52ec2b0..baa2bc4 100644
--- a/libgfortran/generated/minloc1_16_r4.c
+++ b/libgfortran/generated/minloc1_16_r4.c
@@ -80,7 +80,7 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_16_r4 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_16_r8.c b/libgfortran/generated/minloc1_16_r8.c
index a53ed34..482391d 100644
--- a/libgfortran/generated/minloc1_16_r8.c
+++ b/libgfortran/generated/minloc1_16_r8.c
@@ -80,7 +80,7 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_16_r8 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_4_i1.c b/libgfortran/generated/minloc1_4_i1.c
index e8af361..73c1a23 100644
--- a/libgfortran/generated/minloc1_4_i1.c
+++ b/libgfortran/generated/minloc1_4_i1.c
@@ -80,7 +80,7 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_4_i1 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_4_i16.c b/libgfortran/generated/minloc1_4_i16.c
index 8d3da20..442f518 100644
--- a/libgfortran/generated/minloc1_4_i16.c
+++ b/libgfortran/generated/minloc1_4_i16.c
@@ -80,7 +80,7 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_4_i16 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_4_i2.c b/libgfortran/generated/minloc1_4_i2.c
index e7f2449..f235b09 100644
--- a/libgfortran/generated/minloc1_4_i2.c
+++ b/libgfortran/generated/minloc1_4_i2.c
@@ -80,7 +80,7 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_4_i2 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_4_i4.c b/libgfortran/generated/minloc1_4_i4.c
index 94d45c9..e0a54f2 100644
--- a/libgfortran/generated/minloc1_4_i4.c
+++ b/libgfortran/generated/minloc1_4_i4.c
@@ -80,7 +80,7 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_4_i4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_4_i8.c b/libgfortran/generated/minloc1_4_i8.c
index fa07bcb..2d28829 100644
--- a/libgfortran/generated/minloc1_4_i8.c
+++ b/libgfortran/generated/minloc1_4_i8.c
@@ -80,7 +80,7 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_4_i8 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_4_r10.c b/libgfortran/generated/minloc1_4_r10.c
index 5cb23a6..08947086 100644
--- a/libgfortran/generated/minloc1_4_r10.c
+++ b/libgfortran/generated/minloc1_4_r10.c
@@ -80,7 +80,7 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_4_r10 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_4_r16.c b/libgfortran/generated/minloc1_4_r16.c
index 40854a1..082d409 100644
--- a/libgfortran/generated/minloc1_4_r16.c
+++ b/libgfortran/generated/minloc1_4_r16.c
@@ -80,7 +80,7 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_4_r16 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_4_r4.c b/libgfortran/generated/minloc1_4_r4.c
index 4231d18..60c8f73 100644
--- a/libgfortran/generated/minloc1_4_r4.c
+++ b/libgfortran/generated/minloc1_4_r4.c
@@ -80,7 +80,7 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_4_r4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_4_r8.c b/libgfortran/generated/minloc1_4_r8.c
index 8e5e5dd..267bdae 100644
--- a/libgfortran/generated/minloc1_4_r8.c
+++ b/libgfortran/generated/minloc1_4_r8.c
@@ -80,7 +80,7 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_4_r8 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_8_i1.c b/libgfortran/generated/minloc1_8_i1.c
index 9a54335..17fc399 100644
--- a/libgfortran/generated/minloc1_8_i1.c
+++ b/libgfortran/generated/minloc1_8_i1.c
@@ -80,7 +80,7 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_8_i1 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_8_i16.c b/libgfortran/generated/minloc1_8_i16.c
index f0b477e..350d762 100644
--- a/libgfortran/generated/minloc1_8_i16.c
+++ b/libgfortran/generated/minloc1_8_i16.c
@@ -80,7 +80,7 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_8_i16 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_8_i2.c b/libgfortran/generated/minloc1_8_i2.c
index 9d3d14e..22b10b8 100644
--- a/libgfortran/generated/minloc1_8_i2.c
+++ b/libgfortran/generated/minloc1_8_i2.c
@@ -80,7 +80,7 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_8_i2 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_8_i4.c b/libgfortran/generated/minloc1_8_i4.c
index edac05c..f01ef6d 100644
--- a/libgfortran/generated/minloc1_8_i4.c
+++ b/libgfortran/generated/minloc1_8_i4.c
@@ -80,7 +80,7 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_8_i4 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_8_i8.c b/libgfortran/generated/minloc1_8_i8.c
index 3c0f441..91cbc7e 100644
--- a/libgfortran/generated/minloc1_8_i8.c
+++ b/libgfortran/generated/minloc1_8_i8.c
@@ -80,7 +80,7 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_8_i8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_8_r10.c b/libgfortran/generated/minloc1_8_r10.c
index a9239d2..b04ebfc 100644
--- a/libgfortran/generated/minloc1_8_r10.c
+++ b/libgfortran/generated/minloc1_8_r10.c
@@ -80,7 +80,7 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_8_r10 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_8_r16.c b/libgfortran/generated/minloc1_8_r16.c
index 953ada7..02f9b47 100644
--- a/libgfortran/generated/minloc1_8_r16.c
+++ b/libgfortran/generated/minloc1_8_r16.c
@@ -80,7 +80,7 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_8_r16 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_8_r4.c b/libgfortran/generated/minloc1_8_r4.c
index 3882000..bd7fb36 100644
--- a/libgfortran/generated/minloc1_8_r4.c
+++ b/libgfortran/generated/minloc1_8_r4.c
@@ -80,7 +80,7 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_8_r4 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minloc1_8_r8.c b/libgfortran/generated/minloc1_8_r8.c
index c8d1812..cd300bb 100644
--- a/libgfortran/generated/minloc1_8_r8.c
+++ b/libgfortran/generated/minloc1_8_r8.c
@@ -80,7 +80,7 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -131,8 +131,8 @@ minloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -243,7 +243,7 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -279,7 +279,7 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -307,7 +307,7 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -332,8 +332,8 @@ mminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -472,7 +472,7 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -500,7 +500,7 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -532,7 +532,7 @@ sminloc1_8_r8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minval_i1.c b/libgfortran/generated/minval_i1.c
index d9ee1d7..ed9fb22 100644
--- a/libgfortran/generated/minval_i1.c
+++ b/libgfortran/generated/minval_i1.c
@@ -79,7 +79,7 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ minval_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mminval_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ sminval_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ sminval_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ sminval_i1 (gfc_array_i1 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minval_i16.c b/libgfortran/generated/minval_i16.c
index 8394547..7f11f41 100644
--- a/libgfortran/generated/minval_i16.c
+++ b/libgfortran/generated/minval_i16.c
@@ -79,7 +79,7 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ minval_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mminval_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ sminval_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ sminval_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ sminval_i16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minval_i2.c b/libgfortran/generated/minval_i2.c
index 9cffe84..18663d7 100644
--- a/libgfortran/generated/minval_i2.c
+++ b/libgfortran/generated/minval_i2.c
@@ -79,7 +79,7 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ minval_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mminval_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ sminval_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ sminval_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ sminval_i2 (gfc_array_i2 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minval_i4.c b/libgfortran/generated/minval_i4.c
index 993116a..f6d4803 100644
--- a/libgfortran/generated/minval_i4.c
+++ b/libgfortran/generated/minval_i4.c
@@ -79,7 +79,7 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ minval_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mminval_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ sminval_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ sminval_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ sminval_i4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minval_i8.c b/libgfortran/generated/minval_i8.c
index 3a52b4b..2fdf455 100644
--- a/libgfortran/generated/minval_i8.c
+++ b/libgfortran/generated/minval_i8.c
@@ -79,7 +79,7 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ minval_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mminval_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ sminval_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ sminval_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ sminval_i8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minval_r10.c b/libgfortran/generated/minval_r10.c
index b490b3b..590a4db 100644
--- a/libgfortran/generated/minval_r10.c
+++ b/libgfortran/generated/minval_r10.c
@@ -79,7 +79,7 @@ minval_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ minval_r10 (gfc_array_r10 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mminval_r10 (gfc_array_r10 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ sminval_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ sminval_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ sminval_r10 (gfc_array_r10 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minval_r16.c b/libgfortran/generated/minval_r16.c
index 701191f..ca30114 100644
--- a/libgfortran/generated/minval_r16.c
+++ b/libgfortran/generated/minval_r16.c
@@ -79,7 +79,7 @@ minval_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ minval_r16 (gfc_array_r16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mminval_r16 (gfc_array_r16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ sminval_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ sminval_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ sminval_r16 (gfc_array_r16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minval_r4.c b/libgfortran/generated/minval_r4.c
index e693765..8ec3c7c 100644
--- a/libgfortran/generated/minval_r4.c
+++ b/libgfortran/generated/minval_r4.c
@@ -79,7 +79,7 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ minval_r4 (gfc_array_r4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mminval_r4 (gfc_array_r4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ sminval_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ sminval_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ sminval_r4 (gfc_array_r4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/minval_r8.c b/libgfortran/generated/minval_r8.c
index 611ee57..d03f513 100644
--- a/libgfortran/generated/minval_r8.c
+++ b/libgfortran/generated/minval_r8.c
@@ -79,7 +79,7 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ minval_r8 (gfc_array_r8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -235,7 +235,7 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -271,7 +271,7 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -299,7 +299,7 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -324,8 +324,8 @@ mminval_r8 (gfc_array_r8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -459,7 +459,7 @@ sminval_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -487,7 +487,7 @@ sminval_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -519,7 +519,7 @@ sminval_r8 (gfc_array_r8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/norm2_r10.c b/libgfortran/generated/norm2_r10.c
index 5b64803..d3e8c7a 100644
--- a/libgfortran/generated/norm2_r10.c
+++ b/libgfortran/generated/norm2_r10.c
@@ -83,7 +83,7 @@ norm2_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -104,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -111,8 +112,6 @@ norm2_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -135,8 +134,8 @@ norm2_r10 (gfc_array_r10 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/norm2_r16.c b/libgfortran/generated/norm2_r16.c
index 66b6167..dc5aeac 100644
--- a/libgfortran/generated/norm2_r16.c
+++ b/libgfortran/generated/norm2_r16.c
@@ -87,7 +87,7 @@ norm2_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -108,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -115,8 +116,6 @@ norm2_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -139,8 +138,8 @@ norm2_r16 (gfc_array_r16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/norm2_r4.c b/libgfortran/generated/norm2_r4.c
index f2c5c8c..8c7fae0 100644
--- a/libgfortran/generated/norm2_r4.c
+++ b/libgfortran/generated/norm2_r4.c
@@ -83,7 +83,7 @@ norm2_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -104,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -111,8 +112,6 @@ norm2_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -135,8 +134,8 @@ norm2_r4 (gfc_array_r4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/norm2_r8.c b/libgfortran/generated/norm2_r8.c
index 4a47776..9dcd8cf 100644
--- a/libgfortran/generated/norm2_r8.c
+++ b/libgfortran/generated/norm2_r8.c
@@ -83,7 +83,7 @@ norm2_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -104,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -111,8 +112,6 @@ norm2_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -135,8 +134,8 @@ norm2_r8 (gfc_array_r8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/pack_c10.c b/libgfortran/generated/pack_c10.c
index 621ba8d..577c68a 100644
--- a/libgfortran/generated/pack_c10.c
+++ b/libgfortran/generated/pack_c10.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_c10 (gfc_array_c10 *ret, const gfc_array_c10 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_c10 (gfc_array_c10 *ret, const gfc_array_c10 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_c10 (gfc_array_c10 *ret, const gfc_array_c10 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_COMPLEX_10) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_10) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_c10 (gfc_array_c10 *ret, const gfc_array_c10 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_c10 (gfc_array_c10 *ret, const gfc_array_c10 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_c16.c b/libgfortran/generated/pack_c16.c
index e98de98..121b0a8 100644
--- a/libgfortran/generated/pack_c16.c
+++ b/libgfortran/generated/pack_c16.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_c16 (gfc_array_c16 *ret, const gfc_array_c16 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_c16 (gfc_array_c16 *ret, const gfc_array_c16 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_c16 (gfc_array_c16 *ret, const gfc_array_c16 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_COMPLEX_16) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_16) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_c16 (gfc_array_c16 *ret, const gfc_array_c16 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_c16 (gfc_array_c16 *ret, const gfc_array_c16 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_c4.c b/libgfortran/generated/pack_c4.c
index 85e1541..c9ad6e80 100644
--- a/libgfortran/generated/pack_c4.c
+++ b/libgfortran/generated/pack_c4.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_c4 (gfc_array_c4 *ret, const gfc_array_c4 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_c4 (gfc_array_c4 *ret, const gfc_array_c4 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_c4 (gfc_array_c4 *ret, const gfc_array_c4 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_COMPLEX_4) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_4) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_c4 (gfc_array_c4 *ret, const gfc_array_c4 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_c4 (gfc_array_c4 *ret, const gfc_array_c4 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_c8.c b/libgfortran/generated/pack_c8.c
index bfaec2f..d1a6941 100644
--- a/libgfortran/generated/pack_c8.c
+++ b/libgfortran/generated/pack_c8.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_c8 (gfc_array_c8 *ret, const gfc_array_c8 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_c8 (gfc_array_c8 *ret, const gfc_array_c8 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_c8 (gfc_array_c8 *ret, const gfc_array_c8 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_COMPLEX_8) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_8) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_c8 (gfc_array_c8 *ret, const gfc_array_c8 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_c8 (gfc_array_c8 *ret, const gfc_array_c8 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_i1.c b/libgfortran/generated/pack_i1.c
index c168aff..2aa75c1 100644
--- a/libgfortran/generated/pack_i1.c
+++ b/libgfortran/generated/pack_i1.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_i1 (gfc_array_i1 *ret, const gfc_array_i1 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_i1 (gfc_array_i1 *ret, const gfc_array_i1 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_i1 (gfc_array_i1 *ret, const gfc_array_i1 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_INTEGER_1) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_1) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_i1 (gfc_array_i1 *ret, const gfc_array_i1 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_i1 (gfc_array_i1 *ret, const gfc_array_i1 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_i16.c b/libgfortran/generated/pack_i16.c
index 81ed49a..451c8da 100644
--- a/libgfortran/generated/pack_i16.c
+++ b/libgfortran/generated/pack_i16.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_i16 (gfc_array_i16 *ret, const gfc_array_i16 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_i16 (gfc_array_i16 *ret, const gfc_array_i16 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_i16 (gfc_array_i16 *ret, const gfc_array_i16 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_i16 (gfc_array_i16 *ret, const gfc_array_i16 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_i16 (gfc_array_i16 *ret, const gfc_array_i16 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_i2.c b/libgfortran/generated/pack_i2.c
index a04b7af..9b68c52 100644
--- a/libgfortran/generated/pack_i2.c
+++ b/libgfortran/generated/pack_i2.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_i2 (gfc_array_i2 *ret, const gfc_array_i2 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_i2 (gfc_array_i2 *ret, const gfc_array_i2 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_i2 (gfc_array_i2 *ret, const gfc_array_i2 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_INTEGER_2) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_2) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_i2 (gfc_array_i2 *ret, const gfc_array_i2 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_i2 (gfc_array_i2 *ret, const gfc_array_i2 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_i4.c b/libgfortran/generated/pack_i4.c
index c5d112b..36d1eb1 100644
--- a/libgfortran/generated/pack_i4.c
+++ b/libgfortran/generated/pack_i4.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_i4 (gfc_array_i4 *ret, const gfc_array_i4 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_i4 (gfc_array_i4 *ret, const gfc_array_i4 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_i4 (gfc_array_i4 *ret, const gfc_array_i4 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_i4 (gfc_array_i4 *ret, const gfc_array_i4 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_i4 (gfc_array_i4 *ret, const gfc_array_i4 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_i8.c b/libgfortran/generated/pack_i8.c
index 7307192..8f75038 100644
--- a/libgfortran/generated/pack_i8.c
+++ b/libgfortran/generated/pack_i8.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_i8 (gfc_array_i8 *ret, const gfc_array_i8 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_i8 (gfc_array_i8 *ret, const gfc_array_i8 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_i8 (gfc_array_i8 *ret, const gfc_array_i8 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_i8 (gfc_array_i8 *ret, const gfc_array_i8 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_i8 (gfc_array_i8 *ret, const gfc_array_i8 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_r10.c b/libgfortran/generated/pack_r10.c
index c3b55cc..b8b8135 100644
--- a/libgfortran/generated/pack_r10.c
+++ b/libgfortran/generated/pack_r10.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_r10 (gfc_array_r10 *ret, const gfc_array_r10 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_r10 (gfc_array_r10 *ret, const gfc_array_r10 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_r10 (gfc_array_r10 *ret, const gfc_array_r10 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_REAL_10) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_r10 (gfc_array_r10 *ret, const gfc_array_r10 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_r10 (gfc_array_r10 *ret, const gfc_array_r10 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_r16.c b/libgfortran/generated/pack_r16.c
index 489ff95..932e190 100644
--- a/libgfortran/generated/pack_r16.c
+++ b/libgfortran/generated/pack_r16.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_r16 (gfc_array_r16 *ret, const gfc_array_r16 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_r16 (gfc_array_r16 *ret, const gfc_array_r16 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_r16 (gfc_array_r16 *ret, const gfc_array_r16 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_REAL_16) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_r16 (gfc_array_r16 *ret, const gfc_array_r16 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_r16 (gfc_array_r16 *ret, const gfc_array_r16 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_r4.c b/libgfortran/generated/pack_r4.c
index 05172db..a57daba 100644
--- a/libgfortran/generated/pack_r4.c
+++ b/libgfortran/generated/pack_r4.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_r4 (gfc_array_r4 *ret, const gfc_array_r4 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_r4 (gfc_array_r4 *ret, const gfc_array_r4 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_r4 (gfc_array_r4 *ret, const gfc_array_r4 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_REAL_4) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_r4 (gfc_array_r4 *ret, const gfc_array_r4 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_r4 (gfc_array_r4 *ret, const gfc_array_r4 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/pack_r8.c b/libgfortran/generated/pack_r8.c
index df5cc3f..9516551 100644
--- a/libgfortran/generated/pack_r8.c
+++ b/libgfortran/generated/pack_r8.c
@@ -1,8 +1,9 @@
 /* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -98,7 +99,7 @@ pack_r8 (gfc_array_r8 *ret, const gfc_array_r8 *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -136,9 +137,9 @@ pack_r8 (gfc_array_r8 *ret, const gfc_array_r8 *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -160,7 +161,7 @@ pack_r8 (gfc_array_r8 *ret, const gfc_array_r8 *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -168,7 +169,7 @@ 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->data = internal_malloc_size (sizeof (GFC_REAL_8) * total);
+	  ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * total);
 
 	  if (total == 0)
 	    return;
@@ -191,7 +192,7 @@ pack_r8 (gfc_array_r8 *ret, const gfc_array_r8 *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -236,14 +237,14 @@ pack_r8 (gfc_array_r8 *ret, const gfc_array_r8 *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/generated/parity_l1.c b/libgfortran/generated/parity_l1.c
index af35169..84b1e96 100644
--- a/libgfortran/generated/parity_l1.c
+++ b/libgfortran/generated/parity_l1.c
@@ -80,7 +80,7 @@ parity_l1 (gfc_array_l1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -101,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -108,8 +109,6 @@ parity_l1 (gfc_array_l1 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -132,8 +131,8 @@ parity_l1 (gfc_array_l1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/parity_l16.c b/libgfortran/generated/parity_l16.c
index 58c0a3c..184fdf0 100644
--- a/libgfortran/generated/parity_l16.c
+++ b/libgfortran/generated/parity_l16.c
@@ -80,7 +80,7 @@ parity_l16 (gfc_array_l16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -101,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -108,8 +109,6 @@ parity_l16 (gfc_array_l16 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -132,8 +131,8 @@ parity_l16 (gfc_array_l16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/parity_l2.c b/libgfortran/generated/parity_l2.c
index 71ffff0..5906c2a 100644
--- a/libgfortran/generated/parity_l2.c
+++ b/libgfortran/generated/parity_l2.c
@@ -80,7 +80,7 @@ parity_l2 (gfc_array_l2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -101,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -108,8 +109,6 @@ parity_l2 (gfc_array_l2 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -132,8 +131,8 @@ parity_l2 (gfc_array_l2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/parity_l4.c b/libgfortran/generated/parity_l4.c
index ba9d3fe..b9f183a 100644
--- a/libgfortran/generated/parity_l4.c
+++ b/libgfortran/generated/parity_l4.c
@@ -80,7 +80,7 @@ parity_l4 (gfc_array_l4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -101,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -108,8 +109,6 @@ parity_l4 (gfc_array_l4 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -132,8 +131,8 @@ parity_l4 (gfc_array_l4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/parity_l8.c b/libgfortran/generated/parity_l8.c
index 94166ca..651350b 100644
--- a/libgfortran/generated/parity_l8.c
+++ b/libgfortran/generated/parity_l8.c
@@ -80,7 +80,7 @@ parity_l8 (gfc_array_l8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -101,6 +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);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -108,8 +109,6 @@ parity_l8 (gfc_array_l8 * const restrict retarray,
 	  return;
 
 	}
-      else
-	retarray->data = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -132,8 +131,8 @@ parity_l8 (gfc_array_l8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/generated/product_c10.c b/libgfortran/generated/product_c10.c
index 140aa30..349ab55 100644
--- a/libgfortran/generated/product_c10.c
+++ b/libgfortran/generated/product_c10.c
@@ -79,7 +79,7 @@ product_c10 (gfc_array_c10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_c10 (gfc_array_c10 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_c10 (gfc_array_c10 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_c10 (gfc_array_c10 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_c16.c b/libgfortran/generated/product_c16.c
index d595102..9680b76 100644
--- a/libgfortran/generated/product_c16.c
+++ b/libgfortran/generated/product_c16.c
@@ -79,7 +79,7 @@ product_c16 (gfc_array_c16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_c16 (gfc_array_c16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_c16 (gfc_array_c16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_c16 (gfc_array_c16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_c4.c b/libgfortran/generated/product_c4.c
index 34c1bde2..5e53465 100644
--- a/libgfortran/generated/product_c4.c
+++ b/libgfortran/generated/product_c4.c
@@ -79,7 +79,7 @@ product_c4 (gfc_array_c4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_c4 (gfc_array_c4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_c4 (gfc_array_c4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_c4 (gfc_array_c4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_c8.c b/libgfortran/generated/product_c8.c
index 6e34874..5e5a911 100644
--- a/libgfortran/generated/product_c8.c
+++ b/libgfortran/generated/product_c8.c
@@ -79,7 +79,7 @@ product_c8 (gfc_array_c8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_c8 (gfc_array_c8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_c8 (gfc_array_c8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_c8 (gfc_array_c8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_i1.c b/libgfortran/generated/product_i1.c
index 2e04287..fd19554b 100644
--- a/libgfortran/generated/product_i1.c
+++ b/libgfortran/generated/product_i1.c
@@ -79,7 +79,7 @@ product_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_i1 (gfc_array_i1 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_i16.c b/libgfortran/generated/product_i16.c
index e487ddf..6105413 100644
--- a/libgfortran/generated/product_i16.c
+++ b/libgfortran/generated/product_i16.c
@@ -79,7 +79,7 @@ product_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_i16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_i2.c b/libgfortran/generated/product_i2.c
index b4b0a4c..803bd0c 100644
--- a/libgfortran/generated/product_i2.c
+++ b/libgfortran/generated/product_i2.c
@@ -79,7 +79,7 @@ product_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_i2 (gfc_array_i2 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_i4.c b/libgfortran/generated/product_i4.c
index a0164a1..71f353e 100644
--- a/libgfortran/generated/product_i4.c
+++ b/libgfortran/generated/product_i4.c
@@ -79,7 +79,7 @@ product_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_i4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_i8.c b/libgfortran/generated/product_i8.c
index 64c6487..2422ce6 100644
--- a/libgfortran/generated/product_i8.c
+++ b/libgfortran/generated/product_i8.c
@@ -79,7 +79,7 @@ product_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_i8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_r10.c b/libgfortran/generated/product_r10.c
index 71a70da..6621f9f 100644
--- a/libgfortran/generated/product_r10.c
+++ b/libgfortran/generated/product_r10.c
@@ -79,7 +79,7 @@ product_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_r10 (gfc_array_r10 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_r10 (gfc_array_r10 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_r10 (gfc_array_r10 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_r16.c b/libgfortran/generated/product_r16.c
index 0028ba1..846b5c2 100644
--- a/libgfortran/generated/product_r16.c
+++ b/libgfortran/generated/product_r16.c
@@ -79,7 +79,7 @@ product_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_r16 (gfc_array_r16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_r16 (gfc_array_r16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_r16 (gfc_array_r16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_r4.c b/libgfortran/generated/product_r4.c
index 492980e..2c6feff 100644
--- a/libgfortran/generated/product_r4.c
+++ b/libgfortran/generated/product_r4.c
@@ -79,7 +79,7 @@ product_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_r4 (gfc_array_r4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_r4 (gfc_array_r4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_r4 (gfc_array_r4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/product_r8.c b/libgfortran/generated/product_r8.c
index cf05af1..ddb0215 100644
--- a/libgfortran/generated/product_r8.c
+++ b/libgfortran/generated/product_r8.c
@@ -79,7 +79,7 @@ product_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ product_r8 (gfc_array_r8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ mproduct_r8 (gfc_array_r8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ sproduct_r8 (gfc_array_r8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/reshape_c10.c b/libgfortran/generated/reshape_c10.c
index 44446eb..13dedbc 100644
--- a/libgfortran/generated/reshape_c10.c
+++ b/libgfortran/generated/reshape_c10.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_COMPLEX_10);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_c10 (gfc_array_c10 * const restrict ret,
       rsize *= sizeof (GFC_COMPLEX_10);
       ssize *= sizeof (GFC_COMPLEX_10);
       psize *= sizeof (GFC_COMPLEX_10);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/reshape_c16.c b/libgfortran/generated/reshape_c16.c
index ca588dc..72aba60 100644
--- a/libgfortran/generated/reshape_c16.c
+++ b/libgfortran/generated/reshape_c16.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_COMPLEX_16);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_c16 (gfc_array_c16 * const restrict ret,
       rsize *= sizeof (GFC_COMPLEX_16);
       ssize *= sizeof (GFC_COMPLEX_16);
       psize *= sizeof (GFC_COMPLEX_16);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/reshape_c4.c b/libgfortran/generated/reshape_c4.c
index e16d32c..63f66ec 100644
--- a/libgfortran/generated/reshape_c4.c
+++ b/libgfortran/generated/reshape_c4.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_COMPLEX_4);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_c4 (gfc_array_c4 * const restrict ret,
       rsize *= sizeof (GFC_COMPLEX_4);
       ssize *= sizeof (GFC_COMPLEX_4);
       psize *= sizeof (GFC_COMPLEX_4);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/reshape_c8.c b/libgfortran/generated/reshape_c8.c
index c8da0bc..ab64683 100644
--- a/libgfortran/generated/reshape_c8.c
+++ b/libgfortran/generated/reshape_c8.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_COMPLEX_8);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_c8 (gfc_array_c8 * const restrict ret,
       rsize *= sizeof (GFC_COMPLEX_8);
       ssize *= sizeof (GFC_COMPLEX_8);
       psize *= sizeof (GFC_COMPLEX_8);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/reshape_i16.c b/libgfortran/generated/reshape_i16.c
index 43fbefc..dbf812d 100644
--- a/libgfortran/generated/reshape_i16.c
+++ b/libgfortran/generated/reshape_i16.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_INTEGER_16);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_16 (gfc_array_i16 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_16 (gfc_array_i16 * const restrict ret,
       rsize *= sizeof (GFC_INTEGER_16);
       ssize *= sizeof (GFC_INTEGER_16);
       psize *= sizeof (GFC_INTEGER_16);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/reshape_i4.c b/libgfortran/generated/reshape_i4.c
index 2c136de..a4c83ad 100644
--- a/libgfortran/generated/reshape_i4.c
+++ b/libgfortran/generated/reshape_i4.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_INTEGER_4);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_4 (gfc_array_i4 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_4 (gfc_array_i4 * const restrict ret,
       rsize *= sizeof (GFC_INTEGER_4);
       ssize *= sizeof (GFC_INTEGER_4);
       psize *= sizeof (GFC_INTEGER_4);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/reshape_i8.c b/libgfortran/generated/reshape_i8.c
index c97b747..e7288bb 100644
--- a/libgfortran/generated/reshape_i8.c
+++ b/libgfortran/generated/reshape_i8.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_INTEGER_8);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_8 (gfc_array_i8 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_8 (gfc_array_i8 * const restrict ret,
       rsize *= sizeof (GFC_INTEGER_8);
       ssize *= sizeof (GFC_INTEGER_8);
       psize *= sizeof (GFC_INTEGER_8);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/reshape_r10.c b/libgfortran/generated/reshape_r10.c
index fa3873e..87216f4 100644
--- a/libgfortran/generated/reshape_r10.c
+++ b/libgfortran/generated/reshape_r10.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_REAL_10);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_r10 (gfc_array_r10 * const restrict ret,
       rsize *= sizeof (GFC_REAL_10);
       ssize *= sizeof (GFC_REAL_10);
       psize *= sizeof (GFC_REAL_10);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/reshape_r16.c b/libgfortran/generated/reshape_r16.c
index c2b6556..cb1f7f3 100644
--- a/libgfortran/generated/reshape_r16.c
+++ b/libgfortran/generated/reshape_r16.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_REAL_16);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_r16 (gfc_array_r16 * const restrict ret,
       rsize *= sizeof (GFC_REAL_16);
       ssize *= sizeof (GFC_REAL_16);
       psize *= sizeof (GFC_REAL_16);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/reshape_r4.c b/libgfortran/generated/reshape_r4.c
index 2b859fc..64f3991 100644
--- a/libgfortran/generated/reshape_r4.c
+++ b/libgfortran/generated/reshape_r4.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_REAL_4);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_r4 (gfc_array_r4 * const restrict ret,
       rsize *= sizeof (GFC_REAL_4);
       ssize *= sizeof (GFC_REAL_4);
       psize *= sizeof (GFC_REAL_4);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/reshape_r8.c b/libgfortran/generated/reshape_r8.c
index 49b2352..4b6f4c6 100644
--- a/libgfortran/generated/reshape_r8.c
+++ b/libgfortran/generated/reshape_r8.c
@@ -1,8 +1,8 @@
 /* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -87,7 +87,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -95,7 +95,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -115,7 +115,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
       else
         alloc_size = rs * sizeof (GFC_REAL_8);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -143,7 +143,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -193,7 +193,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -212,7 +212,7 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -258,12 +258,12 @@ reshape_r8 (gfc_array_r8 * const restrict ret,
       rsize *= sizeof (GFC_REAL_8);
       ssize *= sizeof (GFC_REAL_8);
       psize *= sizeof (GFC_REAL_8);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/generated/shape_i16.c b/libgfortran/generated/shape_i16.c
index 802e00a..c42aca9 100644
--- a/libgfortran/generated/shape_i16.c
+++ b/libgfortran/generated/shape_i16.c
@@ -1,8 +1,8 @@
 /* Implementation of the SHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -45,11 +45,11 @@ shape_16 (gfc_array_i16 * const restrict ret,
 
   rank = GFC_DESCRIPTOR_RANK (array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1);
       ret->offset = 0;
-      ret->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * rank);
     }
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
@@ -60,7 +60,7 @@ shape_16 (gfc_array_i16 * const restrict ret,
   for (n = 0; n < rank; n++)
     {
       extent = GFC_DESCRIPTOR_EXTENT(array,n);
-      ret->data[n * stride] = extent > 0 ? extent : 0 ;
+      ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
     }
 }
 
diff --git a/libgfortran/generated/shape_i4.c b/libgfortran/generated/shape_i4.c
index fa2d4eb..3f57399 100644
--- a/libgfortran/generated/shape_i4.c
+++ b/libgfortran/generated/shape_i4.c
@@ -1,8 +1,8 @@
 /* Implementation of the SHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -45,11 +45,11 @@ shape_4 (gfc_array_i4 * const restrict ret,
 
   rank = GFC_DESCRIPTOR_RANK (array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1);
       ret->offset = 0;
-      ret->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * rank);
     }
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
@@ -60,7 +60,7 @@ shape_4 (gfc_array_i4 * const restrict ret,
   for (n = 0; n < rank; n++)
     {
       extent = GFC_DESCRIPTOR_EXTENT(array,n);
-      ret->data[n * stride] = extent > 0 ? extent : 0 ;
+      ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
     }
 }
 
diff --git a/libgfortran/generated/shape_i8.c b/libgfortran/generated/shape_i8.c
index d6664de..49910ac 100644
--- a/libgfortran/generated/shape_i8.c
+++ b/libgfortran/generated/shape_i8.c
@@ -1,8 +1,8 @@
 /* Implementation of the SHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -45,11 +45,11 @@ shape_8 (gfc_array_i8 * const restrict ret,
 
   rank = GFC_DESCRIPTOR_RANK (array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1);
       ret->offset = 0;
-      ret->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
+      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * rank);
     }
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
@@ -60,7 +60,7 @@ shape_8 (gfc_array_i8 * const restrict ret,
   for (n = 0; n < rank; n++)
     {
       extent = GFC_DESCRIPTOR_EXTENT(array,n);
-      ret->data[n * stride] = extent > 0 ? extent : 0 ;
+      ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
     }
 }
 
diff --git a/libgfortran/generated/spread_c10.c b/libgfortran/generated/spread_c10.c
index d8a5baf..fb4efb0 100644
--- a/libgfortran/generated/spread_c10.c
+++ b/libgfortran/generated/spread_c10.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_c10 (gfc_array_c10 *ret, const gfc_array_c10 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_COMPLEX_10));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_10));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_c10 (gfc_array_c10 *ret, const gfc_array_c10 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_c10 (gfc_array_c10 *ret, const GFC_COMPLEX_10 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_10));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_10));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_c10 (gfc_array_c10 *ret, const GFC_COMPLEX_10 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_c16.c b/libgfortran/generated/spread_c16.c
index 0bfba7f..46789ca 100644
--- a/libgfortran/generated/spread_c16.c
+++ b/libgfortran/generated/spread_c16.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_c16 (gfc_array_c16 *ret, const gfc_array_c16 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_COMPLEX_16));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_16));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_c16 (gfc_array_c16 *ret, const gfc_array_c16 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_c16 (gfc_array_c16 *ret, const GFC_COMPLEX_16 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_16));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_16));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_c16 (gfc_array_c16 *ret, const GFC_COMPLEX_16 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_c4.c b/libgfortran/generated/spread_c4.c
index e1a475f..ef91ca5 100644
--- a/libgfortran/generated/spread_c4.c
+++ b/libgfortran/generated/spread_c4.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_c4 (gfc_array_c4 *ret, const gfc_array_c4 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_COMPLEX_4));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_4));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_c4 (gfc_array_c4 *ret, const gfc_array_c4 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_c4 (gfc_array_c4 *ret, const GFC_COMPLEX_4 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_4));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_4));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_c4 (gfc_array_c4 *ret, const GFC_COMPLEX_4 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_c8.c b/libgfortran/generated/spread_c8.c
index a290290..dbcc029 100644
--- a/libgfortran/generated/spread_c8.c
+++ b/libgfortran/generated/spread_c8.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_c8 (gfc_array_c8 *ret, const gfc_array_c8 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_COMPLEX_8));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_COMPLEX_8));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_c8 (gfc_array_c8 *ret, const gfc_array_c8 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_c8 (gfc_array_c8 *ret, const GFC_COMPLEX_8 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_8));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_COMPLEX_8));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_c8 (gfc_array_c8 *ret, const GFC_COMPLEX_8 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_i1.c b/libgfortran/generated/spread_i1.c
index 111c4cc..0e654eb 100644
--- a/libgfortran/generated/spread_i1.c
+++ b/libgfortran/generated/spread_i1.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_i1 (gfc_array_i1 *ret, const gfc_array_i1 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_1));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_1));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_i1 (gfc_array_i1 *ret, const gfc_array_i1 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_i1 (gfc_array_i1 *ret, const GFC_INTEGER_1 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_1));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_1));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_i1 (gfc_array_i1 *ret, const GFC_INTEGER_1 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_i16.c b/libgfortran/generated/spread_i16.c
index 2a4864b..4167651 100644
--- a/libgfortran/generated/spread_i16.c
+++ b/libgfortran/generated/spread_i16.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_i16 (gfc_array_i16 *ret, const gfc_array_i16 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_16));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_16));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_i16 (gfc_array_i16 *ret, const gfc_array_i16 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_i16 (gfc_array_i16 *ret, const GFC_INTEGER_16 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_16));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_16));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_i16 (gfc_array_i16 *ret, const GFC_INTEGER_16 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_i2.c b/libgfortran/generated/spread_i2.c
index 5a5d870..e65b942 100644
--- a/libgfortran/generated/spread_i2.c
+++ b/libgfortran/generated/spread_i2.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_i2 (gfc_array_i2 *ret, const gfc_array_i2 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_2));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_2));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_i2 (gfc_array_i2 *ret, const gfc_array_i2 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_i2 (gfc_array_i2 *ret, const GFC_INTEGER_2 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_2));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_2));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_i2 (gfc_array_i2 *ret, const GFC_INTEGER_2 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_i4.c b/libgfortran/generated/spread_i4.c
index e990408..599da3f 100644
--- a/libgfortran/generated/spread_i4.c
+++ b/libgfortran/generated/spread_i4.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_i4 (gfc_array_i4 *ret, const gfc_array_i4 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_4));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_4));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_i4 (gfc_array_i4 *ret, const gfc_array_i4 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_i4 (gfc_array_i4 *ret, const GFC_INTEGER_4 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_4));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_4));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_i4 (gfc_array_i4 *ret, const GFC_INTEGER_4 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_i8.c b/libgfortran/generated/spread_i8.c
index 1e3b305..ddb8163 100644
--- a/libgfortran/generated/spread_i8.c
+++ b/libgfortran/generated/spread_i8.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_i8 (gfc_array_i8 *ret, const gfc_array_i8 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_INTEGER_8));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_INTEGER_8));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_i8 (gfc_array_i8 *ret, const gfc_array_i8 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_i8 (gfc_array_i8 *ret, const GFC_INTEGER_8 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_8));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_INTEGER_8));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_i8 (gfc_array_i8 *ret, const GFC_INTEGER_8 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_r10.c b/libgfortran/generated/spread_r10.c
index ef86bc5..d023a27 100644
--- a/libgfortran/generated/spread_r10.c
+++ b/libgfortran/generated/spread_r10.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_r10 (gfc_array_r10 *ret, const gfc_array_r10 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_REAL_10));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_10));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_r10 (gfc_array_r10 *ret, const gfc_array_r10 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_r10 (gfc_array_r10 *ret, const GFC_REAL_10 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_REAL_10));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_10));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_r10 (gfc_array_r10 *ret, const GFC_REAL_10 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_r16.c b/libgfortran/generated/spread_r16.c
index 9678e87..17bffbe 100644
--- a/libgfortran/generated/spread_r16.c
+++ b/libgfortran/generated/spread_r16.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_r16 (gfc_array_r16 *ret, const gfc_array_r16 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_REAL_16));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_16));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_r16 (gfc_array_r16 *ret, const gfc_array_r16 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_r16 (gfc_array_r16 *ret, const GFC_REAL_16 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_REAL_16));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_16));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_r16 (gfc_array_r16 *ret, const GFC_REAL_16 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_r4.c b/libgfortran/generated/spread_r4.c
index fac0900..656205f 100644
--- a/libgfortran/generated/spread_r4.c
+++ b/libgfortran/generated/spread_r4.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_r4 (gfc_array_r4 *ret, const gfc_array_r4 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_REAL_4));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_4));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_r4 (gfc_array_r4 *ret, const gfc_array_r4 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_r4 (gfc_array_r4 *ret, const GFC_REAL_4 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_REAL_4));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_4));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_r4 (gfc_array_r4 *ret, const GFC_REAL_4 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/spread_r8.c b/libgfortran/generated/spread_r8.c
index 0dd9e7b..2c77f1c 100644
--- a/libgfortran/generated/spread_r8.c
+++ b/libgfortran/generated/spread_r8.c
@@ -1,9 +1,9 @@
 /* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -67,7 +67,7 @@ spread_r8 (gfc_array_r8 *ret, const gfc_array_r8 *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -102,7 +102,7 @@ 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->data = internal_malloc_size (rs * sizeof(GFC_REAL_8));
+      ret->base_addr = internal_malloc_size (rs * sizeof(GFC_REAL_8));
       if (rs <= 0)
         return;
     }
@@ -181,8 +181,8 @@ spread_r8 (gfc_array_r8 *ret, const gfc_array_r8 *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -242,9 +242,9 @@ spread_scalar_r8 (gfc_array_r8 *ret, const GFC_REAL_8 *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof (GFC_REAL_8));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof (GFC_REAL_8));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -255,7 +255,7 @@ spread_scalar_r8 (gfc_array_r8 *ret, const GFC_REAL_8 *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/generated/sum_c10.c b/libgfortran/generated/sum_c10.c
index b982bfe..2a289f4 100644
--- a/libgfortran/generated/sum_c10.c
+++ b/libgfortran/generated/sum_c10.c
@@ -79,7 +79,7 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_c10 (gfc_array_c10 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_c10 (gfc_array_c10 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_c10 (gfc_array_c10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_c10 (gfc_array_c10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_c10 (gfc_array_c10 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_c16.c b/libgfortran/generated/sum_c16.c
index 0bf2b69..d87e086 100644
--- a/libgfortran/generated/sum_c16.c
+++ b/libgfortran/generated/sum_c16.c
@@ -79,7 +79,7 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_c16 (gfc_array_c16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_c16 (gfc_array_c16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_c16 (gfc_array_c16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_c16 (gfc_array_c16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_c16 (gfc_array_c16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_c4.c b/libgfortran/generated/sum_c4.c
index a34e63c..7964eb9 100644
--- a/libgfortran/generated/sum_c4.c
+++ b/libgfortran/generated/sum_c4.c
@@ -79,7 +79,7 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_c4 (gfc_array_c4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_c4 (gfc_array_c4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_c4 (gfc_array_c4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_c4 (gfc_array_c4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_c4 (gfc_array_c4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_c8.c b/libgfortran/generated/sum_c8.c
index 42dea7b..2fd6782 100644
--- a/libgfortran/generated/sum_c8.c
+++ b/libgfortran/generated/sum_c8.c
@@ -79,7 +79,7 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_c8 (gfc_array_c8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_c8 (gfc_array_c8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_c8 (gfc_array_c8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_c8 (gfc_array_c8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_c8 (gfc_array_c8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_i1.c b/libgfortran/generated/sum_i1.c
index 4eb6d64..c746e07 100644
--- a/libgfortran/generated/sum_i1.c
+++ b/libgfortran/generated/sum_i1.c
@@ -79,7 +79,7 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_i1 (gfc_array_i1 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_i1 (gfc_array_i1 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_i1 (gfc_array_i1 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_i1 (gfc_array_i1 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_i16.c b/libgfortran/generated/sum_i16.c
index 8e2c7b3..02d6cc8 100644
--- a/libgfortran/generated/sum_i16.c
+++ b/libgfortran/generated/sum_i16.c
@@ -79,7 +79,7 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_i16 (gfc_array_i16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_i16 (gfc_array_i16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_i16 (gfc_array_i16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_i16 (gfc_array_i16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_i2.c b/libgfortran/generated/sum_i2.c
index 12ef64d3..5e6d3b9 100644
--- a/libgfortran/generated/sum_i2.c
+++ b/libgfortran/generated/sum_i2.c
@@ -79,7 +79,7 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_i2 (gfc_array_i2 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_i2 (gfc_array_i2 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_i2 (gfc_array_i2 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_i2 (gfc_array_i2 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_i4.c b/libgfortran/generated/sum_i4.c
index 645ef43..e199544 100644
--- a/libgfortran/generated/sum_i4.c
+++ b/libgfortran/generated/sum_i4.c
@@ -79,7 +79,7 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_i4 (gfc_array_i4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_i4 (gfc_array_i4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_i4 (gfc_array_i4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_i4 (gfc_array_i4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_i8.c b/libgfortran/generated/sum_i8.c
index adb29b5..68e8539 100644
--- a/libgfortran/generated/sum_i8.c
+++ b/libgfortran/generated/sum_i8.c
@@ -79,7 +79,7 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_i8 (gfc_array_i8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_i8 (gfc_array_i8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_i8 (gfc_array_i8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_i8 (gfc_array_i8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_r10.c b/libgfortran/generated/sum_r10.c
index 9f588a5..42f676e 100644
--- a/libgfortran/generated/sum_r10.c
+++ b/libgfortran/generated/sum_r10.c
@@ -79,7 +79,7 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_r10 (gfc_array_r10 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_r10 (gfc_array_r10 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_r10 (gfc_array_r10 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_r10 (gfc_array_r10 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_r10 (gfc_array_r10 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_r16.c b/libgfortran/generated/sum_r16.c
index 292e66f..ca98de1 100644
--- a/libgfortran/generated/sum_r16.c
+++ b/libgfortran/generated/sum_r16.c
@@ -79,7 +79,7 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_r16 (gfc_array_r16 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_r16 (gfc_array_r16 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_r16 (gfc_array_r16 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_r16 (gfc_array_r16 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_r16 (gfc_array_r16 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_r4.c b/libgfortran/generated/sum_r4.c
index 8fd563f..863191a 100644
--- a/libgfortran/generated/sum_r4.c
+++ b/libgfortran/generated/sum_r4.c
@@ -79,7 +79,7 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_r4 (gfc_array_r4 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_r4 (gfc_array_r4 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_r4 (gfc_array_r4 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_r4 (gfc_array_r4 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_r4 (gfc_array_r4 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/sum_r8.c b/libgfortran/generated/sum_r8.c
index e583980..45de9f4 100644
--- a/libgfortran/generated/sum_r8.c
+++ b/libgfortran/generated/sum_r8.c
@@ -79,7 +79,7 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -130,8 +130,8 @@ sum_r8 (gfc_array_r8 * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -221,7 +221,7 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -257,7 +257,7 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -285,7 +285,7 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -310,8 +310,8 @@ msum_r8 (gfc_array_r8 * const restrict retarray,
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -417,7 +417,7 @@ ssum_r8 (gfc_array_r8 * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -445,7 +445,7 @@ ssum_r8 (gfc_array_r8 * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -477,7 +477,7 @@ ssum_r8 (gfc_array_r8 * const restrict retarray,
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/generated/transpose_c10.c b/libgfortran/generated/transpose_c10.c
index e740d12..f863688 100644
--- a/libgfortran/generated/transpose_c10.c
+++ b/libgfortran/generated/transpose_c10.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_c10 (gfc_array_c10 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_10) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_c10 (gfc_array_c10 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/transpose_c16.c b/libgfortran/generated/transpose_c16.c
index 31115bd..af0b43f 100644
--- a/libgfortran/generated/transpose_c16.c
+++ b/libgfortran/generated/transpose_c16.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_c16 (gfc_array_c16 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_16) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_c16 (gfc_array_c16 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/transpose_c4.c b/libgfortran/generated/transpose_c4.c
index a63f62c..81e1584 100644
--- a/libgfortran/generated/transpose_c4.c
+++ b/libgfortran/generated/transpose_c4.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_c4 (gfc_array_c4 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_4) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_c4 (gfc_array_c4 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/transpose_c8.c b/libgfortran/generated/transpose_c8.c
index 8322394..b523bb0 100644
--- a/libgfortran/generated/transpose_c8.c
+++ b/libgfortran/generated/transpose_c8.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_c8 (gfc_array_c8 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_COMPLEX_8) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_c8 (gfc_array_c8 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/transpose_i16.c b/libgfortran/generated/transpose_i16.c
index f8cfd82..5f15534 100644
--- a/libgfortran/generated/transpose_i16.c
+++ b/libgfortran/generated/transpose_i16.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_i16 (gfc_array_i16 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_INTEGER_16) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_16) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_i16 (gfc_array_i16 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/transpose_i4.c b/libgfortran/generated/transpose_i4.c
index 9b15e47..adfd0ad 100644
--- a/libgfortran/generated/transpose_i4.c
+++ b/libgfortran/generated/transpose_i4.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_i4 (gfc_array_i4 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_INTEGER_4) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_4) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_i4 (gfc_array_i4 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/transpose_i8.c b/libgfortran/generated/transpose_i8.c
index ddf772b..07b80c9 100644
--- a/libgfortran/generated/transpose_i8.c
+++ b/libgfortran/generated/transpose_i8.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_i8 (gfc_array_i8 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_INTEGER_8) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_INTEGER_8) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_i8 (gfc_array_i8 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/transpose_r10.c b/libgfortran/generated/transpose_r10.c
index 2b2e02d..8179688 100644
--- a/libgfortran/generated/transpose_r10.c
+++ b/libgfortran/generated/transpose_r10.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_r10 (gfc_array_r10 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_REAL_10) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_10) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_r10 (gfc_array_r10 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/transpose_r16.c b/libgfortran/generated/transpose_r16.c
index 4d2e406..b1f7b41 100644
--- a/libgfortran/generated/transpose_r16.c
+++ b/libgfortran/generated/transpose_r16.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_r16 (gfc_array_r16 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_REAL_16) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_16) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_r16 (gfc_array_r16 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/transpose_r4.c b/libgfortran/generated/transpose_r4.c
index 1748c1d..8c854cc 100644
--- a/libgfortran/generated/transpose_r4.c
+++ b/libgfortran/generated/transpose_r4.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_r4 (gfc_array_r4 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_REAL_4) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_4) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_r4 (gfc_array_r4 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/transpose_r8.c b/libgfortran/generated/transpose_r8.c
index 09054b61..f60a69e 100644
--- a/libgfortran/generated/transpose_r8.c
+++ b/libgfortran/generated/transpose_r8.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -49,7 +49,7 @@ transpose_r8 (gfc_array_r8 * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof (GFC_REAL_8) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof (GFC_REAL_8) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -94,8 +94,8 @@ transpose_r8 (gfc_array_r8 * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/generated/unpack_c10.c b/libgfortran/generated/unpack_c10.c
index 9b89a5b..150509d 100644
--- a/libgfortran/generated/unpack_c10.c
+++ b/libgfortran/generated/unpack_c10.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_c10 (gfc_array_c10 *ret, const gfc_array_c10 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_c10 (gfc_array_c10 *ret, const gfc_array_c10 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_c10 (gfc_array_c10 *ret, const gfc_array_c10 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_10));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_10));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_c10 (gfc_array_c10 *ret, const gfc_array_c10 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_c10 (gfc_array_c10 *ret, const gfc_array_c10 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_c10 (gfc_array_c10 *ret, const gfc_array_c10 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_c10 (gfc_array_c10 *ret, const gfc_array_c10 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_10));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_10));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_c10 (gfc_array_c10 *ret, const gfc_array_c10 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_c16.c b/libgfortran/generated/unpack_c16.c
index 2d9931f..f33830d 100644
--- a/libgfortran/generated/unpack_c16.c
+++ b/libgfortran/generated/unpack_c16.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_c16 (gfc_array_c16 *ret, const gfc_array_c16 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_c16 (gfc_array_c16 *ret, const gfc_array_c16 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_c16 (gfc_array_c16 *ret, const gfc_array_c16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_16));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_16));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_c16 (gfc_array_c16 *ret, const gfc_array_c16 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_c16 (gfc_array_c16 *ret, const gfc_array_c16 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_c16 (gfc_array_c16 *ret, const gfc_array_c16 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_c16 (gfc_array_c16 *ret, const gfc_array_c16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_16));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_16));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_c16 (gfc_array_c16 *ret, const gfc_array_c16 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_c4.c b/libgfortran/generated/unpack_c4.c
index 116f213..2106202 100644
--- a/libgfortran/generated/unpack_c4.c
+++ b/libgfortran/generated/unpack_c4.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_c4 (gfc_array_c4 *ret, const gfc_array_c4 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_c4 (gfc_array_c4 *ret, const gfc_array_c4 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_c4 (gfc_array_c4 *ret, const gfc_array_c4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_4));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_4));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_c4 (gfc_array_c4 *ret, const gfc_array_c4 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_c4 (gfc_array_c4 *ret, const gfc_array_c4 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_c4 (gfc_array_c4 *ret, const gfc_array_c4 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_c4 (gfc_array_c4 *ret, const gfc_array_c4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_4));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_4));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_c4 (gfc_array_c4 *ret, const gfc_array_c4 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_c8.c b/libgfortran/generated/unpack_c8.c
index 7298eec..c8903cf 100644
--- a/libgfortran/generated/unpack_c8.c
+++ b/libgfortran/generated/unpack_c8.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_c8 (gfc_array_c8 *ret, const gfc_array_c8 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_c8 (gfc_array_c8 *ret, const gfc_array_c8 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_c8 (gfc_array_c8 *ret, const gfc_array_c8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_8));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_8));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_c8 (gfc_array_c8 *ret, const gfc_array_c8 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_c8 (gfc_array_c8 *ret, const gfc_array_c8 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_c8 (gfc_array_c8 *ret, const gfc_array_c8 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_c8 (gfc_array_c8 *ret, const gfc_array_c8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_COMPLEX_8));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_COMPLEX_8));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_c8 (gfc_array_c8 *ret, const gfc_array_c8 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_i1.c b/libgfortran/generated/unpack_i1.c
index f5dcb93..517474e 100644
--- a/libgfortran/generated/unpack_i1.c
+++ b/libgfortran/generated/unpack_i1.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_i1 (gfc_array_i1 *ret, const gfc_array_i1 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_i1 (gfc_array_i1 *ret, const gfc_array_i1 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_i1 (gfc_array_i1 *ret, const gfc_array_i1 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_1));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_1));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_i1 (gfc_array_i1 *ret, const gfc_array_i1 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_i1 (gfc_array_i1 *ret, const gfc_array_i1 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_i1 (gfc_array_i1 *ret, const gfc_array_i1 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_i1 (gfc_array_i1 *ret, const gfc_array_i1 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_1));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_1));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_i1 (gfc_array_i1 *ret, const gfc_array_i1 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_i16.c b/libgfortran/generated/unpack_i16.c
index 77920ea..c21a61e 100644
--- a/libgfortran/generated/unpack_i16.c
+++ b/libgfortran/generated/unpack_i16.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_i16 (gfc_array_i16 *ret, const gfc_array_i16 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_i16 (gfc_array_i16 *ret, const gfc_array_i16 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_i16 (gfc_array_i16 *ret, const gfc_array_i16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_16));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_16));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_i16 (gfc_array_i16 *ret, const gfc_array_i16 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_i16 (gfc_array_i16 *ret, const gfc_array_i16 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_i16 (gfc_array_i16 *ret, const gfc_array_i16 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_i16 (gfc_array_i16 *ret, const gfc_array_i16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_16));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_16));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_i16 (gfc_array_i16 *ret, const gfc_array_i16 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_i2.c b/libgfortran/generated/unpack_i2.c
index c7257bb..d77b049 100644
--- a/libgfortran/generated/unpack_i2.c
+++ b/libgfortran/generated/unpack_i2.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_i2 (gfc_array_i2 *ret, const gfc_array_i2 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_i2 (gfc_array_i2 *ret, const gfc_array_i2 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_i2 (gfc_array_i2 *ret, const gfc_array_i2 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_2));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_2));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_i2 (gfc_array_i2 *ret, const gfc_array_i2 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_i2 (gfc_array_i2 *ret, const gfc_array_i2 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_i2 (gfc_array_i2 *ret, const gfc_array_i2 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_i2 (gfc_array_i2 *ret, const gfc_array_i2 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_2));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_2));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_i2 (gfc_array_i2 *ret, const gfc_array_i2 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_i4.c b/libgfortran/generated/unpack_i4.c
index e3cdde6..95ce538 100644
--- a/libgfortran/generated/unpack_i4.c
+++ b/libgfortran/generated/unpack_i4.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_i4 (gfc_array_i4 *ret, const gfc_array_i4 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_i4 (gfc_array_i4 *ret, const gfc_array_i4 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_i4 (gfc_array_i4 *ret, const gfc_array_i4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_4));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_4));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_i4 (gfc_array_i4 *ret, const gfc_array_i4 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_i4 (gfc_array_i4 *ret, const gfc_array_i4 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_i4 (gfc_array_i4 *ret, const gfc_array_i4 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_i4 (gfc_array_i4 *ret, const gfc_array_i4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_4));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_4));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_i4 (gfc_array_i4 *ret, const gfc_array_i4 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_i8.c b/libgfortran/generated/unpack_i8.c
index 2f72064..59412d3 100644
--- a/libgfortran/generated/unpack_i8.c
+++ b/libgfortran/generated/unpack_i8.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_i8 (gfc_array_i8 *ret, const gfc_array_i8 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_i8 (gfc_array_i8 *ret, const gfc_array_i8 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_i8 (gfc_array_i8 *ret, const gfc_array_i8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_8));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_8));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_i8 (gfc_array_i8 *ret, const gfc_array_i8 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_i8 (gfc_array_i8 *ret, const gfc_array_i8 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_i8 (gfc_array_i8 *ret, const gfc_array_i8 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_i8 (gfc_array_i8 *ret, const gfc_array_i8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_INTEGER_8));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_INTEGER_8));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_i8 (gfc_array_i8 *ret, const gfc_array_i8 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_r10.c b/libgfortran/generated/unpack_r10.c
index 796df2e..34c2262 100644
--- a/libgfortran/generated/unpack_r10.c
+++ b/libgfortran/generated/unpack_r10.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_r10 (gfc_array_r10 *ret, const gfc_array_r10 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_r10 (gfc_array_r10 *ret, const gfc_array_r10 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_r10 (gfc_array_r10 *ret, const gfc_array_r10 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_10));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_10));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_r10 (gfc_array_r10 *ret, const gfc_array_r10 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_r10 (gfc_array_r10 *ret, const gfc_array_r10 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_r10 (gfc_array_r10 *ret, const gfc_array_r10 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_r10 (gfc_array_r10 *ret, const gfc_array_r10 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_10));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_10));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_r10 (gfc_array_r10 *ret, const gfc_array_r10 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_r16.c b/libgfortran/generated/unpack_r16.c
index b25d286..c50dc71 100644
--- a/libgfortran/generated/unpack_r16.c
+++ b/libgfortran/generated/unpack_r16.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_r16 (gfc_array_r16 *ret, const gfc_array_r16 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_r16 (gfc_array_r16 *ret, const gfc_array_r16 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_r16 (gfc_array_r16 *ret, const gfc_array_r16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_16));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_16));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_r16 (gfc_array_r16 *ret, const gfc_array_r16 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_r16 (gfc_array_r16 *ret, const gfc_array_r16 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_r16 (gfc_array_r16 *ret, const gfc_array_r16 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_r16 (gfc_array_r16 *ret, const gfc_array_r16 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_16));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_16));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_r16 (gfc_array_r16 *ret, const gfc_array_r16 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_r4.c b/libgfortran/generated/unpack_r4.c
index f4b763f..3e022b9 100644
--- a/libgfortran/generated/unpack_r4.c
+++ b/libgfortran/generated/unpack_r4.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_r4 (gfc_array_r4 *ret, const gfc_array_r4 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_r4 (gfc_array_r4 *ret, const gfc_array_r4 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_r4 (gfc_array_r4 *ret, const gfc_array_r4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_4));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_4));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_r4 (gfc_array_r4 *ret, const gfc_array_r4 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_r4 (gfc_array_r4 *ret, const gfc_array_r4 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_r4 (gfc_array_r4 *ret, const gfc_array_r4 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_r4 (gfc_array_r4 *ret, const gfc_array_r4 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_4));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_4));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_r4 (gfc_array_r4 *ret, const gfc_array_r4 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/generated/unpack_r8.c b/libgfortran/generated/unpack_r8.c
index dc9b4d3..0d343cd 100644
--- a/libgfortran/generated/unpack_r8.c
+++ b/libgfortran/generated/unpack_r8.c
@@ -1,9 +1,9 @@
 /* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -61,7 +61,7 @@ unpack0_r8 (gfc_array_r8 *ret, const gfc_array_r8 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -81,7 +81,7 @@ unpack0_r8 (gfc_array_r8 *ret, const gfc_array_r8 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -99,7 +99,7 @@ unpack0_r8 (gfc_array_r8 *ret, const gfc_array_r8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_8));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_8));
     }
   else
     {
@@ -127,8 +127,8 @@ unpack0_r8 (gfc_array_r8 *ret, const gfc_array_r8 *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -205,7 +205,7 @@ unpack1_r8 (gfc_array_r8 *ret, const gfc_array_r8 *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -225,7 +225,7 @@ unpack1_r8 (gfc_array_r8 *ret, const gfc_array_r8 *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -244,7 +244,7 @@ unpack1_r8 (gfc_array_r8 *ret, const gfc_array_r8 *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof (GFC_REAL_8));
+      ret->base_addr = internal_malloc_size (rs * sizeof (GFC_REAL_8));
     }
   else
     {
@@ -276,9 +276,9 @@ unpack1_r8 (gfc_array_r8 *ret, const gfc_array_r8 *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/intrinsics/cshift0.c b/libgfortran/intrinsics/cshift0.c
index 026dd1a..5da73d4 100644
--- a/libgfortran/intrinsics/cshift0.c
+++ b/libgfortran/intrinsics/cshift0.c
@@ -1,5 +1,5 @@
 /* Generic implementation of the CSHIFT intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2010 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2010, 2012 Free Software Foundation, Inc.
    Contributed by Feng Wang <wf_cs@yahoo.com>
 
 This file is part of the GNU Fortran runtime library (libgfortran).
@@ -58,7 +58,7 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
 
   arraysize = size0 ((array_t *) array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
@@ -80,7 +80,7 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
         }
 
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -199,7 +199,7 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
       break;
 
     case sizeof (GFC_INTEGER_2):
-      if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(array->data))
+      if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(array->base_addr))
 	break;
       else
 	{
@@ -209,7 +209,7 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
 	}
 
     case sizeof (GFC_INTEGER_4):
-      if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(array->data))
+      if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(array->base_addr))
 	break;
       else
 	{
@@ -219,7 +219,7 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
 	}
 
     case sizeof (GFC_INTEGER_8):
-      if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(array->data))
+      if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(array->base_addr))
 	{
 	  /* Let's try to use the complex routines.  First, a sanity
 	     check that the sizes match; this should be optimized to
@@ -227,7 +227,8 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
 	  if (sizeof(GFC_INTEGER_8) != sizeof(GFC_COMPLEX_4))
 	    break;
 
-	  if (GFC_UNALIGNED_C4(ret->data) || GFC_UNALIGNED_C4(array->data))
+	  if (GFC_UNALIGNED_C4(ret->base_addr)
+	      || GFC_UNALIGNED_C4(array->base_addr))
 	    break;
 
 	  cshift0_c4 ((gfc_array_c4 *) ret, (gfc_array_c4 *) array, shift,
@@ -243,7 +244,8 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
 
 #ifdef HAVE_GFC_INTEGER_16
     case sizeof (GFC_INTEGER_16):
-      if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(array->data))
+      if (GFC_UNALIGNED_16(ret->base_addr)
+	  || GFC_UNALIGNED_16(array->base_addr))
 	{
 	  /* Let's try to use the complex routines.  First, a sanity
 	     check that the sizes match; this should be optimized to
@@ -251,7 +253,8 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
 	  if (sizeof(GFC_INTEGER_16) != sizeof(GFC_COMPLEX_8))
 	    break;
 
-	  if (GFC_UNALIGNED_C8(ret->data) || GFC_UNALIGNED_C8(array->data))
+	  if (GFC_UNALIGNED_C8(ret->base_addr)
+	      || GFC_UNALIGNED_C8(array->base_addr))
 	    break;
 
 	  cshift0_c8 ((gfc_array_c8 *) ret, (gfc_array_c8 *) array, shift,
@@ -267,7 +270,8 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
 #else
     case sizeof (GFC_COMPLEX_8):
 
-      if (GFC_UNALIGNED_C8(ret->data) || GFC_UNALIGNED_C8(array->data))
+      if (GFC_UNALIGNED_C8(ret->base_addr)
+	  || GFC_UNALIGNED_C8(array->base_addr))
 	break;
       else
 	{
@@ -323,8 +327,8 @@ cshift0 (gfc_array_char * ret, const gfc_array_char * array,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/intrinsics/date_and_time.c b/libgfortran/intrinsics/date_and_time.c
index 3c38636..c785f84 100644
--- a/libgfortran/intrinsics/date_and_time.c
+++ b/libgfortran/intrinsics/date_and_time.c
@@ -1,5 +1,5 @@
 /* Implementation of the DATE_AND_TIME intrinsic.
-   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011
+   Copyright (C) 2003, 2004, 2005, 2006, 2007, 2009, 2010, 2011, 2012
    Free Software Foundation, Inc.
    Contributed by Steven Bosscher.
 
@@ -208,14 +208,14 @@ date_and_time (char *__date, char *__time, char *__zone,
       /* Cope with different type kinds.  */
       if (elt_size == 4)
         {
-	  GFC_INTEGER_4 *vptr4 = __values->data;
+	  GFC_INTEGER_4 *vptr4 = __values->base_addr;
 
 	  for (i = 0; i < VALUES_SIZE; i++, vptr4 += delta)
 	    *vptr4 = values[i];
 	}
       else if (elt_size == 8)
         {
-	  GFC_INTEGER_8 *vptr8 = (GFC_INTEGER_8 *)__values->data;
+	  GFC_INTEGER_8 *vptr8 = (GFC_INTEGER_8 *)__values->base_addr;
 
 	  for (i = 0; i < VALUES_SIZE; i++, vptr8 += delta)
 	    {
@@ -271,7 +271,7 @@ secnds (GFC_REAL_4 *x)
 
   /* Make the INTEGER*4 array for passing to date_and_time.  */
   gfc_array_i4 *avalues = internal_malloc_size (sizeof (gfc_array_i4));
-  avalues->data = &values[0];
+  avalues->base_addr = &values[0];
   GFC_DESCRIPTOR_DTYPE (avalues) = ((BT_REAL << GFC_DTYPE_TYPE_SHIFT)
 				        & GFC_DTYPE_TYPE_MASK) +
 				    (4 << GFC_DTYPE_SIZE_SHIFT);
@@ -336,7 +336,7 @@ itime_i4 (gfc_array_i4 *__values)
   if (delta == 0)
     delta = 1;
 
-  vptr = __values->data;
+  vptr = __values->base_addr;
   for (i = 0; i < 3; i++, vptr += delta)
     *vptr = x[i];
 }
@@ -362,7 +362,7 @@ itime_i8 (gfc_array_i8 *__values)
   if (delta == 0)
     delta = 1;
 
-  vptr = __values->data;
+  vptr = __values->base_addr;
   for (i = 0; i < 3; i++, vptr += delta)
     *vptr = x[i];
 }
@@ -414,7 +414,7 @@ idate_i4 (gfc_array_i4 *__values)
   if (delta == 0)
     delta = 1;
 
-  vptr = __values->data;
+  vptr = __values->base_addr;
   for (i = 0; i < 3; i++, vptr += delta)
     *vptr = x[i];
 }
@@ -440,7 +440,7 @@ idate_i8 (gfc_array_i8 *__values)
   if (delta == 0)
     delta = 1;
 
-  vptr = __values->data;
+  vptr = __values->base_addr;
   for (i = 0; i < 3; i++, vptr += delta)
     *vptr = x[i];
 }
@@ -504,7 +504,7 @@ gmtime_i4 (GFC_INTEGER_4 * t, gfc_array_i4 * tarray)
   if (delta == 0)
     delta = 1;
 
-  vptr = tarray->data;
+  vptr = tarray->base_addr;
   for (i = 0; i < 9; i++, vptr += delta)
     *vptr = x[i];
 }
@@ -531,7 +531,7 @@ gmtime_i8 (GFC_INTEGER_8 * t, gfc_array_i8 * tarray)
   if (delta == 0)
     delta = 1;
 
-  vptr = tarray->data;
+  vptr = tarray->base_addr;
   for (i = 0; i < 9; i++, vptr += delta)
     *vptr = x[i];
 }
@@ -596,7 +596,7 @@ ltime_i4 (GFC_INTEGER_4 * t, gfc_array_i4 * tarray)
   if (delta == 0)
     delta = 1;
 
-  vptr = tarray->data;
+  vptr = tarray->base_addr;
   for (i = 0; i < 9; i++, vptr += delta)
     *vptr = x[i];
 }
@@ -623,7 +623,7 @@ ltime_i8 (GFC_INTEGER_8 * t, gfc_array_i8 * tarray)
   if (delta == 0)
     delta = 1;
 
-  vptr = tarray->data;
+  vptr = tarray->base_addr;
   for (i = 0; i < 9; i++, vptr += delta)
     *vptr = x[i];
 }
diff --git a/libgfortran/intrinsics/dtime.c b/libgfortran/intrinsics/dtime.c
index e36e1f1..b5dc91e 100644
--- a/libgfortran/intrinsics/dtime.c
+++ b/libgfortran/intrinsics/dtime.c
@@ -1,6 +1,6 @@
 /* Implementation of the dtime intrinsic.
-   Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011 Free Software
-   Foundation, Inc.
+   Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011, 2012
+   Free Software Foundation, Inc.
 
 This file is part of the GNU Fortran runtime library (libgfortran).
 
@@ -65,7 +65,7 @@ dtime_sub (gfc_array_r4 *t, GFC_REAL_4 *result)
       tt = -1;
     }
 
-  tp = t->data;
+  tp = t->base_addr;
 
   *tp = tu;
   tp += GFC_DESCRIPTOR_STRIDE(t,0);
diff --git a/libgfortran/intrinsics/eoshift0.c b/libgfortran/intrinsics/eoshift0.c
index 6ceed20..8b7dd0a 100644
--- a/libgfortran/intrinsics/eoshift0.c
+++ b/libgfortran/intrinsics/eoshift0.c
@@ -1,8 +1,8 @@
 /* Generic implementation of the EOSHIFT intrinsic
-   Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -64,7 +64,7 @@ eoshift0 (gfc_array_char * ret, const gfc_array_char * array,
 
   arraysize = size0 ((array_t *) array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
@@ -87,7 +87,7 @@ eoshift0 (gfc_array_char * ret, const gfc_array_char * array,
         }
 
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -134,8 +134,8 @@ eoshift0 (gfc_array_char * ret, const gfc_array_char * array,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   if ((shift >= 0 ? shift : -shift) > len)
     {
diff --git a/libgfortran/intrinsics/eoshift2.c b/libgfortran/intrinsics/eoshift2.c
index b4f8278..cd2a827 100644
--- a/libgfortran/intrinsics/eoshift2.c
+++ b/libgfortran/intrinsics/eoshift2.c
@@ -1,8 +1,8 @@
 /* Generic implementation of the EOSHIFT intrinsic
-   Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -71,7 +71,7 @@ eoshift2 (gfc_array_char *ret, const gfc_array_char *array,
 
   arraysize = size0 ((array_t *) array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
@@ -92,7 +92,7 @@ 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->data = internal_malloc_size (size * arraysize);
+	  ret->base_addr = internal_malloc_size (size * arraysize);
 
         }
     }
@@ -149,8 +149,8 @@ eoshift2 (gfc_array_char *ret, const gfc_array_char *array,
   rstride0 = rstride[0];
   sstride0 = sstride[0];
   bstride0 = bstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   if ((shift >= 0 ? shift : -shift ) > len)
     {
@@ -166,7 +166,7 @@ eoshift2 (gfc_array_char *ret, const gfc_array_char *array,
     }
   
   if (bound)
-    bptr = bound->data;
+    bptr = bound->base_addr;
   else
     bptr = NULL;
 
diff --git a/libgfortran/intrinsics/etime.c b/libgfortran/intrinsics/etime.c
index d90bc30..96c6d71 100644
--- a/libgfortran/intrinsics/etime.c
+++ b/libgfortran/intrinsics/etime.c
@@ -1,6 +1,6 @@
 /* Implementation of the ETIME intrinsic.
-   Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011 Free Software
-   Foundation, Inc.
+   Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011, 2012
+   Free Software Foundation, Inc.
    Contributed by Steven G. Kargl <kargls@comcast.net>.
 
 This file is part of the GNU Fortran runtime library (libgfortran).
@@ -52,7 +52,7 @@ etime_sub (gfc_array_r4 *t, GFC_REAL_4 *result)
       tt = (GFC_REAL_4)-1.0;
     }
 
-  tp = t->data;
+  tp = t->base_addr;
 
   *tp = tu;
   tp += GFC_DESCRIPTOR_STRIDE(t,0);
diff --git a/libgfortran/intrinsics/iso_c_binding.c b/libgfortran/intrinsics/iso_c_binding.c
index 327ad51..cab7feb 100644
--- a/libgfortran/intrinsics/iso_c_binding.c
+++ b/libgfortran/intrinsics/iso_c_binding.c
@@ -1,8 +1,8 @@
 /* Implementation of the ISO_C_BINDING library helper functions.
-   Copyright (C) 2007, 2009, 2010 Free Software Foundation, Inc.
+   Copyright (C) 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
    Contributed by Christopher Rickett.
 
-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
@@ -100,7 +100,7 @@ ISO_C_BINDING_PREFIX (c_f_pointer_u0) (void *c_ptr_in,
 
       f_ptr_out->offset = str;
       shapeSize = 0;
-      p = shape->data;
+      p = shape->base_addr;
       size = GFC_DESCRIPTOR_SIZE(shape);
 
       source_stride = GFC_DESCRIPTOR_STRIDE_BYTES(shape,0);
diff --git a/libgfortran/intrinsics/move_alloc.c b/libgfortran/intrinsics/move_alloc.c
index 7b489ad..a27de4e 100644
--- a/libgfortran/intrinsics/move_alloc.c
+++ b/libgfortran/intrinsics/move_alloc.c
@@ -1,5 +1,5 @@
 /* Generic implementation of the MOVE_ALLOC intrinsic
-   Copyright (C) 2006, 2007, 2009, 2011 Free Software Foundation, Inc.
+   Copyright (C) 2006, 2007, 2009, 2011, 2012 Free Software Foundation, Inc.
    Contributed by Paul Thomas
 
 This file is part of the GNU Fortran runtime library (libgfortran).
@@ -35,7 +35,7 @@ move_alloc (gfc_array_char * from, gfc_array_char * to)
 {
   int i;
 
-  free (to->data);
+  free (to->base_addr);
 
   for (i = 0; i < GFC_DESCRIPTOR_RANK (from); i++)
     {
@@ -48,8 +48,8 @@ move_alloc (gfc_array_char * from, gfc_array_char * to)
 
   to->offset = from->offset;
   to->dtype = from->dtype;
-  to->data = from->data;
-  from->data = NULL;
+  to->base_addr = from->base_addr;
+  from->base_addr = NULL;
 }
 
 extern void move_alloc_c (gfc_array_char *, GFC_INTEGER_4,
diff --git a/libgfortran/intrinsics/pack_generic.c b/libgfortran/intrinsics/pack_generic.c
index de1e07f..77d600a 100644
--- a/libgfortran/intrinsics/pack_generic.c
+++ b/libgfortran/intrinsics/pack_generic.c
@@ -1,9 +1,9 @@
 /* Generic implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2009, 2010
+   Copyright (C) 2002, 2004, 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 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
@@ -96,8 +96,8 @@ pack_internal (gfc_array_char *ret, const gfc_array_char *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  sptr = array->data;
-  mptr = mask->data;
+  sptr = array->base_addr;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -129,7 +129,7 @@ pack_internal (gfc_array_char *ret, const gfc_array_char *array,
   if (mstride[0] == 0)
     mstride[0] = mask_kind;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -147,14 +147,14 @@ pack_internal (gfc_array_char *ret, const gfc_array_char *array,
 	  total = count_0 (mask);
 	}
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
 
 	  ret->offset = 0;
 	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->data = internal_malloc_size (size * total);
+	  ret->base_addr = internal_malloc_size (size * total);
 
 	  if (total == 0)
 	    return;      /* In this case, nothing remains to be done.  */
@@ -177,7 +177,7 @@ pack_internal (gfc_array_char *ret, const gfc_array_char *array,
     rstride0 = size;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -222,14 +222,14 @@ pack_internal (gfc_array_char *ret, const gfc_array_char *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE_BYTES(vector,0);
           if (sstride0 == 0)
             sstride0 = size;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
@@ -358,8 +358,8 @@ pack (gfc_array_char *ret, const gfc_array_char *array,
 	 the unpack functions.  */
 
     case GFC_DTYPE_DERIVED_2:
-      if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(array->data)
-	  || (vector && GFC_UNALIGNED_2(vector->data)))
+      if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(array->base_addr)
+	  || (vector && GFC_UNALIGNED_2(vector->base_addr)))
 	break;
       else
 	{
@@ -369,8 +369,8 @@ pack (gfc_array_char *ret, const gfc_array_char *array,
 	}
 
     case GFC_DTYPE_DERIVED_4:
-      if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(array->data)
-	  || (vector && GFC_UNALIGNED_4(vector->data)))
+      if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(array->base_addr)
+	  || (vector && GFC_UNALIGNED_4(vector->base_addr)))
 	break;
       else
 	{
@@ -380,8 +380,8 @@ pack (gfc_array_char *ret, const gfc_array_char *array,
 	}
 
     case GFC_DTYPE_DERIVED_8:
-      if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(array->data)
-	  || (vector && GFC_UNALIGNED_8(vector->data)))
+      if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(array->base_addr)
+	  || (vector && GFC_UNALIGNED_8(vector->base_addr)))
 	break;
       else
 	{
@@ -392,8 +392,8 @@ pack (gfc_array_char *ret, const gfc_array_char *array,
 
 #ifdef HAVE_GFC_INTEGER_16
     case GFC_DTYPE_DERIVED_16:
-      if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(array->data)
-	  || (vector && GFC_UNALIGNED_16(vector->data)))
+      if (GFC_UNALIGNED_16(ret->base_addr) || GFC_UNALIGNED_16(array->base_addr)
+	  || (vector && GFC_UNALIGNED_16(vector->base_addr)))
 	break;
       else
 	{
@@ -481,11 +481,11 @@ pack_s_internal (gfc_array_char *ret, const gfc_array_char *array,
   sstride0 = sstride[0];
 
   if (ssize != 0)
-    sptr = array->data;
+    sptr = array->base_addr;
   else
     sptr = NULL;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* Allocate the memory for the result.  */
 
@@ -520,7 +520,7 @@ pack_s_internal (gfc_array_char *ret, const gfc_array_char *array,
 
       ret->offset = 0;
 
-      ret->data = internal_malloc_size (size * total);
+      ret->base_addr = internal_malloc_size (size * total);
 
       if (total == 0)
 	return;
@@ -529,7 +529,7 @@ pack_s_internal (gfc_array_char *ret, const gfc_array_char *array,
   rstride0 = GFC_DESCRIPTOR_STRIDE_BYTES(ret,0);
   if (rstride0 == 0)
     rstride0 = size;
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   /* The remaining possibilities are now:
        If MASK is .TRUE., we have to copy the source array into the
@@ -577,14 +577,14 @@ pack_s_internal (gfc_array_char *ret, const gfc_array_char *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE_BYTES(vector,0);
           if (sstride0 == 0)
             sstride0 = size;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/intrinsics/random.c b/libgfortran/intrinsics/random.c
index 35576b8..a6fede0 100644
--- a/libgfortran/intrinsics/random.c
+++ b/libgfortran/intrinsics/random.c
@@ -1,10 +1,10 @@
 /* Implementation of the RANDOM intrinsics
-   Copyright 2002, 2004, 2005, 2006, 2007, 2009, 2010
+   Copyright 2002, 2004, 2005, 2006, 2007, 2009, 2010, 2012
    Free Software Foundation, Inc.
    Contributed by Lars Segerlund <seger@linuxmail.org>
    and Steve Kargl.
 
-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
@@ -368,7 +368,7 @@ arandom_r4 (gfc_array_r4 *x)
   GFC_UINTEGER_4 kiss;
   int n;
 
-  dest = x->data;
+  dest = x->base_addr;
 
   dim = GFC_DESCRIPTOR_RANK (x);
 
@@ -435,7 +435,7 @@ arandom_r8 (gfc_array_r8 *x)
   GFC_UINTEGER_8 kiss;
   int n;
 
-  dest = x->data;
+  dest = x->base_addr;
 
   dim = GFC_DESCRIPTOR_RANK (x);
 
@@ -505,7 +505,7 @@ arandom_r10 (gfc_array_r10 *x)
   GFC_UINTEGER_8 kiss;
   int n;
 
-  dest = x->data;
+  dest = x->base_addr;
 
   dim = GFC_DESCRIPTOR_RANK (x);
 
@@ -577,7 +577,7 @@ arandom_r16 (gfc_array_r16 *x)
   GFC_UINTEGER_8 kiss1, kiss2;
   int n;
 
-  dest = x->data;
+  dest = x->base_addr;
 
   dim = GFC_DESCRIPTOR_RANK (x);
 
@@ -697,7 +697,7 @@ random_seed_i4 (GFC_INTEGER_4 *size, gfc_array_i4 *put, gfc_array_i4 *get)
       /*  We copy the seed given by the user.  */
       for (i = 0; i < kiss_size; i++)
 	memcpy (seed + i * sizeof(GFC_UINTEGER_4),
-		&(put->data[(kiss_size - 1 - i) * GFC_DESCRIPTOR_STRIDE(put,0)]),
+		&(put->base_addr[(kiss_size - 1 - i) * GFC_DESCRIPTOR_STRIDE(put,0)]),
 		sizeof(GFC_UINTEGER_4));
 
       /* We put it after scrambling the bytes, to paper around users who
@@ -721,7 +721,7 @@ random_seed_i4 (GFC_INTEGER_4 *size, gfc_array_i4 *put, gfc_array_i4 *get)
 
       /*  Then copy it back to the user variable.  */
       for (i = 0; i < kiss_size; i++)
-	memcpy (&(get->data[(kiss_size - 1 - i) * GFC_DESCRIPTOR_STRIDE(get,0)]),
+	memcpy (&(get->base_addr[(kiss_size - 1 - i) * GFC_DESCRIPTOR_STRIDE(get,0)]),
                seed + i * sizeof(GFC_UINTEGER_4),
                sizeof(GFC_UINTEGER_4));
     }
@@ -763,7 +763,7 @@ random_seed_i8 (GFC_INTEGER_8 *size, gfc_array_i8 *put, gfc_array_i8 *get)
 
       /*  This code now should do correct strides.  */
       for (i = 0; i < kiss_size / 2; i++)
-	memcpy (&kiss_seed[2*i], &(put->data[i * GFC_DESCRIPTOR_STRIDE(put,0)]),
+	memcpy (&kiss_seed[2*i], &(put->base_addr[i * GFC_DESCRIPTOR_STRIDE(put,0)]),
 		sizeof (GFC_UINTEGER_8));
     }
 
@@ -780,7 +780,7 @@ random_seed_i8 (GFC_INTEGER_8 *size, gfc_array_i8 *put, gfc_array_i8 *get)
 
       /*  This code now should do correct strides.  */
       for (i = 0; i < kiss_size / 2; i++)
-	memcpy (&(get->data[i * GFC_DESCRIPTOR_STRIDE(get,0)]), &kiss_seed[2*i],
+	memcpy (&(get->base_addr[i * GFC_DESCRIPTOR_STRIDE(get,0)]), &kiss_seed[2*i],
 		sizeof (GFC_UINTEGER_8));
     }
 
diff --git a/libgfortran/intrinsics/reshape_generic.c b/libgfortran/intrinsics/reshape_generic.c
index 5b39711..b16690a 100644
--- a/libgfortran/intrinsics/reshape_generic.c
+++ b/libgfortran/intrinsics/reshape_generic.c
@@ -1,8 +1,8 @@
 /* Generic implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -75,7 +75,7 @@ reshape_internal (parray *ret, parray *source, shape_type *shape,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
 	{
 	  shape_data[n] = 0;
@@ -83,7 +83,7 @@ reshape_internal (parray *ret, parray *source, shape_type *shape,
 	}
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -103,7 +103,7 @@ reshape_internal (parray *ret, parray *source, shape_type *shape,
       else
 	alloc_size = rs * size;
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
 
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
@@ -132,7 +132,7 @@ reshape_internal (parray *ret, parray *source, shape_type *shape,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -182,7 +182,7 @@ reshape_internal (parray *ret, parray *source, shape_type *shape,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -201,7 +201,7 @@ reshape_internal (parray *ret, parray *source, shape_type *shape,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -245,12 +245,12 @@ reshape_internal (parray *ret, parray *source, shape_type *shape,
       rsize *= size;
       ssize *= size;
       psize *= size;
-      reshape_packed (ret->data, rsize, source->data, ssize,
-		      pad ? pad->data : NULL, psize);
+      reshape_packed (ret->base_addr, rsize, source->base_addr, ssize,
+		      pad ? pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0] * size;
   sstride0 = sstride[0] * size;
 
diff --git a/libgfortran/intrinsics/spread_generic.c b/libgfortran/intrinsics/spread_generic.c
index 2eeb24b..2a478f1 100644
--- a/libgfortran/intrinsics/spread_generic.c
+++ b/libgfortran/intrinsics/spread_generic.c
@@ -1,8 +1,8 @@
 /* Generic implementation of the SPREAD intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009, 2010 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 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
@@ -66,7 +66,7 @@ spread_internal (gfc_array_char *ret, const gfc_array_char *source,
 
   ncopies = *pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -100,7 +100,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->data = internal_malloc_size (rs * size);
+      ret->base_addr = internal_malloc_size (rs * size);
 
       if (rs <= 0)
 	return;
@@ -180,8 +180,8 @@ spread_internal (gfc_array_char *ret, const gfc_array_char *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -243,9 +243,9 @@ spread_internal_scalar (gfc_array_char *ret, const char *source,
   if (*along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * size);
+      ret->base_addr = internal_malloc_size (ncopies * size);
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -258,7 +258,7 @@ spread_internal_scalar (gfc_array_char *ret, const char *source,
 
   for (n = 0; n < ncopies; n++)
     {
-      dest = (char*)(ret->data + n * GFC_DESCRIPTOR_STRIDE_BYTES(ret,0));
+      dest = (char*)(ret->base_addr + n * GFC_DESCRIPTOR_STRIDE_BYTES(ret,0));
       memcpy (dest , source, size);
     }
 }
@@ -374,7 +374,7 @@ spread (gfc_array_char *ret, const gfc_array_char *source,
 #endif
 
     case GFC_DTYPE_DERIVED_2:
-      if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(source->data))
+      if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(source->base_addr))
 	break;
       else
 	{
@@ -384,7 +384,7 @@ spread (gfc_array_char *ret, const gfc_array_char *source,
 	}
 
     case GFC_DTYPE_DERIVED_4:
-      if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(source->data))
+      if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(source->base_addr))
 	break;
       else
 	{
@@ -394,7 +394,7 @@ spread (gfc_array_char *ret, const gfc_array_char *source,
 	}
 
     case GFC_DTYPE_DERIVED_8:
-      if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(source->data))
+      if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(source->base_addr))
 	break;
       else
 	{
@@ -405,7 +405,8 @@ spread (gfc_array_char *ret, const gfc_array_char *source,
 
 #ifdef HAVE_GFC_INTEGER_16
     case GFC_DTYPE_DERIVED_16:
-      if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(source->data))
+      if (GFC_UNALIGNED_16(ret->base_addr)
+	  || GFC_UNALIGNED_16(source->base_addr))
 	break;
       else
 	{
@@ -569,7 +570,7 @@ spread_scalar (gfc_array_char *ret, const char *source,
 #endif
 
     case GFC_DTYPE_DERIVED_2:
-      if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(source))
+      if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(source))
 	break;
       else
 	{
@@ -579,7 +580,7 @@ spread_scalar (gfc_array_char *ret, const char *source,
 	}
 
     case GFC_DTYPE_DERIVED_4:
-      if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(source))
+      if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(source))
 	break;
       else
 	{
@@ -589,7 +590,7 @@ spread_scalar (gfc_array_char *ret, const char *source,
 	}
 
     case GFC_DTYPE_DERIVED_8:
-      if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(source))
+      if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(source))
 	break;
       else
 	{
@@ -599,7 +600,7 @@ spread_scalar (gfc_array_char *ret, const char *source,
 	}
 #ifdef HAVE_GFC_INTEGER_16
     case GFC_DTYPE_DERIVED_16:
-      if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(source))
+      if (GFC_UNALIGNED_16(ret->base_addr) || GFC_UNALIGNED_16(source))
 	break;
       else
 	{
diff --git a/libgfortran/intrinsics/stat.c b/libgfortran/intrinsics/stat.c
index 28821f1..a0d9910 100644
--- a/libgfortran/intrinsics/stat.c
+++ b/libgfortran/intrinsics/stat.c
@@ -1,5 +1,5 @@
 /* Implementation of the STAT and FSTAT intrinsics.
-   Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011 
+   Copyright (C) 2004, 2005, 2006, 2007, 2009, 2011, 2012
    Free Software Foundation, Inc.
    Contributed by Steven G. Kargl <kargls@comcast.net>.
 
@@ -90,54 +90,54 @@ stat_i4_sub_0 (char *name, gfc_array_i4 *sarray, GFC_INTEGER_4 *status,
       index_type stride = GFC_DESCRIPTOR_STRIDE(sarray,0);
 
       /* Device ID  */
-      sarray->data[0 * stride] = sb.st_dev;
+      sarray->base_addr[0 * stride] = sb.st_dev;
 
       /* Inode number  */
-      sarray->data[1 * stride] = sb.st_ino;
+      sarray->base_addr[1 * stride] = sb.st_ino;
 
       /* File mode  */
-      sarray->data[2 * stride] = sb.st_mode;
+      sarray->base_addr[2 * stride] = sb.st_mode;
 
       /* Number of (hard) links  */
-      sarray->data[3 * stride] = sb.st_nlink;
+      sarray->base_addr[3 * stride] = sb.st_nlink;
 
       /* Owner's uid  */
-      sarray->data[4 * stride] = sb.st_uid;
+      sarray->base_addr[4 * stride] = sb.st_uid;
 
       /* Owner's gid  */
-      sarray->data[5 * stride] = sb.st_gid;
+      sarray->base_addr[5 * stride] = sb.st_gid;
 
       /* ID of device containing directory entry for file (0 if not available) */
 #if HAVE_STRUCT_STAT_ST_RDEV
-      sarray->data[6 * stride] = sb.st_rdev;
+      sarray->base_addr[6 * stride] = sb.st_rdev;
 #else
-      sarray->data[6 * stride] = 0;
+      sarray->base_addr[6 * stride] = 0;
 #endif
 
       /* File size (bytes)  */
-      sarray->data[7 * stride] = sb.st_size;
+      sarray->base_addr[7 * stride] = sb.st_size;
 
       /* Last access time  */
-      sarray->data[8 * stride] = sb.st_atime;
+      sarray->base_addr[8 * stride] = sb.st_atime;
 
       /* Last modification time  */
-      sarray->data[9 * stride] = sb.st_mtime;
+      sarray->base_addr[9 * stride] = sb.st_mtime;
 
       /* Last file status change time  */
-      sarray->data[10 * stride] = sb.st_ctime;
+      sarray->base_addr[10 * stride] = sb.st_ctime;
 
       /* Preferred I/O block size (-1 if not available)  */
 #if HAVE_STRUCT_STAT_ST_BLKSIZE
-      sarray->data[11 * stride] = sb.st_blksize;
+      sarray->base_addr[11 * stride] = sb.st_blksize;
 #else
-      sarray->data[11 * stride] = -1;
+      sarray->base_addr[11 * stride] = -1;
 #endif
 
       /* Number of blocks allocated (-1 if not available)  */
 #if HAVE_STRUCT_STAT_ST_BLOCKS
-      sarray->data[12 * stride] = sb.st_blocks;
+      sarray->base_addr[12 * stride] = sb.st_blocks;
 #else
-      sarray->data[12 * stride] = -1;
+      sarray->base_addr[12 * stride] = -1;
 #endif
     }
 
@@ -211,54 +211,54 @@ stat_i8_sub_0 (char *name, gfc_array_i8 *sarray, GFC_INTEGER_8 *status,
       index_type stride = GFC_DESCRIPTOR_STRIDE(sarray,0);
 
       /* Device ID  */
-      sarray->data[0] = sb.st_dev;
+      sarray->base_addr[0] = sb.st_dev;
 
       /* Inode number  */
-      sarray->data[stride] = sb.st_ino;
+      sarray->base_addr[stride] = sb.st_ino;
 
       /* File mode  */
-      sarray->data[2 * stride] = sb.st_mode;
+      sarray->base_addr[2 * stride] = sb.st_mode;
 
       /* Number of (hard) links  */
-      sarray->data[3 * stride] = sb.st_nlink;
+      sarray->base_addr[3 * stride] = sb.st_nlink;
 
       /* Owner's uid  */
-      sarray->data[4 * stride] = sb.st_uid;
+      sarray->base_addr[4 * stride] = sb.st_uid;
 
       /* Owner's gid  */
-      sarray->data[5 * stride] = sb.st_gid;
+      sarray->base_addr[5 * stride] = sb.st_gid;
 
       /* ID of device containing directory entry for file (0 if not available) */
 #if HAVE_STRUCT_STAT_ST_RDEV
-      sarray->data[6 * stride] = sb.st_rdev;
+      sarray->base_addr[6 * stride] = sb.st_rdev;
 #else
-      sarray->data[6 * stride] = 0;
+      sarray->base_addr[6 * stride] = 0;
 #endif
 
       /* File size (bytes)  */
-      sarray->data[7 * stride] = sb.st_size;
+      sarray->base_addr[7 * stride] = sb.st_size;
 
       /* Last access time  */
-      sarray->data[8 * stride] = sb.st_atime;
+      sarray->base_addr[8 * stride] = sb.st_atime;
 
       /* Last modification time  */
-      sarray->data[9 * stride] = sb.st_mtime;
+      sarray->base_addr[9 * stride] = sb.st_mtime;
 
       /* Last file status change time  */
-      sarray->data[10 * stride] = sb.st_ctime;
+      sarray->base_addr[10 * stride] = sb.st_ctime;
 
       /* Preferred I/O block size (-1 if not available)  */
 #if HAVE_STRUCT_STAT_ST_BLKSIZE
-      sarray->data[11 * stride] = sb.st_blksize;
+      sarray->base_addr[11 * stride] = sb.st_blksize;
 #else
-      sarray->data[11 * stride] = -1;
+      sarray->base_addr[11 * stride] = -1;
 #endif
 
       /* Number of blocks allocated (-1 if not available)  */
 #if HAVE_STRUCT_STAT_ST_BLOCKS
-      sarray->data[12 * stride] = sb.st_blocks;
+      sarray->base_addr[12 * stride] = sb.st_blocks;
 #else
-      sarray->data[12 * stride] = -1;
+      sarray->base_addr[12 * stride] = -1;
 #endif
     }
 
@@ -392,54 +392,54 @@ fstat_i4_sub (GFC_INTEGER_4 *unit, gfc_array_i4 *sarray, GFC_INTEGER_4 *status)
       index_type stride = GFC_DESCRIPTOR_STRIDE(sarray,0);
 
       /* Device ID  */
-      sarray->data[0 * stride] = sb.st_dev;
+      sarray->base_addr[0 * stride] = sb.st_dev;
 
       /* Inode number  */
-      sarray->data[1 * stride] = sb.st_ino;
+      sarray->base_addr[1 * stride] = sb.st_ino;
 
       /* File mode  */
-      sarray->data[2 * stride] = sb.st_mode;
+      sarray->base_addr[2 * stride] = sb.st_mode;
 
       /* Number of (hard) links  */
-      sarray->data[3 * stride] = sb.st_nlink;
+      sarray->base_addr[3 * stride] = sb.st_nlink;
 
       /* Owner's uid  */
-      sarray->data[4 * stride] = sb.st_uid;
+      sarray->base_addr[4 * stride] = sb.st_uid;
 
       /* Owner's gid  */
-      sarray->data[5 * stride] = sb.st_gid;
+      sarray->base_addr[5 * stride] = sb.st_gid;
 
       /* ID of device containing directory entry for file (0 if not available) */
 #if HAVE_STRUCT_STAT_ST_RDEV
-      sarray->data[6 * stride] = sb.st_rdev;
+      sarray->base_addr[6 * stride] = sb.st_rdev;
 #else
-      sarray->data[6 * stride] = 0;
+      sarray->base_addr[6 * stride] = 0;
 #endif
 
       /* File size (bytes)  */
-      sarray->data[7 * stride] = sb.st_size;
+      sarray->base_addr[7 * stride] = sb.st_size;
 
       /* Last access time  */
-      sarray->data[8 * stride] = sb.st_atime;
+      sarray->base_addr[8 * stride] = sb.st_atime;
 
       /* Last modification time  */
-      sarray->data[9 * stride] = sb.st_mtime;
+      sarray->base_addr[9 * stride] = sb.st_mtime;
 
       /* Last file status change time  */
-      sarray->data[10 * stride] = sb.st_ctime;
+      sarray->base_addr[10 * stride] = sb.st_ctime;
 
       /* Preferred I/O block size (-1 if not available)  */
 #if HAVE_STRUCT_STAT_ST_BLKSIZE
-      sarray->data[11 * stride] = sb.st_blksize;
+      sarray->base_addr[11 * stride] = sb.st_blksize;
 #else
-      sarray->data[11 * stride] = -1;
+      sarray->base_addr[11 * stride] = -1;
 #endif
 
       /* Number of blocks allocated (-1 if not available)  */
 #if HAVE_STRUCT_STAT_ST_BLOCKS
-      sarray->data[12 * stride] = sb.st_blocks;
+      sarray->base_addr[12 * stride] = sb.st_blocks;
 #else
-      sarray->data[12 * stride] = -1;
+      sarray->base_addr[12 * stride] = -1;
 #endif
     }
 
@@ -475,54 +475,54 @@ fstat_i8_sub (GFC_INTEGER_8 *unit, gfc_array_i8 *sarray, GFC_INTEGER_8 *status)
       index_type stride = GFC_DESCRIPTOR_STRIDE(sarray,0);
 
       /* Device ID  */
-      sarray->data[0] = sb.st_dev;
+      sarray->base_addr[0] = sb.st_dev;
 
       /* Inode number  */
-      sarray->data[stride] = sb.st_ino;
+      sarray->base_addr[stride] = sb.st_ino;
 
       /* File mode  */
-      sarray->data[2 * stride] = sb.st_mode;
+      sarray->base_addr[2 * stride] = sb.st_mode;
 
       /* Number of (hard) links  */
-      sarray->data[3 * stride] = sb.st_nlink;
+      sarray->base_addr[3 * stride] = sb.st_nlink;
 
       /* Owner's uid  */
-      sarray->data[4 * stride] = sb.st_uid;
+      sarray->base_addr[4 * stride] = sb.st_uid;
 
       /* Owner's gid  */
-      sarray->data[5 * stride] = sb.st_gid;
+      sarray->base_addr[5 * stride] = sb.st_gid;
 
       /* ID of device containing directory entry for file (0 if not available) */
 #if HAVE_STRUCT_STAT_ST_RDEV
-      sarray->data[6 * stride] = sb.st_rdev;
+      sarray->base_addr[6 * stride] = sb.st_rdev;
 #else
-      sarray->data[6 * stride] = 0;
+      sarray->base_addr[6 * stride] = 0;
 #endif
 
       /* File size (bytes)  */
-      sarray->data[7 * stride] = sb.st_size;
+      sarray->base_addr[7 * stride] = sb.st_size;
 
       /* Last access time  */
-      sarray->data[8 * stride] = sb.st_atime;
+      sarray->base_addr[8 * stride] = sb.st_atime;
 
       /* Last modification time  */
-      sarray->data[9 * stride] = sb.st_mtime;
+      sarray->base_addr[9 * stride] = sb.st_mtime;
 
       /* Last file status change time  */
-      sarray->data[10 * stride] = sb.st_ctime;
+      sarray->base_addr[10 * stride] = sb.st_ctime;
 
       /* Preferred I/O block size (-1 if not available)  */
 #if HAVE_STRUCT_STAT_ST_BLKSIZE
-      sarray->data[11 * stride] = sb.st_blksize;
+      sarray->base_addr[11 * stride] = sb.st_blksize;
 #else
-      sarray->data[11 * stride] = -1;
+      sarray->base_addr[11 * stride] = -1;
 #endif
 
       /* Number of blocks allocated (-1 if not available)  */
 #if HAVE_STRUCT_STAT_ST_BLOCKS
-      sarray->data[12 * stride] = sb.st_blocks;
+      sarray->base_addr[12 * stride] = sb.st_blocks;
 #else
-      sarray->data[12 * stride] = -1;
+      sarray->base_addr[12 * stride] = -1;
 #endif
     }
 
diff --git a/libgfortran/intrinsics/transpose_generic.c b/libgfortran/intrinsics/transpose_generic.c
index b0c2fff..03fbbef 100644
--- a/libgfortran/intrinsics/transpose_generic.c
+++ b/libgfortran/intrinsics/transpose_generic.c
@@ -1,8 +1,8 @@
 /* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -50,7 +50,7 @@ transpose_internal (gfc_array_char *ret, gfc_array_char *source)
 
   size = GFC_DESCRIPTOR_SIZE(ret);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (ret->dtype == source->dtype);
 
@@ -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->data = internal_malloc_size (size * size0 ((array_t*)ret));
+      ret->base_addr = internal_malloc_size (size * size0 ((array_t*)ret));
       ret->offset = 0;
     }
   else if (unlikely (compile_options.bounds_check))
@@ -95,8 +95,8 @@ transpose_internal (gfc_array_char *ret, gfc_array_char *source)
   rxstride = GFC_DESCRIPTOR_STRIDE_BYTES(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE_BYTES(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y = 0; y < ycount; y++)
     {
diff --git a/libgfortran/intrinsics/unpack_generic.c b/libgfortran/intrinsics/unpack_generic.c
index db62499..123f5e1 100644
--- a/libgfortran/intrinsics/unpack_generic.c
+++ b/libgfortran/intrinsics/unpack_generic.c
@@ -1,9 +1,9 @@
 /* Generic implementation of the UNPACK intrinsic
-   Copyright 2002, 2003, 2004, 2005, 2007, 2009, 2010
+   Copyright 2002, 2003, 2004, 2005, 2007, 2009, 2010, 2012
    Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -49,7 +49,7 @@ unpack_bounds (gfc_array_char *ret, const gfc_array_char *vector,
     bounds_equal_extents ((array_t *) field, (array_t *) mask,
 			  "FIELD", "UNPACK");
 
-  if (ret->data != NULL)
+  if (ret->base_addr != NULL)
     bounds_equal_extents ((array_t *) ret, (array_t *) mask,
 			  "return value", "UNPACK");
 
@@ -87,7 +87,7 @@ unpack_internal (gfc_array_char *ret, const gfc_array_char *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -107,7 +107,7 @@ unpack_internal (gfc_array_char *ret, const gfc_array_char *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -126,7 +126,7 @@ unpack_internal (gfc_array_char *ret, const gfc_array_char *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * size);
+      ret->base_addr = internal_malloc_size (rs * size);
     }
   else
     {
@@ -149,9 +149,9 @@ unpack_internal (gfc_array_char *ret, const gfc_array_char *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -317,8 +317,8 @@ unpack1 (gfc_array_char *ret, const gfc_array_char *vector,
 #endif
 
     case GFC_DTYPE_DERIVED_2:
-      if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(vector->data)
-	  || GFC_UNALIGNED_2(field->data))
+      if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(vector->base_addr)
+	  || GFC_UNALIGNED_2(field->base_addr))
 	break;
       else
 	{
@@ -328,8 +328,8 @@ unpack1 (gfc_array_char *ret, const gfc_array_char *vector,
 	}
 
     case GFC_DTYPE_DERIVED_4:
-      if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(vector->data)
-	  || GFC_UNALIGNED_4(field->data))
+      if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(vector->base_addr)
+	  || GFC_UNALIGNED_4(field->base_addr))
 	break;
       else
 	{
@@ -339,8 +339,8 @@ unpack1 (gfc_array_char *ret, const gfc_array_char *vector,
 	}
 
     case GFC_DTYPE_DERIVED_8:
-      if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(vector->data)
-	  || GFC_UNALIGNED_8(field->data))
+      if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(vector->base_addr)
+	  || GFC_UNALIGNED_8(field->base_addr))
 	break;
       else
 	{
@@ -351,8 +351,9 @@ unpack1 (gfc_array_char *ret, const gfc_array_char *vector,
 
 #ifdef HAVE_GFC_INTEGER_16
     case GFC_DTYPE_DERIVED_16:
-      if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(vector->data)
-	  || GFC_UNALIGNED_16(field->data))
+      if (GFC_UNALIGNED_16(ret->base_addr)
+	  || GFC_UNALIGNED_16(vector->base_addr)
+	  || GFC_UNALIGNED_16(field->base_addr))
 	break;
       else
 	{
@@ -527,7 +528,7 @@ unpack0 (gfc_array_char *ret, const gfc_array_char *vector,
 #endif
 
     case GFC_DTYPE_DERIVED_2:
-      if (GFC_UNALIGNED_2(ret->data) || GFC_UNALIGNED_2(vector->data)
+      if (GFC_UNALIGNED_2(ret->base_addr) || GFC_UNALIGNED_2(vector->base_addr)
 	  || GFC_UNALIGNED_2(field))
 	break;
       else
@@ -538,7 +539,7 @@ unpack0 (gfc_array_char *ret, const gfc_array_char *vector,
 	}
 
     case GFC_DTYPE_DERIVED_4:
-      if (GFC_UNALIGNED_4(ret->data) || GFC_UNALIGNED_4(vector->data)
+      if (GFC_UNALIGNED_4(ret->base_addr) || GFC_UNALIGNED_4(vector->base_addr)
 	  || GFC_UNALIGNED_4(field))
 	break;
       else
@@ -549,7 +550,7 @@ unpack0 (gfc_array_char *ret, const gfc_array_char *vector,
 	}
 
     case GFC_DTYPE_DERIVED_8:
-      if (GFC_UNALIGNED_8(ret->data) || GFC_UNALIGNED_8(vector->data)
+      if (GFC_UNALIGNED_8(ret->base_addr) || GFC_UNALIGNED_8(vector->base_addr)
 	  || GFC_UNALIGNED_8(field))
 	break;
       else
@@ -561,7 +562,8 @@ unpack0 (gfc_array_char *ret, const gfc_array_char *vector,
 
 #ifdef HAVE_GFC_INTEGER_16
     case GFC_DTYPE_DERIVED_16:
-      if (GFC_UNALIGNED_16(ret->data) || GFC_UNALIGNED_16(vector->data)
+      if (GFC_UNALIGNED_16(ret->base_addr)
+	  || GFC_UNALIGNED_16(vector->base_addr)
 	  || GFC_UNALIGNED_16(field))
 	break;
       else
@@ -576,7 +578,7 @@ unpack0 (gfc_array_char *ret, const gfc_array_char *vector,
 
   memset (&tmp, 0, sizeof (tmp));
   tmp.dtype = 0;
-  tmp.data = field;
+  tmp.base_addr = field;
   unpack_internal (ret, vector, mask, &tmp, GFC_DESCRIPTOR_SIZE (vector));
 }
 
@@ -600,7 +602,7 @@ unpack0_char (gfc_array_char *ret,
 
   memset (&tmp, 0, sizeof (tmp));
   tmp.dtype = 0;
-  tmp.data = field;
+  tmp.base_addr = field;
   unpack_internal (ret, vector, mask, &tmp, vector_length);
 }
 
@@ -624,7 +626,7 @@ unpack0_char4 (gfc_array_char *ret,
 
   memset (&tmp, 0, sizeof (tmp));
   tmp.dtype = 0;
-  tmp.data = field;
+  tmp.base_addr = field;
   unpack_internal (ret, vector, mask, &tmp,
 		   vector_length * sizeof (gfc_char4_t));
 }
diff --git a/libgfortran/libgfortran.h b/libgfortran/libgfortran.h
index 148dcfb..f2f6c36 100644
--- a/libgfortran/libgfortran.h
+++ b/libgfortran/libgfortran.h
@@ -1,6 +1,6 @@
 /* Common declarations for all of libgfortran.
    Copyright (C) 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010,
-   2011
+   2011, 2012
    Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>, and
    Andy Vaught <andy@xena.eas.asu.edu>
@@ -322,7 +322,7 @@ internal_proto(big_endian);
 typedef struct descriptor_dimension
 {
   index_type _stride;
-  index_type _lbound;
+  index_type lower_bound;
   index_type _ubound;
 }
 
@@ -330,7 +330,7 @@ descriptor_dimension;
 
 #define GFC_ARRAY_DESCRIPTOR(r, type) \
 struct {\
-  type *data;\
+  type *base_addr;\
   size_t offset;\
   index_type dtype;\
   descriptor_dimension dim[r];\
@@ -375,26 +375,26 @@ typedef GFC_ARRAY_DESCRIPTOR (GFC_MAX_DIMENSIONS, GFC_LOGICAL_16) gfc_array_l16;
 #define GFC_DESCRIPTOR_TYPE(desc) (((desc)->dtype & GFC_DTYPE_TYPE_MASK) \
                                    >> GFC_DTYPE_TYPE_SHIFT)
 #define GFC_DESCRIPTOR_SIZE(desc) ((desc)->dtype >> GFC_DTYPE_SIZE_SHIFT)
-#define GFC_DESCRIPTOR_DATA(desc) ((desc)->data)
+#define GFC_DESCRIPTOR_DATA(desc) ((desc)->base_addr)
 #define GFC_DESCRIPTOR_DTYPE(desc) ((desc)->dtype)
 
-#define GFC_DIMENSION_LBOUND(dim) ((dim)._lbound)
+#define GFC_DIMENSION_LBOUND(dim) ((dim).lower_bound)
 #define GFC_DIMENSION_UBOUND(dim) ((dim)._ubound)
 #define GFC_DIMENSION_STRIDE(dim) ((dim)._stride)
-#define GFC_DIMENSION_EXTENT(dim) ((dim)._ubound + 1 - (dim)._lbound)
+#define GFC_DIMENSION_EXTENT(dim) ((dim)._ubound + 1 - (dim).lower_bound)
 #define GFC_DIMENSION_SET(dim,lb,ub,str) \
   do \
     { \
-      (dim)._lbound = lb;			\
+      (dim).lower_bound = lb;			\
       (dim)._ubound = ub;			\
       (dim)._stride = str;			\
     } while (0)
 	    
 
-#define GFC_DESCRIPTOR_LBOUND(desc,i) ((desc)->dim[i]._lbound)
+#define GFC_DESCRIPTOR_LBOUND(desc,i) ((desc)->dim[i].lower_bound)
 #define GFC_DESCRIPTOR_UBOUND(desc,i) ((desc)->dim[i]._ubound)
 #define GFC_DESCRIPTOR_EXTENT(desc,i) ((desc)->dim[i]._ubound + 1 \
-				      - (desc)->dim[i]._lbound)
+				      - (desc)->dim[i].lower_bound)
 #define GFC_DESCRIPTOR_EXTENT_BYTES(desc,i) \
   (GFC_DESCRIPTOR_EXTENT(desc,i) * GFC_DESCRIPTOR_SIZE(desc))
 
diff --git a/libgfortran/m4/bessel.m4 b/libgfortran/m4/bessel.m4
index acef7ea..d9e7f89 100644
--- a/libgfortran/m4/bessel.m4
+++ b/libgfortran/m4/bessel.m4
@@ -1,6 +1,6 @@
 `/* Implementation of the BESSEL_JN and BESSEL_YN transformational
    function using a recurrence algorithm.
-   Copyright 2010 Free Software Foundation, Inc.
+   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).
@@ -52,11 +52,11 @@ bessel_jn_r'rtype_kind` ('rtype` * const restrict ret, int n1, int n2, 'rtype_na
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
-      ret->data = internal_malloc_size (sizeof ('rtype_name`) * size);
+      ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * size);
       ret->offset = 0;
     }
 
@@ -73,21 +73,20 @@ bessel_jn_r'rtype_kind` ('rtype` * const restrict ret, int n1, int n2, 'rtype_na
 
   if (unlikely (x == 0))
     {
-      ret->data[0] = 1;
+      ret->base_addr[0] = 1;
       for (i = 1; i <= n2-n1; i++)
-        ret->data[i*stride] = 0;
+        ret->base_addr[i*stride] = 0;
       return;
     }
 
-  ret->data = ret->data;
   last1 = MATHFUNC(jn) (n2, x);
-  ret->data[(n2-n1)*stride] = last1;
+  ret->base_addr[(n2-n1)*stride] = last1;
 
   if (n1 == n2)
     return;
 
   last2 = MATHFUNC(jn) (n2 - 1, x);
-  ret->data[(n2-n1-1)*stride] = last2;
+  ret->base_addr[(n2-n1-1)*stride] = last2;
 
   if (n1 + 1 == n2)
     return;
@@ -96,9 +95,9 @@ bessel_jn_r'rtype_kind` ('rtype` * const restrict ret, int n1, int n2, 'rtype_na
 
   for (i = n2-n1-2; i >= 0; i--)
     {
-      ret->data[i*stride] = x2rev * (i+1+n1) * last2 - last1;
+      ret->base_addr[i*stride] = x2rev * (i+1+n1) * last2 - last1;
       last1 = last2;
-      last2 = ret->data[i*stride];
+      last2 = ret->base_addr[i*stride];
     }
 }
 
@@ -120,11 +119,11 @@ bessel_yn_r'rtype_kind` ('rtype` * const restrict ret, int n1, int n2,
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       size_t size = n2 < n1 ? 0 : n2-n1+1; 
       GFC_DIMENSION_SET(ret->dim[0], 0, size-1, 1);
-      ret->data = internal_malloc_size (sizeof ('rtype_name`) * size);
+      ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * size);
       ret->offset = 0;
     }
 
@@ -143,22 +142,22 @@ bessel_yn_r'rtype_kind` ('rtype` * const restrict ret, int n1, int n2,
     {
       for (i = 0; i <= n2-n1; i++)
 #if defined('rtype_name`_INFINITY)
-        ret->data[i*stride] = -'rtype_name`_INFINITY;
+        ret->base_addr[i*stride] = -'rtype_name`_INFINITY;
 #else
-        ret->data[i*stride] = -'rtype_name`_HUGE;
+        ret->base_addr[i*stride] = -'rtype_name`_HUGE;
 #endif
       return;
     }
 
-  ret->data = ret->data;
+  ret->base_addr = ret->base_addr;
   last1 = MATHFUNC(yn) (n1, x);
-  ret->data[0] = last1;
+  ret->base_addr[0] = last1;
 
   if (n1 == n2)
     return;
 
   last2 = MATHFUNC(yn) (n1 + 1, x);
-  ret->data[1*stride] = last2;
+  ret->base_addr[1*stride] = last2;
 
   if (n1 + 1 == n2)
     return;
@@ -170,14 +169,14 @@ bessel_yn_r'rtype_kind` ('rtype` * const restrict ret, int n1, int n2,
 #if defined('rtype_name`_INFINITY)
       if (unlikely (last2 == -'rtype_name`_INFINITY))
 	{
-	  ret->data[i*stride] = -'rtype_name`_INFINITY;
+	  ret->base_addr[i*stride] = -'rtype_name`_INFINITY;
 	}
       else
 #endif
 	{
-	  ret->data[i*stride] = x2rev * (i-1+n1) * last2 - last1;
+	  ret->base_addr[i*stride] = x2rev * (i-1+n1) * last2 - last1;
 	  last1 = last2;
-	  last2 = ret->data[i*stride];
+	  last2 = ret->base_addr[i*stride];
 	}
     }
 }
diff --git a/libgfortran/m4/cshift0.m4 b/libgfortran/m4/cshift0.m4
index 5c0d22e..567222b 100644
--- a/libgfortran/m4/cshift0.m4
+++ b/libgfortran/m4/cshift0.m4
@@ -1,8 +1,8 @@
 `/* Helper function for cshift functions.
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>
 
-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
@@ -95,8 +95,8 @@ cshift0_'rtype_code` ('rtype` *ret, const 'rtype` *array, ptrdiff_t shift,
   dim = GFC_DESCRIPTOR_RANK (array);
   rstride0 = rstride[0];
   sstride0 = sstride[0];
-  rptr = ret->data;
-  sptr = array->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
 
   shift = len == 0 ? 0 : shift % (ptrdiff_t)len;
   if (shift < 0)
diff --git a/libgfortran/m4/cshift1.m4 b/libgfortran/m4/cshift1.m4
index 49a4f73..88fce1a 100644
--- a/libgfortran/m4/cshift1.m4
+++ b/libgfortran/m4/cshift1.m4
@@ -1,8 +1,8 @@
 `/* Implementation of the CSHIFT intrinsic
-   Copyright 2003, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Feng Wang <wf_cs@yahoo.com>
 
-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
@@ -77,11 +77,11 @@ cshift1 (gfc_array_char * const restrict ret,
 
   arraysize = size0 ((array_t *)array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -157,9 +157,9 @@ cshift1 (gfc_array_char * const restrict ret,
   rstride0 = rstride[0];
   sstride0 = sstride[0];
   hstride0 = hstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/m4/eoshift1.m4 b/libgfortran/m4/eoshift1.m4
index 339e1d8..691edd1 100644
--- a/libgfortran/m4/eoshift1.m4
+++ b/libgfortran/m4/eoshift1.m4
@@ -1,8 +1,8 @@
 `/* Implementation of the EOSHIFT intrinsic
-   Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -85,7 +85,7 @@ eoshift1 (gfc_array_char * const restrict ret,
   count[0] = 0;
 
   arraysize = size0 ((array_t *) array);
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
@@ -107,7 +107,7 @@ eoshift1 (gfc_array_char * const restrict ret,
 
         }
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
@@ -160,9 +160,9 @@ eoshift1 (gfc_array_char * const restrict ret,
   rstride0 = rstride[0];
   sstride0 = sstride[0];
   hstride0 = hstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/m4/eoshift3.m4 b/libgfortran/m4/eoshift3.m4
index 1c19575..b5c8bb4 100644
--- a/libgfortran/m4/eoshift3.m4
+++ b/libgfortran/m4/eoshift3.m4
@@ -1,8 +1,8 @@
 `/* Implementation of the EOSHIFT intrinsic
-   Copyright 2002, 2005, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -86,11 +86,11 @@ eoshift3 (gfc_array_char * const restrict ret,
   else
     which = 0;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       int i;
 
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
       ret->offset = 0;
       ret->dtype = array->dtype;
       for (i = 0; i < GFC_DESCRIPTOR_RANK (array); i++)
@@ -109,7 +109,7 @@ eoshift3 (gfc_array_char * const restrict ret,
 
         }
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (size * arraysize);
+      ret->base_addr = internal_malloc_size (size * arraysize);
 
     }
   else if (unlikely (compile_options.bounds_check))
@@ -171,11 +171,11 @@ eoshift3 (gfc_array_char * const restrict ret,
   sstride0 = sstride[0];
   hstride0 = hstride[0];
   bstride0 = bstride[0];
-  rptr = ret->data;
-  sptr = array->data;
-  hptr = h->data;
+  rptr = ret->base_addr;
+  sptr = array->base_addr;
+  hptr = h->base_addr;
   if (bound)
-    bptr = bound->data;
+    bptr = bound->base_addr;
   else
     bptr = NULL;
 
diff --git a/libgfortran/m4/iforeach.m4 b/libgfortran/m4/iforeach.m4
index 14e501c..86d4350 100644
--- a/libgfortran/m4/iforeach.m4
+++ b/libgfortran/m4/iforeach.m4
@@ -1,6 +1,6 @@
 dnl Support macro file for intrinsic functions.
 dnl Contains the generic sections of the array functions.
-dnl This file is part of the GNU Fortran 95 Runtime Library (libgfortran)
+dnl This file is part of the GNU Fortran Runtime Library (libgfortran)
 dnl Distributed under the GNU GPL with exception.  See COPYING for details.
 define(START_FOREACH_FUNCTION,
 `
@@ -25,12 +25,12 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (rtype_name) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (rtype_name) * rank);
     }
   else
     {
@@ -40,7 +40,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -55,7 +55,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -128,12 +128,12 @@ void
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank - 1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (rtype_name) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (rtype_name) * rank);
     }
   else
     {
@@ -149,7 +149,7 @@ void
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   if (mask_kind == 1 || mask_kind == 2 || mask_kind == 4 || mask_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -161,7 +161,7 @@ void
     runtime_error ("Funny sized logical array");
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n < rank; n++)
     {
       sstride[n] = GFC_DESCRIPTOR_STRIDE(array,n);
@@ -177,7 +177,7 @@ void
 	}
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   /* Initialize the return value.  */
   for (n = 0; n < rank; n++)
@@ -259,12 +259,12 @@ void
   if (rank <= 0)
     runtime_error ("Rank of array needs to be > 0");
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       GFC_DIMENSION_SET(retarray->dim[0], 0, rank-1, 1);
       retarray->dtype = (retarray->dtype & ~GFC_DTYPE_RANK_MASK) | 1;
       retarray->offset = 0;
-      retarray->data = internal_malloc_size (sizeof (rtype_name) * rank);
+      retarray->base_addr = internal_malloc_size (sizeof (rtype_name) * rank);
     }
   else if (unlikely (compile_options.bounds_check))
     {
@@ -273,7 +273,7 @@ void
     }
 
   dstride = GFC_DESCRIPTOR_STRIDE(retarray,0);
-  dest = retarray->data;
+  dest = retarray->base_addr;
   for (n = 0; n<rank; n++)
     dest[n * dstride] = $1 ;
 }')dnl
diff --git a/libgfortran/m4/ifunction.m4 b/libgfortran/m4/ifunction.m4
index 68e1c5e..1cd3073 100644
--- a/libgfortran/m4/ifunction.m4
+++ b/libgfortran/m4/ifunction.m4
@@ -67,7 +67,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -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->data = internal_malloc_size (alloc_size);
+      retarray->base_addr = internal_malloc_size (alloc_size);
       if (alloc_size == 0)
 	{
 	  /* Make sure we have a zero-sized array.  */
@@ -118,8 +118,8 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
 	return;
     }
 
-  base = array->data;
-  dest = retarray->data;
+  base = array->base_addr;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
@@ -209,7 +209,7 @@ void
   if (len <= 0)
     return;
 
-  mbase = mask->data;
+  mbase = mask->base_addr;
 
   mask_kind = GFC_DESCRIPTOR_SIZE (mask);
 
@@ -245,7 +245,7 @@ void
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -273,7 +273,7 @@ void
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
 
     }
   else
@@ -298,8 +298,8 @@ void
 	return;
     }
 
-  dest = retarray->data;
-  base = array->data;
+  dest = retarray->base_addr;
+  base = array->base_addr;
 
   while (base)
     {
@@ -404,7 +404,7 @@ void
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -432,7 +432,7 @@ void
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -464,7 +464,7 @@ void
       dstride[n] = GFC_DESCRIPTOR_STRIDE(retarray,n);
     }
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   while(1)
     {
diff --git a/libgfortran/m4/ifunction_logical.m4 b/libgfortran/m4/ifunction_logical.m4
index e72f1d8..b36e8e0 100644
--- a/libgfortran/m4/ifunction_logical.m4
+++ b/libgfortran/m4/ifunction_logical.m4
@@ -1,6 +1,6 @@
 dnl Support macro file for intrinsic functions.
 dnl Contains the generic sections of the array functions.
-dnl This file is part of the GNU Fortran 95 Runtime Library (libgfortran)
+dnl This file is part of the GNU Fortran Runtime Library (libgfortran)
 dnl Distributed under the GNU GPL with exception.  See COPYING for details.
 dnl
 dnl Pass the implementation for a single section as the parameter to
@@ -71,7 +71,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
 	extent[n] = 0;
     }
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       size_t alloc_size, str;
 
@@ -99,7 +99,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
 	  return;
 	}
       else
-	retarray->data = internal_malloc_size (alloc_size);
+	retarray->base_addr = internal_malloc_size (alloc_size);
     }
   else
     {
@@ -133,7 +133,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
 	return;
     }
 
-  base = array->data;
+  base = array->base_addr;
 
   if (src_kind == 1 || src_kind == 2 || src_kind == 4 || src_kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
@@ -147,7 +147,7 @@ name`'rtype_qual`_'atype_code (rtype * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array in u_name intrinsic");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 
   continue_loop = 1;
   while (continue_loop)
diff --git a/libgfortran/m4/in_pack.m4 b/libgfortran/m4/in_pack.m4
index a4337aa..7cee37b 100644
--- a/libgfortran/m4/in_pack.m4
+++ b/libgfortran/m4/in_pack.m4
@@ -1,8 +1,8 @@
 `/* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -76,12 +76,12 @@ internal_pack_'rtype_ccode` ('rtype` * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
   /* Allocate storage for the destination.  */
   destptr = ('rtype_name` *)internal_malloc_size (ssize * sizeof ('rtype_name`));
   dest = destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0];
 
 
diff --git a/libgfortran/m4/in_unpack.m4 b/libgfortran/m4/in_unpack.m4
index 661c54e..e8b29db 100644
--- a/libgfortran/m4/in_unpack.m4
+++ b/libgfortran/m4/in_unpack.m4
@@ -1,8 +1,8 @@
 `/* Helper function for repacking arrays.
-   Copyright 2003, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -46,7 +46,7 @@ internal_unpack_'rtype_ccode` ('rtype` * d, const 'rtype_name` * src)
   'rtype_name` * restrict dest;
   int n;
 
-  dest = d->data;
+  dest = d->base_addr;
   if (src == dest || !src)
     return;
 
diff --git a/libgfortran/m4/matmul.m4 b/libgfortran/m4/matmul.m4
index bb42f2a..6a7ce5c 100644
--- a/libgfortran/m4/matmul.m4
+++ b/libgfortran/m4/matmul.m4
@@ -1,8 +1,8 @@
 `/* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -102,7 +102,7 @@ matmul_'rtype_code` ('rtype` * const restrict retarray,
      dimensioned [count, 1], so ycount=1.
   */
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -124,7 +124,7 @@ matmul_'rtype_code` ('rtype` * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
 
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof ('rtype_name`) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -228,9 +228,9 @@ sinclude(`matmul_asm_'rtype_code`.m4')dnl
       ycount = GFC_DESCRIPTOR_EXTENT(b,1);
     }
 
-  abase = a->data;
-  bbase = b->data;
-  dest = retarray->data;
+  abase = a->base_addr;
+  bbase = b->base_addr;
+  dest = retarray->base_addr;
 
 
   /* Now that everything is set up, we''`re performing the multiplication
diff --git a/libgfortran/m4/matmull.m4 b/libgfortran/m4/matmull.m4
index c5bad25..87245ae 100644
--- a/libgfortran/m4/matmull.m4
+++ b/libgfortran/m4/matmull.m4
@@ -1,8 +1,8 @@
 `/* Implementation of the MATMUL intrinsic
-   Copyright 2002, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -66,7 +66,7 @@ matmul_'rtype_code` ('rtype` * const restrict retarray,
   assert (GFC_DESCRIPTOR_RANK (a) == 2
           || GFC_DESCRIPTOR_RANK (b) == 2);
 
-  if (retarray->data == NULL)
+  if (retarray->base_addr == NULL)
     {
       if (GFC_DESCRIPTOR_RANK (a) == 1)
         {
@@ -88,7 +88,7 @@ matmul_'rtype_code` ('rtype` * const restrict retarray,
 			    GFC_DESCRIPTOR_EXTENT(retarray,0));
         }
           
-      retarray->data
+      retarray->base_addr
 	= internal_malloc_size (sizeof ('rtype_name`) * size0 ((array_t *) retarray));
       retarray->offset = 0;
     }
@@ -134,7 +134,7 @@ matmul_'rtype_code` ('rtype` * const restrict retarray,
 	  }
       }
 
-  abase = a->data;
+  abase = a->base_addr;
   a_kind = GFC_DESCRIPTOR_SIZE (a);
 
   if (a_kind == 1 || a_kind == 2 || a_kind == 4 || a_kind == 8
@@ -146,7 +146,7 @@ matmul_'rtype_code` ('rtype` * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array");
 
-  bbase = b->data;
+  bbase = b->base_addr;
   b_kind = GFC_DESCRIPTOR_SIZE (b);
 
   if (b_kind == 1 || b_kind == 2 || b_kind == 4 || b_kind == 8
@@ -158,7 +158,7 @@ matmul_'rtype_code` ('rtype` * const restrict retarray,
   else
     internal_error (NULL, "Funny sized logical array");
 
-  dest = retarray->data;
+  dest = retarray->base_addr;
 '
 sinclude(`matmul_asm_'rtype_code`.m4')dnl
 `
diff --git a/libgfortran/m4/pack.m4 b/libgfortran/m4/pack.m4
index e1882d0..e88e84e 100644
--- a/libgfortran/m4/pack.m4
+++ b/libgfortran/m4/pack.m4
@@ -1,8 +1,9 @@
 `/* Specific implementation of the PACK intrinsic
-   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
+   Copyright (C) 2002, 2004, 2005, 2006, 2007, 2008, 2009, 2012
+   Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -99,7 +100,7 @@ pack_'rtype_code` ('rtype` *ret, const 'rtype` *array,
 
   dim = GFC_DESCRIPTOR_RANK (array);
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -137,9 +138,9 @@ pack_'rtype_code` ('rtype` *ret, const 'rtype` *array,
   if (zero_sized)
     sptr = NULL;
   else
-    sptr = array->data;
+    sptr = array->base_addr;
 
-  if (ret->data == NULL || unlikely (compile_options.bounds_check))
+  if (ret->base_addr == NULL || unlikely (compile_options.bounds_check))
     {
       /* Count the elements, either for allocating memory or
 	 for bounds checking.  */
@@ -161,7 +162,7 @@ pack_'rtype_code` ('rtype` *ret, const 'rtype` *array,
 	  total = count_0 (mask);
         }
 
-      if (ret->data == NULL)
+      if (ret->base_addr == NULL)
 	{
 	  /* Setup the array descriptor.  */
 	  GFC_DIMENSION_SET(ret->dim[0], 0, total-1, 1);
@@ -169,7 +170,7 @@ pack_'rtype_code` ('rtype` *ret, const 'rtype` *array,
 	  ret->offset = 0;
 
 	  /* internal_malloc_size allocates a single byte for zero size.  */
-	  ret->data = internal_malloc_size (sizeof ('rtype_name`) * total);
+	  ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * total);
 
 	  if (total == 0)
 	    return;
@@ -192,7 +193,7 @@ pack_'rtype_code` ('rtype` *ret, const 'rtype` *array,
     rstride0 = 1;
   sstride0 = sstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
+  rptr = ret->base_addr;
 
   while (sptr && mptr)
     {
@@ -237,14 +238,14 @@ pack_'rtype_code` ('rtype` *ret, const 'rtype` *array,
   if (vector)
     {
       n = GFC_DESCRIPTOR_EXTENT(vector,0);
-      nelem = ((rptr - ret->data) / rstride0);
+      nelem = ((rptr - ret->base_addr) / rstride0);
       if (n > nelem)
         {
           sstride0 = GFC_DESCRIPTOR_STRIDE(vector,0);
           if (sstride0 == 0)
             sstride0 = 1;
 
-          sptr = vector->data + sstride0 * nelem;
+          sptr = vector->base_addr + sstride0 * nelem;
           n -= nelem;
           while (n--)
             {
diff --git a/libgfortran/m4/reshape.m4 b/libgfortran/m4/reshape.m4
index d1486f3..26ea7e0d 100644
--- a/libgfortran/m4/reshape.m4
+++ b/libgfortran/m4/reshape.m4
@@ -1,8 +1,8 @@
 `/* Implementation of the RESHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -91,7 +91,7 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
 
   for (n = 0; n < rdim; n++)
     {
-      shape_data[n] = shape->data[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
+      shape_data[n] = shape->base_addr[n * GFC_DESCRIPTOR_STRIDE(shape,0)];
       if (shape_data[n] <= 0)
       {
         shape_data[n] = 0;
@@ -99,7 +99,7 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
       }
     }
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       index_type alloc_size;
 
@@ -119,7 +119,7 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
       else
         alloc_size = rs * sizeof ('rtype_name`);
 
-      ret->data = internal_malloc_size (alloc_size);
+      ret->base_addr = internal_malloc_size (alloc_size);
       ret->dtype = (source->dtype & ~GFC_DTYPE_RANK_MASK) | rdim;
     }
 
@@ -147,7 +147,7 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
           else
             psize = 0;
         }
-      pptr = pad->data;
+      pptr = pad->base_addr;
     }
   else
     {
@@ -197,7 +197,7 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
 
 	  for (n = 0; n < rdim; n++)
 	    {
-	      v = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+	      v = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
 
 	      if (v < 0 || v >= rdim)
 		runtime_error("Value %ld out of range in ORDER argument"
@@ -216,7 +216,7 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
   for (n = 0; n < rdim; n++)
     {
       if (order)
-        dim = order->data[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
+        dim = order->base_addr[n * GFC_DESCRIPTOR_STRIDE(order,0)] - 1;
       else
         dim = n;
 
@@ -262,12 +262,12 @@ reshape_'rtype_ccode` ('rtype` * const restrict ret,
       rsize *= sizeof ('rtype_name`);
       ssize *= sizeof ('rtype_name`);
       psize *= sizeof ('rtype_name`);
-      reshape_packed ((char *)ret->data, rsize, (char *)source->data,
-		      ssize, pad ? (char *)pad->data : NULL, psize);
+      reshape_packed ((char *)ret->base_addr, rsize, (char *)source->base_addr,
+		      ssize, pad ? (char *)pad->base_addr : NULL, psize);
       return;
     }
-  rptr = ret->data;
-  src = sptr = source->data;
+  rptr = ret->base_addr;
+  src = sptr = source->base_addr;
   rstride0 = rstride[0];
   sstride0 = sstride[0];
 
diff --git a/libgfortran/m4/shape.m4 b/libgfortran/m4/shape.m4
index c079cca..66445ce 100644
--- a/libgfortran/m4/shape.m4
+++ b/libgfortran/m4/shape.m4
@@ -1,8 +1,8 @@
 `/* Implementation of the SHAPE intrinsic
-   Copyright 2002, 2006, 2007, 2009, 2010 Free Software Foundation, Inc.
+   Copyright 2002, 2006, 2007, 2009, 2010, 2012 Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -46,11 +46,11 @@ shape_'rtype_kind` ('rtype` * const restrict ret,
 
   rank = GFC_DESCRIPTOR_RANK (array);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       GFC_DIMENSION_SET(ret->dim[0], 0, rank - 1, 1);
       ret->offset = 0;
-      ret->data = internal_malloc_size (sizeof ('rtype_name`) * rank);
+      ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * rank);
     }
 
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
@@ -61,7 +61,7 @@ shape_'rtype_kind` ('rtype` * const restrict ret,
   for (n = 0; n < rank; n++)
     {
       extent = GFC_DESCRIPTOR_EXTENT(array,n);
-      ret->data[n * stride] = extent > 0 ? extent : 0 ;
+      ret->base_addr[n * stride] = extent > 0 ? extent : 0 ;
     }
 }
 
diff --git a/libgfortran/m4/spread.m4 b/libgfortran/m4/spread.m4
index 89a2e65..52c0022 100644
--- a/libgfortran/m4/spread.m4
+++ b/libgfortran/m4/spread.m4
@@ -1,9 +1,9 @@
 `/* Special implementation of the SPREAD intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    spread_generic.c written by Paul Brook <paul@nowt.org>
 
-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
@@ -68,7 +68,7 @@ spread_'rtype_code` ('rtype` *ret, const 'rtype` *source,
 
   ncopies = pncopies;
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
 
       size_t ub, stride;
@@ -103,7 +103,7 @@ spread_'rtype_code` ('rtype` *ret, const 'rtype` *source,
       ret->offset = 0;
 
       /* internal_malloc_size allocates a single byte for zero size.  */
-      ret->data = internal_malloc_size (rs * sizeof('rtype_name`));
+      ret->base_addr = internal_malloc_size (rs * sizeof('rtype_name`));
       if (rs <= 0)
         return;
     }
@@ -182,8 +182,8 @@ spread_'rtype_code` ('rtype` *ret, const 'rtype` *source,
     }
   sstride0 = sstride[0];
   rstride0 = rstride[0];
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   while (sptr)
     {
@@ -243,9 +243,9 @@ spread_scalar_'rtype_code` ('rtype` *ret, const 'rtype_name` *source,
   if (along > 1)
     runtime_error ("dim outside of rank in spread()");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
-      ret->data = internal_malloc_size (ncopies * sizeof ('rtype_name`));
+      ret->base_addr = internal_malloc_size (ncopies * sizeof ('rtype_name`));
       ret->offset = 0;
       GFC_DIMENSION_SET(ret->dim[0], 0, ncopies - 1, 1);
     }
@@ -256,7 +256,7 @@ spread_scalar_'rtype_code` ('rtype` *ret, const 'rtype_name` *source,
 	runtime_error ("dim too large in spread()");
     }
 
-  dest = ret->data;
+  dest = ret->base_addr;
   stride = GFC_DESCRIPTOR_STRIDE(ret,0);
 
   for (n = 0; n < ncopies; n++)
diff --git a/libgfortran/m4/transpose.m4 b/libgfortran/m4/transpose.m4
index 34c2d6c..a60ca6d 100644
--- a/libgfortran/m4/transpose.m4
+++ b/libgfortran/m4/transpose.m4
@@ -1,8 +1,8 @@
 `/* Implementation of the TRANSPOSE intrinsic
-   Copyright 2003, 2005, 2006, 2007, 2009 Free Software Foundation, Inc.
+   Copyright 2003, 2005, 2006, 2007, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Tobias Schlüter
 
-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
@@ -50,7 +50,7 @@ transpose_'rtype_code` ('rtype` * const restrict ret,
 
   assert (GFC_DESCRIPTOR_RANK (source) == 2);
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       assert (GFC_DESCRIPTOR_RANK (ret) == 2);
       assert (ret->dtype == source->dtype);
@@ -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->data = internal_malloc_size (sizeof ('rtype_name`) * size0 ((array_t *) ret));
+      ret->base_addr = internal_malloc_size (sizeof ('rtype_name`) * size0 ((array_t *) ret));
       ret->offset = 0;
     } else if (unlikely (compile_options.bounds_check))
     {
@@ -95,8 +95,8 @@ transpose_'rtype_code` ('rtype` * const restrict ret,
   rxstride = GFC_DESCRIPTOR_STRIDE(ret,0);
   rystride = GFC_DESCRIPTOR_STRIDE(ret,1);
 
-  rptr = ret->data;
-  sptr = source->data;
+  rptr = ret->base_addr;
+  sptr = source->base_addr;
 
   for (y=0; y < ycount; y++)
     {
diff --git a/libgfortran/m4/unpack.m4 b/libgfortran/m4/unpack.m4
index bf348ae..0395715 100644
--- a/libgfortran/m4/unpack.m4
+++ b/libgfortran/m4/unpack.m4
@@ -1,9 +1,9 @@
 `/* Specific implementation of the UNPACK intrinsic
-   Copyright 2008, 2009 Free Software Foundation, Inc.
+   Copyright 2008, 2009, 2012 Free Software Foundation, Inc.
    Contributed by Thomas Koenig <tkoenig@gcc.gnu.org>, based on
    unpack_generic.c by Paul Brook <paul@nowt.org>.
 
-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
@@ -62,7 +62,7 @@ unpack0_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -82,7 +82,7 @@ unpack0_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -100,7 +100,7 @@ unpack0_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof ('rtype_name`));
+      ret->base_addr = internal_malloc_size (rs * sizeof ('rtype_name`));
     }
   else
     {
@@ -128,8 +128,8 @@ unpack0_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
     vstride0 = 1;
   rstride0 = rstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
@@ -206,7 +206,7 @@ unpack1_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
 
   empty = 0;
 
-  mptr = mask->data;
+  mptr = mask->base_addr;
 
   /* Use the same loop for all logical types, by using GFC_LOGICAL_1
      and using shifting to address size and endian issues.  */
@@ -226,7 +226,7 @@ unpack1_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
   else
     runtime_error ("Funny sized logical array");
 
-  if (ret->data == NULL)
+  if (ret->base_addr == NULL)
     {
       /* The front end has signalled that we need to populate the
 	 return array descriptor.  */
@@ -245,7 +245,7 @@ unpack1_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
 	  rs *= extent[n];
 	}
       ret->offset = 0;
-      ret->data = internal_malloc_size (rs * sizeof ('rtype_name`));
+      ret->base_addr = internal_malloc_size (rs * sizeof ('rtype_name`));
     }
   else
     {
@@ -277,9 +277,9 @@ unpack1_'rtype_code` ('rtype` *ret, const 'rtype` *vector,
   rstride0 = rstride[0];
   fstride0 = fstride[0];
   mstride0 = mstride[0];
-  rptr = ret->data;
-  fptr = field->data;
-  vptr = vector->data;
+  rptr = ret->base_addr;
+  fptr = field->base_addr;
+  vptr = vector->base_addr;
 
   while (rptr)
     {
diff --git a/libgfortran/runtime/bounds.c b/libgfortran/runtime/bounds.c
index 35bfa1e..b39b743 100644
--- a/libgfortran/runtime/bounds.c
+++ b/libgfortran/runtime/bounds.c
@@ -1,4 +1,4 @@
-/* Copyright (C) 2009
+/* Copyright (C) 2009, 2012
    Free Software Foundation, Inc.
    Contributed by Thomas Koenig
 
@@ -217,7 +217,7 @@ index_type count_0 (const gfc_array_l1 * array)
   rank = GFC_DESCRIPTOR_RANK (array);
   kind = GFC_DESCRIPTOR_SIZE (array);
 
-  base = array->data;
+  base = array->base_addr;
 
   if (kind == 1 || kind == 2 || kind == 4 || kind == 8
 #ifdef HAVE_GFC_LOGICAL_16
diff --git a/libgfortran/runtime/in_pack_generic.c b/libgfortran/runtime/in_pack_generic.c
index 64ae662..7ebebca 100644
--- a/libgfortran/runtime/in_pack_generic.c
+++ b/libgfortran/runtime/in_pack_generic.c
@@ -1,9 +1,9 @@
 /* Generic helper function for repacking arrays.
-   Copyright 2003, 2004, 2005, 2007, 2009, 2010
+   Copyright 2003, 2004, 2005, 2007, 2009, 2010, 2012
    Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -124,26 +124,26 @@ internal_pack (gfc_array_char * source)
 #endif
 
     case GFC_DTYPE_DERIVED_2:
-      if (GFC_UNALIGNED_2(source->data))
+      if (GFC_UNALIGNED_2(source->base_addr))
 	break;
       else
 	return internal_pack_2 ((gfc_array_i2 *) source);
 
     case GFC_DTYPE_DERIVED_4:
-      if (GFC_UNALIGNED_4(source->data))
+      if (GFC_UNALIGNED_4(source->base_addr))
 	break;
       else
 	return internal_pack_4 ((gfc_array_i4 *) source);
 
     case GFC_DTYPE_DERIVED_8:
-      if (GFC_UNALIGNED_8(source->data))
+      if (GFC_UNALIGNED_8(source->base_addr))
 	break;
       else
 	return internal_pack_8 ((gfc_array_i8 *) source);
 
 #ifdef HAVE_GFC_INTEGER_16
     case GFC_DTYPE_DERIVED_16:
-      if (GFC_UNALIGNED_16(source->data))
+      if (GFC_UNALIGNED_16(source->base_addr))
 	break;
       else
 	return internal_pack_16 ((gfc_array_i16 *) source);
@@ -175,12 +175,12 @@ internal_pack (gfc_array_char * source)
     }
 
   if (packed)
-    return source->data;
+    return source->base_addr;
 
    /* Allocate storage for the destination.  */
   destptr = internal_malloc_size (ssize * size);
   dest = (char *)destptr;
-  src = source->data;
+  src = source->base_addr;
   stride0 = stride[0] * size;
 
   while (src)
diff --git a/libgfortran/runtime/in_unpack_generic.c b/libgfortran/runtime/in_unpack_generic.c
index 32cc94b..f07d85f 100644
--- a/libgfortran/runtime/in_unpack_generic.c
+++ b/libgfortran/runtime/in_unpack_generic.c
@@ -1,9 +1,9 @@
 /* Generic helper function for repacking arrays.
-   Copyright 2003, 2004, 2005, 2007, 2009, 2010
+   Copyright 2003, 2004, 2005, 2007, 2009, 2010, 2012
    Free Software Foundation, Inc.
    Contributed by Paul Brook <paul@nowt.org>
 
-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
@@ -47,7 +47,7 @@ internal_unpack (gfc_array_char * d, const void * s)
   int size;
   int type_size;
 
-  dest = d->data;
+  dest = d->base_addr;
   /* This check may be redundant, but do it anyway.  */
   if (s == dest || !s)
     return;
@@ -140,7 +140,7 @@ internal_unpack (gfc_array_char * d, const void * s)
 #endif
 
     case GFC_DTYPE_DERIVED_2:
-      if (GFC_UNALIGNED_2(d->data) || GFC_UNALIGNED_2(s))
+      if (GFC_UNALIGNED_2(d->base_addr) || GFC_UNALIGNED_2(s))
 	break;
       else
 	{
@@ -148,7 +148,7 @@ internal_unpack (gfc_array_char * d, const void * s)
 	  return;
 	}
     case GFC_DTYPE_DERIVED_4:
-      if (GFC_UNALIGNED_4(d->data) || GFC_UNALIGNED_4(s))
+      if (GFC_UNALIGNED_4(d->base_addr) || GFC_UNALIGNED_4(s))
 	break;
       else
 	{
@@ -157,7 +157,7 @@ internal_unpack (gfc_array_char * d, const void * s)
 	}
 
     case GFC_DTYPE_DERIVED_8:
-      if (GFC_UNALIGNED_8(d->data) || GFC_UNALIGNED_8(s))
+      if (GFC_UNALIGNED_8(d->base_addr) || GFC_UNALIGNED_8(s))
 	break;
       else
 	{
@@ -167,7 +167,7 @@ internal_unpack (gfc_array_char * d, const void * s)
 
 #ifdef HAVE_GFC_INTEGER_16
     case GFC_DTYPE_DERIVED_16:
-      if (GFC_UNALIGNED_16(d->data) || GFC_UNALIGNED_16(s))
+      if (GFC_UNALIGNED_16(d->base_addr) || GFC_UNALIGNED_16(s))
 	break;
       else
 	{