Daily bump.
[official-gcc.git] / gcc / compare-elim.c
blob3fbe140b80c675b7fc6613cb780537050f1a1f8c
1 /* Post-reload compare elimination.
2 Copyright (C) 2010-2014 Free Software Foundation, Inc.
4 This file is part of GCC.
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 for more details.
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3. If not see
18 <http://www.gnu.org/licenses/>. */
20 /* There is a set of targets whose general-purpose move or addition
21 instructions clobber the flags. These targets cannot split their
22 CBRANCH/CSTORE etc patterns before reload is complete, lest reload
23 itself insert these instructions in between the flags setter and user.
24 Because these targets cannot split the compare from the use, they
25 cannot make use of the comparison elimination offered by the combine pass.
27 This is a small pass intended to provide comparison elimination similar to
28 what is available via NOTICE_UPDATE_CC for cc0 targets. This should help
29 encourage cc0 targets to convert to an explicit post-reload representation
30 of the flags.
32 This pass assumes:
34 (0) CBRANCH/CSTORE etc have been split in pass_split_after_reload.
36 (1) All comparison patterns are represented as
38 [(set (reg:CC) (compare:CC (reg) (immediate)))]
40 (2) All insn patterns that modify the flags are represented as
42 [(set (reg) (operation)
43 (clobber (reg:CC))]
45 (3) If an insn of form (2) can usefully set the flags, there is
46 another pattern of the form
48 [(set (reg) (operation)
49 (set (reg:CCM) (compare:CCM (operation) (immediate)))]
51 The mode CCM will be chosen as if by SELECT_CC_MODE.
53 Note that unlike NOTICE_UPDATE_CC, we do not handle memory operands.
54 This could be handled as a future enhancement.
57 #include "config.h"
58 #include "system.h"
59 #include "coretypes.h"
60 #include "tm.h"
61 #include "rtl.h"
62 #include "tm_p.h"
63 #include "insn-config.h"
64 #include "recog.h"
65 #include "flags.h"
66 #include "basic-block.h"
67 #include "tree-pass.h"
68 #include "target.h"
69 #include "df.h"
70 #include "domwalk.h"
73 /* These structures describe a comparison and how it is used. */
75 /* The choice of maximum 3 uses comes from wanting to eliminate the two
76 duplicate compares from a three-way branch on the sign of a value.
77 This is also sufficient to eliminate the duplicate compare against the
78 high-part of a double-word comparison. */
79 #define MAX_CMP_USE 3
81 struct comparison_use
83 /* The instruction in which the result of the compare is used. */
84 rtx insn;
85 /* The location of the flags register within the use. */
86 rtx *loc;
87 /* The comparison code applied against the flags register. */
88 enum rtx_code code;
91 struct comparison
93 /* The comparison instruction. */
94 rtx insn;
96 /* The insn prior to the comparison insn that clobbers the flags. */
97 rtx prev_clobber;
99 /* The two values being compared. These will be either REGs or
100 constants. */
101 rtx in_a, in_b;
103 /* Information about how this comparison is used. */
104 struct comparison_use uses[MAX_CMP_USE];
106 /* The original CC_MODE for this comparison. */
107 enum machine_mode orig_mode;
109 /* The number of uses identified for this comparison. */
110 unsigned short n_uses;
112 /* True if not all uses of this comparison have been identified.
113 This can happen either for overflowing the array above, or if
114 the flags register is used in some unusual context. */
115 bool missing_uses;
117 /* True if its inputs are still valid at the end of the block. */
118 bool inputs_valid;
121 typedef struct comparison *comparison_struct_p;
123 static vec<comparison_struct_p> all_compares;
125 /* Look for a "conforming" comparison, as defined above. If valid, return
126 the rtx for the COMPARE itself. */
128 static rtx
129 conforming_compare (rtx insn)
131 rtx set, src, dest;
133 set = single_set (insn);
134 if (set == NULL)
135 return NULL;
137 src = SET_SRC (set);
138 if (GET_CODE (src) != COMPARE)
139 return NULL;
141 dest = SET_DEST (set);
142 if (!REG_P (dest) || REGNO (dest) != targetm.flags_regnum)
143 return NULL;
145 if (REG_P (XEXP (src, 0))
146 && REG_P (XEXP (src, 0))
147 && (REG_P (XEXP (src, 1)) || CONSTANT_P (XEXP (src, 1))))
148 return src;
150 return NULL;
153 /* Look for a pattern of the "correct" form for an insn with a flags clobber
154 for which we may be able to eliminate a compare later. We're not looking
155 to validate any inputs at this time, merely see that the basic shape is
156 correct. The term "arithmetic" may be somewhat misleading... */
158 static bool
159 arithmetic_flags_clobber_p (rtx insn)
161 rtx pat, x;
163 if (!NONJUMP_INSN_P (insn))
164 return false;
165 pat = PATTERN (insn);
166 if (extract_asm_operands (pat))
167 return false;
169 if (GET_CODE (pat) == PARALLEL && XVECLEN (pat, 0) == 2)
171 x = XVECEXP (pat, 0, 0);
172 if (GET_CODE (x) != SET)
173 return false;
174 x = SET_DEST (x);
175 if (!REG_P (x))
176 return false;
178 x = XVECEXP (pat, 0, 1);
179 if (GET_CODE (x) == CLOBBER)
181 x = XEXP (x, 0);
182 if (REG_P (x) && REGNO (x) == targetm.flags_regnum)
183 return true;
187 return false;
190 /* Look for uses of FLAGS in INSN. If we find one we can analyze, record
191 it in CMP; otherwise indicate that we've missed a use. */
193 static void
194 find_flags_uses_in_insn (struct comparison *cmp, rtx insn)
196 df_ref *use_rec, use;
198 /* If we've already lost track of uses, don't bother collecting more. */
199 if (cmp->missing_uses)
200 return;
202 /* Find a USE of the flags register. */
203 for (use_rec = DF_INSN_USES (insn); (use = *use_rec) != NULL; use_rec++)
204 if (DF_REF_REGNO (use) == targetm.flags_regnum)
206 rtx x, *loc;
208 /* If this is an unusual use, quit. */
209 if (DF_REF_TYPE (use) != DF_REF_REG_USE)
210 goto fail;
212 /* If we've run out of slots to record uses, quit. */
213 if (cmp->n_uses == MAX_CMP_USE)
214 goto fail;
216 /* Unfortunately the location of the flags register, while present
217 in the reference structure, doesn't help. We need to find the
218 comparison code that is outer to the actual flags use. */
219 loc = DF_REF_LOC (use);
220 x = PATTERN (insn);
221 if (GET_CODE (x) == PARALLEL)
222 x = XVECEXP (x, 0, 0);
223 x = SET_SRC (x);
224 if (GET_CODE (x) == IF_THEN_ELSE)
225 x = XEXP (x, 0);
226 if (COMPARISON_P (x)
227 && loc == &XEXP (x, 0)
228 && XEXP (x, 1) == const0_rtx)
230 /* We've found a use of the flags that we understand. */
231 struct comparison_use *cuse = &cmp->uses[cmp->n_uses++];
232 cuse->insn = insn;
233 cuse->loc = loc;
234 cuse->code = GET_CODE (x);
236 else
237 goto fail;
239 return;
241 fail:
242 /* We failed to recognize this use of the flags register. */
243 cmp->missing_uses = true;
246 class find_comparison_dom_walker : public dom_walker
248 public:
249 find_comparison_dom_walker (cdi_direction direction)
250 : dom_walker (direction) {}
252 virtual void before_dom_children (basic_block);
255 /* Identify comparison instructions within BB. If the flags from the last
256 compare in the BB is live at the end of the block, install the compare
257 in BB->AUX. Called via dom_walker.walk (). */
259 void
260 find_comparison_dom_walker::before_dom_children (basic_block bb)
262 struct comparison *last_cmp;
263 rtx insn, next, last_clobber;
264 bool last_cmp_valid;
265 bitmap killed;
267 killed = BITMAP_ALLOC (NULL);
269 /* The last comparison that was made. Will be reset to NULL
270 once the flags are clobbered. */
271 last_cmp = NULL;
273 /* True iff the last comparison has not been clobbered, nor
274 have its inputs. Used to eliminate duplicate compares. */
275 last_cmp_valid = false;
277 /* The last insn that clobbered the flags, if that insn is of
278 a form that may be valid for eliminating a following compare.
279 To be reset to NULL once the flags are set otherwise. */
280 last_clobber = NULL;
282 /* Propagate the last live comparison throughout the extended basic block. */
283 if (single_pred_p (bb))
285 last_cmp = (struct comparison *) single_pred (bb)->aux;
286 if (last_cmp)
287 last_cmp_valid = last_cmp->inputs_valid;
290 for (insn = BB_HEAD (bb); insn; insn = next)
292 rtx src;
294 next = (insn == BB_END (bb) ? NULL_RTX : NEXT_INSN (insn));
295 if (!NONDEBUG_INSN_P (insn))
296 continue;
298 /* Compute the set of registers modified by this instruction. */
299 bitmap_clear (killed);
300 df_simulate_find_defs (insn, killed);
302 src = conforming_compare (insn);
303 if (src)
305 enum machine_mode src_mode = GET_MODE (src);
307 /* Eliminate a compare that's redundant with the previous. */
308 if (last_cmp_valid
309 && rtx_equal_p (last_cmp->in_a, XEXP (src, 0))
310 && rtx_equal_p (last_cmp->in_b, XEXP (src, 1)))
312 rtx flags, x;
313 enum machine_mode new_mode
314 = targetm.cc_modes_compatible (last_cmp->orig_mode, src_mode);
316 /* New mode is incompatible with the previous compare mode. */
317 if (new_mode == VOIDmode)
318 continue;
320 if (new_mode != last_cmp->orig_mode)
322 flags = gen_rtx_REG (src_mode, targetm.flags_regnum);
324 /* Generate new comparison for substitution. */
325 x = gen_rtx_COMPARE (new_mode, XEXP (src, 0), XEXP (src, 1));
326 x = gen_rtx_SET (VOIDmode, flags, x);
328 if (!validate_change (last_cmp->insn,
329 &PATTERN (last_cmp->insn), x, false))
330 continue;
332 last_cmp->orig_mode = new_mode;
335 delete_insn (insn);
336 continue;
339 last_cmp = XCNEW (struct comparison);
340 last_cmp->insn = insn;
341 last_cmp->prev_clobber = last_clobber;
342 last_cmp->in_a = XEXP (src, 0);
343 last_cmp->in_b = XEXP (src, 1);
344 last_cmp->orig_mode = src_mode;
345 all_compares.safe_push (last_cmp);
347 /* It's unusual, but be prepared for comparison patterns that
348 also clobber an input, or perhaps a scratch. */
349 last_clobber = NULL;
350 last_cmp_valid = true;
353 /* Notice if this instruction kills the flags register. */
354 else if (bitmap_bit_p (killed, targetm.flags_regnum))
356 /* See if this insn could be the "clobber" that eliminates
357 a future comparison. */
358 last_clobber = (arithmetic_flags_clobber_p (insn) ? insn : NULL);
360 /* In either case, the previous compare is no longer valid. */
361 last_cmp = NULL;
362 last_cmp_valid = false;
363 continue;
366 /* Notice if this instruction uses the flags register. */
367 else if (last_cmp)
368 find_flags_uses_in_insn (last_cmp, insn);
370 /* Notice if any of the inputs to the comparison have changed. */
371 if (last_cmp_valid
372 && (bitmap_bit_p (killed, REGNO (last_cmp->in_a))
373 || (REG_P (last_cmp->in_b)
374 && bitmap_bit_p (killed, REGNO (last_cmp->in_b)))))
375 last_cmp_valid = false;
378 BITMAP_FREE (killed);
380 /* Remember the live comparison for subsequent members of
381 the extended basic block. */
382 if (last_cmp)
384 bb->aux = last_cmp;
385 last_cmp->inputs_valid = last_cmp_valid;
387 /* Look to see if the flags register is live outgoing here, and
388 incoming to any successor not part of the extended basic block. */
389 if (bitmap_bit_p (df_get_live_out (bb), targetm.flags_regnum))
391 edge e;
392 edge_iterator ei;
394 FOR_EACH_EDGE (e, ei, bb->succs)
396 basic_block dest = e->dest;
397 if (bitmap_bit_p (df_get_live_in (bb),
398 targetm.flags_regnum)
399 && !single_pred_p (dest))
401 last_cmp->missing_uses = true;
402 break;
409 /* Find all comparisons in the function. */
411 static void
412 find_comparisons (void)
414 calculate_dominance_info (CDI_DOMINATORS);
416 find_comparison_dom_walker (CDI_DOMINATORS)
417 .walk (cfun->cfg->x_entry_block_ptr);
419 clear_aux_for_blocks ();
420 free_dominance_info (CDI_DOMINATORS);
423 /* Select an alternate CC_MODE for a comparison insn comparing A and B.
424 Note that inputs are almost certainly different than the IN_A and IN_B
425 stored in CMP -- we're called while attempting to eliminate the compare
426 after all. Return the new FLAGS rtx if successful, else return NULL.
427 Note that this function may start a change group. */
429 static rtx
430 maybe_select_cc_mode (struct comparison *cmp, rtx a ATTRIBUTE_UNUSED,
431 rtx b ATTRIBUTE_UNUSED)
433 enum machine_mode sel_mode;
434 const int n = cmp->n_uses;
435 rtx flags = NULL;
437 #ifndef SELECT_CC_MODE
438 /* Minimize code differences when this target macro is undefined. */
439 return NULL;
440 #define SELECT_CC_MODE(A,B,C) (gcc_unreachable (), VOIDmode)
441 #endif
443 /* If we don't have access to all of the uses, we can't validate. */
444 if (cmp->missing_uses || n == 0)
445 return NULL;
447 /* Find a new mode that works for all of the uses. Special case the
448 common case of exactly one use. */
449 if (n == 1)
451 sel_mode = SELECT_CC_MODE (cmp->uses[0].code, a, b);
452 if (sel_mode != cmp->orig_mode)
454 flags = gen_rtx_REG (sel_mode, targetm.flags_regnum);
455 validate_change (cmp->uses[0].insn, cmp->uses[0].loc, flags, true);
458 else
460 int i;
462 sel_mode = SELECT_CC_MODE (cmp->uses[0].code, a, b);
463 for (i = 1; i < n; ++i)
465 enum machine_mode new_mode;
466 new_mode = SELECT_CC_MODE (cmp->uses[i].code, a, b);
467 if (new_mode != sel_mode)
469 sel_mode = targetm.cc_modes_compatible (sel_mode, new_mode);
470 if (sel_mode == VOIDmode)
471 return NULL;
475 if (sel_mode != cmp->orig_mode)
477 flags = gen_rtx_REG (sel_mode, targetm.flags_regnum);
478 for (i = 0; i < n; ++i)
479 validate_change (cmp->uses[i].insn, cmp->uses[i].loc, flags, true);
483 return flags;
486 /* Attempt to replace a comparison with a prior arithmetic insn that can
487 compute the same flags value as the comparison itself. Return true if
488 successful, having made all rtl modifications necessary. */
490 static bool
491 try_eliminate_compare (struct comparison *cmp)
493 rtx x, insn, bb_head, flags, in_a, cmp_src;
495 /* We must have found an interesting "clobber" preceding the compare. */
496 if (cmp->prev_clobber == NULL)
497 return false;
499 /* ??? For the moment we don't handle comparisons for which IN_B
500 is a register. We accepted these during initial comparison
501 recognition in order to eliminate duplicate compares.
502 An improvement here would be to handle x = a - b; if (a cmp b). */
503 if (!CONSTANT_P (cmp->in_b))
504 return false;
506 /* Verify that IN_A is not clobbered in between CMP and PREV_CLOBBER.
507 Given that this target requires this pass, we can assume that most
508 insns do clobber the flags, and so the distance between the compare
509 and the clobber is likely to be small. */
510 /* ??? This is one point at which one could argue that DF_REF_CHAIN would
511 be useful, but it is thought to be too heavy-weight a solution here. */
513 in_a = cmp->in_a;
514 insn = cmp->insn;
515 bb_head = BB_HEAD (BLOCK_FOR_INSN (insn));
516 for (insn = PREV_INSN (insn);
517 insn != cmp->prev_clobber;
518 insn = PREV_INSN (insn))
520 const int abnormal_flags
521 = (DF_REF_CONDITIONAL | DF_REF_PARTIAL | DF_REF_MAY_CLOBBER
522 | DF_REF_MUST_CLOBBER | DF_REF_SIGN_EXTRACT
523 | DF_REF_ZERO_EXTRACT | DF_REF_STRICT_LOW_PART
524 | DF_REF_PRE_POST_MODIFY);
525 df_ref *def_rec, def;
527 /* Note that the BB_HEAD is always either a note or a label, but in
528 any case it means that IN_A is defined outside the block. */
529 if (insn == bb_head)
530 return false;
531 if (NOTE_P (insn) || DEBUG_INSN_P (insn))
532 continue;
534 /* Find a possible def of IN_A in INSN. */
535 for (def_rec = DF_INSN_DEFS (insn); (def = *def_rec) != NULL; def_rec++)
536 if (DF_REF_REGNO (def) == REGNO (in_a))
537 break;
539 /* No definitions of IN_A; continue searching. */
540 if (def == NULL)
541 continue;
543 /* Bail if this is not a totally normal set of IN_A. */
544 if (DF_REF_IS_ARTIFICIAL (def))
545 return false;
546 if (DF_REF_FLAGS (def) & abnormal_flags)
547 return false;
549 /* We've found an insn between the compare and the clobber that sets
550 IN_A. Given that pass_cprop_hardreg has not yet run, we still find
551 situations in which we can usefully look through a copy insn. */
552 x = single_set (insn);
553 if (x == NULL)
554 return false;
555 in_a = SET_SRC (x);
556 if (!REG_P (in_a))
557 return false;
560 /* We've reached PREV_CLOBBER without finding a modification of IN_A.
561 Validate that PREV_CLOBBER itself does in fact refer to IN_A. Do
562 recall that we've already validated the shape of PREV_CLOBBER. */
563 x = XVECEXP (PATTERN (insn), 0, 0);
564 if (rtx_equal_p (SET_DEST (x), in_a))
565 cmp_src = SET_SRC (x);
567 /* Also check operations with implicit extensions, e.g.:
568 [(set (reg:DI)
569 (zero_extend:DI (plus:SI (reg:SI)(reg:SI))))
570 (set (reg:CCZ flags)
571 (compare:CCZ
572 (plus:SI (reg:SI)(reg:SI))
573 (const_int 0)))] */
574 else if (REG_P (SET_DEST (x))
575 && REG_P (in_a)
576 && REGNO (SET_DEST (x)) == REGNO (in_a)
577 && (GET_CODE (SET_SRC (x)) == ZERO_EXTEND
578 || GET_CODE (SET_SRC (x)) == SIGN_EXTEND)
579 && GET_MODE (XEXP (SET_SRC (x), 0)) == GET_MODE (in_a))
580 cmp_src = XEXP (SET_SRC (x), 0);
581 else
582 return false;
584 /* Determine if we ought to use a different CC_MODE here. */
585 flags = maybe_select_cc_mode (cmp, cmp_src, cmp->in_b);
586 if (flags == NULL)
587 flags = gen_rtx_REG (cmp->orig_mode, targetm.flags_regnum);
589 /* Generate a new comparison for installation in the setter. */
590 x = copy_rtx (cmp_src);
591 x = gen_rtx_COMPARE (GET_MODE (flags), x, cmp->in_b);
592 x = gen_rtx_SET (VOIDmode, flags, x);
594 /* Succeed if the new instruction is valid. Note that we may have started
595 a change group within maybe_select_cc_mode, therefore we must continue. */
596 validate_change (insn, &XVECEXP (PATTERN (insn), 0, 1), x, true);
597 if (!apply_change_group ())
598 return false;
600 /* Success. Delete the compare insn... */
601 delete_insn (cmp->insn);
603 /* ... and any notes that are now invalid due to multiple sets. */
604 x = find_regno_note (insn, REG_UNUSED, targetm.flags_regnum);
605 if (x)
606 remove_note (insn, x);
607 x = find_reg_note (insn, REG_EQUAL, NULL);
608 if (x)
609 remove_note (insn, x);
610 x = find_reg_note (insn, REG_EQUIV, NULL);
611 if (x)
612 remove_note (insn, x);
614 return true;
617 /* Main entry point to the pass. */
619 static unsigned int
620 execute_compare_elim_after_reload (void)
622 df_analyze ();
624 gcc_checking_assert (!all_compares.exists ());
626 /* Locate all comparisons and their uses, and eliminate duplicates. */
627 find_comparisons ();
628 if (all_compares.exists ())
630 struct comparison *cmp;
631 size_t i;
633 /* Eliminate comparisons that are redundant with flags computation. */
634 FOR_EACH_VEC_ELT (all_compares, i, cmp)
636 try_eliminate_compare (cmp);
637 XDELETE (cmp);
640 all_compares.release ();
643 return 0;
646 static bool
647 gate_compare_elim_after_reload (void)
649 /* Setting this target hook value is how a backend indicates the need. */
650 if (targetm.flags_regnum == INVALID_REGNUM)
651 return false;
652 return flag_compare_elim_after_reload;
655 namespace {
657 const pass_data pass_data_compare_elim_after_reload =
659 RTL_PASS, /* type */
660 "cmpelim", /* name */
661 OPTGROUP_NONE, /* optinfo_flags */
662 true, /* has_gate */
663 true, /* has_execute */
664 TV_NONE, /* tv_id */
665 0, /* properties_required */
666 0, /* properties_provided */
667 0, /* properties_destroyed */
668 0, /* todo_flags_start */
669 ( TODO_df_finish | TODO_df_verify
670 | TODO_verify_rtl_sharing ), /* todo_flags_finish */
673 class pass_compare_elim_after_reload : public rtl_opt_pass
675 public:
676 pass_compare_elim_after_reload (gcc::context *ctxt)
677 : rtl_opt_pass (pass_data_compare_elim_after_reload, ctxt)
680 /* opt_pass methods: */
681 bool gate () { return gate_compare_elim_after_reload (); }
682 unsigned int execute () { return execute_compare_elim_after_reload (); }
684 }; // class pass_compare_elim_after_reload
686 } // anon namespace
688 rtl_opt_pass *
689 make_pass_compare_elim_after_reload (gcc::context *ctxt)
691 return new pass_compare_elim_after_reload (ctxt);