Mercurial > hg > CbC > CbC_gcc
annotate gcc/sel-sched-ir.h @ 136:4627f235cf2a
fix c-next example
author | Shinji KONO <kono@ie.u-ryukyu.ac.jp> |
---|---|
date | Thu, 08 Nov 2018 14:11:56 +0900 |
parents | 84e7813d76e9 |
children | 1830386684a0 |
rev | line source |
---|---|
0 | 1 /* Instruction scheduling pass. This file contains definitions used |
2 internally in the scheduler. | |
131 | 3 Copyright (C) 2006-2018 Free Software Foundation, Inc. |
0 | 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 3, 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 COPYING3. If not see | |
19 <http://www.gnu.org/licenses/>. */ | |
20 | |
21 #ifndef GCC_SEL_SCHED_IR_H | |
22 #define GCC_SEL_SCHED_IR_H | |
23 | |
24 /* For state_t. */ | |
25 /* For reg_note. */ | |
26 | |
27 /* tc_t is a short for target context. This is a state of the target | |
28 backend. */ | |
29 typedef void *tc_t; | |
30 | |
31 /* List data types used for av sets, fences, paths, and boundaries. */ | |
32 | |
33 /* Forward declarations for types that are part of some list nodes. */ | |
34 struct _list_node; | |
35 | |
36 /* List backend. */ | |
37 typedef struct _list_node *_list_t; | |
38 #define _LIST_NEXT(L) ((L)->next) | |
39 | |
40 /* Instruction data that is part of vinsn type. */ | |
41 struct idata_def; | |
42 typedef struct idata_def *idata_t; | |
43 | |
44 /* A virtual instruction, i.e. an instruction as seen by the scheduler. */ | |
45 struct vinsn_def; | |
46 typedef struct vinsn_def *vinsn_t; | |
47 | |
48 /* RTX list. | |
49 This type is the backend for ilist. */ | |
50 typedef _list_t _xlist_t; | |
51 #define _XLIST_X(L) ((L)->u.x) | |
52 #define _XLIST_NEXT(L) (_LIST_NEXT (L)) | |
53 | |
54 /* Instruction. */ | |
111 | 55 typedef rtx_insn *insn_t; |
0 | 56 |
57 /* List of insns. */ | |
111 | 58 typedef _list_t ilist_t; |
59 #define ILIST_INSN(L) ((L)->u.insn) | |
60 #define ILIST_NEXT(L) (_LIST_NEXT (L)) | |
0 | 61 |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
62 /* This lists possible transformations that done locally, i.e. in |
0 | 63 moveup_expr. */ |
64 enum local_trans_type | |
65 { | |
66 TRANS_SUBSTITUTION, | |
67 TRANS_SPECULATION | |
68 }; | |
69 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
70 /* This struct is used to record the history of expression's |
0 | 71 transformations. */ |
72 struct expr_history_def_1 | |
73 { | |
74 /* UID of the insn. */ | |
75 unsigned uid; | |
76 | |
77 /* How the expression looked like. */ | |
78 vinsn_t old_expr_vinsn; | |
79 | |
80 /* How the expression looks after the transformation. */ | |
81 vinsn_t new_expr_vinsn; | |
82 | |
83 /* And its speculative status. */ | |
84 ds_t spec_ds; | |
85 | |
86 /* Type of the transformation. */ | |
87 enum local_trans_type type; | |
88 }; | |
89 | |
90 typedef struct expr_history_def_1 expr_history_def; | |
91 | |
92 | |
93 /* Expression information. */ | |
94 struct _expr | |
95 { | |
96 /* Insn description. */ | |
97 vinsn_t vinsn; | |
98 | |
99 /* SPEC is the degree of speculativeness. | |
100 FIXME: now spec is increased when an rhs is moved through a | |
101 conditional, thus showing only control speculativeness. In the | |
102 future we'd like to count data spec separately to allow a better | |
103 control on scheduling. */ | |
104 int spec; | |
105 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
106 /* Degree of speculativeness measured as probability of executing |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
107 instruction's original basic block given relative to |
0 | 108 the current scheduling point. */ |
109 int usefulness; | |
110 | |
111 /* A priority of this expression. */ | |
112 int priority; | |
113 | |
114 /* A priority adjustment of this expression. */ | |
115 int priority_adj; | |
116 | |
117 /* Number of times the insn was scheduled. */ | |
118 int sched_times; | |
119 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
120 /* A basic block index this was originated from. Zero when there is |
0 | 121 more than one originator. */ |
122 int orig_bb_index; | |
123 | |
124 /* Instruction should be of SPEC_DONE_DS type in order to be moved to this | |
125 point. */ | |
126 ds_t spec_done_ds; | |
127 | |
128 /* SPEC_TO_CHECK_DS hold speculation types that should be checked | |
129 (used only during move_op ()). */ | |
130 ds_t spec_to_check_ds; | |
131 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
132 /* Cycle on which original insn was scheduled. Zero when it has not yet |
0 | 133 been scheduled or more than one originator. */ |
134 int orig_sched_cycle; | |
135 | |
136 /* This vector contains the history of insn's transformations. */ | |
111 | 137 vec<expr_history_def> history_of_changes; |
0 | 138 |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
139 /* True (1) when original target (register or memory) of this instruction |
0 | 140 is available for scheduling, false otherwise. -1 means we're not sure; |
141 please run find_used_regs to clarify. */ | |
142 signed char target_available; | |
143 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
144 /* True when this expression needs a speculation check to be scheduled. |
0 | 145 This is used during find_used_regs. */ |
146 BOOL_BITFIELD needs_spec_check_p : 1; | |
147 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
148 /* True when the expression was substituted. Used for statistical |
0 | 149 purposes. */ |
150 BOOL_BITFIELD was_substituted : 1; | |
151 | |
152 /* True when the expression was renamed. */ | |
153 BOOL_BITFIELD was_renamed : 1; | |
154 | |
155 /* True when expression can't be moved. */ | |
156 BOOL_BITFIELD cant_move : 1; | |
157 }; | |
158 | |
159 typedef struct _expr expr_def; | |
160 typedef expr_def *expr_t; | |
161 | |
162 #define EXPR_VINSN(EXPR) ((EXPR)->vinsn) | |
163 #define EXPR_INSN_RTX(EXPR) (VINSN_INSN_RTX (EXPR_VINSN (EXPR))) | |
164 #define EXPR_PATTERN(EXPR) (VINSN_PATTERN (EXPR_VINSN (EXPR))) | |
165 #define EXPR_LHS(EXPR) (VINSN_LHS (EXPR_VINSN (EXPR))) | |
166 #define EXPR_RHS(EXPR) (VINSN_RHS (EXPR_VINSN (EXPR))) | |
167 #define EXPR_TYPE(EXPR) (VINSN_TYPE (EXPR_VINSN (EXPR))) | |
168 #define EXPR_SEPARABLE_P(EXPR) (VINSN_SEPARABLE_P (EXPR_VINSN (EXPR))) | |
169 | |
170 #define EXPR_SPEC(EXPR) ((EXPR)->spec) | |
171 #define EXPR_USEFULNESS(EXPR) ((EXPR)->usefulness) | |
172 #define EXPR_PRIORITY(EXPR) ((EXPR)->priority) | |
173 #define EXPR_PRIORITY_ADJ(EXPR) ((EXPR)->priority_adj) | |
174 #define EXPR_SCHED_TIMES(EXPR) ((EXPR)->sched_times) | |
175 #define EXPR_ORIG_BB_INDEX(EXPR) ((EXPR)->orig_bb_index) | |
176 #define EXPR_ORIG_SCHED_CYCLE(EXPR) ((EXPR)->orig_sched_cycle) | |
177 #define EXPR_SPEC_DONE_DS(EXPR) ((EXPR)->spec_done_ds) | |
178 #define EXPR_SPEC_TO_CHECK_DS(EXPR) ((EXPR)->spec_to_check_ds) | |
179 #define EXPR_HISTORY_OF_CHANGES(EXPR) ((EXPR)->history_of_changes) | |
180 #define EXPR_TARGET_AVAILABLE(EXPR) ((EXPR)->target_available) | |
181 #define EXPR_NEEDS_SPEC_CHECK_P(EXPR) ((EXPR)->needs_spec_check_p) | |
182 #define EXPR_WAS_SUBSTITUTED(EXPR) ((EXPR)->was_substituted) | |
183 #define EXPR_WAS_RENAMED(EXPR) ((EXPR)->was_renamed) | |
184 #define EXPR_CANT_MOVE(EXPR) ((EXPR)->cant_move) | |
185 | |
186 /* Insn definition for list of original insns in find_used_regs. */ | |
187 struct _def | |
188 { | |
189 insn_t orig_insn; | |
190 | |
191 /* FIXME: Get rid of CROSSES_CALL in each def, since if we're moving up | |
192 rhs from two different places, but only one of the code motion paths | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
193 crosses a call, we can't use any of the call_used_regs, no matter which |
0 | 194 path or whether all paths crosses a call. Thus we should move CROSSES_CALL |
195 to static params. */ | |
196 bool crosses_call; | |
197 }; | |
198 typedef struct _def *def_t; | |
199 | |
200 | |
201 /* Availability sets are sets of expressions we're scheduling. */ | |
202 typedef _list_t av_set_t; | |
203 #define _AV_SET_EXPR(L) (&(L)->u.expr) | |
204 #define _AV_SET_NEXT(L) (_LIST_NEXT (L)) | |
205 | |
206 | |
207 /* Boundary of the current fence group. */ | |
208 struct _bnd | |
209 { | |
210 /* The actual boundary instruction. */ | |
211 insn_t to; | |
212 | |
213 /* Its path to the fence. */ | |
214 ilist_t ptr; | |
215 | |
216 /* Availability set at the boundary. */ | |
217 av_set_t av; | |
218 | |
219 /* This set moved to the fence. */ | |
220 av_set_t av1; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
221 |
0 | 222 /* Deps context at this boundary. As long as we have one boundary per fence, |
223 this is just a pointer to the same deps context as in the corresponding | |
224 fence. */ | |
225 deps_t dc; | |
226 }; | |
227 typedef struct _bnd *bnd_t; | |
228 #define BND_TO(B) ((B)->to) | |
229 | |
230 /* PTR stands not for pointer as you might think, but as a Path To Root of the | |
231 current instruction group from boundary B. */ | |
232 #define BND_PTR(B) ((B)->ptr) | |
233 #define BND_AV(B) ((B)->av) | |
234 #define BND_AV1(B) ((B)->av1) | |
235 #define BND_DC(B) ((B)->dc) | |
236 | |
237 /* List of boundaries. */ | |
238 typedef _list_t blist_t; | |
239 #define BLIST_BND(L) (&(L)->u.bnd) | |
240 #define BLIST_NEXT(L) (_LIST_NEXT (L)) | |
241 | |
242 | |
243 /* Fence information. A fence represents current scheduling point and also | |
244 blocks code motion through it when pipelining. */ | |
245 struct _fence | |
246 { | |
247 /* Insn before which we gather an instruction group.*/ | |
248 insn_t insn; | |
249 | |
250 /* Modeled state of the processor pipeline. */ | |
251 state_t state; | |
252 | |
253 /* Current cycle that is being scheduled on this fence. */ | |
254 int cycle; | |
255 | |
256 /* Number of insns that were scheduled on the current cycle. | |
257 This information has to be local to a fence. */ | |
258 int cycle_issued_insns; | |
259 | |
260 /* At the end of fill_insns () this field holds the list of the instructions | |
261 that are inner boundaries of the scheduled parallel group. */ | |
262 ilist_t bnds; | |
263 | |
264 /* Deps context at this fence. It is used to model dependencies at the | |
265 fence so that insn ticks can be properly evaluated. */ | |
266 deps_t dc; | |
267 | |
268 /* Target context at this fence. Used to save and load any local target | |
269 scheduling information when changing fences. */ | |
270 tc_t tc; | |
271 | |
272 /* A vector of insns that are scheduled but not yet completed. */ | |
111 | 273 vec<rtx_insn *, va_gc> *executing_insns; |
0 | 274 |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
275 /* A vector indexed by UIDs that caches the earliest cycle on which |
0 | 276 an insn can be scheduled on this fence. */ |
277 int *ready_ticks; | |
278 | |
279 /* Its size. */ | |
280 int ready_ticks_size; | |
281 | |
282 /* Insn, which has been scheduled last on this fence. */ | |
111 | 283 rtx_insn *last_scheduled_insn; |
0 | 284 |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
285 /* The last value of can_issue_more variable on this fence. */ |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
286 int issue_more; |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
287 |
0 | 288 /* If non-NULL force the next scheduled insn to be SCHED_NEXT. */ |
111 | 289 rtx_insn *sched_next; |
0 | 290 |
291 /* True if fill_insns processed this fence. */ | |
292 BOOL_BITFIELD processed_p : 1; | |
293 | |
294 /* True if fill_insns actually scheduled something on this fence. */ | |
295 BOOL_BITFIELD scheduled_p : 1; | |
296 | |
297 /* True when the next insn scheduled here would start a cycle. */ | |
298 BOOL_BITFIELD starts_cycle_p : 1; | |
299 | |
300 /* True when the next insn scheduled here would be scheduled after a stall. */ | |
301 BOOL_BITFIELD after_stall_p : 1; | |
302 }; | |
303 typedef struct _fence *fence_t; | |
304 | |
305 #define FENCE_INSN(F) ((F)->insn) | |
306 #define FENCE_STATE(F) ((F)->state) | |
307 #define FENCE_BNDS(F) ((F)->bnds) | |
308 #define FENCE_PROCESSED_P(F) ((F)->processed_p) | |
309 #define FENCE_SCHEDULED_P(F) ((F)->scheduled_p) | |
310 #define FENCE_ISSUED_INSNS(F) ((F)->cycle_issued_insns) | |
311 #define FENCE_CYCLE(F) ((F)->cycle) | |
312 #define FENCE_STARTS_CYCLE_P(F) ((F)->starts_cycle_p) | |
313 #define FENCE_AFTER_STALL_P(F) ((F)->after_stall_p) | |
314 #define FENCE_DC(F) ((F)->dc) | |
315 #define FENCE_TC(F) ((F)->tc) | |
316 #define FENCE_LAST_SCHEDULED_INSN(F) ((F)->last_scheduled_insn) | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
317 #define FENCE_ISSUE_MORE(F) ((F)->issue_more) |
0 | 318 #define FENCE_EXECUTING_INSNS(F) ((F)->executing_insns) |
319 #define FENCE_READY_TICKS(F) ((F)->ready_ticks) | |
320 #define FENCE_READY_TICKS_SIZE(F) ((F)->ready_ticks_size) | |
321 #define FENCE_SCHED_NEXT(F) ((F)->sched_next) | |
322 | |
323 /* List of fences. */ | |
324 typedef _list_t flist_t; | |
325 #define FLIST_FENCE(L) (&(L)->u.fence) | |
326 #define FLIST_NEXT(L) (_LIST_NEXT (L)) | |
327 | |
328 /* List of fences with pointer to the tail node. */ | |
329 struct flist_tail_def | |
330 { | |
331 flist_t head; | |
332 flist_t *tailp; | |
333 }; | |
334 | |
335 typedef struct flist_tail_def *flist_tail_t; | |
336 #define FLIST_TAIL_HEAD(L) ((L)->head) | |
337 #define FLIST_TAIL_TAILP(L) ((L)->tailp) | |
338 | |
339 /* List node information. A list node can be any of the types above. */ | |
340 struct _list_node | |
341 { | |
342 _list_t next; | |
343 | |
344 union | |
345 { | |
346 rtx x; | |
111 | 347 insn_t insn; |
0 | 348 struct _bnd bnd; |
349 expr_def expr; | |
350 struct _fence fence; | |
351 struct _def def; | |
352 void *data; | |
353 } u; | |
354 }; | |
355 | |
356 | |
357 /* _list_t functions. | |
358 All of _*list_* functions are used through accessor macros, thus | |
359 we can't move them in sel-sched-ir.c. */ | |
111 | 360 extern object_allocator<_list_node> sched_lists_pool; |
0 | 361 |
362 static inline _list_t | |
363 _list_alloc (void) | |
364 { | |
111 | 365 return sched_lists_pool.allocate (); |
0 | 366 } |
367 | |
368 static inline void | |
369 _list_add (_list_t *lp) | |
370 { | |
371 _list_t l = _list_alloc (); | |
372 | |
373 _LIST_NEXT (l) = *lp; | |
374 *lp = l; | |
375 } | |
376 | |
377 static inline void | |
378 _list_remove_nofree (_list_t *lp) | |
379 { | |
380 _list_t n = *lp; | |
381 | |
382 *lp = _LIST_NEXT (n); | |
383 } | |
384 | |
385 static inline void | |
386 _list_remove (_list_t *lp) | |
387 { | |
388 _list_t n = *lp; | |
389 | |
390 *lp = _LIST_NEXT (n); | |
111 | 391 sched_lists_pool.remove (n); |
0 | 392 } |
393 | |
394 static inline void | |
395 _list_clear (_list_t *l) | |
396 { | |
397 while (*l) | |
398 _list_remove (l); | |
399 } | |
400 | |
401 | |
402 /* List iterator backend. */ | |
111 | 403 struct _list_iterator |
0 | 404 { |
405 /* The list we're iterating. */ | |
406 _list_t *lp; | |
407 | |
408 /* True when this iterator supprts removing. */ | |
409 bool can_remove_p; | |
410 | |
411 /* True when we've actually removed something. */ | |
412 bool removed_p; | |
111 | 413 }; |
0 | 414 |
415 static inline void | |
416 _list_iter_start (_list_iterator *ip, _list_t *lp, bool can_remove_p) | |
417 { | |
418 ip->lp = lp; | |
419 ip->can_remove_p = can_remove_p; | |
420 ip->removed_p = false; | |
421 } | |
422 | |
423 static inline void | |
424 _list_iter_next (_list_iterator *ip) | |
425 { | |
426 if (!ip->removed_p) | |
427 ip->lp = &_LIST_NEXT (*ip->lp); | |
428 else | |
429 ip->removed_p = false; | |
430 } | |
431 | |
432 static inline void | |
433 _list_iter_remove (_list_iterator *ip) | |
434 { | |
435 gcc_assert (!ip->removed_p && ip->can_remove_p); | |
436 _list_remove (ip->lp); | |
437 ip->removed_p = true; | |
438 } | |
439 | |
440 static inline void | |
441 _list_iter_remove_nofree (_list_iterator *ip) | |
442 { | |
443 gcc_assert (!ip->removed_p && ip->can_remove_p); | |
444 _list_remove_nofree (ip->lp); | |
445 ip->removed_p = true; | |
446 } | |
447 | |
448 /* General macros to traverse a list. FOR_EACH_* interfaces are | |
449 implemented using these. */ | |
450 #define _FOR_EACH(TYPE, ELEM, I, L) \ | |
451 for (_list_iter_start (&(I), &(L), false); \ | |
452 _list_iter_cond_##TYPE (*(I).lp, &(ELEM)); \ | |
453 _list_iter_next (&(I))) | |
454 | |
455 #define _FOR_EACH_1(TYPE, ELEM, I, LP) \ | |
456 for (_list_iter_start (&(I), (LP), true); \ | |
457 _list_iter_cond_##TYPE (*(I).lp, &(ELEM)); \ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
458 _list_iter_next (&(I))) |
0 | 459 |
460 | |
461 /* _xlist_t functions. */ | |
462 | |
463 static inline void | |
464 _xlist_add (_xlist_t *lp, rtx x) | |
465 { | |
466 _list_add (lp); | |
467 _XLIST_X (*lp) = x; | |
468 } | |
469 | |
470 #define _xlist_remove(LP) (_list_remove (LP)) | |
471 #define _xlist_clear(LP) (_list_clear (LP)) | |
472 | |
473 static inline bool | |
474 _xlist_is_in_p (_xlist_t l, rtx x) | |
475 { | |
476 while (l) | |
477 { | |
478 if (_XLIST_X (l) == x) | |
479 return true; | |
480 l = _XLIST_NEXT (l); | |
481 } | |
482 | |
483 return false; | |
484 } | |
485 | |
486 /* Used through _FOR_EACH. */ | |
487 static inline bool | |
488 _list_iter_cond_x (_xlist_t l, rtx *xp) | |
489 { | |
490 if (l) | |
491 { | |
492 *xp = _XLIST_X (l); | |
493 return true; | |
494 } | |
495 | |
496 return false; | |
497 } | |
498 | |
499 #define _xlist_iter_remove(IP) (_list_iter_remove (IP)) | |
500 | |
501 typedef _list_iterator _xlist_iterator; | |
502 #define _FOR_EACH_X(X, I, L) _FOR_EACH (x, (X), (I), (L)) | |
503 #define _FOR_EACH_X_1(X, I, LP) _FOR_EACH_1 (x, (X), (I), (LP)) | |
504 | |
505 | |
111 | 506 /* ilist_t functions. */ |
507 | |
508 static inline void | |
509 ilist_add (ilist_t *lp, insn_t insn) | |
510 { | |
511 _list_add (lp); | |
512 ILIST_INSN (*lp) = insn; | |
513 } | |
514 #define ilist_remove(LP) (_list_remove (LP)) | |
515 #define ilist_clear(LP) (_list_clear (LP)) | |
516 | |
517 static inline bool | |
518 ilist_is_in_p (ilist_t l, insn_t insn) | |
519 { | |
520 while (l) | |
521 { | |
522 if (ILIST_INSN (l) == insn) | |
523 return true; | |
524 l = ILIST_NEXT (l); | |
525 } | |
0 | 526 |
111 | 527 return false; |
528 } | |
0 | 529 |
111 | 530 /* Used through _FOR_EACH. */ |
531 static inline bool | |
532 _list_iter_cond_insn (ilist_t l, insn_t *ip) | |
533 { | |
534 if (l) | |
535 { | |
536 *ip = ILIST_INSN (l); | |
537 return true; | |
538 } | |
539 | |
540 return false; | |
541 } | |
542 | |
543 #define ilist_iter_remove(IP) (_list_iter_remove (IP)) | |
544 | |
545 typedef _list_iterator ilist_iterator; | |
546 #define FOR_EACH_INSN(INSN, I, L) _FOR_EACH (insn, (INSN), (I), (L)) | |
547 #define FOR_EACH_INSN_1(INSN, I, LP) _FOR_EACH_1 (insn, (INSN), (I), (LP)) | |
0 | 548 |
549 | |
550 /* Av set iterators. */ | |
551 typedef _list_iterator av_set_iterator; | |
552 #define FOR_EACH_EXPR(EXPR, I, AV) _FOR_EACH (expr, (EXPR), (I), (AV)) | |
553 #define FOR_EACH_EXPR_1(EXPR, I, AV) _FOR_EACH_1 (expr, (EXPR), (I), (AV)) | |
554 | |
111 | 555 inline bool |
0 | 556 _list_iter_cond_expr (av_set_t av, expr_t *exprp) |
557 { | |
558 if (av) | |
559 { | |
560 *exprp = _AV_SET_EXPR (av); | |
561 return true; | |
562 } | |
563 | |
564 return false; | |
565 } | |
566 | |
567 | |
568 /* Def list iterators. */ | |
569 typedef _list_t def_list_t; | |
570 typedef _list_iterator def_list_iterator; | |
571 | |
572 #define DEF_LIST_NEXT(L) (_LIST_NEXT (L)) | |
573 #define DEF_LIST_DEF(L) (&(L)->u.def) | |
574 | |
575 #define FOR_EACH_DEF(DEF, I, DEF_LIST) _FOR_EACH (def, (DEF), (I), (DEF_LIST)) | |
576 | |
577 static inline bool | |
578 _list_iter_cond_def (def_list_t def_list, def_t *def) | |
579 { | |
580 if (def_list) | |
581 { | |
582 *def = DEF_LIST_DEF (def_list); | |
583 return true; | |
584 } | |
585 | |
586 return false; | |
587 } | |
588 | |
589 | |
590 /* InstructionData. Contains information about insn pattern. */ | |
591 struct idata_def | |
592 { | |
593 /* Type of the insn. | |
594 o CALL_INSN - Call insn | |
595 o JUMP_INSN - Jump insn | |
596 o INSN - INSN that cannot be cloned | |
597 o USE - INSN that can be cloned | |
598 o SET - INSN that can be cloned and separable into lhs and rhs | |
599 o PC - simplejump. Insns that simply redirect control flow should not | |
600 have any dependencies. Sched-deps.c, though, might consider them as | |
601 producers or consumers of certain registers. To avoid that we handle | |
602 dependency for simple jumps ourselves. */ | |
603 int type; | |
604 | |
605 /* If insn is a SET, this is its left hand side. */ | |
606 rtx lhs; | |
607 | |
608 /* If insn is a SET, this is its right hand side. */ | |
609 rtx rhs; | |
610 | |
611 /* Registers that are set/used by this insn. This info is now gathered | |
612 via sched-deps.c. The downside of this is that we also use live info | |
613 from flow that is accumulated in the basic blocks. These two infos | |
614 can be slightly inconsistent, hence in the beginning we make a pass | |
615 through CFG and calculating the conservative solution for the info in | |
616 basic blocks. When this scheduler will be switched to use dataflow, | |
617 this can be unified as df gives us both per basic block and per | |
618 instruction info. Actually, we don't do that pass and just hope | |
619 for the best. */ | |
620 regset reg_sets; | |
621 | |
622 regset reg_clobbers; | |
623 | |
624 regset reg_uses; | |
625 }; | |
626 | |
627 #define IDATA_TYPE(ID) ((ID)->type) | |
628 #define IDATA_LHS(ID) ((ID)->lhs) | |
629 #define IDATA_RHS(ID) ((ID)->rhs) | |
630 #define IDATA_REG_SETS(ID) ((ID)->reg_sets) | |
631 #define IDATA_REG_USES(ID) ((ID)->reg_uses) | |
632 #define IDATA_REG_CLOBBERS(ID) ((ID)->reg_clobbers) | |
633 | |
634 /* Type to represent all needed info to emit an insn. | |
635 This is a virtual equivalent of the insn. | |
636 Every insn in the stream has an associated vinsn. This is used | |
637 to reduce memory consumption basing on the fact that many insns | |
638 don't change through the scheduler. | |
639 | |
640 vinsn can be either normal or unique. | |
641 * Normal vinsn is the one, that can be cloned multiple times and typically | |
642 corresponds to normal instruction. | |
643 | |
644 * Unique vinsn derivates from CALL, ASM, JUMP (for a while) and other | |
645 unusual stuff. Such a vinsn is described by its INSN field, which is a | |
646 reference to the original instruction. */ | |
647 struct vinsn_def | |
648 { | |
649 /* Associated insn. */ | |
111 | 650 rtx_insn *insn_rtx; |
0 | 651 |
652 /* Its description. */ | |
653 struct idata_def id; | |
654 | |
655 /* Hash of vinsn. It is computed either from pattern or from rhs using | |
656 hash_rtx. It is not placed in ID for faster compares. */ | |
657 unsigned hash; | |
658 | |
659 /* Hash of the insn_rtx pattern. */ | |
660 unsigned hash_rtx; | |
661 | |
662 /* Smart pointer counter. */ | |
663 int count; | |
664 | |
665 /* Cached cost of the vinsn. To access it please use vinsn_cost (). */ | |
666 int cost; | |
667 | |
668 /* Mark insns that may trap so we don't move them through jumps. */ | |
669 bool may_trap_p; | |
670 }; | |
671 | |
672 #define VINSN_INSN_RTX(VI) ((VI)->insn_rtx) | |
673 #define VINSN_PATTERN(VI) (PATTERN (VINSN_INSN_RTX (VI))) | |
674 | |
675 #define VINSN_ID(VI) (&((VI)->id)) | |
676 #define VINSN_HASH(VI) ((VI)->hash) | |
677 #define VINSN_HASH_RTX(VI) ((VI)->hash_rtx) | |
678 #define VINSN_TYPE(VI) (IDATA_TYPE (VINSN_ID (VI))) | |
679 #define VINSN_SEPARABLE_P(VI) (VINSN_TYPE (VI) == SET) | |
680 #define VINSN_CLONABLE_P(VI) (VINSN_SEPARABLE_P (VI) || VINSN_TYPE (VI) == USE) | |
681 #define VINSN_UNIQUE_P(VI) (!VINSN_CLONABLE_P (VI)) | |
682 #define VINSN_LHS(VI) (IDATA_LHS (VINSN_ID (VI))) | |
683 #define VINSN_RHS(VI) (IDATA_RHS (VINSN_ID (VI))) | |
684 #define VINSN_REG_SETS(VI) (IDATA_REG_SETS (VINSN_ID (VI))) | |
685 #define VINSN_REG_USES(VI) (IDATA_REG_USES (VINSN_ID (VI))) | |
686 #define VINSN_REG_CLOBBERS(VI) (IDATA_REG_CLOBBERS (VINSN_ID (VI))) | |
687 #define VINSN_COUNT(VI) ((VI)->count) | |
688 #define VINSN_MAY_TRAP_P(VI) ((VI)->may_trap_p) | |
689 | |
690 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
691 /* An entry of the hashtable describing transformations happened when |
0 | 692 moving up through an insn. */ |
693 struct transformed_insns | |
694 { | |
695 /* Previous vinsn. Used to find the proper element. */ | |
696 vinsn_t vinsn_old; | |
697 | |
698 /* A new vinsn. */ | |
699 vinsn_t vinsn_new; | |
700 | |
701 /* Speculative status. */ | |
702 ds_t ds; | |
703 | |
704 /* Type of transformation happened. */ | |
705 enum local_trans_type type; | |
706 | |
707 /* Whether a conflict on the target register happened. */ | |
708 BOOL_BITFIELD was_target_conflict : 1; | |
709 | |
710 /* Whether a check was needed. */ | |
711 BOOL_BITFIELD needs_check : 1; | |
712 }; | |
713 | |
714 /* Indexed by INSN_LUID, the collection of all data associated with | |
715 a single instruction that is in the stream. */ | |
716 struct _sel_insn_data | |
717 { | |
718 /* The expression that contains vinsn for this insn and some | |
719 flow-sensitive data like priority. */ | |
720 expr_def expr; | |
721 | |
722 /* If (WS_LEVEL == GLOBAL_LEVEL) then AV is empty. */ | |
723 int ws_level; | |
724 | |
725 /* A number that helps in defining a traversing order for a region. */ | |
726 int seqno; | |
727 | |
728 /* A liveness data computed above this insn. */ | |
729 regset live; | |
730 | |
731 /* An INSN_UID bit is set when deps analysis result is already known. */ | |
732 bitmap analyzed_deps; | |
733 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
734 /* An INSN_UID bit is set when a hard dep was found, not set when |
0 | 735 no dependence is found. This is meaningful only when the analyzed_deps |
736 bitmap has its bit set. */ | |
737 bitmap found_deps; | |
738 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
739 /* An INSN_UID bit is set when this is a bookkeeping insn generated from |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
740 a parent with this uid. If a parent is a bookkeeping copy, all its |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
741 originators are transitively included in this set. */ |
0 | 742 bitmap originators; |
743 | |
744 /* A hashtable caching the result of insn transformations through this one. */ | |
745 htab_t transformed_insns; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
746 |
0 | 747 /* A context incapsulating this insn. */ |
67
f6334be47118
update gcc from gcc-4.6-20100522 to gcc-4.6-20110318
nobuyasu <dimolto@cr.ie.u-ryukyu.ac.jp>
parents:
63
diff
changeset
|
748 struct deps_desc deps_context; |
0 | 749 |
750 /* This field is initialized at the beginning of scheduling and is used | |
751 to handle sched group instructions. If it is non-null, then it points | |
752 to the instruction, which should be forced to schedule next. Such | |
753 instructions are unique. */ | |
754 insn_t sched_next; | |
755 | |
756 /* Cycle at which insn was scheduled. It is greater than zero if insn was | |
757 scheduled. This is used for bundling. */ | |
758 int sched_cycle; | |
759 | |
760 /* Cycle at which insn's data will be fully ready. */ | |
761 int ready_cycle; | |
762 | |
763 /* Speculations that are being checked by this insn. */ | |
764 ds_t spec_checked_ds; | |
765 | |
766 /* Whether the live set valid or not. */ | |
767 BOOL_BITFIELD live_valid_p : 1; | |
768 /* Insn is an ASM. */ | |
769 BOOL_BITFIELD asm_p : 1; | |
770 | |
771 /* True when an insn is scheduled after we've determined that a stall is | |
772 required. | |
773 This is used when emulating the Haifa scheduler for bundling. */ | |
774 BOOL_BITFIELD after_stall_p : 1; | |
775 }; | |
776 | |
777 typedef struct _sel_insn_data sel_insn_data_def; | |
778 typedef sel_insn_data_def *sel_insn_data_t; | |
779 | |
111 | 780 extern vec<sel_insn_data_def> s_i_d; |
0 | 781 |
782 /* Accessor macros for s_i_d. */ | |
111 | 783 #define SID(INSN) (&s_i_d[INSN_LUID (INSN)]) |
784 #define SID_BY_UID(UID) (&s_i_d[LUID_BY_UID (UID)]) | |
0 | 785 |
786 extern sel_insn_data_def insn_sid (insn_t); | |
787 | |
788 #define INSN_ASM_P(INSN) (SID (INSN)->asm_p) | |
789 #define INSN_SCHED_NEXT(INSN) (SID (INSN)->sched_next) | |
790 #define INSN_ANALYZED_DEPS(INSN) (SID (INSN)->analyzed_deps) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
791 #define INSN_FOUND_DEPS(INSN) (SID (INSN)->found_deps) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
792 #define INSN_DEPS_CONTEXT(INSN) (SID (INSN)->deps_context) |
0 | 793 #define INSN_ORIGINATORS(INSN) (SID (INSN)->originators) |
794 #define INSN_ORIGINATORS_BY_UID(UID) (SID_BY_UID (UID)->originators) | |
795 #define INSN_TRANSFORMED_INSNS(INSN) (SID (INSN)->transformed_insns) | |
796 | |
797 #define INSN_EXPR(INSN) (&SID (INSN)->expr) | |
798 #define INSN_LIVE(INSN) (SID (INSN)->live) | |
799 #define INSN_LIVE_VALID_P(INSN) (SID (INSN)->live_valid_p) | |
800 #define INSN_VINSN(INSN) (EXPR_VINSN (INSN_EXPR (INSN))) | |
801 #define INSN_TYPE(INSN) (VINSN_TYPE (INSN_VINSN (INSN))) | |
802 #define INSN_SIMPLEJUMP_P(INSN) (INSN_TYPE (INSN) == PC) | |
803 #define INSN_LHS(INSN) (VINSN_LHS (INSN_VINSN (INSN))) | |
804 #define INSN_RHS(INSN) (VINSN_RHS (INSN_VINSN (INSN))) | |
805 #define INSN_REG_SETS(INSN) (VINSN_REG_SETS (INSN_VINSN (INSN))) | |
806 #define INSN_REG_CLOBBERS(INSN) (VINSN_REG_CLOBBERS (INSN_VINSN (INSN))) | |
807 #define INSN_REG_USES(INSN) (VINSN_REG_USES (INSN_VINSN (INSN))) | |
808 #define INSN_SCHED_TIMES(INSN) (EXPR_SCHED_TIMES (INSN_EXPR (INSN))) | |
809 #define INSN_SEQNO(INSN) (SID (INSN)->seqno) | |
810 #define INSN_AFTER_STALL_P(INSN) (SID (INSN)->after_stall_p) | |
811 #define INSN_SCHED_CYCLE(INSN) (SID (INSN)->sched_cycle) | |
812 #define INSN_READY_CYCLE(INSN) (SID (INSN)->ready_cycle) | |
813 #define INSN_SPEC_CHECKED_DS(INSN) (SID (INSN)->spec_checked_ds) | |
814 | |
815 /* A global level shows whether an insn is valid or not. */ | |
816 extern int global_level; | |
817 | |
818 #define INSN_WS_LEVEL(INSN) (SID (INSN)->ws_level) | |
819 | |
820 extern av_set_t get_av_set (insn_t); | |
821 extern int get_av_level (insn_t); | |
822 | |
823 #define AV_SET(INSN) (get_av_set (INSN)) | |
824 #define AV_LEVEL(INSN) (get_av_level (INSN)) | |
825 #define AV_SET_VALID_P(INSN) (AV_LEVEL (INSN) == global_level) | |
826 | |
827 /* A list of fences currently in the works. */ | |
828 extern flist_t fences; | |
829 | |
830 /* A NOP pattern used as a placeholder for real insns. */ | |
831 extern rtx nop_pattern; | |
832 | |
833 /* An insn that 'contained' in EXIT block. */ | |
111 | 834 extern rtx_insn *exit_insn; |
0 | 835 |
836 /* Provide a separate luid for the insn. */ | |
837 #define INSN_INIT_TODO_LUID (1) | |
838 | |
839 /* Initialize s_s_i_d. */ | |
840 #define INSN_INIT_TODO_SSID (2) | |
841 | |
842 /* Initialize data for simplejump. */ | |
843 #define INSN_INIT_TODO_SIMPLEJUMP (4) | |
844 | |
845 /* Return true if INSN is a local NOP. The nop is local in the sense that | |
846 it was emitted by the scheduler as a temporary insn and will soon be | |
847 deleted. These nops are identified by their pattern. */ | |
848 #define INSN_NOP_P(INSN) (PATTERN (INSN) == nop_pattern) | |
849 | |
850 /* Return true if INSN is linked into instruction stream. | |
851 NB: It is impossible for INSN to have one field null and the other not | |
852 null: gcc_assert ((PREV_INSN (INSN) == NULL_RTX) | |
853 == (NEXT_INSN (INSN) == NULL_RTX)) is valid. */ | |
854 #define INSN_IN_STREAM_P(INSN) (PREV_INSN (INSN) && NEXT_INSN (INSN)) | |
855 | |
856 /* Return true if INSN is in current fence. */ | |
857 #define IN_CURRENT_FENCE_P(INSN) (flist_lookup (fences, INSN) != NULL) | |
858 | |
859 /* Marks loop as being considered for pipelining. */ | |
860 #define MARK_LOOP_FOR_PIPELINING(LOOP) ((LOOP)->aux = (void *)(size_t)(1)) | |
861 #define LOOP_MARKED_FOR_PIPELINING_P(LOOP) ((size_t)((LOOP)->aux)) | |
862 | |
863 /* Saved loop preheader to transfer when scheduling the loop. */ | |
864 #define LOOP_PREHEADER_BLOCKS(LOOP) ((size_t)((LOOP)->aux) == 1 \ | |
865 ? NULL \ | |
111 | 866 : ((vec<basic_block> *) (LOOP)->aux)) |
0 | 867 #define SET_LOOP_PREHEADER_BLOCKS(LOOP,BLOCKS) ((LOOP)->aux \ |
868 = (BLOCKS != NULL \ | |
869 ? BLOCKS \ | |
870 : (LOOP)->aux)) | |
871 | |
872 extern bitmap blocks_to_reschedule; | |
873 | |
874 | |
875 /* A variable to track which part of rtx we are scanning in | |
876 sched-deps.c: sched_analyze_insn (). */ | |
111 | 877 enum deps_where_t |
878 { | |
879 DEPS_IN_INSN, | |
880 DEPS_IN_LHS, | |
881 DEPS_IN_RHS, | |
882 DEPS_IN_NOWHERE | |
883 }; | |
0 | 884 |
885 | |
886 /* Per basic block data for the whole CFG. */ | |
111 | 887 struct sel_global_bb_info_def |
0 | 888 { |
889 /* For each bb header this field contains a set of live registers. | |
890 For all other insns this field has a NULL. | |
111 | 891 We also need to know LV sets for the instructions, that are immediately |
0 | 892 after the border of the region. */ |
893 regset lv_set; | |
894 | |
895 /* Status of LV_SET. | |
896 true - block has usable LV_SET. | |
897 false - block's LV_SET should be recomputed. */ | |
898 bool lv_set_valid_p; | |
111 | 899 }; |
0 | 900 |
901 typedef sel_global_bb_info_def *sel_global_bb_info_t; | |
902 | |
903 | |
904 /* Per basic block data. This array is indexed by basic block index. */ | |
111 | 905 extern vec<sel_global_bb_info_def> sel_global_bb_info; |
0 | 906 |
907 extern void sel_extend_global_bb_info (void); | |
908 extern void sel_finish_global_bb_info (void); | |
909 | |
910 /* Get data for BB. */ | |
911 #define SEL_GLOBAL_BB_INFO(BB) \ | |
111 | 912 (&sel_global_bb_info[(BB)->index]) |
0 | 913 |
914 /* Access macros. */ | |
915 #define BB_LV_SET(BB) (SEL_GLOBAL_BB_INFO (BB)->lv_set) | |
916 #define BB_LV_SET_VALID_P(BB) (SEL_GLOBAL_BB_INFO (BB)->lv_set_valid_p) | |
917 | |
918 /* Per basic block data for the region. */ | |
111 | 919 struct sel_region_bb_info_def |
0 | 920 { |
921 /* This insn stream is constructed in such a way that it should be | |
922 traversed by PREV_INSN field - (*not* NEXT_INSN). */ | |
111 | 923 rtx_insn *note_list; |
0 | 924 |
925 /* Cached availability set at the beginning of a block. | |
926 See also AV_LEVEL () for conditions when this av_set can be used. */ | |
927 av_set_t av_set; | |
928 | |
929 /* If (AV_LEVEL == GLOBAL_LEVEL) then AV is valid. */ | |
930 int av_level; | |
111 | 931 }; |
0 | 932 |
933 typedef sel_region_bb_info_def *sel_region_bb_info_t; | |
934 | |
935 | |
936 /* Per basic block data. This array is indexed by basic block index. */ | |
111 | 937 extern vec<sel_region_bb_info_def> sel_region_bb_info; |
0 | 938 |
939 /* Get data for BB. */ | |
111 | 940 #define SEL_REGION_BB_INFO(BB) (&sel_region_bb_info[(BB)->index]) |
0 | 941 |
942 /* Get BB's note_list. | |
943 A note_list is a list of various notes that was scattered across BB | |
944 before scheduling, and will be appended at the beginning of BB after | |
945 scheduling is finished. */ | |
946 #define BB_NOTE_LIST(BB) (SEL_REGION_BB_INFO (BB)->note_list) | |
947 | |
948 #define BB_AV_SET(BB) (SEL_REGION_BB_INFO (BB)->av_set) | |
949 #define BB_AV_LEVEL(BB) (SEL_REGION_BB_INFO (BB)->av_level) | |
950 #define BB_AV_SET_VALID_P(BB) (BB_AV_LEVEL (BB) == global_level) | |
951 | |
952 /* Used in bb_in_ebb_p. */ | |
953 extern bitmap_head *forced_ebb_heads; | |
954 | |
955 /* The loop nest being pipelined. */ | |
956 extern struct loop *current_loop_nest; | |
957 | |
958 /* Saves pipelined blocks. Bitmap is indexed by bb->index. */ | |
959 extern sbitmap bbs_pipelined; | |
960 | |
961 /* Various flags. */ | |
962 extern bool enable_moveup_set_path_p; | |
963 extern bool pipelining_p; | |
964 extern bool bookkeeping_p; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
965 extern int max_insns_to_rename; |
0 | 966 extern bool preheader_removed; |
967 | |
968 /* Software lookahead window size. | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
969 According to the results in Nakatani and Ebcioglu [1993], window size of 16 |
0 | 970 is enough to extract most ILP in integer code. */ |
971 #define MAX_WS (PARAM_VALUE (PARAM_SELSCHED_MAX_LOOKAHEAD)) | |
972 | |
973 extern regset sel_all_regs; | |
974 | |
975 | |
976 /* Successor iterator backend. */ | |
111 | 977 struct succ_iterator |
0 | 978 { |
979 /* True if we're at BB end. */ | |
980 bool bb_end; | |
981 | |
982 /* An edge on which we're iterating. */ | |
983 edge e1; | |
984 | |
985 /* The previous edge saved after skipping empty blocks. */ | |
986 edge e2; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
987 |
0 | 988 /* Edge iterator used when there are successors in other basic blocks. */ |
989 edge_iterator ei; | |
990 | |
991 /* Successor block we're traversing. */ | |
992 basic_block bb; | |
993 | |
994 /* Flags that are passed to the iterator. We return only successors | |
995 that comply to these flags. */ | |
996 short flags; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
997 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
998 /* When flags include SUCCS_ALL, this will be set to the exact type |
111 | 999 of the successor we're traversing now. */ |
0 | 1000 short current_flags; |
1001 | |
1002 /* If skip to loop exits, save here information about loop exits. */ | |
1003 int current_exit; | |
111 | 1004 vec<edge> loop_exits; |
1005 }; | |
0 | 1006 |
1007 /* A structure returning all successor's information. */ | |
1008 struct succs_info | |
1009 { | |
1010 /* Flags that these succcessors were computed with. */ | |
1011 short flags; | |
1012 | |
1013 /* Successors that correspond to the flags. */ | |
1014 insn_vec_t succs_ok; | |
1015 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1016 /* Their probabilities. As of now, we don't need this for other |
0 | 1017 successors. */ |
111 | 1018 vec<int> probs_ok; |
0 | 1019 |
1020 /* Other successors. */ | |
1021 insn_vec_t succs_other; | |
1022 | |
1023 /* Probability of all successors. */ | |
1024 int all_prob; | |
1025 | |
1026 /* The number of all successors. */ | |
1027 int all_succs_n; | |
1028 | |
1029 /* The number of good successors. */ | |
1030 int succs_ok_n; | |
1031 }; | |
1032 | |
1033 /* Some needed definitions. */ | |
1034 extern basic_block after_recovery; | |
1035 | |
111 | 1036 extern rtx_insn *sel_bb_head (basic_block); |
1037 extern rtx_insn *sel_bb_end (basic_block); | |
0 | 1038 extern bool sel_bb_empty_p (basic_block); |
1039 extern bool in_current_region_p (basic_block); | |
1040 | |
1041 /* True when BB is a header of the inner loop. */ | |
1042 static inline bool | |
1043 inner_loop_header_p (basic_block bb) | |
1044 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1045 struct loop *inner_loop; |
0 | 1046 |
1047 if (!current_loop_nest) | |
1048 return false; | |
1049 | |
111 | 1050 if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun)) |
0 | 1051 return false; |
1052 | |
1053 inner_loop = bb->loop_father; | |
1054 if (inner_loop == current_loop_nest) | |
1055 return false; | |
1056 | |
1057 /* If successor belongs to another loop. */ | |
1058 if (bb == inner_loop->header | |
1059 && flow_bb_inside_loop_p (current_loop_nest, bb)) | |
1060 { | |
1061 /* Could be '=' here because of wrong loop depths. */ | |
1062 gcc_assert (loop_depth (inner_loop) >= loop_depth (current_loop_nest)); | |
1063 return true; | |
1064 } | |
1065 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1066 return false; |
0 | 1067 } |
1068 | |
1069 /* Return exit edges of LOOP, filtering out edges with the same dest bb. */ | |
111 | 1070 static inline vec<edge> |
0 | 1071 get_loop_exit_edges_unique_dests (const struct loop *loop) |
1072 { | |
111 | 1073 vec<edge> edges = vNULL; |
0 | 1074 struct loop_exit *exit; |
1075 | |
111 | 1076 gcc_assert (loop->latch != EXIT_BLOCK_PTR_FOR_FN (cfun) |
0 | 1077 && current_loops->state & LOOPS_HAVE_RECORDED_EXITS); |
1078 | |
1079 for (exit = loop->exits->next; exit->e; exit = exit->next) | |
1080 { | |
1081 int i; | |
1082 edge e; | |
1083 bool was_dest = false; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1084 |
111 | 1085 for (i = 0; edges.iterate (i, &e); i++) |
0 | 1086 if (e->dest == exit->e->dest) |
1087 { | |
1088 was_dest = true; | |
1089 break; | |
1090 } | |
1091 | |
1092 if (!was_dest) | |
111 | 1093 edges.safe_push (exit->e); |
0 | 1094 } |
1095 return edges; | |
1096 } | |
1097 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1098 static bool |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1099 sel_bb_empty_or_nop_p (basic_block bb) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1100 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1101 insn_t first = sel_bb_head (bb), last; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1102 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1103 if (first == NULL_RTX) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1104 return true; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1105 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1106 if (!INSN_NOP_P (first)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1107 return false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1108 |
111 | 1109 if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun)) |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1110 return false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1111 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1112 last = sel_bb_end (bb); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1113 if (first != last) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1114 return false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1115 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1116 return true; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1117 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1118 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1119 /* Collect all loop exits recursively, skipping empty BBs between them. |
0 | 1120 E.g. if BB is a loop header which has several loop exits, |
1121 traverse all of them and if any of them turns out to be another loop header | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1122 (after skipping empty BBs), add its loop exits to the resulting vector |
0 | 1123 as well. */ |
111 | 1124 static inline vec<edge> |
0 | 1125 get_all_loop_exits (basic_block bb) |
1126 { | |
111 | 1127 vec<edge> exits = vNULL; |
0 | 1128 |
1129 /* If bb is empty, and we're skipping to loop exits, then | |
1130 consider bb as a possible gate to the inner loop now. */ | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1131 while (sel_bb_empty_or_nop_p (bb) |
111 | 1132 && in_current_region_p (bb) |
1133 && EDGE_COUNT (bb->succs) > 0) | |
0 | 1134 { |
1135 bb = single_succ (bb); | |
1136 | |
1137 /* This empty block could only lead outside the region. */ | |
1138 gcc_assert (! in_current_region_p (bb)); | |
1139 } | |
1140 | |
1141 /* And now check whether we should skip over inner loop. */ | |
1142 if (inner_loop_header_p (bb)) | |
1143 { | |
1144 struct loop *this_loop; | |
1145 struct loop *pred_loop = NULL; | |
1146 int i; | |
1147 edge e; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1148 |
0 | 1149 for (this_loop = bb->loop_father; |
1150 this_loop && this_loop != current_loop_nest; | |
1151 this_loop = loop_outer (this_loop)) | |
1152 pred_loop = this_loop; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1153 |
0 | 1154 this_loop = pred_loop; |
1155 gcc_assert (this_loop != NULL); | |
1156 | |
1157 exits = get_loop_exit_edges_unique_dests (this_loop); | |
1158 | |
1159 /* Traverse all loop headers. */ | |
111 | 1160 for (i = 0; exits.iterate (i, &e); i++) |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1161 if (in_current_region_p (e->dest) |
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1162 || inner_loop_header_p (e->dest)) |
0 | 1163 { |
111 | 1164 vec<edge> next_exits = get_all_loop_exits (e->dest); |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1165 |
111 | 1166 if (next_exits.exists ()) |
0 | 1167 { |
1168 int j; | |
1169 edge ne; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1170 |
0 | 1171 /* Add all loop exits for the current edge into the |
1172 resulting vector. */ | |
111 | 1173 for (j = 0; next_exits.iterate (j, &ne); j++) |
1174 exits.safe_push (ne); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1175 |
0 | 1176 /* Remove the original edge. */ |
111 | 1177 exits.ordered_remove (i); |
0 | 1178 |
1179 /* Decrease the loop counter so we won't skip anything. */ | |
1180 i--; | |
1181 continue; | |
1182 } | |
1183 } | |
1184 } | |
1185 | |
1186 return exits; | |
1187 } | |
1188 | |
1189 /* Flags to pass to compute_succs_info and FOR_EACH_SUCC. | |
1190 Any successor will fall into exactly one category. */ | |
1191 | |
1192 /* Include normal successors. */ | |
1193 #define SUCCS_NORMAL (1) | |
1194 | |
1195 /* Include back-edge successors. */ | |
1196 #define SUCCS_BACK (2) | |
1197 | |
1198 /* Include successors that are outside of the current region. */ | |
1199 #define SUCCS_OUT (4) | |
1200 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1201 /* When pipelining of the outer loops is enabled, skip innermost loops |
0 | 1202 to their exits. */ |
1203 #define SUCCS_SKIP_TO_LOOP_EXITS (8) | |
1204 | |
1205 /* Include all successors. */ | |
1206 #define SUCCS_ALL (SUCCS_NORMAL | SUCCS_BACK | SUCCS_OUT) | |
1207 | |
1208 /* We need to return a succ_iterator to avoid 'unitialized' warning | |
1209 during bootstrap. */ | |
1210 static inline succ_iterator | |
1211 _succ_iter_start (insn_t *succp, insn_t insn, int flags) | |
1212 { | |
1213 succ_iterator i; | |
1214 | |
1215 basic_block bb = BLOCK_FOR_INSN (insn); | |
1216 | |
1217 gcc_assert (INSN_P (insn) || NOTE_INSN_BASIC_BLOCK_P (insn)); | |
1218 | |
1219 i.flags = flags; | |
1220 | |
1221 /* Avoid 'uninitialized' warning. */ | |
1222 *succp = NULL; | |
1223 i.e1 = NULL; | |
1224 i.e2 = NULL; | |
1225 i.bb = bb; | |
1226 i.current_flags = 0; | |
1227 i.current_exit = -1; | |
111 | 1228 i.loop_exits.create (0); |
0 | 1229 |
111 | 1230 if (bb != EXIT_BLOCK_PTR_FOR_FN (cfun) && BB_END (bb) != insn) |
0 | 1231 { |
1232 i.bb_end = false; | |
1233 | |
1234 /* Avoid 'uninitialized' warning. */ | |
1235 i.ei.index = 0; | |
111 | 1236 i.ei.container = 0; |
0 | 1237 } |
1238 else | |
1239 { | |
1240 i.ei = ei_start (bb->succs); | |
1241 i.bb_end = true; | |
1242 } | |
1243 | |
1244 return i; | |
1245 } | |
1246 | |
1247 static inline bool | |
111 | 1248 _succ_iter_cond (succ_iterator *ip, insn_t *succp, insn_t insn, |
0 | 1249 bool check (edge, succ_iterator *)) |
1250 { | |
1251 if (!ip->bb_end) | |
1252 { | |
1253 /* When we're in a middle of a basic block, return | |
1254 the next insn immediately, but only when SUCCS_NORMAL is set. */ | |
1255 if (*succp != NULL || (ip->flags & SUCCS_NORMAL) == 0) | |
1256 return false; | |
1257 | |
1258 *succp = NEXT_INSN (insn); | |
1259 ip->current_flags = SUCCS_NORMAL; | |
1260 return true; | |
1261 } | |
1262 else | |
1263 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1264 while (1) |
0 | 1265 { |
1266 edge e_tmp = NULL; | |
1267 | |
1268 /* First, try loop exits, if we have them. */ | |
111 | 1269 if (ip->loop_exits.exists ()) |
0 | 1270 { |
1271 do | |
1272 { | |
111 | 1273 ip->loop_exits.iterate (ip->current_exit, &e_tmp); |
0 | 1274 ip->current_exit++; |
1275 } | |
1276 while (e_tmp && !check (e_tmp, ip)); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1277 |
0 | 1278 if (!e_tmp) |
111 | 1279 ip->loop_exits.release (); |
0 | 1280 } |
1281 | |
1282 /* If we have found a successor, then great. */ | |
1283 if (e_tmp) | |
1284 { | |
1285 ip->e1 = e_tmp; | |
1286 break; | |
1287 } | |
1288 | |
1289 /* If not, then try the next edge. */ | |
1290 while (ei_cond (ip->ei, &(ip->e1))) | |
1291 { | |
1292 basic_block bb = ip->e1->dest; | |
1293 | |
1294 /* Consider bb as a possible loop header. */ | |
1295 if ((ip->flags & SUCCS_SKIP_TO_LOOP_EXITS) | |
1296 && flag_sel_sched_pipelining_outer_loops | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1297 && (!in_current_region_p (bb) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1298 || BLOCK_TO_BB (ip->bb->index) |
0 | 1299 < BLOCK_TO_BB (bb->index))) |
1300 { | |
1301 /* Get all loop exits recursively. */ | |
1302 ip->loop_exits = get_all_loop_exits (bb); | |
1303 | |
111 | 1304 if (ip->loop_exits.exists ()) |
0 | 1305 { |
1306 ip->current_exit = 0; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1307 /* Move the iterator now, because we won't do |
0 | 1308 succ_iter_next until loop exits will end. */ |
1309 ei_next (&(ip->ei)); | |
1310 break; | |
1311 } | |
1312 } | |
1313 | |
1314 /* bb is not a loop header, check as usual. */ | |
1315 if (check (ip->e1, ip)) | |
1316 break; | |
1317 | |
1318 ei_next (&(ip->ei)); | |
1319 } | |
1320 | |
1321 /* If loop_exits are non null, we have found an inner loop; | |
1322 do one more iteration to fetch an edge from these exits. */ | |
111 | 1323 if (ip->loop_exits.exists ()) |
0 | 1324 continue; |
1325 | |
1326 /* Otherwise, we've found an edge in a usual way. Break now. */ | |
1327 break; | |
1328 } | |
1329 | |
1330 if (ip->e1) | |
1331 { | |
1332 basic_block bb = ip->e2->dest; | |
1333 | |
111 | 1334 if (bb == EXIT_BLOCK_PTR_FOR_FN (cfun) || bb == after_recovery) |
0 | 1335 *succp = exit_insn; |
1336 else | |
1337 { | |
1338 *succp = sel_bb_head (bb); | |
1339 | |
1340 gcc_assert (ip->flags != SUCCS_NORMAL | |
1341 || *succp == NEXT_INSN (bb_note (bb))); | |
1342 gcc_assert (BLOCK_FOR_INSN (*succp) == bb); | |
1343 } | |
1344 | |
1345 return true; | |
1346 } | |
1347 else | |
1348 return false; | |
1349 } | |
1350 } | |
1351 | |
1352 static inline void | |
1353 _succ_iter_next (succ_iterator *ip) | |
1354 { | |
1355 gcc_assert (!ip->e2 || ip->e1); | |
1356 | |
111 | 1357 if (ip->bb_end && ip->e1 && !ip->loop_exits.exists ()) |
0 | 1358 ei_next (&(ip->ei)); |
1359 } | |
1360 | |
1361 /* Returns true when E1 is an eligible successor edge, possibly skipping | |
1362 empty blocks. When E2P is not null, the resulting edge is written there. | |
1363 FLAGS are used to specify whether back edges and out-of-region edges | |
1364 should be considered. */ | |
1365 static inline bool | |
1366 _eligible_successor_edge_p (edge e1, succ_iterator *ip) | |
1367 { | |
1368 edge e2 = e1; | |
1369 basic_block bb; | |
1370 int flags = ip->flags; | |
1371 bool src_outside_rgn = !in_current_region_p (e1->src); | |
1372 | |
1373 gcc_assert (flags != 0); | |
1374 | |
1375 if (src_outside_rgn) | |
1376 { | |
1377 /* Any successor of the block that is outside current region is | |
1378 ineligible, except when we're skipping to loop exits. */ | |
1379 gcc_assert (flags & (SUCCS_OUT | SUCCS_SKIP_TO_LOOP_EXITS)); | |
1380 | |
1381 if (flags & SUCCS_OUT) | |
1382 return false; | |
1383 } | |
1384 | |
1385 bb = e2->dest; | |
1386 | |
1387 /* Skip empty blocks, but be careful not to leave the region. */ | |
1388 while (1) | |
1389 { | |
1390 if (!sel_bb_empty_p (bb)) | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1391 { |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1392 edge ne; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1393 basic_block nbb; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1394 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1395 if (!sel_bb_empty_or_nop_p (bb)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1396 break; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1397 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1398 ne = EDGE_SUCC (bb, 0); |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1399 nbb = ne->dest; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1400 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1401 if (!in_current_region_p (nbb) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1402 && !(flags & SUCCS_OUT)) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1403 break; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1404 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1405 e2 = ne; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1406 bb = nbb; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1407 continue; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1408 } |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1409 |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1410 if (!in_current_region_p (bb) |
0 | 1411 && !(flags & SUCCS_OUT)) |
1412 return false; | |
1413 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1414 if (EDGE_COUNT (bb->succs) == 0) |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1415 return false; |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1416 |
0 | 1417 e2 = EDGE_SUCC (bb, 0); |
1418 bb = e2->dest; | |
1419 } | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1420 |
0 | 1421 /* Save the second edge for later checks. */ |
1422 ip->e2 = e2; | |
1423 | |
1424 if (in_current_region_p (bb)) | |
1425 { | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1426 /* BLOCK_TO_BB sets topological order of the region here. |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1427 It is important to use real predecessor here, which is ip->bb, |
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1428 as we may well have e1->src outside current region, |
0 | 1429 when skipping to loop exits. */ |
1430 bool succeeds_in_top_order = (BLOCK_TO_BB (ip->bb->index) | |
1431 < BLOCK_TO_BB (bb->index)); | |
1432 | |
1433 /* This is true for the all cases except the last one. */ | |
1434 ip->current_flags = SUCCS_NORMAL; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1435 |
0 | 1436 /* We are advancing forward in the region, as usual. */ |
1437 if (succeeds_in_top_order) | |
1438 { | |
1439 /* We are skipping to loop exits here. */ | |
1440 gcc_assert (!src_outside_rgn | |
1441 || flag_sel_sched_pipelining_outer_loops); | |
1442 return !!(flags & SUCCS_NORMAL); | |
1443 } | |
1444 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1445 /* This is a back edge. During pipelining we ignore back edges, |
0 | 1446 but only when it leads to the same loop. It can lead to the header |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1447 of the outer loop, which will also be the preheader of |
0 | 1448 the current loop. */ |
1449 if (pipelining_p | |
1450 && e1->src->loop_father == bb->loop_father) | |
1451 return !!(flags & SUCCS_NORMAL); | |
1452 | |
1453 /* A back edge should be requested explicitly. */ | |
1454 ip->current_flags = SUCCS_BACK; | |
1455 return !!(flags & SUCCS_BACK); | |
1456 } | |
1457 | |
1458 ip->current_flags = SUCCS_OUT; | |
1459 return !!(flags & SUCCS_OUT); | |
1460 } | |
1461 | |
1462 #define FOR_EACH_SUCC_1(SUCC, ITER, INSN, FLAGS) \ | |
1463 for ((ITER) = _succ_iter_start (&(SUCC), (INSN), (FLAGS)); \ | |
1464 _succ_iter_cond (&(ITER), &(SUCC), (INSN), _eligible_successor_edge_p); \ | |
1465 _succ_iter_next (&(ITER))) | |
1466 | |
1467 #define FOR_EACH_SUCC(SUCC, ITER, INSN) \ | |
1468 FOR_EACH_SUCC_1 (SUCC, ITER, INSN, SUCCS_NORMAL) | |
1469 | |
1470 /* Return the current edge along which a successor was built. */ | |
1471 #define SUCC_ITER_EDGE(ITER) ((ITER)->e1) | |
1472 | |
1473 /* Return the next block of BB not running into inconsistencies. */ | |
1474 static inline basic_block | |
1475 bb_next_bb (basic_block bb) | |
1476 { | |
1477 switch (EDGE_COUNT (bb->succs)) | |
1478 { | |
1479 case 0: | |
1480 return bb->next_bb; | |
1481 | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1482 case 1: |
0 | 1483 return single_succ (bb); |
1484 | |
1485 case 2: | |
1486 return FALLTHRU_EDGE (bb)->dest; | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1487 |
0 | 1488 default: |
1489 return bb->next_bb; | |
1490 } | |
1491 | |
1492 gcc_unreachable (); | |
1493 } | |
1494 | |
1495 | |
1496 | |
1497 /* Functions that are used in sel-sched.c. */ | |
1498 | |
1499 /* List functions. */ | |
1500 extern ilist_t ilist_copy (ilist_t); | |
1501 extern ilist_t ilist_invert (ilist_t); | |
1502 extern void blist_add (blist_t *, insn_t, ilist_t, deps_t); | |
1503 extern void blist_remove (blist_t *); | |
1504 extern void flist_tail_init (flist_tail_t); | |
1505 | |
1506 extern fence_t flist_lookup (flist_t, insn_t); | |
1507 extern void flist_clear (flist_t *); | |
1508 extern void def_list_add (def_list_t *, insn_t, bool); | |
1509 | |
1510 /* Target context functions. */ | |
1511 extern tc_t create_target_context (bool); | |
1512 extern void set_target_context (tc_t); | |
1513 extern void reset_target_context (tc_t, bool); | |
1514 | |
1515 /* Deps context functions. */ | |
1516 extern void advance_deps_context (deps_t, insn_t); | |
1517 | |
1518 /* Fences functions. */ | |
1519 extern void init_fences (insn_t); | |
1520 extern void add_clean_fence_to_fences (flist_tail_t, insn_t, fence_t); | |
1521 extern void add_dirty_fence_to_fences (flist_tail_t, insn_t, fence_t); | |
1522 extern void move_fence_to_fences (flist_t, flist_tail_t); | |
1523 | |
1524 /* Pool functions. */ | |
1525 extern regset get_regset_from_pool (void); | |
1526 extern regset get_clear_regset_from_pool (void); | |
1527 extern void return_regset_to_pool (regset); | |
1528 extern void free_regset_pool (void); | |
1529 | |
1530 extern insn_t get_nop_from_pool (insn_t); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1531 extern void return_nop_to_pool (insn_t, bool); |
0 | 1532 extern void free_nop_pool (void); |
1533 | |
1534 /* Vinsns functions. */ | |
1535 extern bool vinsn_separable_p (vinsn_t); | |
1536 extern bool vinsn_cond_branch_p (vinsn_t); | |
1537 extern void recompute_vinsn_lhs_rhs (vinsn_t); | |
1538 extern int sel_vinsn_cost (vinsn_t); | |
1539 extern insn_t sel_gen_insn_from_rtx_after (rtx, expr_t, int, insn_t); | |
1540 extern insn_t sel_gen_recovery_insn_from_rtx_after (rtx, expr_t, int, insn_t); | |
1541 extern insn_t sel_gen_insn_from_expr_after (expr_t, vinsn_t, int, insn_t); | |
1542 extern insn_t sel_move_insn (expr_t, int, insn_t); | |
1543 extern void vinsn_attach (vinsn_t); | |
1544 extern void vinsn_detach (vinsn_t); | |
1545 extern vinsn_t vinsn_copy (vinsn_t, bool); | |
1546 extern bool vinsn_equal_p (vinsn_t, vinsn_t); | |
1547 | |
1548 /* EXPR functions. */ | |
1549 extern void copy_expr (expr_t, expr_t); | |
1550 extern void copy_expr_onside (expr_t, expr_t); | |
1551 extern void merge_expr_data (expr_t, expr_t, insn_t); | |
1552 extern void merge_expr (expr_t, expr_t, insn_t); | |
1553 extern void clear_expr (expr_t); | |
1554 extern unsigned expr_dest_regno (expr_t); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1555 extern rtx expr_dest_reg (expr_t); |
111 | 1556 extern int find_in_history_vect (vec<expr_history_def> , |
0 | 1557 rtx, vinsn_t, bool); |
111 | 1558 extern void insert_in_history_vect (vec<expr_history_def> *, |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1559 unsigned, enum local_trans_type, |
0 | 1560 vinsn_t, vinsn_t, ds_t); |
1561 extern void mark_unavailable_targets (av_set_t, av_set_t, regset); | |
1562 extern int speculate_expr (expr_t, ds_t); | |
1563 | |
1564 /* Av set functions. */ | |
1565 extern void av_set_add (av_set_t *, expr_t); | |
1566 extern void av_set_iter_remove (av_set_iterator *); | |
1567 extern expr_t av_set_lookup (av_set_t, vinsn_t); | |
1568 extern expr_t merge_with_other_exprs (av_set_t *, av_set_iterator *, expr_t); | |
1569 extern bool av_set_is_in_p (av_set_t, vinsn_t); | |
1570 extern av_set_t av_set_copy (av_set_t); | |
1571 extern void av_set_union_and_clear (av_set_t *, av_set_t *, insn_t); | |
1572 extern void av_set_union_and_live (av_set_t *, av_set_t *, regset, regset, insn_t); | |
1573 extern void av_set_clear (av_set_t *); | |
1574 extern void av_set_leave_one_nonspec (av_set_t *); | |
1575 extern expr_t av_set_element (av_set_t, int); | |
1576 extern void av_set_substract_cond_branches (av_set_t *); | |
1577 extern void av_set_split_usefulness (av_set_t, int, int); | |
111 | 1578 extern void av_set_code_motion_filter (av_set_t *, av_set_t); |
0 | 1579 |
1580 extern void sel_save_haifa_priorities (void); | |
1581 | |
1582 extern void sel_init_global_and_expr (bb_vec_t); | |
1583 extern void sel_finish_global_and_expr (void); | |
1584 | |
1585 extern regset compute_live (insn_t); | |
111 | 1586 extern bool register_unavailable_p (regset, rtx); |
0 | 1587 |
1588 /* Dependence analysis functions. */ | |
1589 extern void sel_clear_has_dependence (void); | |
1590 extern ds_t has_dependence_p (expr_t, insn_t, ds_t **); | |
1591 | |
1592 extern int tick_check_p (expr_t, deps_t, fence_t); | |
1593 | |
1594 /* Functions to work with insns. */ | |
1595 extern bool lhs_of_insn_equals_to_dest_p (insn_t, rtx); | |
1596 extern bool insn_eligible_for_subst_p (insn_t); | |
111 | 1597 extern void get_dest_and_mode (rtx, rtx *, machine_mode *); |
0 | 1598 |
1599 extern bool bookkeeping_can_be_created_if_moved_through_p (insn_t); | |
1600 extern bool sel_remove_insn (insn_t, bool, bool); | |
1601 extern bool bb_header_p (insn_t); | |
1602 extern void sel_init_invalid_data_sets (insn_t); | |
1603 extern bool insn_at_boundary_p (insn_t); | |
1604 | |
1605 /* Basic block and CFG functions. */ | |
1606 | |
111 | 1607 extern rtx_insn *sel_bb_head (basic_block); |
0 | 1608 extern bool sel_bb_head_p (insn_t); |
111 | 1609 extern rtx_insn *sel_bb_end (basic_block); |
0 | 1610 extern bool sel_bb_end_p (insn_t); |
1611 extern bool sel_bb_empty_p (basic_block); | |
1612 | |
1613 extern bool in_current_region_p (basic_block); | |
111 | 1614 extern basic_block fallthru_bb_of_jump (const rtx_insn *); |
0 | 1615 |
111 | 1616 extern void sel_init_bbs (bb_vec_t); |
0 | 1617 extern void sel_finish_bbs (void); |
1618 | |
1619 extern struct succs_info * compute_succs_info (insn_t, short); | |
1620 extern void free_succs_info (struct succs_info *); | |
1621 extern bool sel_insn_has_single_succ_p (insn_t, int); | |
1622 extern bool sel_num_cfg_preds_gt_1 (insn_t); | |
111 | 1623 extern int get_seqno_by_preds (rtx_insn *); |
0 | 1624 |
1625 extern bool bb_ends_ebb_p (basic_block); | |
1626 extern bool in_same_ebb_p (insn_t, insn_t); | |
1627 | |
1628 extern bool tidy_control_flow (basic_block, bool); | |
1629 extern void free_bb_note_pool (void); | |
1630 | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1631 extern void purge_empty_blocks (void); |
0 | 1632 extern basic_block sel_split_edge (edge); |
1633 extern basic_block sel_create_recovery_block (insn_t); | |
63
b7f97abdc517
update gcc from gcc-4.5.0 to gcc-4.6
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
55
diff
changeset
|
1634 extern bool sel_redirect_edge_and_branch (edge, basic_block); |
0 | 1635 extern void sel_redirect_edge_and_branch_force (edge, basic_block); |
1636 extern void sel_init_pipelining (void); | |
1637 extern void sel_finish_pipelining (void); | |
1638 extern void sel_sched_region (int); | |
1639 extern loop_p get_loop_nest_for_rgn (unsigned int); | |
1640 extern bool considered_for_pipelining_p (struct loop *); | |
111 | 1641 extern void make_region_from_loop_preheader (vec<basic_block> *&); |
1642 extern void sel_add_loop_preheaders (bb_vec_t *); | |
0 | 1643 extern bool sel_is_loop_preheader_p (basic_block); |
1644 extern void clear_outdated_rtx_info (basic_block); | |
1645 extern void free_data_sets (basic_block); | |
1646 extern void exchange_data_sets (basic_block, basic_block); | |
1647 extern void copy_data_sets (basic_block, basic_block); | |
1648 | |
1649 extern void sel_register_cfg_hooks (void); | |
1650 extern void sel_unregister_cfg_hooks (void); | |
1651 | |
1652 /* Expression transformation routines. */ | |
111 | 1653 extern rtx_insn *create_insn_rtx_from_pattern (rtx, rtx); |
1654 extern vinsn_t create_vinsn_from_insn_rtx (rtx_insn *, bool); | |
1655 extern rtx_insn *create_copy_of_insn_rtx (rtx); | |
0 | 1656 extern void change_vinsn_in_expr (expr_t, vinsn_t); |
1657 | |
1658 /* Various initialization functions. */ | |
1659 extern void init_lv_sets (void); | |
1660 extern void free_lv_sets (void); | |
1661 extern void setup_nop_and_exit_insns (void); | |
1662 extern void free_nop_and_exit_insns (void); | |
55
77e2b8dfacca
update it from 4.4.3 to 4.5.0
ryoma <e075725@ie.u-ryukyu.ac.jp>
parents:
0
diff
changeset
|
1663 extern void free_data_for_scheduled_insn (insn_t); |
0 | 1664 extern void setup_nop_vinsn (void); |
1665 extern void free_nop_vinsn (void); | |
1666 extern void sel_set_sched_flags (void); | |
1667 extern void sel_setup_sched_infos (void); | |
1668 extern void alloc_sched_pools (void); | |
1669 extern void free_sched_pools (void); | |
1670 | |
1671 #endif /* GCC_SEL_SCHED_IR_H */ |