GCC Middle and Back End API Reference
cfgloop.h
Go to the documentation of this file.
1 /* Natural loop functions
2  Copyright (C) 1987-2013 Free Software Foundation, Inc.
3 
4 This file is part of GCC.
5 
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10 
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
15 
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
19 
20 #ifndef GCC_CFGLOOP_H
21 #define GCC_CFGLOOP_H
22 
23 #include "double-int.h"
24 #include "bitmap.h"
25 #include "sbitmap.h"
26 #include "function.h"
27 
28 /* Structure to hold decision about unrolling/peeling. */
29 enum lpt_dec
30 {
37 };
38 
39 struct GTY (()) lpt_decision {
40  enum lpt_dec decision;
41  unsigned times;
42 };
43 
44 /* The type of extend applied to an IV. */
45 enum iv_extend_code
46 {
50 };
51 
52 /* The structure describing a bound on number of iterations of a loop. */
53 
54 struct GTY ((chain_next ("%h.next"))) nb_iter_bound {
55  /* The statement STMT is executed at most ... */
56  gimple stmt;
57 
58  /* ... BOUND + 1 times (BOUND must be an unsigned constant).
59  The + 1 is added for the following reasons:
60 
61  a) 0 would otherwise be unused, while we would need to care more about
62  overflows (as MAX + 1 is sometimes produced as the estimate on number
63  of executions of STMT).
64  b) it is consistent with the result of number_of_iterations_exit. */
65  double_int bound;
66 
67  /* True if the statement will cause the loop to be leaved the (at most)
68  BOUND + 1-st time it is executed, that is, all the statements after it
69  are executed at most BOUND times. */
70  bool is_exit;
71 
72  /* The next bound in the list. */
73  struct nb_iter_bound *next;
74 };
75 
76 /* Description of the loop exit. */
77 
78 struct GTY (()) loop_exit {
79  /* The exit edge. */
80  edge e;
81 
82  /* Previous and next exit in the list of the exits of the loop. */
83  struct loop_exit *prev;
84  struct loop_exit *next;
85 
86  /* Next element in the list of loops from that E exits. */
87  struct loop_exit *next_e;
88 };
89 
90 typedef struct loop *loop_p;
91 
92 /* An integer estimation of the number of iterations. Estimate_state
93  describes what is the state of the estimation. */
94 enum loop_estimation
95 {
96  /* Estimate was not computed yet. */
97  EST_NOT_COMPUTED,
98  /* Estimate is ready. */
99  EST_AVAILABLE,
100  EST_LAST
101 };
103 /* Structure to hold information for each natural loop. */
104 struct GTY ((chain_next ("%h.next"))) loop {
105  /* Index into loops array. */
106  int num;
108  /* Number of loop insns. */
109  unsigned ninsns;
110 
111  /* Basic block of loop header. */
112  basic_block header;
113 
114  /* Basic block of loop latch. */
115  basic_block latch;
116 
117  /* For loop unrolling/peeling decision. */
118  struct lpt_decision lpt_decision;
119 
120  /* Average number of executed insns per iteration. */
121  unsigned av_ninsns;
122 
123  /* Number of blocks contained within the loop. */
124  unsigned num_nodes;
125 
126  /* Superloops of the loop, starting with the outermost loop. */
127  vec<loop_p, va_gc> *superloops;
128 
129  /* The first inner (child) loop or NULL if innermost loop. */
130  struct loop *inner;
132  /* Link to the next (sibling) loop. */
133  struct loop *next;
134 
135  /* Auxiliary info specific to a pass. */
136  PTR GTY ((skip (""))) aux;
137 
138  /* The number of times the latch of the loop is executed. This can be an
139  INTEGER_CST, or a symbolic expression representing the number of
140  iterations like "N - 1", or a COND_EXPR containing the runtime
141  conditions under which the number of iterations is non zero.
142 
143  Don't access this field directly: number_of_latch_executions
144  computes and caches the computed information in this field. */
145  tree nb_iterations;
146 
147  /* An integer guaranteed to be greater or equal to nb_iterations. Only
148  valid if any_upper_bound is true. */
149  double_int nb_iterations_upper_bound;
150 
151  /* An integer giving an estimate on nb_iterations. Unlike
152  nb_iterations_upper_bound, there is no guarantee that it is at least
153  nb_iterations. */
154  double_int nb_iterations_estimate;
156  bool any_upper_bound;
157  bool any_estimate;
158 
159  /* True if the loop can be parallel. */
160  bool can_be_parallel;
161 
162  /* True if -Waggressive-loop-optimizations warned about this loop
163  already. */
164  bool warned_aggressive_loop_optimizations;
165 
166  /* An integer estimation of the number of iterations. Estimate_state
167  describes what is the state of the estimation. */
168  enum loop_estimation estimate_state;
169 
170  /* If > 0, an integer, where the user asserted that for any
171  I in [ 0, nb_iterations ) and for any J in
172  [ I, min ( I + safelen, nb_iterations ) ), the Ith and Jth iterations
173  of the loop can be safely evaluated concurrently. */
174  int safelen;
175 
176  /* True if we should try harder to vectorize this loop. */
177  bool force_vect;
179  /* For SIMD loops, this is a unique identifier of the loop, referenced
180  by IFN_GOMP_SIMD_VF, IFN_GOMP_SIMD_LANE and IFN_GOMP_SIMD_LAST_LANE
181  builtins. */
182  tree simduid;
183 
184  /* Upper bound on number of iterations of a loop. */
185  struct nb_iter_bound *bounds;
187  /* Head of the cyclic list of the exits of the loop. */
188  struct loop_exit *exits;
189 
190  /* Number of iteration analysis data for RTL. */
191  struct niter_desc *simple_loop_desc;
192 };
193 
194 /* Flags for state of loop structure. */
195 enum
196 {
197  LOOPS_HAVE_PREHEADERS = 1,
198  LOOPS_HAVE_SIMPLE_LATCHES = 2,
199  LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS = 4,
200  LOOPS_HAVE_RECORDED_EXITS = 8,
201  LOOPS_MAY_HAVE_MULTIPLE_LATCHES = 16,
202  LOOP_CLOSED_SSA = 32,
203  LOOPS_NEED_FIXUP = 64,
204  LOOPS_HAVE_FALLTHRU_PREHEADERS = 128
205 };
206 
207 #define LOOPS_NORMAL (LOOPS_HAVE_PREHEADERS | LOOPS_HAVE_SIMPLE_LATCHES \
208  | LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
209 #define AVOID_CFG_MODIFICATIONS (LOOPS_MAY_HAVE_MULTIPLE_LATCHES)
210 
211 /* Structure to hold CFG information about natural loops within a function. */
212 struct GTY (()) loops {
213  /* State of loops. */
214  int state;
215 
216  /* Array of the loops. */
217  vec<loop_p, va_gc> *larray;
219  /* Maps edges to the list of their descriptions as loop exits. Edges
220  whose sources or destinations have loop_father == NULL (which may
221  happen during the cfg manipulations) should not appear in EXITS. */
222  htab_t GTY((param_is (struct loop_exit))) exits;
223 
224  /* Pointer to root of loop hierarchy tree. */
225  struct loop *tree_root;
226 };
227 
228 /* Loop recognition. */
229 bool bb_loop_header_p (basic_block);
230 void init_loops_structure (struct function *, struct loops *, unsigned);
231 extern struct loops *flow_loops_find (struct loops *);
232 extern void disambiguate_loops_with_multiple_latches (void);
233 extern void flow_loops_free (struct loops *);
234 extern void flow_loops_dump (FILE *,
235  void (*)(const struct loop *, FILE *, int), int);
236 extern void flow_loop_dump (const struct loop *, FILE *,
237  void (*)(const struct loop *, FILE *, int), int);
238 struct loop *alloc_loop (void);
239 extern void flow_loop_free (struct loop *);
240 int flow_loop_nodes_find (basic_block, struct loop *);
241 unsigned fix_loop_structure (bitmap changed_bbs);
242 bool mark_irreducible_loops (void);
243 void release_recorded_exits (void);
244 void record_loop_exits (void);
245 void rescan_loop_exit (edge, bool, bool);
246 
247 /* Loop data structure manipulation/querying. */
248 extern void flow_loop_tree_node_add (struct loop *, struct loop *);
249 extern void flow_loop_tree_node_remove (struct loop *);
250 extern void place_new_loop (struct function *, struct loop *);
251 extern void add_loop (struct loop *, struct loop *);
252 extern bool flow_loop_nested_p (const struct loop *, const struct loop *);
253 extern bool flow_bb_inside_loop_p (const struct loop *, const_basic_block);
254 extern struct loop * find_common_loop (struct loop *, struct loop *);
255 struct loop *superloop_at_depth (struct loop *, unsigned);
256 struct eni_weights_d;
257 extern int num_loop_insns (const struct loop *);
258 extern int average_num_loop_insns (const struct loop *);
259 extern unsigned get_loop_level (const struct loop *);
260 extern bool loop_exit_edge_p (const struct loop *, const_edge);
261 extern bool loop_exits_to_bb_p (struct loop *, basic_block);
262 extern bool loop_exits_from_bb_p (struct loop *, basic_block);
263 extern void mark_loop_exit_edges (void);
264 extern location_t get_loop_location (struct loop *loop);
265 
266 /* Loops & cfg manipulation. */
267 extern basic_block *get_loop_body (const struct loop *);
268 extern unsigned get_loop_body_with_size (const struct loop *, basic_block *,
269  unsigned);
270 extern basic_block *get_loop_body_in_dom_order (const struct loop *);
271 extern basic_block *get_loop_body_in_bfs_order (const struct loop *);
272 extern basic_block *get_loop_body_in_custom_order (const struct loop *,
273  int (*) (const void *, const void *));
274 
275 extern vec<edge> get_loop_exit_edges (const struct loop *);
276 extern edge single_exit (const struct loop *);
277 extern edge single_likely_exit (struct loop *loop);
278 extern unsigned num_loop_branches (const struct loop *);
279 
280 extern edge loop_preheader_edge (const struct loop *);
281 extern edge loop_latch_edge (const struct loop *);
282 
283 extern void add_bb_to_loop (basic_block, struct loop *);
284 extern void remove_bb_from_loops (basic_block);
285 
286 extern void cancel_loop_tree (struct loop *);
287 extern void delete_loop (struct loop *);
288 
289 enum
290 {
291  CP_SIMPLE_PREHEADERS = 1,
292  CP_FALLTHRU_PREHEADERS = 2
293 };
294 
295 basic_block create_preheader (struct loop *, int);
296 extern void create_preheaders (int);
297 extern void force_single_succ_latches (void);
298 
299 extern void verify_loop_structure (void);
300 
301 /* Loop analysis. */
302 extern bool just_once_each_iteration_p (const struct loop *, const_basic_block);
303 gcov_type expected_loop_iterations_unbounded (const struct loop *);
304 extern unsigned expected_loop_iterations (const struct loop *);
305 extern rtx doloop_condition_get (rtx);
306 
307 
308 /* Loop manipulation. */
309 extern bool can_duplicate_loop_p (const struct loop *loop);
310 
311 #define DLTHE_FLAG_UPDATE_FREQ 1 /* Update frequencies in
312  duplicate_loop_to_header_edge. */
313 #define DLTHE_RECORD_COPY_NUMBER 2 /* Record copy number in the aux
314  field of newly create BB. */
315 #define DLTHE_FLAG_COMPLETTE_PEEL 4 /* Update frequencies expecting
316  a complete peeling. */
317 
318 extern edge create_empty_if_region_on_edge (edge, tree);
319 extern struct loop *create_empty_loop_on_edge (edge, tree, tree, tree, tree,
320  tree *, tree *, struct loop *);
321 extern struct loop * duplicate_loop (struct loop *, struct loop *);
322 extern void copy_loop_info (struct loop *loop, struct loop *target);
323 extern void duplicate_subloops (struct loop *, struct loop *);
324 extern bool duplicate_loop_to_header_edge (struct loop *, edge,
325  unsigned, sbitmap, edge,
326  vec<edge> *, int);
327 extern struct loop *loopify (edge, edge,
328  basic_block, edge, edge, bool,
329  unsigned, unsigned);
330 struct loop * loop_version (struct loop *, void *,
331  basic_block *, unsigned, unsigned, unsigned, bool);
332 extern bool remove_path (edge);
333 extern void unloop (struct loop *, bool *, bitmap);
334 extern void scale_loop_frequencies (struct loop *, int, int);
335 
336 /* Induction variable analysis. */
337 
338 /* The description of induction variable. The things are a bit complicated
339  due to need to handle subregs and extends. The value of the object described
340  by it can be obtained as follows (all computations are done in extend_mode):
341 
342  Value in i-th iteration is
343  delta + mult * extend_{extend_mode} (subreg_{mode} (base + i * step)).
344 
345  If first_special is true, the value in the first iteration is
346  delta + mult * base
347 
348  If extend = UNKNOWN, first_special must be false, delta 0, mult 1 and value is
349  subreg_{mode} (base + i * step)
350 
351  The get_iv_value function can be used to obtain these expressions.
352 
353  ??? Add a third mode field that would specify the mode in that inner
354  computation is done, which would enable it to be different from the
355  outer one? */
356 
357 struct rtx_iv
358 {
359  /* Its base and step (mode of base and step is supposed to be extend_mode,
360  see the description above). */
361  rtx base, step;
363  /* The type of extend applied to it (IV_SIGN_EXTEND, IV_ZERO_EXTEND,
364  or IV_UNKNOWN_EXTEND). */
365  enum iv_extend_code extend;
366 
367  /* Operations applied in the extended mode. */
368  rtx delta, mult;
369 
370  /* The mode it is extended to. */
371  enum machine_mode extend_mode;
372 
373  /* The mode the variable iterates in. */
374  enum machine_mode mode;
375 
376  /* Whether the first iteration needs to be handled specially. */
377  unsigned first_special : 1;
378 };
379 
380 /* The description of an exit from the loop and of the number of iterations
381  till we take the exit. */
382 
383 struct GTY(()) niter_desc
384 {
385  /* The edge out of the loop. */
386  edge out_edge;
387 
388  /* The other edge leading from the condition. */
389  edge in_edge;
390 
391  /* True if we are able to say anything about number of iterations of the
392  loop. */
393  bool simple_p;
394 
395  /* True if the loop iterates the constant number of times. */
396  bool const_iter;
397 
398  /* Number of iterations if constant. */
399  unsigned HOST_WIDEST_INT niter;
400 
401  /* Assumptions under that the rest of the information is valid. */
402  rtx assumptions;
403 
404  /* Assumptions under that the loop ends before reaching the latch,
405  even if value of niter_expr says otherwise. */
406  rtx noloop_assumptions;
407 
408  /* Condition under that the loop is infinite. */
409  rtx infinite;
410 
411  /* Whether the comparison is signed. */
412  bool signed_p;
413 
414  /* The mode in that niter_expr should be computed. */
415  enum machine_mode mode;
417  /* The number of iterations of the loop. */
418  rtx niter_expr;
419 };
421 extern void iv_analysis_loop_init (struct loop *);
422 extern bool iv_analyze (rtx, rtx, struct rtx_iv *);
423 extern bool iv_analyze_result (rtx, rtx, struct rtx_iv *);
424 extern bool iv_analyze_expr (rtx, rtx, enum machine_mode, struct rtx_iv *);
425 extern rtx get_iv_value (struct rtx_iv *, rtx);
426 extern bool biv_p (rtx, rtx);
427 extern void find_simple_exit (struct loop *, struct niter_desc *);
428 extern void iv_analysis_done (void);
429 
430 extern struct niter_desc *get_simple_loop_desc (struct loop *loop);
431 extern void free_simple_loop_desc (struct loop *loop);
433 static inline struct niter_desc *
434 simple_loop_desc (struct loop *loop)
435 {
436  return loop->simple_loop_desc;
437 }
438 
439 /* Accessors for the loop structures. */
440 
441 /* Returns the loop with index NUM from FNs loop tree. */
442 
443 static inline struct loop *
444 get_loop (struct function *fn, unsigned num)
445 {
446  return (*loops_for_fn (fn)->larray)[num];
447 }
448 
449 /* Returns the number of superloops of LOOP. */
450 
451 static inline unsigned
452 loop_depth (const struct loop *loop)
453 {
454  return vec_safe_length (loop->superloops);
455 }
457 /* Returns the immediate superloop of LOOP, or NULL if LOOP is the outermost
458  loop. */
459 
460 static inline struct loop *
461 loop_outer (const struct loop *loop)
462 {
463  unsigned n = vec_safe_length (loop->superloops);
465  if (n == 0)
466  return NULL;
467 
468  return (*loop->superloops)[n - 1];
469 }
470 
471 /* Returns true if LOOP has at least one exit edge. */
472 
473 static inline bool
474 loop_has_exit_edges (const struct loop *loop)
475 {
476  return loop->exits->next->e != NULL;
477 }
478 
479 /* Returns the list of loops in FN. */
480 
481 inline vec<loop_p, va_gc> *
482 get_loops (struct function *fn)
483 {
484  struct loops *loops = loops_for_fn (fn);
485  if (!loops)
486  return NULL;
487 
488  return loops->larray;
489 }
490 
491 /* Returns the number of loops in FN (including the removed
492  ones and the fake loop that forms the root of the loop tree). */
493 
494 static inline unsigned
495 number_of_loops (struct function *fn)
496 {
497  struct loops *loops = loops_for_fn (fn);
498  if (!loops)
499  return 0;
500 
501  return vec_safe_length (loops->larray);
502 }
503 
504 /* Returns true if state of the loops satisfies all properties
505  described by FLAGS. */
506 
507 static inline bool
508 loops_state_satisfies_p (unsigned flags)
509 {
510  return (current_loops->state & flags) == flags;
511 }
512 
513 /* Sets FLAGS to the loops state. */
514 
515 static inline void
516 loops_state_set (unsigned flags)
517 {
518  current_loops->state |= flags;
519 }
520 
521 /* Clears FLAGS from the loops state. */
523 static inline void
524 loops_state_clear (unsigned flags)
525 {
526  if (!current_loops)
527  return;
528  current_loops->state &= ~flags;
529 }
530 
531 /* Loop iterators. */
533 /* Flags for loop iteration. */
534 
535 enum li_flags
536 {
537  LI_INCLUDE_ROOT = 1, /* Include the fake root of the loop tree. */
538  LI_FROM_INNERMOST = 2, /* Iterate over the loops in the reverse order,
539  starting from innermost ones. */
540  LI_ONLY_INNERMOST = 4 /* Iterate only over innermost loops. */
541 };
542 
543 /* The iterator for loops. */
544 
545 typedef struct
546 {
547  /* The list of loops to visit. */
548  vec<int> to_visit;
549 
550  /* The index of the actual loop. */
551  unsigned idx;
552 } loop_iterator;
553 
554 static inline void
555 fel_next (loop_iterator *li, loop_p *loop)
556 {
557  int anum;
558 
559  while (li->to_visit.iterate (li->idx, &anum))
560  {
561  li->idx++;
562  *loop = get_loop (cfun, anum);
563  if (*loop)
564  return;
565  }
566 
567  li->to_visit.release ();
568  *loop = NULL;
569 }
570 
571 static inline void
572 fel_init (loop_iterator *li, loop_p *loop, unsigned flags)
573 {
574  struct loop *aloop;
575  unsigned i;
576  int mn;
577 
578  li->idx = 0;
579  if (!current_loops)
580  {
581  li->to_visit.create (0);
582  *loop = NULL;
583  return;
584  }
585 
586  li->to_visit.create (number_of_loops (cfun));
587  mn = (flags & LI_INCLUDE_ROOT) ? 0 : 1;
588 
589  if (flags & LI_ONLY_INNERMOST)
590  {
591  for (i = 0; vec_safe_iterate (current_loops->larray, i, &aloop); i++)
592  if (aloop != NULL
593  && aloop->inner == NULL
594  && aloop->num >= mn)
595  li->to_visit.quick_push (aloop->num);
596  }
597  else if (flags & LI_FROM_INNERMOST)
598  {
599  /* Push the loops to LI->TO_VISIT in postorder. */
600  for (aloop = current_loops->tree_root;
601  aloop->inner != NULL;
602  aloop = aloop->inner)
603  continue;
604 
605  while (1)
606  {
607  if (aloop->num >= mn)
608  li->to_visit.quick_push (aloop->num);
609 
610  if (aloop->next)
611  {
612  for (aloop = aloop->next;
613  aloop->inner != NULL;
614  aloop = aloop->inner)
615  continue;
616  }
617  else if (!loop_outer (aloop))
618  break;
619  else
620  aloop = loop_outer (aloop);
621  }
622  }
623  else
624  {
625  /* Push the loops to LI->TO_VISIT in preorder. */
626  aloop = current_loops->tree_root;
627  while (1)
628  {
629  if (aloop->num >= mn)
630  li->to_visit.quick_push (aloop->num);
631 
632  if (aloop->inner != NULL)
633  aloop = aloop->inner;
634  else
635  {
636  while (aloop != NULL && aloop->next == NULL)
637  aloop = loop_outer (aloop);
638  if (aloop == NULL)
639  break;
640  aloop = aloop->next;
641  }
642  }
643  }
644 
645  fel_next (li, loop);
646 }
647 
648 #define FOR_EACH_LOOP(LI, LOOP, FLAGS) \
649  for (fel_init (&(LI), &(LOOP), FLAGS); \
650  (LOOP); \
651  fel_next (&(LI), &(LOOP)))
652 
653 #define FOR_EACH_LOOP_BREAK(LI) \
654  { \
655  (LI).to_visit.release (); \
656  break; \
657  }
658 
659 /* The properties of the target. */
660 struct target_cfgloop {
661  /* Number of available registers. */
662  unsigned x_target_avail_regs;
663 
664  /* Number of available registers that are call-clobbered. */
665  unsigned x_target_clobbered_regs;
666 
667  /* Number of registers reserved for temporary expressions. */
668  unsigned x_target_res_regs;
669 
670  /* The cost for register when there still is some reserve, but we are
671  approaching the number of available registers. */
672  unsigned x_target_reg_cost[2];
673 
674  /* The cost for register when we need to spill. */
675  unsigned x_target_spill_cost[2];
676 };
677 
678 extern struct target_cfgloop default_target_cfgloop;
679 #if SWITCHABLE_TARGET
680 extern struct target_cfgloop *this_target_cfgloop;
681 #else
682 #define this_target_cfgloop (&default_target_cfgloop)
683 #endif
684 
685 #define target_avail_regs \
686  (this_target_cfgloop->x_target_avail_regs)
687 #define target_clobbered_regs \
688  (this_target_cfgloop->x_target_clobbered_regs)
689 #define target_res_regs \
690  (this_target_cfgloop->x_target_res_regs)
691 #define target_reg_cost \
692  (this_target_cfgloop->x_target_reg_cost)
693 #define target_spill_cost \
694  (this_target_cfgloop->x_target_spill_cost)
695 
696 /* Register pressure estimation for induction variable optimizations & loop
697  invariant motion. */
698 extern unsigned estimate_reg_pressure_cost (unsigned, unsigned, bool, bool);
699 extern void init_set_costs (void);
700 
701 /* Loop optimizer initialization. */
702 extern void loop_optimizer_init (unsigned);
703 extern void loop_optimizer_finalize (void);
704 
705 /* Optimization passes. */
706 extern void unswitch_loops (void);
707 
708 enum
709 {
710  UAP_PEEL = 1, /* Enables loop peeling. */
711  UAP_UNROLL = 2, /* Enables unrolling of loops if it seems profitable. */
712  UAP_UNROLL_ALL = 4 /* Enables unrolling of all loops. */
713 };
714 
715 extern void unroll_and_peel_loops (int);
716 extern void doloop_optimize_loops (void);
717 extern void move_loop_invariants (void);
718 extern void scale_loop_profile (struct loop *loop, int scale, gcov_type iteration_bound);
719 extern vec<basic_block> get_loop_hot_path (const struct loop *loop);
720 
721 /* Returns the outermost loop of the loop nest that contains LOOP.*/
722 static inline struct loop *
723 loop_outermost (struct loop *loop)
724 {
725  unsigned n = vec_safe_length (loop->superloops);
726 
727  if (n <= 1)
728  return loop;
729 
730  return (*loop->superloops)[1];
731 }
733 extern void record_niter_bound (struct loop *, double_int, bool, bool);
734 extern HOST_WIDE_INT get_estimated_loop_iterations_int (struct loop *);
735 extern HOST_WIDE_INT get_max_loop_iterations_int (struct loop *);
736 extern bool get_estimated_loop_iterations (struct loop *loop, double_int *nit);
737 extern bool get_max_loop_iterations (struct loop *loop, double_int *nit);
738 extern int bb_loop_depth (const_basic_block);
739 
740 /* Converts VAL to double_int. */
741 
742 static inline double_int
743 gcov_type_to_double_int (gcov_type val)
744 {
745  double_int ret;
746 
747  ret.low = (unsigned HOST_WIDE_INT) val;
748  /* If HOST_BITS_PER_WIDE_INT == HOST_BITS_PER_WIDEST_INT, avoid shifting by
749  the size of type. */
750  val >>= HOST_BITS_PER_WIDE_INT - 1;
751  val >>= 1;
752  ret.high = (unsigned HOST_WIDE_INT) val;
753 
754  return ret;
755 }
756 #endif /* GCC_CFGLOOP_H */