[gcc.git] / gcc / cfgloop.h

/* Natural loop functions
   Copyright (C) 1987, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
   Free Software Foundation, Inc.

This file is part of GCC.

GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 2, or (at your option) any later
version.

GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
for more details.

You should have received a copy of the GNU General Public License
along with GCC; see the file COPYING.  If not, write to the Free
Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
02110-1301, USA.  */

#ifndef GCC_CFGLOOP_H
#define GCC_CFGLOOP_H

#include "basic-block.h"
/* For rtx_code.  */
#include "rtl.h"

/* Structure to hold decision about unrolling/peeling.  */
enum lpt_dec
{
  LPT_NONE,
  LPT_PEEL_COMPLETELY,
  LPT_PEEL_SIMPLE,
  LPT_UNROLL_CONSTANT,
  LPT_UNROLL_RUNTIME,
  LPT_UNROLL_STUPID
};

struct lpt_decision
{
  enum lpt_dec decision;
  unsigned times;
};

/* The structure describing a bound on number of iterations of a loop.  */

struct nb_iter_bound
{
  tree bound;		/* The expression whose value is an upper bound on the
			   number of executions of anything after ...  */
  tree at_stmt;		/* ... this statement during one execution of loop.  */
  tree additional;	/* A conjunction of conditions the operands of BOUND
			   satisfy.  The additional information about the value
			   of the bound may be derived from it.  */
  struct nb_iter_bound *next;
			/* The next bound in a list.  */
};

/* Structure to hold information for each natural loop.  */
struct loop
{
  /* Index into loops array.  */
  int num;

  /* Basic block of loop header.  */
  basic_block header;

  /* Basic block of loop latch.  */
  basic_block latch;

  /* For loop unrolling/peeling decision.  */
  struct lpt_decision lpt_decision;

  /* Number of loop insns.  */
  unsigned ninsns;

  /* Average number of executed insns per iteration.  */
  unsigned av_ninsns;

  /* Number of blocks contained within the loop.  */
  unsigned num_nodes;

  /* The loop nesting depth.  */
  int depth;

  /* Superloops of the loop.  */
  struct loop **pred;

  /* The height of the loop (enclosed loop levels) within the loop
     hierarchy tree.  */
  int level;

  /* The outer (parent) loop or NULL if outermost loop.  */
  struct loop *outer;

  /* The first inner (child) loop or NULL if innermost loop.  */
  struct loop *inner;

  /* Link to the next (sibling) loop.  */
  struct loop *next;

  /* Loop that is copy of this loop.  */
  struct loop *copy;

  /* Auxiliary info specific to a pass.  */
  void *aux;

  /* The probable number of times the loop is executed at runtime.
     This is an INTEGER_CST or an expression containing symbolic
     names.  Don't access this field directly:
     number_of_iterations_in_loop computes and caches the computed
     information in this field.  */
  tree nb_iterations;

  /* An INTEGER_CST estimation of the number of iterations.  NULL_TREE
     if there is no estimation.  */
  tree estimated_nb_iterations;

  /* Upper bound on number of iterations of a loop.  */
  struct nb_iter_bound *bounds;

  /* If not NULL, loop has just single exit edge stored here (edges to the
     EXIT_BLOCK_PTR do not count.  */
  edge single_exit;

  /* True when the loop does not carry data dependences, and
     consequently the iterations can be executed in any order.  False
     when the loop carries data dependences, or when the property is
     not decidable.  */
  bool parallel_p;
};

/* Flags for state of loop structure.  */
enum
{
  LOOPS_HAVE_PREHEADERS = 1,
  LOOPS_HAVE_SIMPLE_LATCHES = 2,
  LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS = 4,
  LOOPS_HAVE_MARKED_SINGLE_EXITS = 8
};

#define LOOPS_NORMAL (LOOPS_HAVE_PREHEADERS | LOOPS_HAVE_SIMPLE_LATCHES \
		      | LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)

