gcc/gcc/sel-sched-ir.c

81 /* The loop nest being pipelined.  */
82 struct loop *current_loop_nest;
84 /* LOOP_NESTS is a vector containing the corresponding loop nest for
88 /* Saves blocks already in loop regions, indexed by bb->index.  */
152 /* TRUE if while scheduling current region, which is loop, its preheader
677          there are two edges: one going around of inner loop and the other -
4086              for pipelining of an outer loop.  Use succ instead.
4745   /* Remove current loop preheader from this loop.  */
4822       /* FIXME: this doesn't work for skipping to loop exits, as we don't
4831                        inner loop to exits.  */
5184      when removing loop preheader from the region.  At the point of
5455       struct loop *loop;
5457       for (loop = current_loop_nest; loop; loop = loop_outer (loop))
5458         if (considered_for_pipelining_p (loop) && loop->latch == from)
5460             gcc_assert (loop == current_loop_nest);
5461             loop->latch = to;
5462             gcc_assert (loop_latch_edge (loop));
5559       /* Some of the basic blocks might not have been added to the loop.
5681   /* This function could not be used to spoil the loop structure by now,
6056 make_region_from_loop (struct loop *loop)
6060   struct loop *inner;
6067   if (loop->num_nodes
6072   for (inner = loop->inner; inner; inner = inner->inner)
6073     if (flow_bb_inside_loop_p (inner, loop->latch))
6076   loop->ninsns = num_loop_insns (loop);
6077   if ((int) loop->ninsns > PARAM_VALUE (PARAM_MAX_PIPELINE_REGION_INSNS))
6080   loop_blocks = get_loop_body_in_custom_order (loop, bb_top_order_comparator);
6082   for (i = 0; i < loop->num_nodes; i++)
6089   preheader_block = loop_preheader_edge (loop)->src;
6091   gcc_assert (loop_blocks[0] == loop->header);
6098   for (i = 0; i < loop->num_nodes; i++)
6100       /* Add only those blocks that haven't been scheduled in the inner loop.
6102 	 be added to the region (and they actually don't belong to the loop
6103 	 body, but to the region containing that loop body).  */
6116   MARK_LOOP_FOR_PIPELINING (loop);
6145 /* Create region(s) from loop nest LOOP, such that inner loops will be
6149 make_regions_from_loop_nest (struct loop *loop)
6151   struct loop *cur_loop;
6154   /* Traverse all inner nodes of the loop.  */
6155   for (cur_loop = loop->inner; cur_loop; cur_loop = cur_loop->next)
6160      Try to create a region from this loop.  */
6161   rgn_number = make_region_from_loop (loop);
6166   loop_nests.safe_push (loop);
6174   /* Collect loop information to be used in outer loops pipelining.  */
6187 /* Returns a struct loop for region RGN.  */
6191   /* Regions created with extend_rgns don't have corresponding loop nests,
6201 considered_for_pipelining_p (struct loop *loop)
6203   if (loop_depth (loop) == 0)
6206   /* Now, the loop could be too large or irreducible.  Check whether its
6211      Latch can't be used because it could be in the inner loop too.  */
6212   if (LOOP_MARKED_FOR_PIPELINING_P (loop))
6214       int rgn = CONTAINING_RGN (loop->latch->index);
6241      any loop or belong to irreducible loops.  Prepare the data structures
6244   /* LOOP_HDR[I] == -1 if I-th bb doesn't belong to any loop,
6246      loop.  */
6251   /* For each basic block that belongs to some loop assign the number
6252      of innermost loop it belongs to.  */
6303   struct loop *loop;
6306   FOR_EACH_LOOP (loop, 0)
6307     loop->aux = NULL;
6327       loop_p loop;
6329       FOR_EACH_LOOP (loop, (flag_sel_sched_pipelining_outer_loops
6332 	make_regions_from_loop_nest (loop);
6336      These blocks include blocks that don't belong to any loop or belong
6345 /* Add the preheader blocks from previous loop to current region taking
6369 /* While pipelining outer loops, returns TRUE if BB is a loop preheader.
6378       struct loop *outer;
6394       /* Support the situation when the latch block of outer loop
6427 /* Removes the loop preheader from the current region and saves it in
6428    PREHEADER_BLOCKS of the father loop, so they will be added later to
6429    region that represents an outer loop.  */
6445   /* Add blocks that aren't within the current loop to PREHEADER_BLOCKS.  */
6451 	 corresponding loop, then it should be a preheader.  */
6514     /* Store preheader within the father's loop structure.  */