gcc/fortran/trans-intrinsic.c

1191 	  for (int n = 0; n < se->ss->loop->dimen; n++)
1192 	    if (se->loop->to[n] == NULL_TREE)
1194 		se->loop->from[n] =
1196 		se->loop->to[n] =
1317      temporary and a loop.  */
1442   stmtblock_t loop;
1492       /* Create an implicit second parameter from the loop variable.  */
1495       gcc_assert (se->loop->dimen == 1);
1498       dim_arg = se->loop->loopvar[0];
1606   gfc_init_block (&loop);
1609   gfc_add_modify (&loop, ml, m);
1618   gfc_add_modify (&loop, m,
1628   gfc_add_expr_to_block (&loop, tmp);
1630   /* Increment loop variable: i++.  */
1631   gfc_add_modify (&loop, loop_var,
1636   /* Making the loop... actually loop!  */
1637   tmp = gfc_finish_block (&loop);
1864       /* Create an implicit second parameter from the loop variable.  */
1866       gcc_assert (se->loop->dimen == 1);
1869       bound = se->loop->loopvar[0];
1872 			       se->loop->from[0]);
2076       /* Create an implicit second parameter from the loop variable.  */
2079       gcc_assert (se->loop->dimen == 1);
2082       bound = se->loop->loopvar[0];
3156   gfc_loopinfo loop;
3183   gfc_init_loopinfo (&loop);
3186   gfc_add_ss_to_loop (&loop, arrayss);
3188   /* Initialize the loop.  */
3189   gfc_conv_ss_startstride (&loop);
3190   gfc_conv_loop_setup (&loop, &expr->where);
3193   /* Generate the loop body.  */
3194   gfc_start_scalarized_body (&loop, &body);
3204   /* And break out of the loop.  */
3212   gfc_copy_loopinfo_to_se (&arrayse, &loop);
3223   gfc_trans_scalarizing_loops (&loop, &body);
3227   gfc_add_expr_to_block (&loop.pre, tmp);
3229   gfc_add_block_to_block (&se->pre, &loop.pre);
3230   gfc_add_block_to_block (&se->pre, &loop.post);
3231   gfc_cleanup_loop (&loop);
3244   gfc_loopinfo loop;
3267   gfc_init_loopinfo (&loop);
3268   gfc_add_ss_to_loop (&loop, arrayss);
3270   /* Initialize the loop.  */
3271   gfc_conv_ss_startstride (&loop);
3272   gfc_conv_loop_setup (&loop, &expr->where);
3275   /* Generate the loop body.  */
3276   gfc_start_scalarized_body (&loop, &body);
3283   gfc_copy_loopinfo_to_se (&arrayse, &loop);
3293   gfc_trans_scalarizing_loops (&loop, &body);
3295   gfc_add_block_to_block (&se->pre, &loop.pre);
3296   gfc_add_block_to_block (&se->pre, &loop.post);
3297   gfc_cleanup_loop (&loop);
3310   gcc_assert (se->ss == se->ss->loop->ss);
3312   return se->ss->loop;
3327   gfc_loopinfo loop, *ploop;
3399       gfc_init_loopinfo (&loop);
3400       gfc_add_ss_to_loop (&loop, arrayss);
3402 	gfc_add_ss_to_loop (&loop, maskss);
3404       /* Initialize the loop.  */
3405       gfc_conv_ss_startstride (&loop);
3406       gfc_conv_loop_setup (&loop, &expr->where);
3412       ploop = &loop;
3420   /* Generate the loop body.  */
3531   /* For a scalar mask, enclose the loop in an if statement.  */
3591   gfc_loopinfo loop;
3621   gfc_init_loopinfo (&loop);
3622   gfc_add_ss_to_loop (&loop, arrayss1);
3623   gfc_add_ss_to_loop (&loop, arrayss2);
3625   /* Initialize the loop.  */
3626   gfc_conv_ss_startstride (&loop);
3627   gfc_conv_loop_setup (&loop, &expr->where);
3632   /* Generate the loop body.  */
3633   gfc_start_scalarized_body (&loop, &body);
3638   gfc_copy_loopinfo_to_se (&arrayse1, &loop);
3648   gfc_copy_loopinfo_to_se (&arrayse2, &loop);
3668   /* Finish up the loop block and the loop.  */
3672   gfc_trans_scalarizing_loops (&loop, &body);
3673   gfc_add_block_to_block (&se->pre, &loop.pre);
3674   gfc_add_block_to_block (&se->pre, &loop.post);
3675   gfc_cleanup_loop (&loop);
3763   gfc_loopinfo loop;
3844   gfc_init_loopinfo (&loop);
3845   gfc_add_ss_to_loop (&loop, arrayss);
3847     gfc_add_ss_to_loop (&loop, maskss);
3849   /* Initialize the loop.  */
3850   gfc_conv_ss_startstride (&loop);
3852   /* The code generated can have more than one loop in sequence (see the
3856      are  currently inlined in the scalar case only (for which loop is of rank
3866      loop minmaxloc implementation.  See PR 31067.  */
3867   loop.temp_dim = loop.dimen;
3868   gfc_conv_loop_setup (&loop, &expr->where);
3870   gcc_assert (loop.dimen == 1);
3871   if (nonempty == NULL && maskss == NULL && loop.from[0] && loop.to[0])
3873 				loop.from[0], loop.to[0]);
3881      the inner loop.  */
3883     gfc_add_modify (&loop.pre, pos,
3890       gfc_add_modify (&loop.pre, pos, gfc_index_zero_node);
3897   /* An offset must be added to the loop
3899   gcc_assert (loop.from[0]);
3902 			 gfc_index_one_node, loop.from[0]);
3903   gfc_add_modify (&loop.pre, offset, tmp);
3908   /* Generate the loop body.  */
3909   gfc_start_scalarized_body (&loop, &body);
3915       gfc_copy_loopinfo_to_se (&maskse, &loop);
3927   gfc_copy_loopinfo_to_se (&arrayse, &loop);
3945 			     loop.loopvar[0], offset);
3956 			 loop.loopvar[0], offset);
3993       gfc_trans_scalarized_loop_boundary (&loop, &body);
4002 	      gfc_add_expr_to_block (&loop.code[0], tmp);
4006       gfc_add_expr_to_block (&loop.code[0], build1_v (GOTO_EXPR, lab2));
4007       gfc_add_expr_to_block (&loop.code[0], build1_v (LABEL_EXPR, lab1));
4013 	  gfc_copy_loopinfo_to_se (&maskse, &loop);
4025       gfc_copy_loopinfo_to_se (&arrayse, &loop);
4037 			     loop.loopvar[0], offset);
4061 	 it finished by the first loop.  */
4062       loop.from[0] = loop.loopvar[0];
4065   gfc_trans_scalarizing_loops (&loop, &body);
4068     gfc_add_expr_to_block (&loop.pre, build1_v (LABEL_EXPR, lab2));
4070   /* For a scalar mask, enclose the loop in an if statement.  */
4076       gfc_add_block_to_block (&block, &loop.pre);
4077       gfc_add_block_to_block (&block, &loop.post);
4093       gfc_add_block_to_block (&se->pre, &loop.pre);
4094       gfc_add_block_to_block (&se->pre, &loop.post);
4096   gfc_cleanup_loop (&loop);
4208   gfc_loopinfo loop;
4301   gfc_init_loopinfo (&loop);
4302   gfc_add_ss_to_loop (&loop, arrayss);
4304     gfc_add_ss_to_loop (&loop, maskss);
4306   /* Initialize the loop.  */
4307   gfc_conv_ss_startstride (&loop);
4309   /* The code generated can have more than one loop in sequence (see the
4322      loop minmaxval implementation.  See PR 31067.  */
4323   loop.temp_dim = loop.dimen;
4324   gfc_conv_loop_setup (&loop, &expr->where);
4327       && loop.dimen == 1 && loop.from[0] && loop.to[0])
4329 				loop.from[0], loop.to[0]);
4343       if (loop.dimen == 1)
4358   /* Generate the loop body.  */
4359   gfc_start_scalarized_body (&loop, &body);
4365       gfc_copy_loopinfo_to_se (&maskse, &loop);
4377   gfc_copy_loopinfo_to_se (&arrayse, &loop);
4467       gfc_trans_scalarized_loop_boundary (&loop, &body);
4471       gfc_add_modify (&loop.code[0], limit, tmp);
4472       gfc_add_expr_to_block (&loop.code[0], build1_v (LABEL_EXPR, lab));
4478 	  gfc_copy_loopinfo_to_se (&maskse, &loop);
4490       gfc_copy_loopinfo_to_se (&arrayse, &loop);
4524 	 it finished by the first loop.  */
4525       loop.from[0] = loop.loopvar[0];
4527   gfc_trans_scalarizing_loops (&loop, &body);
4536       gfc_add_expr_to_block (&loop.pre, tmp);
4542       gfc_add_modify (&loop.pre, limit, tmp);
4545   /* For a scalar mask, enclose the loop in an if statement.  */
4553       gfc_add_block_to_block (&block, &loop.pre);
4554       gfc_add_block_to_block (&block, &loop.post);
4567       gfc_add_block_to_block (&se->pre, &loop.pre);
4568       gfc_add_block_to_block (&se->pre, &loop.post);
4571   gfc_cleanup_loop (&loop);
5994 	  /* Create loop:
6192   if (se->loop)
6399   /* Evaluate the bounds of the result.  If the loop range exists, we have
6400      to check if it is too large.  If so, we modify loop->to be consistent
6402      the loop range, so that the right number of bytes is transferred.*/
6403   n = se->loop->order[0];
6404   if (se->loop->to[n] != NULL_TREE)
6407 			     se->loop->to[n], se->loop->from[n]);
6418 			       size_words, se->loop->from[n]);
6426       se->loop->from[n] = gfc_index_zero_node;
6429   se->loop->to[n] = upper;
7027   /* Start the loop body.  */
7030   /* Exit the loop if count >= ncopies.  */
7061   /* Build the loop.  */
7226   gfc_loopinfo loop;
7276   gfc_init_loopinfo (&loop);
7277   gfc_add_ss_to_loop (&loop, shape_ss);
7278   gfc_conv_ss_startstride (&loop);
7279   gfc_conv_loop_setup (&loop, &arg->next->expr->where);
7282   gfc_copy_loopinfo_to_se (&shapese, &loop);
7291   gfc_start_scalarized_body (&loop, &body);
7294 			     loop.loopvar[0], loop.from[0]);
7315   /* Finish scalarization loop.  */
7316   gfc_trans_scalarizing_loops (&loop, &body);
7317   gfc_add_block_to_block (&block, &loop.pre);
7318   gfc_add_block_to_block (&block, &loop.post);
7320   gfc_cleanup_loop (&loop);
8457      the array (to make an if around the nested loop). Thus it shall
8494 /* This generates code to execute before entering the scalarization loop.
8498 gfc_add_intrinsic_ss_code (gfc_loopinfo * loop ATTRIBUTE_UNUSED, gfc_ss * ss)
8516    are expanded into code inside the scalarization loop.  */