/* Structure to hold CFG information about natural loops within a function.  */
struct loops
{
  /* Number of natural loops in the function.  */
  unsigned num;

  /* State of loops.  */
  int state;

  /* We store just pointers to loops here.  
     Note that a loop in this array may actually be NULL, if the loop
     has been removed and the entire loops structure has not been
     recomputed since that time.  */
  struct loop **parray;

  /* Pointer to root of loop hierarchy tree.  */
  struct loop *tree_root;

  /* Information derived from the CFG.  */
  struct cfg
  {
    /* The ordering of the basic blocks in a depth first search.  */
    int *dfs_order;

    /* The reverse completion ordering of the basic blocks found in a
       depth first search.  */
    int *rc_order;
  } cfg;

  /* Headers shared by multiple loops that should be merged.  */
  sbitmap shared_headers;
};

/* The loop tree currently optimized.  */

extern struct loops *current_loops;

/* Loop recognition.  */
extern int flow_loops_find (struct loops *);
extern void flow_loops_free (struct loops *);
extern void flow_loops_dump (const struct loops *, FILE *,
			     void (*)(const struct loop *, FILE *, int), int);
extern void flow_loop_dump (const struct loop *, FILE *,
			    void (*)(const struct loop *, FILE *, int), int);
extern void flow_loop_free (struct loop *);
int flow_loop_nodes_find (basic_block, struct loop *);
void fix_loop_structure (struct loops *, bitmap changed_bbs);
void mark_irreducible_loops (struct loops *);
void mark_single_exit_loops (struct loops *);

/* Loop data structure manipulation/querying.  */
extern void flow_loop_tree_node_add (struct loop *, struct loop *);
extern void flow_loop_tree_node_remove (struct loop *);
extern bool flow_loop_nested_p	(const struct loop *, const struct loop *);
extern bool flow_bb_inside_loop_p (const struct loop *, const basic_block);
extern struct loop * find_common_loop (struct loop *, struct loop *);
struct loop *superloop_at_depth (struct loop *, unsigned);
extern unsigned tree_num_loop_insns (struct loop *);
extern int num_loop_insns (struct loop *);
extern int average_num_loop_insns (struct loop *);
extern unsigned get_loop_level (const struct loop *);
extern bool loop_exit_edge_p (const struct loop *, edge);
extern void mark_loop_exit_edges (struct loops *);

/* Loops & cfg manipulation.  */
extern basic_block *get_loop_body (const struct loop *);
extern basic_block *get_loop_body_in_dom_order (const struct loop *);
extern basic_block *get_loop_body_in_bfs_order (const struct loop *);
extern edge *get_loop_exit_edges (const struct loop *, unsigned *);
extern unsigned num_loop_branches (const struct loop *);

extern edge loop_preheader_edge (const struct loop *);
extern edge loop_latch_edge (const struct loop *);

extern void add_bb_to_loop (basic_block, struct loop *);
extern void remove_bb_from_loops (basic_block);

extern void cancel_loop_tree (struct loops *, struct loop *);

extern basic_block loop_split_edge_with (edge, rtx);
extern int fix_loop_placement (struct loop *);

enum
{
  CP_SIMPLE_PREHEADERS = 1
};

extern void create_preheaders (struct loops *, int);
extern void force_single_succ_latches (struct loops *);

extern void verify_loop_structure (struct loops *);

/* Loop analysis.  */
extern bool just_once_each_iteration_p (const struct loop *, basic_block);
extern unsigned expected_loop_iterations (const struct loop *);
extern rtx doloop_condition_get (rtx);

/* Loop manipulation.  */
extern bool can_duplicate_loop_p (struct loop *loop);

#define DLTHE_FLAG_UPDATE_FREQ	1	/* Update frequencies in
					   duplicate_loop_to_header_edge.  */
#define DLTHE_RECORD_COPY_NUMBER 2	/* Record copy number in the aux
					   field of newly create BB.  */
