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 49b4681e130..a5094358aac 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 edf98184865..541e7258516 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 d5cde25a983..8162ac1596e 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 1128adabf58..0e98cf64acb 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 97ad5a4f638..857175159a4 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 8846d34e5aa..9b9d16a8844 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 8f52b51fd79..e8b9cab99e8 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 7f3f69e11e4..c6055886b41 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 d2c4dbedbd6..6c4afeea01b 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 f9d563743d3..b2c4cde3c3d 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 f595826cc36..86fd28c1462 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 93d08d6ce6d..7d11614b039 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 28c35c10438..ae23dbced72 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 3d6e3ca231a..d3b05907082 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 7e3bcab4a1c..b48c04bfcc3 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 e894e561dc3..652244004fe 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 894ad0c291f..5b7776eb9b3 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 d0e5ee497a4..8a104d1bdfc 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 43af56b78fa..0edca41c492 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 6ddd701f97b..e3d95dca825 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 ec4bb8a084d..43e173bf417 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 ac7e8b762c7..f1f2539bc77 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 482af77f2a8..bf8554e1abe 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 2b3a69ef495..e3fd5b66e22 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 65173e3cc6a..f2315de95fa 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 4374c45f820..7566042c8fb 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 1a39632d217..4a8154c4c55 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 9d223634fce..7d25b7b0200 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 43358aa1224..2f565caeede 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 bf469fd1a00..b7f21caffb2 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 b9e19ffb6e9..320b705f382 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 9bd02142455..93ccf529b6d 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 1f99135eb94..a3f747993c9 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 b2cb7f17ce4..41cc1ea81f5 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 30f3d99dc35..9652222bda0 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 c3bf473e49c..8ccd63b5208 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 eb3a27a1c64..2de9208cf9d 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 d3776b911b0..8a9f1aaafbf 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 5f026acdfcb..136f5464c17 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 1cf216767ac..d363d90ae0c 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 c6033d0a58a..1b623c28f51 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 7a7b196eec4..2af1ccb9cf5 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 23a8f4fd925..d60f7f358ba 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 d16c1821603..88be6a8bad8 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 ef45da58c22..14fa83b1c60 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 f2c10bf0b68..ce5e185d690 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 2c5aa0953af..fee269a8cfe 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 1f9f91c7080..f1b0aebe936 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 55f3840106f..511e36989e4 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 aabb9923ed6..b52f5512cef 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 de7b66e998d..a0949e17ec9 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 71569e04261..e365f5f97b0 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 97ce9d1eaad..1d6b0db637b 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 74e3cb67d58..a627094ee43 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 ae52bc68940..833d7e8d515 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 142ad99cdf7..d86ce9f1b67 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 dc26c1af6df..2b582a5df6f 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 32ce3a4ea3e..294e3ca47ff 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 3c39f8e610f..6a95af3b516 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 4cd7dba479a..4a5a8637172 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 17acc684f1d..cb7e785f060 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 557ccc2aae7..b479001562f 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 b737cc7d22c..f16fd2fea66 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 68a7e5a0dca..e5b09a70f1b 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 1453f86b582..12670d27724 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 bcac6e7a5d4..1afa8761ba9 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 1d09a800690..11c6127ea0e 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 9ad8a33102f..558f3b145e9 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 6adae640e5e..72b00d84fd8 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 e632816c918..d045c92e920 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 c7199207e2a..612e7d83fd8 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 ec0c1c3aca9..e9a08071546 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 ce5d29df760..6fc836b7c16 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 347f0116cfc..d7bd8118244 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 aa5f08eb25b..afc8e2d9b13 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 0b08228ce70..57fcb176292 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 f436c8afa85..9e1d69fba16 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 76aff2e5925..4a5ccb2429b 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 e2b40c2983d..5fcb29d1af7 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 5ebdabb3fc9..aef94588875 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 f908a7ae49b..22f95e360dd 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 2e5811b8c20..58b18b86a0e 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 c4432758ac9..78de1c429e2 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 c54c78ed435..3496a83eea0 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 880c0e12782..0140dd311cd 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 020033a770c..fd8ce9f1794 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 1522dcd5a19..e71b5fb58ad 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 db56678510c..7525ea77ab3 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 f607e27b81c..19b6995a3fb 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 58e340b7722..73935067a16 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 46ed493d0e0..2e9e016816a 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 54ffe6248f4..6c6c655625a 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 5fbeeb7da1d..1ae8f7a9cb6 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 19ca9f1e577..dfe3369c0a7 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 558ed252e26..258a953d023 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 8e325549ce5..79a57712951 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 c11553180d2..87bc587acee 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 54208725dfb..4f72b6a4c80 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 72ad1fd58f0..422a1f03ea3 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 5649018db89..fbac3ad12ff 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 1ff74f6e222..e15ebf26e53 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 8ca75b9f99c..90b2b3a8ff7 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 18feabbcde4..dc75d83e78c 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 bc5a3b3ebb7..43879c7ddcd 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 ee0052f9328..3e3bcb5ffdd 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 3c28d196855..cec39633b65 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 616ec7acd97..985dcd6bdf6 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 8bb5f0d8f8a..7f385d713f6 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 5fb626b59e7..6d7cf6188b9 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 e4d252d4ec3..0d8bf75667f 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 a3866e4867f..b0c05c80a2d 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 0a4a5bda97f..9be70991764 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 435123bdc61..cb337239b2c 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 4b99bbecf22..48abb630b9c 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 1290355cc8e..3fae48df1be 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 5483fda44a2..d2a985d0a27 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 e4631db4ef8..6f57fca5aea 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 ddfc4df57f1..07815cf5518 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 ce324b5fdf6..dc5c57503e0 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 1b59bb62508..f01ec69905e 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 f1071d1e990..13f32e02820 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 2774558ea0e..066cedf6121 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 0d5183c41a6..f34984dcd49 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 51bc7b3ee8c..e28ba0fe89f 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 cebe571ccbe..d6594ab3004 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 d33299504ec..2a9b7546da9 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 3e424631153..2621fafe625 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 d6819aa713e..51758850181 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 691d034866a..a8067821b12 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 1e5b87cab3b..85dd48c7c5c 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 c6a73d8335f..d6a96ec4bf7 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 d954000c8ee..551d207212b 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 4ecb78418c1..d44ecd44fce 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 e5cd29156f3..ffd484ca678 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 2d209d78691..d03ba72a2c4 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 efd6958072e..4c528f27d5b 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 71850fcf8a6..5c0a8017f78 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 d825039e8d5..3d35b0c46c4 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 f70b5aa10be..ec2f43422dc 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 cda4a99ca75..0bee414b681 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 7901a4b15dd..cfb16f96716 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 f06d7b2bb2e..4bf9b8c0378 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 e6837aa61ff..c3721d9e51a 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 26c10c7b937..a756665a53a 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 c9dc6102056..59be8b71f12 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 7cd62ac3a90..107426e96c7 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 fd0cc217248..21a8dceaab8 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 97cd54bb550..2c7d860bc62 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 f9c455cb030..0638ab03332 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 ab1173c6c37..acc5689a0f6 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 9a02e1273ba..1cd2a45c459 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 584bdb81f54..177f06e4d97 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 c6f3efd7054..35739aa8159 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 5b676827d44..7a4a58e711b 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 148319d6210..fe42c27a6e8 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 f87f3edf3ea..19b233d80ec 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 51f2511b4cc..d4ef8ed2c6a 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 74aca03cf1b..814357d4577 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 3eaaa4c475c..736cced85a6 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 bc4cf27bb37..37ae298a6b9 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 d7e25ee7a9d..0cd73194763 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 21c08e9ef1a..f8ac97d08f2 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 2fbd7609d1e..617588528d3 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 613ad4813be..d938dd7b90d 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 7591cd5bda9..8f0528e8cc3 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 85601fb3c4f..cf57b7936d8 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 88e1ee89dfd..23c72931570 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 7bfc7a71e15..52c0ab74c90 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 d40885435e1..e35ad66d4be 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 6b35a7a9c56..37e877b8c1e 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 c9ee9bf07c2..dbd7ad37b11 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 0187a3d8afd..fa9dcf59416 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 ce3cd2789b4..5a8e4401a63 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 cedfbf3b5b2..d3ce2ede032 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 42211a993cd..dc2d60692a4 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 39cc14dd790..98da2decf92 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 9edd1057fb1..8302d23518d 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 0cb3ee02bf9..d8617ff9483 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 817e61e44d8..2cdbc7dafca 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 84c219b4fea..f8ef3a55c11 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 52f4f504f3d..0d6b52194fe 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 980cd7e4a8f..37d6561a8d2 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 26f79d468f9..3418ceee2f6 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 87f1927346e..c36785e67f5 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 73059620302..817f1c17ee8 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 38ba7f09d5a..d5a68eae635 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 29b37f40b94..c2235b8f3b2 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 cf4c3b643e2..05230f516b3 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 3c5d3384617..0ec3067f4bc 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 8b4b53f81a7..7b5ae81ff96 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 3a18e8c3672..c08cb66e238 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 bc13bee9eda..3e89ba7cf28 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 84d131a7aec..1097c3b1131 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 1f3e0549da1..326b9cfd799 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 6bda151ae4c..7bf30bd4d1e 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 c31cf4bcbbd..bc65a036f59 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 52ec2b078cf..baa2bc42dae 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 a53ed3452ce..482391dfb02 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 e8af3612742..73c1a235c43 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 8d3da2059d1..442f518c521 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 e7f24491f5f..f235b0931be 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 94d45c92d66..e0a54f2f8b1 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 fa07bcb8789..2d2882954d7 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 5cb23a6b694..08947086bd5 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 40854a12b8b..082d4097e32 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 4231d180d5d..60c8f731a33 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 8e5e5ddc41b..267bdae4045 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 9a54335c8e2..17fc399b0c5 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 f0b477ebd83..350d762fc2a 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 9d3d14ee5c9..22b10b8828b 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 edac05ccd58..f01ef6dc370 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 3c0f44127ca..91cbc7e6a26 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 a9239d28cbd..b04ebfcbd09 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 953ada7ef98..02f9b477f4f 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 3882000168b..bd7fb36ee6f 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 c8d181277da..cd300bbe218 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 d9ee1d75465..ed9fb22ae34 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 8394547568d..7f11f411230 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 9cffe844d80..18663d7664d 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 993116a8345..f6d48035069 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 3a52b4b7e21..2fdf455b02b 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 b490b3beec0..590a4dba8d3 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 701191f4041..ca30114a585 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 e69376590aa..8ec3c7c24a0 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 611ee57968c..d03f5135339 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 5b648038c4e..d3e8c7a9306 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 66b6167c669..dc5aeac43ce 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 f2c5c8c8385..8c7fae09025 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 4a477762b3b..9dcd8cfa6f9 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 621ba8d8b79..577c68a4476 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 e98de98c91c..121b0a86b47 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 85e15417851..c9ad6e80e2f 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 bfaec2fc910..d1a6941a940 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 c168affaea0..2aa75c19deb 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 81ed49a8208..451c8da6c95 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 a04b7af6969..9b68c5207f5 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 c5d112bd394..36d1eb149e1 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 7307192749b..8f75038efb0 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 c3b55cc1a9f..b8b81359030 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 489ff957aa1..932e190aeba 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 05172dbbb06..a57daba216b 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 df5cc3f3a6e..9516551b443 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 af35169891d..84b1e9676d0 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 58c0a3c8d02..184fdf0f8ed 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 71ffff0375b..5906c2a8c95 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 ba9d3fed347..b9f183a5b16 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 94166cadcb6..651350b62e0 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 140aa305f66..349ab55bf8a 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 d59510248b5..9680b76f347 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 34c1bde263e..5e5346518be 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 6e3487489e8..5e5a9116ff4 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 2e042871889..fd19554b362 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 e487ddfeda6..6105413dadc 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 b4b0a4ce736..803bd0cd7e8 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 a0164a1615b..71f353eb2fb 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 64c648774a9..2422ce62b1c 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 71a70da966f..6621f9f3948 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 0028ba1f861..846b5c226b1 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 492980e6769..2c6feffc458 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 cf05af1faaf..ddb021564c4 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 44446ebfee8..13dedbcc5ad 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 ca588dc2c93..72aba60fb4b 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 e16d32c5239..63f66ecdd7b 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 c8da0bc5f6a..ab646834825 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 43fbefc8ccb..dbf812d8e36 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 2c136deeae2..a4c83adc386 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 c97b747ee6d..e7288bb20d6 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 fa3873e1617..87216f49936 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 c2b6556b017..cb1f7f34993 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 2b859fca7d8..64f3991e363 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 49b23524fdb..4b6f4c67dd4 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 802e00aefd2..c42aca9d63d 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 fa2d4ebe2eb..3f573999629 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 d6664de4340..49910ac7e4c 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 d8a5bafe235..fb4efb0fa24 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 0bfba7f4145..46789ca8adc 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 e1a475f6f12..ef91ca55bc8 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 a2902908e76..dbcc0293a21 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 111c4ccea5f..0e654eb75b8 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 2a4864ba41c..41676510f88 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 5a5d87064e6..e65b942bd27 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 e990408b0a4..599da3fe129 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 1e3b3055b8f..ddb8163d5a5 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 ef86bc59007..d023a2774f1 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 9678e8768a0..17bffbe5d0b 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 fac0900cbb4..656205fc153 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 0dd9e7bf5ad..2c77f1cf2b3 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 b982bfea04a..2a289f4ee40 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 0bf2b69d79d..d87e086bfed 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 a34e63cdd89..7964eb91276 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 42dea7b2810..2fd67828d95 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 4eb6d642008..c746e073f76 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 8e2c7b3aeb7..02d6cc86b1b 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 12ef64d3523..5e6d3b98df3 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 645ef436bff..e199544f193 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 adb29b51c73..68e8539a785 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 9f588a5da51..42f676eaf92 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 292e66f7117..ca98de1bfe1 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 8fd563fc9d5..863191af478 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 e5839806054..45de9f4f649 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 e740d12a7e7..f86368801b6 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 31115bdfdde..af0b43f2e97 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 a63f62c95ff..81e1584a9cf 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 83223940330..b523bb067ec 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 f8cfd823f95..5f15534f777 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 9b15e470269..adfd0adf70f 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 ddf772b0e42..07b80c9d684 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 2b2e02d1c98..817968881bf 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 4d2e40660fb..b1f7b41b53e 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 1748c1d0561..8c854cc2fb6 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 09054b6138e..f60a69e248c 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 9b89a5bea79..150509deaba 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 2d9931f02ac..f33830d43ae 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 116f213f9fc..2106202b57c 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 7298eeceedb..c8903cf3e92 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 f5dcb93df81..517474ef86d 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 77920ea60d8..c21a61e0895 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 c7257bb2f01..d77b049db4f 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 e3cdde67790..95ce538cc43 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 2f720640370..59412d3906c 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 796df2edd45..34c226254c4 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 b25d2869ac9..c50dc71c6a9 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 f4b763fc1c5..3e022b98672 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 dc9b4d398ce..0d343cde7fc 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 026dd1adc0d..5da73d4e170 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 3c386363df4..c785f84c0d9 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 e36e1f1d04a..b5dc91ea067 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 6ceed2000e0..8b7dd0a641f 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 b4f82786964..cd2a827fbfc 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 d90bc3022d7..96c6d712c5c 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 327ad5128fd..cab7feb4b47 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 7b489ade4c7..a27de4e7c60 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 de1e07facab..77d600a5ecc 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 35576b85bda..a6fede034c8 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 5b39711cea6..b16690ac1fc 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 2eeb24b8444..2a478f18899 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 28821f1546d..a0d99104b17 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 b0c2fff5719..03fbbef24ed 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 db624996def..123f5e1980f 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 148dcfb59a0..f2f6c36f964 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 acef7eaa718..d9e7f893f8e 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 5c0d22e8191..567222b7146 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 49a4f73404a..88fce1aa9b7 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 339e1d89965..691edd1733c 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 1c19575ffb8..b5c8bb4ff43 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 14e501c67fe..86d43506c6a 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 68e1c5e18a3..1cd30739cd5 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 e72f1d8a8f7..b36e8e04ae3 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 a4337aad8f7..7cee37bd647 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 661c54e1da5..e8b29dbd3b5 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 bb42f2a6c47..6a7ce5c49ef 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 c5bad25f78a..87245ae04a2 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 e1882d077c2..e88e84e0adc 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 d1486f3942e..26ea7e0d875 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 c079cca9903..66445ce8301 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 89a2e65297c..52c0022f43e 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 34c2d6c06aa..a60ca6d27cc 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 bf348aebe1f..0395715a0c1 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 35bfa1e2a46..b39b74398d3 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 64ae66204e5..7ebebcad16a 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 32cc94b1169..f07d85f2646 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
 	{