Lines 42-48
Link Here
|
42 |
#include "trans-stmt.h" |
42 |
#include "trans-stmt.h" |
43 |
#include "dependency.h" |
43 |
#include "dependency.h" |
44 |
|
44 |
|
45 |
static tree gfc_trans_structure_assign (tree dest, gfc_expr * expr); |
45 |
static tree gfc_trans_structure_assign (gfc_se * outer_se, tree dest, gfc_expr * expr); |
46 |
static void gfc_apply_interface_mapping_to_expr (gfc_interface_mapping *, |
46 |
static void gfc_apply_interface_mapping_to_expr (gfc_interface_mapping *, |
47 |
gfc_expr *); |
47 |
gfc_expr *); |
48 |
|
48 |
|
Lines 1702-1708
Link Here
|
1702 |
|
1702 |
|
1703 |
if (intent != INTENT_OUT) |
1703 |
if (intent != INTENT_OUT) |
1704 |
{ |
1704 |
{ |
1705 |
tmp = gfc_trans_scalar_assign (&lse, &rse, expr->ts.type); |
1705 |
tmp = gfc_trans_scalar_assign (&lse, &rse, expr->ts, true, false); |
1706 |
gfc_add_expr_to_block (&body, tmp); |
1706 |
gfc_add_expr_to_block (&body, tmp); |
1707 |
gcc_assert (rse.ss == gfc_ss_terminator); |
1707 |
gcc_assert (rse.ss == gfc_ss_terminator); |
1708 |
gfc_trans_scalarizing_loops (&loop, &body); |
1708 |
gfc_trans_scalarizing_loops (&loop, &body); |
Lines 1787-1793
Link Here
|
1787 |
|
1787 |
|
1788 |
gcc_assert (lse.ss == gfc_ss_terminator); |
1788 |
gcc_assert (lse.ss == gfc_ss_terminator); |
1789 |
|
1789 |
|
1790 |
tmp = gfc_trans_scalar_assign (&lse, &rse, expr->ts.type); |
1790 |
tmp = gfc_trans_scalar_assign (&lse, &rse, expr->ts, false, false); |
1791 |
gfc_add_expr_to_block (&body, tmp); |
1791 |
gfc_add_expr_to_block (&body, tmp); |
1792 |
|
1792 |
|
1793 |
/* Generate the copying loops. */ |
1793 |
/* Generate the copying loops. */ |
Lines 1859-1864
Link Here
|
1859 |
gfc_ss *argss; |
1859 |
gfc_ss *argss; |
1860 |
gfc_ss_info *info; |
1860 |
gfc_ss_info *info; |
1861 |
int byref; |
1861 |
int byref; |
|
|
1862 |
int parm_kind; |
1862 |
tree type; |
1863 |
tree type; |
1863 |
tree var; |
1864 |
tree var; |
1864 |
tree len; |
1865 |
tree len; |
Lines 1872-1877
Link Here
|
1872 |
gfc_expr *e; |
1873 |
gfc_expr *e; |
1873 |
gfc_symbol *fsym; |
1874 |
gfc_symbol *fsym; |
1874 |
stmtblock_t post; |
1875 |
stmtblock_t post; |
|
|
1876 |
enum {MISSING = 0, ELEMENTAL, SCALAR, SCALAR_POINTER, ARRAY}; |
1875 |
|
1877 |
|
1876 |
arglist = NULL_TREE; |
1878 |
arglist = NULL_TREE; |
1877 |
retargs = NULL_TREE; |
1879 |
retargs = NULL_TREE; |
Lines 1914-1919
Link Here
|
1914 |
{ |
1916 |
{ |
1915 |
e = arg->expr; |
1917 |
e = arg->expr; |
1916 |
fsym = formal ? formal->sym : NULL; |
1918 |
fsym = formal ? formal->sym : NULL; |
|
|
1919 |
parm_kind = MISSING; |
1917 |
if (e == NULL) |
1920 |
if (e == NULL) |
1918 |
{ |
1921 |
{ |
1919 |
|
1922 |
|
Lines 1942-1947
Link Here
|
1942 |
/* An elemental function inside a scalarized loop. */ |
1945 |
/* An elemental function inside a scalarized loop. */ |
1943 |
gfc_init_se (&parmse, se); |
1946 |
gfc_init_se (&parmse, se); |
1944 |
gfc_conv_expr_reference (&parmse, e); |
1947 |
gfc_conv_expr_reference (&parmse, e); |
|
|
1948 |
parm_kind = ELEMENTAL; |
1945 |
} |
1949 |
} |
1946 |
else |
1950 |
else |
1947 |
{ |
1951 |
{ |
Lines 1952-1963
Link Here
|
1952 |
if (argss == gfc_ss_terminator) |
1956 |
if (argss == gfc_ss_terminator) |
1953 |
{ |
1957 |
{ |
1954 |
gfc_conv_expr_reference (&parmse, e); |
1958 |
gfc_conv_expr_reference (&parmse, e); |
|
|
1959 |
parm_kind = SCALAR; |
1955 |
if (fsym && fsym->attr.pointer |
1960 |
if (fsym && fsym->attr.pointer |
1956 |
&& e->expr_type != EXPR_NULL) |
1961 |
&& e->expr_type != EXPR_NULL) |
1957 |
{ |
1962 |
{ |
1958 |
/* Scalar pointer dummy args require an extra level of |
1963 |
/* Scalar pointer dummy args require an extra level of |
1959 |
indirection. The null pointer already contains |
1964 |
indirection. The null pointer already contains |
1960 |
this level of indirection. */ |
1965 |
this level of indirection. */ |
|
|
1966 |
parm_kind = SCALAR_POINTER; |
1961 |
parmse.expr = build_fold_addr_expr (parmse.expr); |
1967 |
parmse.expr = build_fold_addr_expr (parmse.expr); |
1962 |
} |
1968 |
} |
1963 |
} |
1969 |
} |
Lines 2014-2019
Link Here
|
2014 |
gfc_add_block_to_block (&se->pre, &parmse.pre); |
2020 |
gfc_add_block_to_block (&se->pre, &parmse.pre); |
2015 |
gfc_add_block_to_block (&post, &parmse.post); |
2021 |
gfc_add_block_to_block (&post, &parmse.post); |
2016 |
|
2022 |
|
|
|
2023 |
/* Allocated allocatable components of derived types must be |
2024 |
deallocated for INTENT(OUT) dummy arguments and non-variable |
2025 |
scalars. Non-variable arrays are dealt with in trans-array.c |
2026 |
(gfc_conv_array_parameter). */ |
2027 |
if (e && e->ts.type == BT_DERIVED |
2028 |
&& e->ts.derived->attr.alloc_comp |
2029 |
&& ((formal && formal->sym->attr.intent == INTENT_OUT) |
2030 |
|| |
2031 |
(e->expr_type != EXPR_VARIABLE && !e->rank))) |
2032 |
{ |
2033 |
int parm_rank; |
2034 |
tmp = build_fold_indirect_ref (parmse.expr); |
2035 |
parm_rank = e->rank; |
2036 |
switch (parm_kind) |
2037 |
{ |
2038 |
case (ELEMENTAL): |
2039 |
case (SCALAR): |
2040 |
parm_rank = 0; |
2041 |
break; |
2042 |
|
2043 |
case (SCALAR_POINTER): |
2044 |
tmp = build_fold_indirect_ref (tmp); |
2045 |
break; |
2046 |
case (ARRAY): |
2047 |
tmp = parmse.expr; |
2048 |
break; |
2049 |
} |
2050 |
|
2051 |
tmp = deallocate_alloc_comp (e->ts.derived, tmp, parm_rank); |
2052 |
if (e->expr_type == EXPR_VARIABLE && e->symtree->n.sym->attr.optional) |
2053 |
tmp = build3_v (COND_EXPR, gfc_conv_expr_present (e->symtree->n.sym), |
2054 |
tmp, build_empty_stmt ()); |
2055 |
|
2056 |
if (e->expr_type == EXPR_FUNCTION) |
2057 |
/* Don't deallocate function results until they have been used. */ |
2058 |
gfc_add_expr_to_block (&se->post, tmp); |
2059 |
else |
2060 |
gfc_add_expr_to_block (&se->pre, tmp); |
2061 |
} |
2062 |
|
2017 |
/* Character strings are passed as two parameters, a length and a |
2063 |
/* Character strings are passed as two parameters, a length and a |
2018 |
pointer. */ |
2064 |
pointer. */ |
2019 |
if (parmse.string_length != NULL_TREE) |
2065 |
if (parmse.string_length != NULL_TREE) |
Lines 2590-2596
Link Here
|
2590 |
|
2636 |
|
2591 |
gfc_conv_expr (&rse, expr); |
2637 |
gfc_conv_expr (&rse, expr); |
2592 |
|
2638 |
|
2593 |
tmp = gfc_trans_scalar_assign (&lse, &rse, cm->ts.type); |
2639 |
tmp = gfc_trans_scalar_assign (&lse, &rse, cm->ts, true, false); |
2594 |
gfc_add_expr_to_block (&body, tmp); |
2640 |
gfc_add_expr_to_block (&body, tmp); |
2595 |
|
2641 |
|
2596 |
gcc_assert (rse.ss == gfc_ss_terminator); |
2642 |
gcc_assert (rse.ss == gfc_ss_terminator); |
Lines 2614-2627
Link Here
|
2614 |
/* Assign a single component of a derived type constructor. */ |
2660 |
/* Assign a single component of a derived type constructor. */ |
2615 |
|
2661 |
|
2616 |
static tree |
2662 |
static tree |
2617 |
gfc_trans_subcomponent_assign (tree dest, gfc_component * cm, gfc_expr * expr) |
2663 |
gfc_trans_subcomponent_assign (gfc_se * outer_se, tree dest, |
|
|
2664 |
gfc_component * cm, gfc_expr * expr) |
2618 |
{ |
2665 |
{ |
2619 |
gfc_se se; |
2666 |
gfc_se se; |
|
|
2667 |
gfc_se lse; |
2620 |
gfc_ss *rss; |
2668 |
gfc_ss *rss; |
2621 |
stmtblock_t block; |
2669 |
stmtblock_t block; |
2622 |
tree tmp; |
2670 |
tree tmp; |
|
|
2671 |
tree offset; |
2672 |
int n; |
2623 |
|
2673 |
|
2624 |
gfc_start_block (&block); |
2674 |
gfc_start_block (&block); |
|
|
2675 |
|
2676 |
#if 0 |
2677 |
if (cm->ts.type == BT_DERIVED && cm->ts.derived->attr.alloc_comp) |
2678 |
gfc_todo_error ("derived types with allocatable components as " |
2679 |
"arguments of derived type constructors"); |
2680 |
#endif |
2625 |
if (cm->pointer) |
2681 |
if (cm->pointer) |
2626 |
{ |
2682 |
{ |
2627 |
gfc_init_se (&se, NULL); |
2683 |
gfc_init_se (&se, NULL); |
Lines 2654-2673
Link Here
|
2654 |
} |
2710 |
} |
2655 |
else if (cm->dimension) |
2711 |
else if (cm->dimension) |
2656 |
{ |
2712 |
{ |
2657 |
tmp = gfc_trans_subarray_assign (dest, cm, expr); |
2713 |
if (cm->allocatable && expr->expr_type == EXPR_NULL) |
2658 |
gfc_add_expr_to_block (&block, tmp); |
2714 |
gfc_conv_descriptor_data_set (&block, dest, null_pointer_node); |
|
|
2715 |
else if (cm->allocatable) |
2716 |
{ |
2717 |
tree tmp2; |
2718 |
|
2719 |
gfc_init_se (&se, NULL); |
2720 |
gfc_init_se (&lse, NULL); |
2721 |
|
2722 |
se.want_pointer = 0; |
2723 |
gfc_conv_expr_descriptor (&se, expr, gfc_walk_expr (expr)); |
2724 |
if (cm->ts.type == BT_CHARACTER) |
2725 |
lse.string_length = cm->ts.cl->backend_decl; |
2726 |
|
2727 |
lse.expr = dest; |
2728 |
|
2729 |
/* Clean up temporaries at the right time. */ |
2730 |
if (expr->expr_type == EXPR_FUNCTION) |
2731 |
{ |
2732 |
stmtblock_t tmp_block; |
2733 |
|
2734 |
/* Prevent the freeing of the memory after the array assignment to |
2735 |
the derived type component.... */ |
2736 |
gfc_init_block (&tmp_block); |
2737 |
gfc_add_block_to_block (&tmp_block, &se.post); |
2738 |
gfc_conv_descriptor_data_set (&se.post, se.expr, null_pointer_node); |
2739 |
gfc_add_block_to_block (&se.post, &tmp_block); |
2740 |
|
2741 |
/* ...and do it when the derived type is completed. */ |
2742 |
tmp = gfc_conv_descriptor_data_get (lse.expr); |
2743 |
tmp = convert (pvoid_type_node, tmp); |
2744 |
tmp = gfc_chainon_list (NULL_TREE, tmp); |
2745 |
tmp = build_function_call_expr (gfor_fndecl_internal_free, tmp); |
2746 |
gfc_add_expr_to_block (&outer_se->post, tmp); |
2747 |
} |
2748 |
|
2749 |
tmp = gfc_trans_scalar_assign (&lse, &se, cm->ts, true, false); |
2750 |
gfc_add_expr_to_block (&block, tmp); |
2751 |
|
2752 |
/* Shift the lbound and ubound of temporaries to being unity, rather |
2753 |
than zero, based. Calculate the offset for all cases. */ |
2754 |
offset = gfc_conv_descriptor_offset (dest); |
2755 |
gfc_add_modify_expr (&block, offset, gfc_index_zero_node); |
2756 |
tmp2 =gfc_create_var (gfc_array_index_type, NULL); |
2757 |
for (n = 0; n < expr->rank; n++) |
2758 |
{ |
2759 |
if (expr->expr_type != EXPR_VARIABLE |
2760 |
&& expr->expr_type != EXPR_CONSTANT) |
2761 |
{ |
2762 |
tmp = gfc_conv_descriptor_ubound (dest, gfc_rank_cst[n]); |
2763 |
gfc_add_modify_expr (&block, tmp, |
2764 |
fold_build2 (PLUS_EXPR, gfc_array_index_type, |
2765 |
tmp, gfc_index_one_node)); |
2766 |
tmp = gfc_conv_descriptor_lbound (dest, gfc_rank_cst[n]); |
2767 |
gfc_add_modify_expr (&block, tmp, gfc_index_one_node); |
2768 |
} |
2769 |
tmp = fold_build2 (MULT_EXPR, gfc_array_index_type, |
2770 |
gfc_conv_descriptor_lbound (dest, gfc_rank_cst[n]), |
2771 |
gfc_conv_descriptor_stride (dest, gfc_rank_cst[n])); |
2772 |
gfc_add_modify_expr (&block, tmp2, tmp); |
2773 |
tmp = fold_build2 (MINUS_EXPR, gfc_array_index_type, offset, tmp2); |
2774 |
gfc_add_modify_expr (&block, offset, tmp); |
2775 |
} |
2776 |
} |
2777 |
else |
2778 |
{ |
2779 |
tmp = gfc_trans_subarray_assign (dest, cm, expr); |
2780 |
gfc_add_expr_to_block (&block, tmp); |
2781 |
} |
2659 |
} |
2782 |
} |
2660 |
else if (expr->ts.type == BT_DERIVED) |
2783 |
else if (expr->ts.type == BT_DERIVED) |
2661 |
{ |
2784 |
{ |
2662 |
/* Nested derived type. */ |
2785 |
/* Nested derived type. */ |
2663 |
tmp = gfc_trans_structure_assign (dest, expr); |
2786 |
tmp = gfc_trans_structure_assign (outer_se, dest, expr); |
2664 |
gfc_add_expr_to_block (&block, tmp); |
2787 |
gfc_add_expr_to_block (&block, tmp); |
2665 |
} |
2788 |
} |
2666 |
else |
2789 |
else |
2667 |
{ |
2790 |
{ |
2668 |
/* Scalar component. */ |
2791 |
/* Scalar component. */ |
2669 |
gfc_se lse; |
|
|
2670 |
|
2671 |
gfc_init_se (&se, NULL); |
2792 |
gfc_init_se (&se, NULL); |
2672 |
gfc_init_se (&lse, NULL); |
2793 |
gfc_init_se (&lse, NULL); |
2673 |
|
2794 |
|
Lines 2675-2681
Link Here
|
2675 |
if (cm->ts.type == BT_CHARACTER) |
2796 |
if (cm->ts.type == BT_CHARACTER) |
2676 |
lse.string_length = cm->ts.cl->backend_decl; |
2797 |
lse.string_length = cm->ts.cl->backend_decl; |
2677 |
lse.expr = dest; |
2798 |
lse.expr = dest; |
2678 |
tmp = gfc_trans_scalar_assign (&lse, &se, cm->ts.type); |
2799 |
tmp = gfc_trans_scalar_assign (&lse, &se, cm->ts, true, false); |
2679 |
gfc_add_expr_to_block (&block, tmp); |
2800 |
gfc_add_expr_to_block (&block, tmp); |
2680 |
} |
2801 |
} |
2681 |
return gfc_finish_block (&block); |
2802 |
return gfc_finish_block (&block); |
Lines 2684-2690
Link Here
|
2684 |
/* Assign a derived type constructor to a variable. */ |
2805 |
/* Assign a derived type constructor to a variable. */ |
2685 |
|
2806 |
|
2686 |
static tree |
2807 |
static tree |
2687 |
gfc_trans_structure_assign (tree dest, gfc_expr * expr) |
2808 |
gfc_trans_structure_assign (gfc_se * outer_se, tree dest, gfc_expr * expr) |
2688 |
{ |
2809 |
{ |
2689 |
gfc_constructor *c; |
2810 |
gfc_constructor *c; |
2690 |
gfc_component *cm; |
2811 |
gfc_component *cm; |
Lines 2702-2708
Link Here
|
2702 |
|
2823 |
|
2703 |
field = cm->backend_decl; |
2824 |
field = cm->backend_decl; |
2704 |
tmp = build3 (COMPONENT_REF, TREE_TYPE (field), dest, field, NULL_TREE); |
2825 |
tmp = build3 (COMPONENT_REF, TREE_TYPE (field), dest, field, NULL_TREE); |
2705 |
tmp = gfc_trans_subcomponent_assign (tmp, cm, c->expr); |
2826 |
tmp = gfc_trans_subcomponent_assign (outer_se, tmp, cm, c->expr); |
2706 |
gfc_add_expr_to_block (&block, tmp); |
2827 |
gfc_add_expr_to_block (&block, tmp); |
2707 |
} |
2828 |
} |
2708 |
return gfc_finish_block (&block); |
2829 |
return gfc_finish_block (&block); |
Lines 2729-2735
Link Here
|
2729 |
{ |
2850 |
{ |
2730 |
/* Create a temporary variable and fill it in. */ |
2851 |
/* Create a temporary variable and fill it in. */ |
2731 |
se->expr = gfc_create_var (type, expr->ts.derived->name); |
2852 |
se->expr = gfc_create_var (type, expr->ts.derived->name); |
2732 |
tmp = gfc_trans_structure_assign (se->expr, expr); |
2853 |
tmp = gfc_trans_structure_assign (se, se->expr, expr); |
2733 |
gfc_add_expr_to_block (&se->pre, tmp); |
2854 |
gfc_add_expr_to_block (&se->pre, tmp); |
2734 |
return; |
2855 |
return; |
2735 |
} |
2856 |
} |
Lines 3036-3048
Link Here
|
3036 |
strings. */ |
3157 |
strings. */ |
3037 |
|
3158 |
|
3038 |
tree |
3159 |
tree |
3039 |
gfc_trans_scalar_assign (gfc_se * lse, gfc_se * rse, bt type) |
3160 |
gfc_trans_scalar_assign (gfc_se * lse, gfc_se * rse, gfc_typespec ts, |
|
|
3161 |
bool l_is_temp, bool r_is_var) |
3040 |
{ |
3162 |
{ |
3041 |
stmtblock_t block; |
3163 |
stmtblock_t block; |
|
|
3164 |
tree tmp; |
3165 |
tree cond; |
3042 |
|
3166 |
|
3043 |
gfc_init_block (&block); |
3167 |
gfc_init_block (&block); |
3044 |
|
3168 |
|
3045 |
if (type == BT_CHARACTER) |
3169 |
if (ts.type == BT_CHARACTER) |
3046 |
{ |
3170 |
{ |
3047 |
gcc_assert (lse->string_length != NULL_TREE |
3171 |
gcc_assert (lse->string_length != NULL_TREE |
3048 |
&& rse->string_length != NULL_TREE); |
3172 |
&& rse->string_length != NULL_TREE); |
Lines 3056-3061
Link Here
|
3056 |
gfc_trans_string_copy (&block, lse->string_length, lse->expr, |
3180 |
gfc_trans_string_copy (&block, lse->string_length, lse->expr, |
3057 |
rse->string_length, rse->expr); |
3181 |
rse->string_length, rse->expr); |
3058 |
} |
3182 |
} |
|
|
3183 |
else if (ts.type == BT_DERIVED && ts.derived->attr.alloc_comp) |
3184 |
{ |
3185 |
cond = NULL_TREE; |
3186 |
|
3187 |
/* Are the rhs and the lhs the same? */ |
3188 |
if (r_is_var) |
3189 |
{ |
3190 |
cond = fold_build2 (EQ_EXPR, boolean_type_node, |
3191 |
build_fold_addr_expr (lse->expr), |
3192 |
build_fold_addr_expr (rse->expr)); |
3193 |
cond = gfc_evaluate_now (cond, &lse->pre); |
3194 |
} |
3195 |
|
3196 |
/* Deallocate the lhs allocated components as long as it is not |
3197 |
the same as the rhs. */ |
3198 |
if (!l_is_temp) |
3199 |
{ |
3200 |
tmp = deallocate_alloc_comp (ts.derived, lse->expr, 0); |
3201 |
if (r_is_var) |
3202 |
tmp = build3_v (COND_EXPR, cond, build_empty_stmt (), tmp); |
3203 |
gfc_add_expr_to_block (&lse->pre, tmp); |
3204 |
} |
3205 |
|
3206 |
gfc_add_block_to_block (&block, &lse->pre); |
3207 |
gfc_add_block_to_block (&block, &rse->pre); |
3208 |
|
3209 |
gfc_add_modify_expr (&block, lse->expr, |
3210 |
fold_convert (TREE_TYPE (lse->expr), rse->expr)); |
3211 |
|
3212 |
/* Do a deep copy if the rhs is a variable, as long as it is not the |
3213 |
same as the lhs. Otherwise, nullify the data fields so that the |
3214 |
lhs retains the allocated resources. */ |
3215 |
if (r_is_var) |
3216 |
{ |
3217 |
tmp = copy_alloc_comp (ts.derived, rse->expr, lse->expr, 0); |
3218 |
tmp = build3_v (COND_EXPR, cond, build_empty_stmt (), tmp); |
3219 |
gfc_add_expr_to_block (&block, tmp); |
3220 |
} |
3221 |
else |
3222 |
{ |
3223 |
tmp = nullify_alloc_comp (ts.derived, rse->expr, 0); |
3224 |
gfc_add_expr_to_block (&block, tmp); |
3225 |
} |
3226 |
} |
3059 |
else |
3227 |
else |
3060 |
{ |
3228 |
{ |
3061 |
gfc_add_block_to_block (&block, &lse->pre); |
3229 |
gfc_add_block_to_block (&block, &lse->pre); |
Lines 3250-3256
Link Here
|
3250 |
else |
3418 |
else |
3251 |
gfc_conv_expr (&lse, expr1); |
3419 |
gfc_conv_expr (&lse, expr1); |
3252 |
|
3420 |
|
3253 |
tmp = gfc_trans_scalar_assign (&lse, &rse, expr1->ts.type); |
3421 |
tmp = gfc_trans_scalar_assign (&lse, &rse, expr1->ts, |
|
|
3422 |
loop.temp_ss != NULL, |
3423 |
expr2->expr_type == EXPR_VARIABLE); |
3254 |
gfc_add_expr_to_block (&body, tmp); |
3424 |
gfc_add_expr_to_block (&body, tmp); |
3255 |
|
3425 |
|
3256 |
if (lss == gfc_ss_terminator) |
3426 |
if (lss == gfc_ss_terminator) |
Lines 3283-3291
Link Here
|
3283 |
gcc_assert (lse.ss == gfc_ss_terminator |
3453 |
gcc_assert (lse.ss == gfc_ss_terminator |
3284 |
&& rse.ss == gfc_ss_terminator); |
3454 |
&& rse.ss == gfc_ss_terminator); |
3285 |
|
3455 |
|
3286 |
tmp = gfc_trans_scalar_assign (&lse, &rse, expr1->ts.type); |
3456 |
tmp = gfc_trans_scalar_assign (&lse, &rse, expr1->ts, false, false); |
3287 |
gfc_add_expr_to_block (&body, tmp); |
3457 |
gfc_add_expr_to_block (&body, tmp); |
3288 |
} |
3458 |
} |
|
|
3459 |
|
3289 |
/* Generate the copying loops. */ |
3460 |
/* Generate the copying loops. */ |
3290 |
gfc_trans_scalarizing_loops (&loop, &body); |
3461 |
gfc_trans_scalarizing_loops (&loop, &body); |
3291 |
|
3462 |
|