#define DLTHE_FLAG_COMPLETTE_PEEL 4	/* Update frequencies expecting
					   a complete peeling.  */

extern struct loop * duplicate_loop (struct loops *, struct loop *,
				     struct loop *);
extern bool duplicate_loop_to_header_edge (struct loop *, edge, struct loops *,
					   unsigned, sbitmap, edge, edge *,
					   unsigned *, int);
extern struct loop *loopify (struct loops *, edge, edge,
			     basic_block, edge, edge, bool);
struct loop * loop_version (struct loops *, struct loop *, void *,
			    basic_block *, bool);
extern bool remove_path (struct loops *, edge);

/* Induction variable analysis.  */

/* The description of induction variable.  The things are a bit complicated
   due to need to handle subregs and extends.  The value of the object described
   by it can be obtained as follows (all computations are done in extend_mode):

   Value in i-th iteration is
     delta + mult * extend_{extend_mode} (subreg_{mode} (base + i * step)).

   If first_special is true, the value in the first iteration is
     delta + mult * base
     
   If extend = UNKNOWN, first_special must be false, delta 0, mult 1 and value is
     subreg_{mode} (base + i * step)

   The get_iv_value function can be used to obtain these expressions.

   ??? Add a third mode field that would specify the mode in that inner
   computation is done, which would enable it to be different from the
   outer one?  */

struct rtx_iv
{
  /* Its base and step (mode of base and step is supposed to be extend_mode,
     see the description above).  */
  rtx base, step;

  /* The type of extend applied to it (SIGN_EXTEND, ZERO_EXTEND or UNKNOWN).  */
  enum rtx_code extend;

  /* Operations applied in the extended mode.  */
  rtx delta, mult;

  /* The mode it is extended to.  */
  enum machine_mode extend_mode;

  /* The mode the variable iterates in.  */
  enum machine_mode mode;

  /* Whether the first iteration needs to be handled specially.  */
  unsigned first_special : 1;
};

/* The description of an exit from the loop and of the number of iterations
   till we take the exit.  */

struct niter_desc
{
  /* The edge out of the loop.  */
  edge out_edge;

  /* The other edge leading from the condition.  */
  edge in_edge;

  /* True if we are able to say anything about number of iterations of the
     loop.  */
  bool simple_p;

  /* True if the loop iterates the constant number of times.  */
  bool const_iter;

  /* Number of iterations if constant.  */
  unsigned HOST_WIDEST_INT niter;

  /* Upper bound on the number of iterations.  */
  unsigned HOST_WIDEST_INT niter_max;

  /* Assumptions under that the rest of the information is valid.  */
  rtx assumptions;

  /* Assumptions under that the loop ends before reaching the latch,
     even if value of niter_expr says otherwise.  */
  rtx noloop_assumptions;

  /* Condition under that the loop is infinite.  */
  rtx infinite;

  /* Whether the comparison is signed.  */
  bool signed_p;

  /* The mode in that niter_expr should be computed.  */
  enum machine_mode mode;

  /* The number of iterations of the loop.  */
  rtx niter_expr;
};

extern void iv_analysis_loop_init (struct loop *);
extern bool iv_analyze (rtx, rtx, struct rtx_iv *);
extern bool iv_analyze_result (rtx, rtx, struct rtx_iv *);
extern bool iv_analyze_expr (rtx, rtx, enum machine_mode, struct rtx_iv *);
extern rtx get_iv_value (struct rtx_iv *, rtx);
extern bool biv_p (rtx, rtx);
extern void find_simple_exit (struct loop *, struct niter_desc *);
extern void iv_analysis_done (void);
extern struct df *iv_current_loop_df (void);

extern struct niter_desc *get_simple_loop_desc (struct loop *loop);
extern void free_simple_loop_desc (struct loop *loop);

static inline struct niter_desc *
simple_loop_desc (struct loop *loop)
{
  return (struct niter_desc *) loop->aux;
}

