1/* Loop optimization definitions for GNU C-Compiler 2 Copyright (C) 1991, 1995, 1998, 1999 Free Software Foundation, Inc. 3 4This file is part of GNU CC. 5 6GNU CC is free software; you can redistribute it and/or modify 7it under the terms of the GNU General Public License as published by 8the Free Software Foundation; either version 2, or (at your option) 9any later version. 10 11GNU CC is distributed in the hope that it will be useful, 12but WITHOUT ANY WARRANTY; without even the implied warranty of 13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14GNU General Public License for more details. 15 16You should have received a copy of the GNU General Public License 17along with GNU CC; see the file COPYING. If not, write to 18the Free Software Foundation, 59 Temple Place - Suite 330, 19Boston, MA 02111-1307, USA. */ 20 21#include "varray.h" 22 23/* Get the luid of an insn. Catch the error of trying to reference the LUID 24 of an insn added during loop, since these don't have LUIDs. */ 25 26#define INSN_LUID(INSN) \ 27 (INSN_UID (INSN) < max_uid_for_loop ? uid_luid[INSN_UID (INSN)] \ 28 : (abort (), -1)) 29 30/* A "basic induction variable" or biv is a pseudo reg that is set 31 (within this loop) only by incrementing or decrementing it. */ 32/* A "general induction variable" or giv is a pseudo reg whose 33 value is a linear function of a biv. */ 34 35/* Bivs are recognized by `basic_induction_var'; 36 Givs by `general_induct_var'. */ 37 38/* An enum for the two different types of givs, those that are used 39 as memory addresses and those that are calculated into registers. */ 40enum g_types { DEST_ADDR, DEST_REG }; 41 42/* A `struct induction' is created for every instruction that sets 43 an induction variable (either a biv or a giv). */ 44 45struct induction 46{ 47 rtx insn; /* The insn that sets a biv or giv */ 48 rtx new_reg; /* New register, containing strength reduced 49 version of this giv. */ 50 rtx src_reg; /* Biv from which this giv is computed. 51 (If this is a biv, then this is the biv.) */ 52 enum g_types giv_type; /* Indicate whether DEST_ADDR or DEST_REG */ 53 rtx dest_reg; /* Destination register for insn: this is the 54 register which was the biv or giv. 55 For a biv, this equals src_reg. 56 For a DEST_ADDR type giv, this is 0. */ 57 rtx *location; /* Place in the insn where this giv occurs. 58 If GIV_TYPE is DEST_REG, this is 0. */ 59 /* For a biv, this is the place where add_val 60 was found. */ 61 enum machine_mode mode; /* The mode of this biv or giv */ 62 enum machine_mode mem_mode; /* For DEST_ADDR, mode of the memory object. */ 63 rtx mult_val; /* Multiplicative factor for src_reg. */ 64 rtx add_val; /* Additive constant for that product. */ 65 int benefit; /* Gain from eliminating this insn. */ 66 rtx final_value; /* If the giv is used outside the loop, and its 67 final value could be calculated, it is put 68 here, and the giv is made replaceable. Set 69 the giv to this value before the loop. */ 70 unsigned combined_with; /* The number of givs this giv has been 71 combined with. If nonzero, this giv 72 cannot combine with any other giv. */ 73 unsigned replaceable : 1; /* 1 if we can substitute the strength-reduced 74 variable for the original variable. 75 0 means they must be kept separate and the 76 new one must be copied into the old pseudo 77 reg each time the old one is set. */ 78 unsigned not_replaceable : 1; /* Used to prevent duplicating work. This is 79 1 if we know that the giv definitely can 80 not be made replaceable, in which case we 81 don't bother checking the variable again 82 even if further info is available. 83 Both this and the above can be zero. */ 84 unsigned ignore : 1; /* 1 prohibits further processing of giv */ 85 unsigned always_computable : 1;/* 1 if this value is computable every 86 iteration. */ 87 unsigned always_executed : 1; /* 1 if this set occurs each iteration. */ 88 unsigned maybe_multiple : 1; /* Only used for a biv and 1 if this biv 89 update may be done multiple times per 90 iteration. */ 91 unsigned cant_derive : 1; /* For giv's, 1 if this giv cannot derive 92 another giv. This occurs in many cases 93 where a giv's lifetime spans an update to 94 a biv. */ 95 unsigned maybe_dead : 1; /* 1 if this giv might be dead. In that case, 96 we won't use it to eliminate a biv, it 97 would probably lose. */ 98 unsigned auto_inc_opt : 1; /* 1 if this giv had its increment output next 99 to it to try to form an auto-inc address. */ 100 unsigned unrolled : 1; /* 1 if new register has been allocated and 101 initialized in unrolled loop. */ 102 unsigned shared : 1; 103 unsigned no_const_addval : 1; /* 1 if add_val does not contain a const. */ 104 int lifetime; /* Length of life of this giv */ 105 rtx derive_adjustment; /* If nonzero, is an adjustment to be 106 subtracted from add_val when this giv 107 derives another. This occurs when the 108 giv spans a biv update by incrementation. */ 109 struct induction *next_iv; /* For givs, links together all givs that are 110 based on the same biv. For bivs, links 111 together all biv entries that refer to the 112 same biv register. */ 113 struct induction *same; /* If this giv has been combined with another 114 giv, this points to the base giv. The base 115 giv will have COMBINED_WITH non-zero. */ 116 struct induction *derived_from;/* For a giv, if we decided to derive this 117 giv from another one. */ 118 HOST_WIDE_INT const_adjust; /* Used by loop unrolling, when an address giv 119 is split, and a constant is eliminated from 120 the address, the -constant is stored here 121 for later use. */ 122 int ix; /* Used by recombine_givs, as n index into 123 the stats array. */ 124 struct induction *same_insn; /* If there are multiple identical givs in 125 the same insn, then all but one have this 126 field set, and they all point to the giv 127 that doesn't have this field set. */ 128 rtx last_use; /* For a giv made from a biv increment, this is 129 a substitute for the lifetime information. */ 130}; 131 132/* A `struct iv_class' is created for each biv. */ 133 134struct iv_class { 135 int regno; /* Pseudo reg which is the biv. */ 136 int biv_count; /* Number of insns setting this reg. */ 137 struct induction *biv; /* List of all insns that set this reg. */ 138 int giv_count; /* Number of DEST_REG givs computed from this 139 biv. The resulting count is only used in 140 check_dbra_loop. */ 141 struct induction *giv; /* List of all insns that compute a giv 142 from this reg. */ 143 int total_benefit; /* Sum of BENEFITs of all those givs */ 144 rtx initial_value; /* Value of reg at loop start */ 145 rtx initial_test; /* Test performed on BIV before loop */ 146 struct iv_class *next; /* Links all class structures together */ 147 rtx init_insn; /* insn which initializes biv, 0 if none. */ 148 rtx init_set; /* SET of INIT_INSN, if any. */ 149 unsigned incremented : 1; /* 1 if somewhere incremented/decremented */ 150 unsigned eliminable : 1; /* 1 if plausible candidate for elimination. */ 151 unsigned nonneg : 1; /* 1 if we added a REG_NONNEG note for this. */ 152 unsigned reversed : 1; /* 1 if we reversed the loop that this 153 biv controls. */ 154}; 155 156/* Information required to calculate the number of loop iterations. 157 This is set by loop_iterations. */ 158 159struct loop_info 160{ 161 /* Register or constant initial loop value. */ 162 rtx initial_value; 163 /* Register or constant value used for comparison test. */ 164 rtx comparison_value; 165 /* Register or constant approximate final value. */ 166 rtx final_value; 167 /* Register or constant initial loop value with term common to 168 final_value removed. */ 169 rtx initial_equiv_value; 170 /* Register or constant final loop value with term common to 171 initial_value removed. */ 172 rtx final_equiv_value; 173 /* Register corresponding to iteration variable. */ 174 rtx iteration_var; 175 /* Constant loop increment. */ 176 rtx increment; 177 enum rtx_code comparison_code; 178 /* Holds the number of loop iterations. It is zero if the number 179 could not be calculated. Must be unsigned since the number of 180 iterations can be as high as 2^wordsize - 1. For loops with a 181 wider iterator, this number will be zero if the number of loop 182 iterations is too large for an unsigned integer to hold. */ 183 unsigned HOST_WIDE_INT n_iterations; 184 /* The loop unrolling factor. 185 Potential values: 186 0: unrolled 187 1: not unrolled. 188 -1: completely unrolled 189 >0: holds the unroll exact factor. */ 190 unsigned int unroll_number; 191 /* Non-zero if the loop has a NOTE_INSN_LOOP_VTOP. */ 192 rtx vtop; 193}; 194 195/* Definitions used by the basic induction variable discovery code. */ 196enum iv_mode { UNKNOWN_INDUCT, BASIC_INDUCT, NOT_BASIC_INDUCT, 197 GENERAL_INDUCT }; 198 199/* Variables declared in loop.c, but also needed in unroll.c. */ 200 201extern int *uid_luid; 202extern int max_uid_for_loop; 203extern int *uid_loop_num; 204extern int *loop_outer_loop; 205extern rtx *loop_number_exit_labels; 206extern int *loop_number_exit_count; 207extern int max_reg_before_loop; 208 209extern FILE *loop_dump_stream; 210 211extern varray_type reg_iv_type; 212extern varray_type reg_iv_info; 213 214#define REG_IV_TYPE(n) \ 215 (*(enum iv_mode *) &VARRAY_INT(reg_iv_type, (n))) 216#define REG_IV_INFO(n) \ 217 (*(struct induction **) &VARRAY_GENERIC_PTR(reg_iv_info, (n))) 218 219extern struct iv_class **reg_biv_class; 220extern struct iv_class *loop_iv_list; 221 222extern int first_increment_giv, last_increment_giv; 223 224/* Forward declarations for non-static functions declared in loop.c and 225 unroll.c. */ 226int invariant_p PROTO((rtx)); 227rtx get_condition_for_loop PROTO((rtx)); 228void emit_iv_add_mult PROTO((rtx, rtx, rtx, rtx, rtx)); 229rtx express_from PROTO((struct induction *, struct induction *)); 230 231void unroll_loop PROTO((rtx, int, rtx, rtx, struct loop_info *, int)); 232rtx biv_total_increment PROTO((struct iv_class *, rtx, rtx)); 233unsigned HOST_WIDE_INT loop_iterations PROTO((rtx, rtx, struct loop_info *)); 234int precondition_loop_p PROTO((rtx, struct loop_info *, 235 rtx *, rtx *, rtx *, 236 enum machine_mode *mode)); 237rtx final_biv_value PROTO((struct iv_class *, rtx, rtx, 238 unsigned HOST_WIDE_INT)); 239rtx final_giv_value PROTO((struct induction *, rtx, rtx, 240 unsigned HOST_WIDE_INT)); 241void emit_unrolled_add PROTO((rtx, rtx, rtx)); 242int back_branch_in_range_p PROTO((rtx, rtx, rtx)); 243int loop_insn_first_p PROTO((rtx, rtx)); 244 245extern int *loop_unroll_number; 246 247/* Forward declarations for non-static functions declared in stmt.c. */ 248void find_loop_tree_blocks PROTO((void)); 249void unroll_block_trees PROTO((void)); 250