/* The properties of the target.  */

extern unsigned target_avail_regs;	/* Number of available registers.  */
extern unsigned target_res_regs;	/* Number of reserved registers.  */
extern unsigned target_small_cost;	/* The cost for register when there
					   is a free one.  */
extern unsigned target_pres_cost;	/* The cost for register when there are
					   not too many free ones.  */
extern unsigned target_spill_cost;	/* The cost for register when we need
					   to spill.  */

/* Register pressure estimation for induction variable optimizations & loop
   invariant motion.  */
extern unsigned global_cost_for_size (unsigned, unsigned, unsigned);
extern void init_set_costs (void);

/* Loop optimizer initialization.  */
extern struct loops *loop_optimizer_init (unsigned);
extern void loop_optimizer_finalize (struct loops *);

/* Optimization passes.  */
extern void unswitch_loops (struct loops *);

enum
{
  UAP_PEEL = 1,		/* Enables loop peeling.  */
  UAP_UNROLL = 2,	/* Enables peeling of loops if it seems profitable.  */
  UAP_UNROLL_ALL = 4	/* Enables peeling of all loops.  */
};

extern void unroll_and_peel_loops (struct loops *, int);
extern void doloop_optimize_loops (struct loops *);
extern void move_loop_invariants (struct loops *);
extern void record_estimate (struct loop *, tree, tree, tree);

#endif /* GCC_CFGLOOP_H */
Commit	Line	Data
3d436d2a	1	/* Natural loop functions
613c5cd0	2	Copyright (C) 1987, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005
3d436d2a ZD	3	Free Software Foundation, Inc.
	4
	5	This file is part of GCC.
	6
	7	GCC is free software; you can redistribute it and/or modify it under
	8	the terms of the GNU General Public License as published by the Free
	9	Software Foundation; either version 2, or (at your option) any later
	10	version.
	11
	12	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
	13	WARRANTY; without even the implied warranty of MERCHANTABILITY or
	14	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	15	for more details.
	16
	17	You should have received a copy of the GNU General Public License
	18	along with GCC; see the file COPYING. If not, write to the Free
366ccddb KC	19	Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
366ccddb KC	20	02110-1301, USA. */
3d436d2a	21
59587b18 JQ	22	#ifndef GCC_CFGLOOP_H
	23	#define GCC_CFGLOOP_H
	24
	25	#include "basic-block.h"
	26	/* For rtx_code. */
	27	#include "rtl.h"
	28
3d436d2a ZD	29	/* Structure to hold decision about unrolling/peeling. */
	30	enum lpt_dec
	31	{
	32	LPT_NONE,
	33	LPT_PEEL_COMPLETELY,
	34	LPT_PEEL_SIMPLE,
	35	LPT_UNROLL_CONSTANT,
	36	LPT_UNROLL_RUNTIME,
	37	LPT_UNROLL_STUPID
	38	};
	39
	40	struct lpt_decision
	41	{
	42	enum lpt_dec decision;
	43	unsigned times;
	44	};
	45
86df10e3 SP	46	/* The structure describing a bound on number of iterations of a loop. */
	47
	48	struct nb_iter_bound
	49	{
	50	tree bound; /* The expression whose value is an upper bound on the
	51	number of executions of anything after ... */
	52	tree at_stmt; /* ... this statement during one execution of loop. */
	53	tree additional; /* A conjunction of conditions the operands of BOUND
	54	satisfy. The additional information about the value
	55	of the bound may be derived from it. */
	56	struct nb_iter_bound *next;
	57	/* The next bound in a list. */
	58	};
	59
3d436d2a ZD	60	/* Structure to hold information for each natural loop. */
	61	struct loop
	62	{
	63	/* Index into loops array. */
	64	int num;
	65
	66	/* Basic block of loop header. */
	67	basic_block header;
	68
	69	/* Basic block of loop latch. */
	70	basic_block latch;
	71
3d436d2a ZD	72	/* For loop unrolling/peeling decision. */
	73	struct lpt_decision lpt_decision;
	74
3d436d2a ZD	75	/* Number of loop insns. */
	76	unsigned ninsns;
	77
	78	/* Average number of executed insns per iteration. */
	79	unsigned av_ninsns;
	80
3d436d2a ZD	81	/* Number of blocks contained within the loop. */
	82	unsigned num_nodes;
	83
3d436d2a ZD	84	/* The loop nesting depth. */
	85	int depth;
	86
	87	/* Superloops of the loop. */
	88	struct loop **pred;
	89
	90	/* The height of the loop (enclosed loop levels) within the loop
	91	hierarchy tree. */
	92	int level;
	93
	94	/* The outer (parent) loop or NULL if outermost loop. */
	95	struct loop *outer;
	96
	97	/* The first inner (child) loop or NULL if innermost loop. */
	98	struct loop *inner;
	99
	100	/* Link to the next (sibling) loop. */
	101	struct loop *next;
	102
	103	/* Loop that is copy of this loop. */
	104	struct loop *copy;
	105
3d436d2a ZD	106	/* Auxiliary info specific to a pass. */
	107	void *aux;
	108
9baba81b SP	109	/* The probable number of times the loop is executed at runtime.
	110	This is an INTEGER_CST or an expression containing symbolic
	111	names. Don't access this field directly:
	112	number_of_iterations_in_loop computes and caches the computed
	113	information in this field. */
	114	tree nb_iterations;
	115
86df10e3 SP	116	/* An INTEGER_CST estimation of the number of iterations. NULL_TREE
	117	if there is no estimation. */
	118	tree estimated_nb_iterations;
	119
e9eb809d ZD	120	/* Upper bound on number of iterations of a loop. */
e9eb809d ZD	121	struct nb_iter_bound *bounds;
82b85a85 ZD	122
	123	/* If not NULL, loop has just single exit edge stored here (edges to the
	124	EXIT_BLOCK_PTR do not count. */
	125	edge single_exit;
86df10e3 SP	126
	127	/* True when the loop does not carry data dependences, and
	128	consequently the iterations can be executed in any order. False
	129	when the loop carries data dependences, or when the property is
	130	not decidable. */
	131	bool parallel_p;
3d436d2a ZD	132	};
	133
	134	/* Flags for state of loop structure. */
	135	enum
	136	{
	137	LOOPS_HAVE_PREHEADERS = 1,
	138	LOOPS_HAVE_SIMPLE_LATCHES = 2,
82b85a85 ZD	139	LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS = 4,
82b85a85 ZD	140	LOOPS_HAVE_MARKED_SINGLE_EXITS = 8
3d436d2a ZD	141	};
3d436d2a ZD	142
d78f3f78 ZD	143	#define LOOPS_NORMAL (LOOPS_HAVE_PREHEADERS \| LOOPS_HAVE_SIMPLE_LATCHES \
	144	\| LOOPS_HAVE_MARKED_IRREDUCIBLE_REGIONS)
	145
3d436d2a ZD	146	/* Structure to hold CFG information about natural loops within a function. */
	147	struct loops
	148	{
	149	/* Number of natural loops in the function. */
	150	unsigned num;
	151
0162f155 RG	152	/* State of loops. */
0162f155 RG	153	int state;
3d436d2a	154
0162f155	155	/* We store just pointers to loops here.
43a613f7 DB	156	Note that a loop in this array may actually be NULL, if the loop
	157	has been removed and the entire loops structure has not been
	158	recomputed since that time. */
3d436d2a ZD	159	struct loop **parray;
	160
	161	/* Pointer to root of loop hierarchy tree. */
	162	struct loop *tree_root;
	163
	164	/* Information derived from the CFG. */
	165	struct cfg
	166	{
3d436d2a ZD	167	/* The ordering of the basic blocks in a depth first search. */
	168	int *dfs_order;
	169
	170	/* The reverse completion ordering of the basic blocks found in a
	171	depth first search. */
	172	int *rc_order;
	173	} cfg;
	174
	175	/* Headers shared by multiple loops that should be merged. */
	176	sbitmap shared_headers;
3d436d2a ZD	177	};
3d436d2a ZD	178
9baba81b SP	179	/* The loop tree currently optimized. */
	180
	181	extern struct loops *current_loops;
	182
3d436d2a	183	/* Loop recognition. */
70388d94	184	extern int flow_loops_find (struct loops *);
d329e058 AJ	185	extern void flow_loops_free (struct loops *);
	186	extern void flow_loops_dump (const struct loops , FILE ,
	187	void ()(const struct loop , FILE *, int), int);
	188	extern void flow_loop_dump (const struct loop , FILE ,
	189	void ()(const struct loop , FILE *, int), int);
d329e058	190	extern void flow_loop_free (struct loop *);
2b271002 ZD	191	int flow_loop_nodes_find (basic_block, struct loop *);
2b271002 ZD	192	void fix_loop_structure (struct loops *, bitmap changed_bbs);
d329e058	193	void mark_irreducible_loops (struct loops *);
82b85a85	194	void mark_single_exit_loops (struct loops *);
3d436d2a	195
4d6922ee	196	/* Loop data structure manipulation/querying. */
d329e058 AJ	197	extern void flow_loop_tree_node_add (struct loop , struct loop );
d329e058 AJ	198	extern void flow_loop_tree_node_remove (struct loop *);
d329e058 AJ	199	extern bool flow_loop_nested_p (const struct loop , const struct loop );
	200	extern bool flow_bb_inside_loop_p (const struct loop *, const basic_block);
	201	extern struct loop * find_common_loop (struct loop , struct loop );
a7e5372d	202	struct loop superloop_at_depth (struct loop , unsigned);
82b85a85	203	extern unsigned tree_num_loop_insns (struct loop *);
d329e058 AJ	204	extern int num_loop_insns (struct loop *);
d329e058 AJ	205	extern int average_num_loop_insns (struct loop *);
689ba89d	206	extern unsigned get_loop_level (const struct loop *);
70388d94 ZD	207	extern bool loop_exit_edge_p (const struct loop *, edge);
70388d94 ZD	208	extern void mark_loop_exit_edges (struct loops *);
3d436d2a ZD	209
3d436d2a ZD	210	/* Loops & cfg manipulation. */
d329e058	211	extern basic_block get_loop_body (const struct loop );
50654f6c	212	extern basic_block get_loop_body_in_dom_order (const struct loop );
40923b20	213	extern basic_block get_loop_body_in_bfs_order (const struct loop );
d329e058	214	extern edge get_loop_exit_edges (const struct loop , unsigned *);
50654f6c	215	extern unsigned num_loop_branches (const struct loop *);
3d436d2a	216
d329e058 AJ	217	extern edge loop_preheader_edge (const struct loop *);
d329e058 AJ	218	extern edge loop_latch_edge (const struct loop *);
3d436d2a	219
d329e058 AJ	220	extern void add_bb_to_loop (basic_block, struct loop *);
d329e058 AJ	221	extern void remove_bb_from_loops (basic_block);
3d436d2a	222
d329e058	223	extern void cancel_loop_tree (struct loops , struct loop );
3d436d2a	224
d47cc544	225	extern basic_block loop_split_edge_with (edge, rtx);
d329e058	226	extern int fix_loop_placement (struct loop *);
3d436d2a ZD	227
	228	enum
	229	{
bc35512f	230	CP_SIMPLE_PREHEADERS = 1
3d436d2a ZD	231	};
3d436d2a ZD	232
d329e058 AJ	233	extern void create_preheaders (struct loops *, int);
d329e058 AJ	234	extern void force_single_succ_latches (struct loops *);
3d436d2a	235
d329e058	236	extern void verify_loop_structure (struct loops *);
3d436d2a ZD	237
3d436d2a ZD	238	/* Loop analysis. */
6c878b23	239	extern bool just_once_each_iteration_p (const struct loop *, basic_block);
d329e058	240	extern unsigned expected_loop_iterations (const struct loop *);
75c70254	241	extern rtx doloop_condition_get (rtx);
617b465c ZD	242
617b465c ZD	243	/* Loop manipulation. */
d329e058	244	extern bool can_duplicate_loop_p (struct loop *loop);
617b465c ZD	245
	246	#define DLTHE_FLAG_UPDATE_FREQ 1 /* Update frequencies in
	247	duplicate_loop_to_header_edge. */
7f7b1718 JH	248	#define DLTHE_RECORD_COPY_NUMBER 2 /* Record copy number in the aux
7f7b1718 JH	249	field of newly create BB. */
178df94f	250	#define DLTHE_FLAG_COMPLETTE_PEEL 4 /* Update frequencies expecting
a4d05547	251	a complete peeling. */
617b465c	252
f67d92e9 DB	253	extern struct loop * duplicate_loop (struct loops , struct loop ,
f67d92e9 DB	254	struct loop *);
1cb7dfc3 MH	255	extern bool duplicate_loop_to_header_edge (struct loop , edge, struct loops ,
	256	unsigned, sbitmap, edge, edge *,
	257	unsigned *, int);
5132abc2 KH	258	extern struct loop loopify (struct loops , edge, edge,
5132abc2 KH	259	basic_block, edge, edge, bool);
1cb7dfc3	260	struct loop * loop_version (struct loops , struct loop , void *,
b9a66240	261	basic_block *, bool);
d329e058	262	extern bool remove_path (struct loops *, edge);
617b465c	263
50654f6c ZD	264	/* Induction variable analysis. */
	265
	266	/* The description of induction variable. The things are a bit complicated
	267	due to need to handle subregs and extends. The value of the object described
	268	by it can be obtained as follows (all computations are done in extend_mode):
	269
	270	Value in i-th iteration is
	271	delta + mult * extend_{extend_mode} (subreg_{mode} (base + i * step)).
	272
	273	If first_special is true, the value in the first iteration is
	274	delta + mult * base
	275
f822d252	276	If extend = UNKNOWN, first_special must be false, delta 0, mult 1 and value is
50654f6c ZD	277	subreg_{mode} (base + i * step)
	278
	279	The get_iv_value function can be used to obtain these expressions.
	280
	281	??? Add a third mode field that would specify the mode in that inner
	282	computation is done, which would enable it to be different from the
	283	outer one? */
	284
	285	struct rtx_iv
	286	{
	287	/* Its base and step (mode of base and step is supposed to be extend_mode,
	288	see the description above). */
	289	rtx base, step;
	290
f822d252	291	/* The type of extend applied to it (SIGN_EXTEND, ZERO_EXTEND or UNKNOWN). */
50654f6c ZD	292	enum rtx_code extend;
	293
	294	/* Operations applied in the extended mode. */
	295	rtx delta, mult;
	296
	297	/* The mode it is extended to. */
	298	enum machine_mode extend_mode;
	299
	300	/* The mode the variable iterates in. */
	301	enum machine_mode mode;
	302
50654f6c ZD	303	/* Whether the first iteration needs to be handled specially. */
	304	unsigned first_special : 1;
	305	};
	306
f2dca510 ZD	307	/* The description of an exit from the loop and of the number of iterations
f2dca510 ZD	308	till we take the exit. */
50654f6c ZD	309
	310	struct niter_desc
	311	{
	312	/* The edge out of the loop. */
	313	edge out_edge;
	314
	315	/* The other edge leading from the condition. */
	316	edge in_edge;
	317
	318	/* True if we are able to say anything about number of iterations of the
	319	loop. */
	320	bool simple_p;
	321
	322	/* True if the loop iterates the constant number of times. */
	323	bool const_iter;
	324
	325	/* Number of iterations if constant. */
	326	unsigned HOST_WIDEST_INT niter;
	327
	328	/* Upper bound on the number of iterations. */
	329	unsigned HOST_WIDEST_INT niter_max;
	330
	331	/* Assumptions under that the rest of the information is valid. */
	332	rtx assumptions;
	333
	334	/* Assumptions under that the loop ends before reaching the latch,
	335	even if value of niter_expr says otherwise. */
	336	rtx noloop_assumptions;
	337
	338	/* Condition under that the loop is infinite. */
	339	rtx infinite;
	340
	341	/* Whether the comparison is signed. */
	342	bool signed_p;
	343
	344	/* The mode in that niter_expr should be computed. */
	345	enum machine_mode mode;
	346
	347	/* The number of iterations of the loop. */
	348	rtx niter_expr;
	349	};
	350
	351	extern void iv_analysis_loop_init (struct loop *);
6d4e0ecc	352	extern bool iv_analyze (rtx, rtx, struct rtx_iv *);
03fd2215 ZD	353	extern bool iv_analyze_result (rtx, rtx, struct rtx_iv *);
03fd2215 ZD	354	extern bool iv_analyze_expr (rtx, rtx, enum machine_mode, struct rtx_iv *);
50654f6c	355	extern rtx get_iv_value (struct rtx_iv *, rtx);
113d659a	356	extern bool biv_p (rtx, rtx);
50654f6c	357	extern void find_simple_exit (struct loop , struct niter_desc );
50654f6c	358	extern void iv_analysis_done (void);
03fd2215	359	extern struct df *iv_current_loop_df (void);
50654f6c ZD	360
	361	extern struct niter_desc get_simple_loop_desc (struct loop loop);
	362	extern void free_simple_loop_desc (struct loop *loop);
	363
	364	static inline struct niter_desc *
	365	simple_loop_desc (struct loop *loop)
	366	{
cceb1885	367	return (struct niter_desc *) loop->aux;
50654f6c ZD	368	}
50654f6c ZD	369
8b11a64c ZD	370	/* The properties of the target. */
	371
	372	extern unsigned target_avail_regs; /* Number of available registers. */
	373	extern unsigned target_res_regs; /* Number of reserved registers. */
	374	extern unsigned target_small_cost; /* The cost for register when there
	375	is a free one. */
	376	extern unsigned target_pres_cost; /* The cost for register when there are
	377	not too many free ones. */
	378	extern unsigned target_spill_cost; /* The cost for register when we need
	379	to spill. */
	380
5e962776 ZD	381	/* Register pressure estimation for induction variable optimizations & loop
	382	invariant motion. */
	383	extern unsigned global_cost_for_size (unsigned, unsigned, unsigned);
	384	extern void init_set_costs (void);
	385
617b465c	386	/* Loop optimizer initialization. */
10d22567 ZD	387	extern struct loops *loop_optimizer_init (unsigned);
10d22567 ZD	388	extern void loop_optimizer_finalize (struct loops *);
617b465c ZD	389
617b465c ZD	390	/* Optimization passes. */
d329e058	391	extern void unswitch_loops (struct loops *);
617b465c	392
b17d5d7c ZD	393	enum
	394	{
	395	UAP_PEEL = 1, /* Enables loop peeling. */
	396	UAP_UNROLL = 2, /* Enables peeling of loops if it seems profitable. */
	397	UAP_UNROLL_ALL = 4 /* Enables peeling of all loops. */
	398	};
	399
d329e058	400	extern void unroll_and_peel_loops (struct loops *, int);
689ba89d	401	extern void doloop_optimize_loops (struct loops *);
5e962776	402	extern void move_loop_invariants (struct loops *);
86df10e3	403	extern void record_estimate (struct loop *, tree, tree, tree);
59587b18 JQ	404
59587b18 JQ	405	#endif /* GCC_CFGLOOP_H */