From: Richard Sandiford Date: Mon, 9 Sep 2019 17:59:19 +0000 (+0000) Subject: Remove IOR_HARD_REG_SET X-Git-Url: https://git.libre-soc.org/?a=commitdiff_plain;h=44942965f4eae141bd1f8300e7f77d0c9a3936e4;p=gcc.git Remove IOR_HARD_REG_SET Use "x |= y" instead of "IOR_HARD_REG_SET (x, y)" (or just "x | y" if the result is a temporary). 2019-09-09 Richard Sandiford gcc/ * hard-reg-set.h (HARD_REG_SET::operator|): New function. (HARD_REG_SET::operator|=): Likewise. (IOR_HARD_REG_SET): Delete. * config/gcn/gcn.c (gcn_md_reorg): Use "|" instead of IOR_HARD_REG_SET. * config/m32c/m32c.c (m32c_register_move_cost): Likewise. * config/s390/s390.c (s390_adjust_loop_scan_osc): Likewise. * final.c (collect_fn_hard_reg_usage): Likewise. * hw-doloop.c (scan_loop, optimize_loop): Likewise. * ira-build.c (merge_hard_reg_conflicts): Likewise. (ior_hard_reg_conflicts, create_cap_allocno, propagate_allocno_info) (propagate_some_info_from_allocno): Likewise. (copy_info_to_removed_store_destinations): Likewise. * ira-color.c (add_allocno_hard_regs_to_forest, assign_hard_reg) (allocno_reload_assign, ira_reassign_pseudos): Likewise. (fast_allocation): Likewise. * ira-conflicts.c (ira_build_conflicts): Likewise. * ira-lives.c (make_object_dead, process_single_reg_class_operands) (process_bb_node_lives): Likewise. * ira.c (setup_pressure_classes, setup_reg_class_relations): Likewise. * lra-assigns.c (find_hard_regno_for_1): Likewise. (setup_live_pseudos_and_spill_after_risky_transforms): Likewise. * lra-constraints.c (process_alt_operands, inherit_in_ebb): Likewise. * lra-eliminations.c (spill_pseudos, update_reg_eliminate): Likewise. * lra-lives.c (mark_pseudo_dead, check_pseudos_live_through_calls) (process_bb_lives): Likewise. * lra-spills.c (assign_spill_hard_regs): Likewise. * postreload.c (reload_combine): Likewise. * reginfo.c (init_reg_sets_1): Likewise. * regrename.c (merge_overlapping_regs, find_rename_reg) (merge_chains): Likewise. * reload1.c (maybe_fix_stack_asms, order_regs_for_reload, find_reg) (find_reload_regs, finish_spills, choose_reload_regs_init) (emit_reload_insns): Likewise. * reorg.c (redundant_insn): Likewise. * resource.c (find_dead_or_set_registers, mark_set_resources) (mark_target_live_regs): Likewise. * rtlanal.c (find_all_hard_reg_sets): Likewise. * sched-deps.c (sched_analyze_insn): Likewise. * sel-sched.c (mark_unavailable_hard_regs): Likewise. (find_best_reg_for_expr): Likewise. * shrink-wrap.c (try_shrink_wrapping): Likewise. From-SVN: r275531 --- diff --git a/gcc/ChangeLog b/gcc/ChangeLog index dcc87c952cf..c7a6716ae80 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,48 @@ +2019-09-09 Richard Sandiford + + * hard-reg-set.h (HARD_REG_SET::operator|): New function. + (HARD_REG_SET::operator|=): Likewise. + (IOR_HARD_REG_SET): Delete. + * config/gcn/gcn.c (gcn_md_reorg): Use "|" instead of + IOR_HARD_REG_SET. + * config/m32c/m32c.c (m32c_register_move_cost): Likewise. + * config/s390/s390.c (s390_adjust_loop_scan_osc): Likewise. + * final.c (collect_fn_hard_reg_usage): Likewise. + * hw-doloop.c (scan_loop, optimize_loop): Likewise. + * ira-build.c (merge_hard_reg_conflicts): Likewise. + (ior_hard_reg_conflicts, create_cap_allocno, propagate_allocno_info) + (propagate_some_info_from_allocno): Likewise. + (copy_info_to_removed_store_destinations): Likewise. + * ira-color.c (add_allocno_hard_regs_to_forest, assign_hard_reg) + (allocno_reload_assign, ira_reassign_pseudos): Likewise. + (fast_allocation): Likewise. + * ira-conflicts.c (ira_build_conflicts): Likewise. + * ira-lives.c (make_object_dead, process_single_reg_class_operands) + (process_bb_node_lives): Likewise. + * ira.c (setup_pressure_classes, setup_reg_class_relations): Likewise. + * lra-assigns.c (find_hard_regno_for_1): Likewise. + (setup_live_pseudos_and_spill_after_risky_transforms): Likewise. + * lra-constraints.c (process_alt_operands, inherit_in_ebb): Likewise. + * lra-eliminations.c (spill_pseudos, update_reg_eliminate): Likewise. + * lra-lives.c (mark_pseudo_dead, check_pseudos_live_through_calls) + (process_bb_lives): Likewise. + * lra-spills.c (assign_spill_hard_regs): Likewise. + * postreload.c (reload_combine): Likewise. + * reginfo.c (init_reg_sets_1): Likewise. + * regrename.c (merge_overlapping_regs, find_rename_reg) + (merge_chains): Likewise. + * reload1.c (maybe_fix_stack_asms, order_regs_for_reload, find_reg) + (find_reload_regs, finish_spills, choose_reload_regs_init) + (emit_reload_insns): Likewise. + * reorg.c (redundant_insn): Likewise. + * resource.c (find_dead_or_set_registers, mark_set_resources) + (mark_target_live_regs): Likewise. + * rtlanal.c (find_all_hard_reg_sets): Likewise. + * sched-deps.c (sched_analyze_insn): Likewise. + * sel-sched.c (mark_unavailable_hard_regs): Likewise. + (find_best_reg_for_expr): Likewise. + * shrink-wrap.c (try_shrink_wrapping): Likewise. + 2019-09-09 Richard Sandiford * hard-reg-set.h (HARD_REG_SET::operator&): New function. diff --git a/gcc/config/gcn/gcn.c b/gcc/config/gcn/gcn.c index 2c6c8727646..8d99eb27e25 100644 --- a/gcc/config/gcn/gcn.c +++ b/gcc/config/gcn/gcn.c @@ -4627,7 +4627,7 @@ gcn_md_reorg (void) not publish the cycle times for instructions. */ prev_insn->age += 1 + nops_rqd; - IOR_HARD_REG_SET (written, iwrites); + written |= iwrites; AND_COMPL_HARD_REG_SET (prev_insn->writes, written); } diff --git a/gcc/config/m32c/m32c.c b/gcc/config/m32c/m32c.c index d89064a7d20..b60044f107b 100644 --- a/gcc/config/m32c/m32c.c +++ b/gcc/config/m32c/m32c.c @@ -2151,8 +2151,7 @@ m32c_register_move_cost (machine_mode mode, reg_class_t from, HARD_REG_SET cc; /* FIXME: pick real values, but not 2 for now. */ - cc = reg_class_contents[from]; - IOR_HARD_REG_SET (cc, reg_class_contents[(int) to]); + cc = reg_class_contents[from] | reg_class_contents[(int) to]; if (mode == QImode && hard_reg_set_intersect_p (cc, reg_class_contents[R23_REGS])) diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c index 389fca8553b..2c6b5983624 100644 --- a/gcc/config/s390/s390.c +++ b/gcc/config/s390/s390.c @@ -14073,7 +14073,7 @@ s390_adjust_loop_scan_osc (struct loop* loop) return false; find_all_hard_reg_sets (insn, &newregs, true); - IOR_HARD_REG_SET (modregs, newregs); + modregs |= newregs; set = single_set (insn); if (!set) @@ -14104,7 +14104,7 @@ s390_adjust_loop_scan_osc (struct loop* loop) return false; find_all_hard_reg_sets (insn, &newregs, true); - IOR_HARD_REG_SET (modregs, newregs); + modregs |= newregs; set = single_set (insn); if (!set) diff --git a/gcc/final.c b/gcc/final.c index 5347facde6d..6d91aa00758 100644 --- a/gcc/final.c +++ b/gcc/final.c @@ -5010,15 +5010,15 @@ collect_fn_hard_reg_usage (void) call_used_reg_set)) return; - IOR_HARD_REG_SET (function_used_regs, insn_used_regs); + function_used_regs |= insn_used_regs; } find_all_hard_reg_sets (insn, &insn_used_regs, false); - IOR_HARD_REG_SET (function_used_regs, insn_used_regs); + function_used_regs |= insn_used_regs; } /* Be conservative - mark fixed and global registers as used. */ - IOR_HARD_REG_SET (function_used_regs, fixed_reg_set); + function_used_regs |= fixed_reg_set; #ifdef STACK_REGS /* Handle STACK_REGS conservatively, since the df-framework does not diff --git a/gcc/hard-reg-set.h b/gcc/hard-reg-set.h index 5733782bc3d..3f98e770d52 100644 --- a/gcc/hard-reg-set.h +++ b/gcc/hard-reg-set.h @@ -79,6 +79,23 @@ struct HARD_REG_SET return *this; } + HARD_REG_SET + operator| (const HARD_REG_SET &other) const + { + HARD_REG_SET res; + for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i) + res.elts[i] = elts[i] | other.elts[i]; + return res; + } + + HARD_REG_SET & + operator|= (const HARD_REG_SET &other) + { + for (unsigned int i = 0; i < ARRAY_SIZE (elts); ++i) + elts[i] |= other.elts[i]; + return *this; + } + HARD_REG_ELT_TYPE elts[HARD_REG_SET_LONGS]; }; typedef const HARD_REG_SET &const_hard_reg_set; @@ -109,12 +126,10 @@ struct hard_reg_set_container CLEAR_HARD_REG_SET and SET_HARD_REG_SET. These take just one argument. - Also define a macro for combining hard reg sets: - IOR_HARD_REG_SET - This takes two arguments TO and FROM; it reads from FROM - and combines bitwise into TO. Define also + Also define: IOR_COMPL_HARD_REG_SET and AND_COMPL_HARD_REG_SET - which use the complement of the set FROM. + These take two arguments TO and FROM; they read from FROM + and combines its complement bitwise into TO. Also define: @@ -137,7 +152,6 @@ struct hard_reg_set_container #define CLEAR_HARD_REG_SET(TO) ((TO) = HARD_CONST (0)) #define SET_HARD_REG_SET(TO) ((TO) = ~ HARD_CONST (0)) -#define IOR_HARD_REG_SET(TO, FROM) ((TO) |= (FROM)) #define IOR_COMPL_HARD_REG_SET(TO, FROM) ((TO) |= ~ (FROM)) #define AND_COMPL_HARD_REG_SET(TO, FROM) ((TO) &= ~ (FROM)) @@ -209,13 +223,6 @@ AND_COMPL_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from) to.elts[i] &= ~from.elts[i]; } -inline void -IOR_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from) -{ - for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i) - to.elts[i] |= from.elts[i]; -} - inline void IOR_COMPL_HARD_REG_SET (HARD_REG_SET &to, const_hard_reg_set from) { diff --git a/gcc/hw-doloop.c b/gcc/hw-doloop.c index 2decece62d9..3ee0b409834 100644 --- a/gcc/hw-doloop.c +++ b/gcc/hw-doloop.c @@ -141,7 +141,7 @@ scan_loop (hwloop_info loop) CLEAR_HARD_REG_BIT (set_this_insn, REGNO (loop->iter_reg)); else if (reg_mentioned_p (loop->iter_reg, PATTERN (insn))) loop->iter_reg_used = true; - IOR_HARD_REG_SET (loop->regs_set_in_loop, set_this_insn); + loop->regs_set_in_loop |= set_this_insn; } } } @@ -581,7 +581,7 @@ optimize_loop (hwloop_info loop, struct hw_doloop_hooks *hooks) inner_depth = inner->depth; /* The set of registers may be changed while optimizing the inner loop. */ - IOR_HARD_REG_SET (loop->regs_set_in_loop, inner->regs_set_in_loop); + loop->regs_set_in_loop |= inner->regs_set_in_loop; } loop->depth = inner_depth + 1; diff --git a/gcc/ira-build.c b/gcc/ira-build.c index 1fa7a868311..354f989e563 100644 --- a/gcc/ira-build.c +++ b/gcc/ira-build.c @@ -602,10 +602,10 @@ merge_hard_reg_conflicts (ira_allocno_t from, ira_allocno_t to, ira_object_t to_obj = ALLOCNO_OBJECT (to, i); if (!total_only) - IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (to_obj), - OBJECT_CONFLICT_HARD_REGS (from_obj)); - IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (to_obj), - OBJECT_TOTAL_CONFLICT_HARD_REGS (from_obj)); + OBJECT_CONFLICT_HARD_REGS (to_obj) + |= OBJECT_CONFLICT_HARD_REGS (from_obj); + OBJECT_TOTAL_CONFLICT_HARD_REGS (to_obj) + |= OBJECT_TOTAL_CONFLICT_HARD_REGS (from_obj); } #ifdef STACK_REGS if (!total_only && ALLOCNO_NO_STACK_REG_P (from)) @@ -625,8 +625,8 @@ ior_hard_reg_conflicts (ira_allocno_t a, HARD_REG_SET *set) FOR_EACH_ALLOCNO_OBJECT (a, obj, i) { - IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), *set); - IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), *set); + OBJECT_CONFLICT_HARD_REGS (obj) |= *set; + OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= *set; } } @@ -907,8 +907,8 @@ create_cap_allocno (ira_allocno_t a) ALLOCNO_CALLS_CROSSED_NUM (cap) = ALLOCNO_CALLS_CROSSED_NUM (a); ALLOCNO_CHEAP_CALLS_CROSSED_NUM (cap) = ALLOCNO_CHEAP_CALLS_CROSSED_NUM (a); - IOR_HARD_REG_SET (ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (cap), - ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (a)); + ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (cap) + |= ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (a); if (internal_flag_ira_verbose > 2 && ira_dump_file != NULL) { fprintf (ira_dump_file, " Creating cap "); @@ -2036,8 +2036,8 @@ propagate_allocno_info (void) += ALLOCNO_CALLS_CROSSED_NUM (a); ALLOCNO_CHEAP_CALLS_CROSSED_NUM (parent_a) += ALLOCNO_CHEAP_CALLS_CROSSED_NUM (a); - IOR_HARD_REG_SET (ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (parent_a), - ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (a)); + ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (parent_a) + |= ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (a); ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (parent_a) += ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (a); aclass = ALLOCNO_CLASS (a); @@ -2419,8 +2419,8 @@ propagate_some_info_from_allocno (ira_allocno_t a, ira_allocno_t from_a) ALLOCNO_CALLS_CROSSED_NUM (a) += ALLOCNO_CALLS_CROSSED_NUM (from_a); ALLOCNO_CHEAP_CALLS_CROSSED_NUM (a) += ALLOCNO_CHEAP_CALLS_CROSSED_NUM (from_a); - IOR_HARD_REG_SET (ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (a), - ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (from_a)); + ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (a) + |= ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (from_a); ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (a) += ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (from_a); @@ -3060,8 +3060,8 @@ copy_info_to_removed_store_destinations (int regno) += ALLOCNO_CALLS_CROSSED_NUM (a); ALLOCNO_CHEAP_CALLS_CROSSED_NUM (parent_a) += ALLOCNO_CHEAP_CALLS_CROSSED_NUM (a); - IOR_HARD_REG_SET (ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (parent_a), - ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (a)); + ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (parent_a) + |= ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (a); ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (parent_a) += ALLOCNO_EXCESS_PRESSURE_POINTS_NUM (a); merged_p = true; diff --git a/gcc/ira-color.c b/gcc/ira-color.c index 0611891ca03..1078ef77de2 100644 --- a/gcc/ira-color.c +++ b/gcc/ira-color.c @@ -397,7 +397,7 @@ add_allocno_hard_regs_to_forest (allocno_hard_regs_node_t *roots, i++) { node = hard_regs_node_vec[i]; - IOR_HARD_REG_SET (temp_set, node->hard_regs->set); + temp_set |= node->hard_regs->set; } hv = add_allocno_hard_regs (temp_set, hv->cost); new_node = create_new_allocno_hard_regs_node (hv); @@ -1798,9 +1798,8 @@ assign_hard_reg (ira_allocno_t a, bool retry_p) hard_regno + num); } else - IOR_HARD_REG_SET - (conflicting_regs[word], - ira_reg_mode_hard_regset[hard_regno][mode]); + conflicting_regs[word] + |= ira_reg_mode_hard_regset[hard_regno][mode]; if (hard_reg_set_subset_p (profitable_hard_regs, conflicting_regs[word])) goto fail; @@ -4383,10 +4382,9 @@ allocno_reload_assign (ira_allocno_t a, HARD_REG_SET forbidden_regs) { ira_object_t obj = ALLOCNO_OBJECT (a, i); saved[i] = OBJECT_TOTAL_CONFLICT_HARD_REGS (obj); - IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), forbidden_regs); + OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= forbidden_regs; if (! flag_caller_saves && ALLOCNO_CALLS_CROSSED_NUM (a) != 0) - IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), - call_used_reg_set); + OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= call_used_reg_set; } ALLOCNO_ASSIGNED_P (a) = false; aclass = ALLOCNO_CLASS (a); @@ -4514,9 +4512,9 @@ ira_reassign_pseudos (int *spilled_pseudo_regs, int num, for (i = 0; i < num; i++) { regno = spilled_pseudo_regs[i]; - forbidden_regs = bad_spill_regs; - IOR_HARD_REG_SET (forbidden_regs, pseudo_forbidden_regs[regno]); - IOR_HARD_REG_SET (forbidden_regs, pseudo_previous_regs[regno]); + forbidden_regs = (bad_spill_regs + | pseudo_forbidden_regs[regno] + | pseudo_previous_regs[regno]); gcc_assert (reg_renumber[regno] < 0); a = ira_regno_allocno_map[regno]; ira_mark_allocation_change (regno); @@ -4881,11 +4879,10 @@ fast_allocation (void) for (l = 0; l < nr; l++) { ira_object_t obj = ALLOCNO_OBJECT (a, l); - IOR_HARD_REG_SET (conflict_hard_regs, - OBJECT_CONFLICT_HARD_REGS (obj)); + conflict_hard_regs |= OBJECT_CONFLICT_HARD_REGS (obj); for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next) for (j = r->start; j <= r->finish; j++) - IOR_HARD_REG_SET (conflict_hard_regs, used_hard_regs[j]); + conflict_hard_regs |= used_hard_regs[j]; } aclass = ALLOCNO_CLASS (a); ALLOCNO_ASSIGNED_P (a) = true; @@ -4933,8 +4930,7 @@ fast_allocation (void) ira_object_t obj = ALLOCNO_OBJECT (a, l); for (r = OBJECT_LIVE_RANGES (obj); r != NULL; r = r->next) for (k = r->start; k <= r->finish; k++) - IOR_HARD_REG_SET (used_hard_regs[k], - ira_reg_mode_hard_regset[hard_regno][mode]); + used_hard_regs[k] |= ira_reg_mode_hard_regset[hard_regno][mode]; } } ira_free (sorted_allocnos); diff --git a/gcc/ira-conflicts.c b/gcc/ira-conflicts.c index f8804b72960..46ff590e62f 100644 --- a/gcc/ira-conflicts.c +++ b/gcc/ira-conflicts.c @@ -762,21 +762,15 @@ ira_build_conflicts (void) && REG_USERVAR_P (allocno_reg) && ! reg_is_parm_p (allocno_reg))) { - IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), - call_used_reg_set); - IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), - call_used_reg_set); + OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= call_used_reg_set; + OBJECT_CONFLICT_HARD_REGS (obj) |= call_used_reg_set; } else if (ALLOCNO_CALLS_CROSSED_NUM (a) != 0) { - IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), - no_caller_save_reg_set); - IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), - temp_hard_reg_set); - IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), - no_caller_save_reg_set); - IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), - temp_hard_reg_set); + OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= no_caller_save_reg_set; + OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= temp_hard_reg_set; + OBJECT_CONFLICT_HARD_REGS (obj) |= no_caller_save_reg_set; + OBJECT_CONFLICT_HARD_REGS (obj) |= temp_hard_reg_set; } /* Now we deal with paradoxical subreg cases where certain registers diff --git a/gcc/ira-lives.c b/gcc/ira-lives.c index 2029027125a..e1d502fd9e2 100644 --- a/gcc/ira-lives.c +++ b/gcc/ira-lives.c @@ -188,8 +188,8 @@ make_object_dead (ira_object_t obj) } } - IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), hard_regs_live); - IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), hard_regs_live); + OBJECT_CONFLICT_HARD_REGS (obj) |= hard_regs_live; + OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= hard_regs_live; /* If IGNORE_REG_FOR_CONFLICTS did not already conflict with OBJ, make sure it still doesn't. */ @@ -990,10 +990,8 @@ process_single_reg_class_operands (bool in_p, int freq) /* We could increase costs of A instead of making it conflicting with the hard register. But it works worse because it will be spilled in reload in anyway. */ - IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), - reg_class_contents[cl]); - IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), - reg_class_contents[cl]); + OBJECT_CONFLICT_HARD_REGS (obj) |= reg_class_contents[cl]; + OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) |= reg_class_contents[cl]; } } } @@ -1275,10 +1273,10 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) } if (can_throw_internal (insn)) { - IOR_HARD_REG_SET (OBJECT_CONFLICT_HARD_REGS (obj), - this_call_used_reg_set); - IOR_HARD_REG_SET (OBJECT_TOTAL_CONFLICT_HARD_REGS (obj), - this_call_used_reg_set); + OBJECT_CONFLICT_HARD_REGS (obj) + |= this_call_used_reg_set; + OBJECT_TOTAL_CONFLICT_HARD_REGS (obj) + |= this_call_used_reg_set; } if (sparseset_bit_p (allocnos_processed, num)) @@ -1295,8 +1293,8 @@ process_bb_node_lives (ira_loop_tree_node_t loop_tree_node) /* Mark it as saved at the next call. */ allocno_saved_at_call[num] = last_call_num + 1; ALLOCNO_CALLS_CROSSED_NUM (a)++; - IOR_HARD_REG_SET (ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (a), - this_call_used_reg_set); + ALLOCNO_CROSSED_CALLS_CLOBBERED_REGS (a) + |= this_call_used_reg_set; if (cheap_reg != NULL_RTX && ALLOCNO_REGNO (a) == (int) REGNO (cheap_reg)) ALLOCNO_CHEAP_CALLS_CROSSED_NUM (a)++; diff --git a/gcc/ira.c b/gcc/ira.c index 6856d37400b..970cf1da620 100644 --- a/gcc/ira.c +++ b/gcc/ira.c @@ -892,15 +892,15 @@ setup_pressure_classes (void) break; if (m >= NUM_MACHINE_MODES) { - IOR_HARD_REG_SET (ignore_hard_regs, reg_class_contents[cl]); + ignore_hard_regs |= reg_class_contents[cl]; continue; } for (i = 0; i < n; i++) if ((int) pressure_classes[i] == cl) break; - IOR_HARD_REG_SET (temp_hard_regset2, reg_class_contents[cl]); + temp_hard_regset2 |= reg_class_contents[cl]; if (i < n) - IOR_HARD_REG_SET (temp_hard_regset, reg_class_contents[cl]); + temp_hard_regset |= reg_class_contents[cl]; } for (i = 0; i < FIRST_PSEUDO_REGISTER; i++) /* Some targets (like SPARC with ICC reg) have allocatable regs @@ -1264,8 +1264,7 @@ setup_reg_class_relations (void) intersection_set = (reg_class_contents[cl1] & reg_class_contents[cl2]); AND_COMPL_HARD_REG_SET (intersection_set, no_unit_alloc_regs); - union_set = reg_class_contents[cl1]; - IOR_HARD_REG_SET (union_set, reg_class_contents[cl2]); + union_set = reg_class_contents[cl1] | reg_class_contents[cl2]; AND_COMPL_HARD_REG_SET (union_set, no_unit_alloc_regs); for (cl3 = 0; cl3 < N_REG_CLASSES; cl3++) { diff --git a/gcc/lra-assigns.c b/gcc/lra-assigns.c index 8c07e90e164..ce6b07b7e74 100644 --- a/gcc/lra-assigns.c +++ b/gcc/lra-assigns.c @@ -495,16 +495,13 @@ find_hard_regno_for_1 (int regno, int *cost, int try_only_hard_regno, if (hard_reg_set_empty_p (regno_set)) conflict_set = lra_no_alloc_regs; else - { - conflict_set = ~regno_set; - IOR_HARD_REG_SET (conflict_set, lra_no_alloc_regs); - } + conflict_set = ~regno_set | lra_no_alloc_regs; rclass = regno_allocno_class_array[regno]; rclass_intersect_p = ira_reg_classes_intersect_p[rclass]; curr_hard_regno_costs_check++; sparseset_clear (conflict_reload_and_inheritance_pseudos); sparseset_clear (live_range_hard_reg_pseudos); - IOR_HARD_REG_SET (conflict_set, lra_reg_info[regno].conflict_hard_regs); + conflict_set |= lra_reg_info[regno].conflict_hard_regs; biggest_mode = lra_reg_info[regno].biggest_mode; for (r = lra_reg_info[regno].live_ranges; r != NULL; r = r->next) { @@ -1218,7 +1215,7 @@ setup_live_pseudos_and_spill_after_risky_transforms (bitmap } } conflict_set = lra_no_alloc_regs; - IOR_HARD_REG_SET (conflict_set, lra_reg_info[regno].conflict_hard_regs); + conflict_set |= lra_reg_info[regno].conflict_hard_regs; val = lra_reg_info[regno].val; offset = lra_reg_info[regno].offset; EXECUTE_IF_SET_IN_SPARSESET (live_range_hard_reg_pseudos, conflict_regno) diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c index c3f0c6ec681..d4eea8585a7 100644 --- a/gcc/lra-constraints.c +++ b/gcc/lra-constraints.c @@ -2373,14 +2373,12 @@ process_alt_operands (int only_alternative) if (mode == BLKmode) break; this_alternative = reg_class_subunion[this_alternative][cl]; - IOR_HARD_REG_SET (this_alternative_set, - reg_class_contents[cl]); + this_alternative_set |= reg_class_contents[cl]; if (costly_p) { this_costly_alternative = reg_class_subunion[this_costly_alternative][cl]; - IOR_HARD_REG_SET (this_costly_alternative_set, - reg_class_contents[cl]); + this_costly_alternative_set |= reg_class_contents[cl]; } winreg = true; if (REG_P (op)) @@ -6245,8 +6243,7 @@ inherit_in_ebb (rtx_insn *head, rtx_insn *tail) bitmap_clear (&invalid_invariant_regs); last_processed_bb = NULL; CLEAR_HARD_REG_SET (potential_reload_hard_regs); - live_hard_regs = eliminable_regset; - IOR_HARD_REG_SET (live_hard_regs, lra_no_alloc_regs); + live_hard_regs = eliminable_regset | lra_no_alloc_regs; /* We don't process new insns generated in the loop. */ for (curr_insn = tail; curr_insn != PREV_INSN (head); curr_insn = prev_insn) { @@ -6316,8 +6313,7 @@ inherit_in_ebb (rtx_insn *head, rtx_insn *tail) else setup_next_usage_insn (src_regno, curr_insn, reloads_num, false); if (hard_reg_set_subset_p (reg_class_contents[cl], live_hard_regs)) - IOR_HARD_REG_SET (potential_reload_hard_regs, - reg_class_contents[cl]); + potential_reload_hard_regs |= reg_class_contents[cl]; } else if (src_regno < 0 && dst_regno >= lra_constraint_new_regno_start @@ -6334,8 +6330,7 @@ inherit_in_ebb (rtx_insn *head, rtx_insn *tail) if (process_invariant_for_inheritance (SET_DEST (curr_set), SET_SRC (curr_set))) change_p = true; if (hard_reg_set_subset_p (reg_class_contents[cl], live_hard_regs)) - IOR_HARD_REG_SET (potential_reload_hard_regs, - reg_class_contents[cl]); + potential_reload_hard_regs |= reg_class_contents[cl]; } else if (src_regno >= lra_constraint_new_regno_start && dst_regno < lra_constraint_new_regno_start @@ -6357,8 +6352,7 @@ inherit_in_ebb (rtx_insn *head, rtx_insn *tail) /* Invalidate. */ usage_insns[dst_regno].check = 0; if (hard_reg_set_subset_p (reg_class_contents[cl], live_hard_regs)) - IOR_HARD_REG_SET (potential_reload_hard_regs, - reg_class_contents[cl]); + potential_reload_hard_regs |= reg_class_contents[cl]; } else if (INSN_P (curr_insn)) { @@ -6593,8 +6587,7 @@ inherit_in_ebb (rtx_insn *head, rtx_insn *tail) if (ira_class_hard_regs_num[cl] <= max_small_class_regs_num) reloads_num++; if (hard_reg_set_subset_p (reg_class_contents[cl], live_hard_regs)) - IOR_HARD_REG_SET (potential_reload_hard_regs, - reg_class_contents[cl]); + potential_reload_hard_regs |= reg_class_contents[cl]; } } if (NONDEBUG_INSN_P (curr_insn)) diff --git a/gcc/lra-eliminations.c b/gcc/lra-eliminations.c index 943da888848..7e5fbe3c5a0 100644 --- a/gcc/lra-eliminations.c +++ b/gcc/lra-eliminations.c @@ -1089,7 +1089,7 @@ spill_pseudos (HARD_REG_SET set) reg_renumber[i] = -1; bitmap_ior_into (&to_process, &lra_reg_info[i].insn_bitmap); } - IOR_HARD_REG_SET (lra_no_alloc_regs, set); + lra_no_alloc_regs |= set; for (insn = get_insns (); insn != NULL_RTX; insn = NEXT_INSN (insn)) if (bitmap_bit_p (&to_process, INSN_UID (insn))) { @@ -1202,7 +1202,7 @@ update_reg_eliminate (bitmap insns_with_changed_offsets) result = true; } } - IOR_HARD_REG_SET (lra_no_alloc_regs, temp_hard_reg_set); + lra_no_alloc_regs |= temp_hard_reg_set; AND_COMPL_HARD_REG_SET (eliminable_regset, temp_hard_reg_set); spill_pseudos (temp_hard_reg_set); return result; diff --git a/gcc/lra-lives.c b/gcc/lra-lives.c index 44038165d81..e046817204c 100644 --- a/gcc/lra-lives.c +++ b/gcc/lra-lives.c @@ -327,7 +327,7 @@ static void mark_pseudo_dead (int regno) { lra_assert (!HARD_REGISTER_NUM_P (regno)); - IOR_HARD_REG_SET (lra_reg_info[regno].conflict_hard_regs, hard_regs_live); + lra_reg_info[regno].conflict_hard_regs |= hard_regs_live; if (!sparseset_bit_p (pseudos_live, regno)) return; @@ -602,8 +602,7 @@ check_pseudos_live_through_calls (int regno, lra_reg_info[regno].call_insn = call_insn; sparseset_clear_bit (pseudos_live_through_calls, regno); - IOR_HARD_REG_SET (lra_reg_info[regno].conflict_hard_regs, - last_call_used_reg_set); + lra_reg_info[regno].conflict_hard_regs |= last_call_used_reg_set; for (hr = 0; HARD_REGISTER_NUM_P (hr); hr++) if (targetm.hard_regno_call_part_clobbered (call_insn, hr, @@ -945,8 +944,8 @@ process_bb_lives (basic_block bb, int &curr_point, bool dead_insn_p) EXECUTE_IF_SET_IN_SPARSESET (pseudos_live, j) { - IOR_HARD_REG_SET (lra_reg_info[j].actual_call_used_reg_set, - this_call_used_reg_set); + lra_reg_info[j].actual_call_used_reg_set + |= this_call_used_reg_set; if (flush) check_pseudos_live_through_calls (j, diff --git a/gcc/lra-spills.c b/gcc/lra-spills.c index 26cb421c81a..0068e52ace1 100644 --- a/gcc/lra-spills.c +++ b/gcc/lra-spills.c @@ -277,7 +277,7 @@ assign_spill_hard_regs (int *pseudo_regnos, int n) conflict_hard_regs = lra_reg_info[regno].conflict_hard_regs; for (r = lra_reg_info[regno].live_ranges; r != NULL; r = r->next) for (p = r->start; p <= r->finish; p++) - IOR_HARD_REG_SET (conflict_hard_regs, reserved_hard_regs[p]); + conflict_hard_regs |= reserved_hard_regs[p]; spill_class_size = ira_class_hard_regs_num[spill_class]; mode = lra_reg_info[regno].biggest_mode; for (k = 0; k < spill_class_size; k++) diff --git a/gcc/postreload.c b/gcc/postreload.c index 268b75b7777..3f2dac34bd6 100644 --- a/gcc/postreload.c +++ b/gcc/postreload.c @@ -1268,7 +1268,7 @@ reload_combine (void) REG_SET_TO_HARD_REG_SET (live, live_in); compute_use_by_pseudos (&live, live_in); LABEL_LIVE (insn) = live; - IOR_HARD_REG_SET (ever_live_at_start, live); + ever_live_at_start |= live; } } diff --git a/gcc/reginfo.c b/gcc/reginfo.c index 86f8b6899b4..9b77261bc13 100644 --- a/gcc/reginfo.c +++ b/gcc/reginfo.c @@ -298,8 +298,7 @@ init_reg_sets_1 (void) HARD_REG_SET c; int k; - c = reg_class_contents[i]; - IOR_HARD_REG_SET (c, reg_class_contents[j]); + c = reg_class_contents[i] | reg_class_contents[j]; for (k = 0; k < N_REG_CLASSES; k++) if (hard_reg_set_subset_p (reg_class_contents[k], c) && !hard_reg_set_subset_p (reg_class_contents[k], @@ -321,8 +320,7 @@ init_reg_sets_1 (void) HARD_REG_SET c; int k; - c = reg_class_contents[i]; - IOR_HARD_REG_SET (c, reg_class_contents[j]); + c = reg_class_contents[i] | reg_class_contents[j]; for (k = 0; k < N_REG_CLASSES; k++) if (hard_reg_set_subset_p (c, reg_class_contents[k])) break; diff --git a/gcc/regrename.c b/gcc/regrename.c index 997e884546c..c28023ea72d 100644 --- a/gcc/regrename.c +++ b/gcc/regrename.c @@ -292,7 +292,7 @@ merge_overlapping_regs (HARD_REG_SET *pset, class du_head *head) { bitmap_iterator bi; unsigned i; - IOR_HARD_REG_SET (*pset, head->hard_conflicts); + *pset |= head->hard_conflicts; EXECUTE_IF_SET_IN_BITMAP (&head->conflicts, 0, i, bi) { du_head_p other = regrename_chain_from_id (i); @@ -367,7 +367,7 @@ find_rename_reg (du_head_p this_head, enum reg_class super_class, If the chain needs a call-saved register, mark the call-used registers as unavailable. */ if (this_head->need_caller_save_reg) - IOR_HARD_REG_SET (*unavailable, call_used_reg_set); + *unavailable |= call_used_reg_set; /* Mark registers that overlap this chain's lifetime as unavailable. */ merge_overlapping_regs (unavailable, this_head); @@ -678,7 +678,7 @@ merge_chains (du_head_p c1, du_head_p c2) c2->first = c2->last = NULL; c2->id = c1->id; - IOR_HARD_REG_SET (c1->hard_conflicts, c2->hard_conflicts); + c1->hard_conflicts |= c2->hard_conflicts; bitmap_ior_into (&c1->conflicts, &c2->conflicts); c1->need_caller_save_reg |= c2->need_caller_save_reg; diff --git a/gcc/reload1.c b/gcc/reload1.c index 7aa3f855832..6c95c9c91c3 100644 --- a/gcc/reload1.c +++ b/gcc/reload1.c @@ -1364,7 +1364,7 @@ maybe_fix_stack_asms (void) { /* End of one alternative - mark the regs in the current class, and reset the class. */ - IOR_HARD_REG_SET (allowed, reg_class_contents[cls]); + allowed |= reg_class_contents[cls]; cls = NO_REGS; p++; if (c == '#') @@ -1745,8 +1745,8 @@ order_regs_for_reload (class insn_chain *chain) REG_SET_TO_HARD_REG_SET (used_by_pseudos, &chain->live_throughout); REG_SET_TO_HARD_REG_SET (used_by_pseudos2, &chain->dead_or_set); - IOR_HARD_REG_SET (bad_spill_regs, used_by_pseudos); - IOR_HARD_REG_SET (bad_spill_regs, used_by_pseudos2); + bad_spill_regs |= used_by_pseudos; + bad_spill_regs |= used_by_pseudos2; /* Now find out which pseudos are allocated to it, and update hard_reg_n_uses. */ @@ -1823,8 +1823,7 @@ find_reg (class insn_chain *chain, int order) static int regno_pseudo_regs[FIRST_PSEUDO_REGISTER]; static int best_regno_pseudo_regs[FIRST_PSEUDO_REGISTER]; - not_usable = bad_spill_regs; - IOR_HARD_REG_SET (not_usable, bad_spill_regs_global); + not_usable = bad_spill_regs | bad_spill_regs_global; IOR_COMPL_HARD_REG_SET (not_usable, reg_class_contents[rl->rclass]); CLEAR_HARD_REG_SET (used_by_other_reload); @@ -2008,7 +2007,7 @@ find_reload_regs (class insn_chain *chain) } chain->used_spill_regs = used_spill_regs_local; - IOR_HARD_REG_SET (used_spill_regs, used_spill_regs_local); + used_spill_regs |= used_spill_regs_local; memcpy (chain->rld, rld, n_reloads * sizeof (struct reload)); } @@ -4251,14 +4250,12 @@ finish_spills (int global) EXECUTE_IF_SET_IN_REG_SET (&chain->live_throughout, FIRST_PSEUDO_REGISTER, i, rsi) { - IOR_HARD_REG_SET (pseudo_forbidden_regs[i], - chain->used_spill_regs); + pseudo_forbidden_regs[i] |= chain->used_spill_regs; } EXECUTE_IF_SET_IN_REG_SET (&chain->dead_or_set, FIRST_PSEUDO_REGISTER, i, rsi) { - IOR_HARD_REG_SET (pseudo_forbidden_regs[i], - chain->used_spill_regs); + pseudo_forbidden_regs[i] |= chain->used_spill_regs; } } @@ -4302,7 +4299,7 @@ finish_spills (int global) { REG_SET_TO_HARD_REG_SET (used_by_pseudos, &chain->live_throughout); REG_SET_TO_HARD_REG_SET (used_by_pseudos2, &chain->dead_or_set); - IOR_HARD_REG_SET (used_by_pseudos, used_by_pseudos2); + used_by_pseudos |= used_by_pseudos2; compute_use_by_pseudos (&used_by_pseudos, &chain->live_throughout); compute_use_by_pseudos (&used_by_pseudos, &chain->dead_or_set); @@ -6239,9 +6236,9 @@ choose_reload_regs_init (class insn_chain *chain, rtx *save_reload_reg_rtx) { HARD_REG_SET tmp; REG_SET_TO_HARD_REG_SET (tmp, &chain->live_throughout); - IOR_HARD_REG_SET (reg_used_in_insn, tmp); + reg_used_in_insn |= tmp; REG_SET_TO_HARD_REG_SET (tmp, &chain->dead_or_set); - IOR_HARD_REG_SET (reg_used_in_insn, tmp); + reg_used_in_insn |= tmp; compute_use_by_pseudos (®_used_in_insn, &chain->live_throughout); compute_use_by_pseudos (®_used_in_insn, &chain->dead_or_set); } @@ -8420,7 +8417,7 @@ emit_reload_insns (class insn_chain *chain) } } } - IOR_HARD_REG_SET (reg_reloaded_dead, reg_reloaded_died); + reg_reloaded_dead |= reg_reloaded_died; } /* Go through the motions to emit INSN and test if it is strictly valid. diff --git a/gcc/reorg.c b/gcc/reorg.c index bdfcf8851cd..f542a104635 100644 --- a/gcc/reorg.c +++ b/gcc/reorg.c @@ -1575,7 +1575,7 @@ redundant_insn (rtx insn, rtx_insn *target, const vec &delay_list) /* Insns we pass may not set either NEEDED or SET, so merge them for simpler tests. */ needed.memory |= set.memory; - IOR_HARD_REG_SET (needed.regs, set.regs); + needed.regs |= set.regs; /* This insn isn't redundant if it conflicts with an insn that either is or will be in a delay slot of TARGET. */ diff --git a/gcc/resource.c b/gcc/resource.c index b24679f4144..f13956b9639 100644 --- a/gcc/resource.c +++ b/gcc/resource.c @@ -581,7 +581,7 @@ find_dead_or_set_registers (rtx_insn *target, struct resources *res, find_dead_or_set_registers (next_insn, &fallthrough_res, 0, jump_count, set, needed); - IOR_HARD_REG_SET (fallthrough_res.regs, target_res.regs); + fallthrough_res.regs |= target_res.regs; res->regs &= fallthrough_res.regs; break; } @@ -670,7 +670,7 @@ mark_set_resources (rtx x, struct resources *res, int in_dest, res->cc = res->memory = 1; get_call_reg_set_usage (call_insn, ®s, regs_invalidated_by_call); - IOR_HARD_REG_SET (res->regs, regs); + res->regs |= regs; for (link = CALL_INSN_FUNCTION_USAGE (call_insn); link; link = XEXP (link, 1)) @@ -1109,7 +1109,7 @@ mark_target_live_regs (rtx_insn *insns, rtx target_maybe_return, struct resource HARD_REG_SET extra_live; REG_SET_TO_HARD_REG_SET (extra_live, DF_LR_IN (bb)); - IOR_HARD_REG_SET (current_live_regs, extra_live); + current_live_regs |= extra_live; } } @@ -1118,7 +1118,7 @@ mark_target_live_regs (rtx_insn *insns, rtx target_maybe_return, struct resource are implicitly required at that point. */ else if (NOTE_P (real_insn) && NOTE_KIND (real_insn) == NOTE_INSN_EPILOGUE_BEG) - IOR_HARD_REG_SET (current_live_regs, start_of_epilogue_needs.regs); + current_live_regs |= start_of_epilogue_needs.regs; } res->regs = current_live_regs; @@ -1162,12 +1162,12 @@ mark_target_live_regs (rtx_insn *insns, rtx target_maybe_return, struct resource scratch = needed.regs; AND_COMPL_HARD_REG_SET (scratch, set.regs); - IOR_HARD_REG_SET (new_resources.regs, scratch); + new_resources.regs |= scratch; mark_set_resources (insn, &set, 0, MARK_SRC_DEST_CALL); } - IOR_HARD_REG_SET (res->regs, new_resources.regs); + res->regs |= new_resources.regs; } if (tinfo != NULL) diff --git a/gcc/rtlanal.c b/gcc/rtlanal.c index 15185b7ad7e..3dcdc846cbe 100644 --- a/gcc/rtlanal.c +++ b/gcc/rtlanal.c @@ -1478,7 +1478,7 @@ find_all_hard_reg_sets (const rtx_insn *insn, HARD_REG_SET *pset, bool implicit) CLEAR_HARD_REG_SET (*pset); note_stores (insn, record_hard_reg_sets, pset); if (CALL_P (insn) && implicit) - IOR_HARD_REG_SET (*pset, call_used_reg_set); + *pset |= call_used_reg_set; for (link = REG_NOTES (insn); link; link = XEXP (link, 1)) if (REG_NOTE_KIND (link) == REG_INC) record_hard_reg_sets (XEXP (link, 0), NULL, pset); diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c index dcc84d73640..8031d72fa63 100644 --- a/gcc/sched-deps.c +++ b/gcc/sched-deps.c @@ -2901,7 +2901,7 @@ sched_analyze_insn (class deps_desc *deps, rtx x, rtx_insn *insn) { HARD_REG_SET temp; get_implicit_reg_pending_clobbers (&temp, insn); - IOR_HARD_REG_SET (implicit_reg_pending_clobbers, temp); + implicit_reg_pending_clobbers |= temp; } can_start_lhs_rhs_p = (NONJUMP_INSN_P (insn) diff --git a/gcc/sel-sched.c b/gcc/sel-sched.c index ccca43d0962..e5b825a102c 100644 --- a/gcc/sel-sched.c +++ b/gcc/sel-sched.c @@ -1221,15 +1221,13 @@ mark_unavailable_hard_regs (def_t def, struct reg_rename *reg_rename_p, The HARD_REGNO_RENAME_OK covers other cases in condition below. */ if (IN_RANGE (REGNO (orig_dest), FIRST_STACK_REG, LAST_STACK_REG) && REGNO_REG_SET_P (used_regs, FIRST_STACK_REG)) - IOR_HARD_REG_SET (reg_rename_p->unavailable_hard_regs, - sel_hrd.stack_regs); + reg_rename_p->unavailable_hard_regs |= sel_hrd.stack_regs; #endif /* If there's a call on this path, make regs from call_used_reg_set unavailable. */ if (def->crosses_call) - IOR_HARD_REG_SET (reg_rename_p->unavailable_hard_regs, - call_used_reg_set); + reg_rename_p->unavailable_hard_regs |= call_used_reg_set; /* Stop here before reload: we need FRAME_REGS, STACK_REGS, and crosses_call, but not register classes. */ @@ -1684,8 +1682,7 @@ find_best_reg_for_expr (expr_t expr, blist_t bnds, bool *is_orig_reg_p) /* Join hard registers unavailable due to register class restrictions and live range intersection. */ - IOR_HARD_REG_SET (hard_regs_used, - reg_rename_data.unavailable_hard_regs); + hard_regs_used |= reg_rename_data.unavailable_hard_regs; best_reg = choose_best_reg (hard_regs_used, ®_rename_data, original_insns, is_orig_reg_p); diff --git a/gcc/shrink-wrap.c b/gcc/shrink-wrap.c index 9ee712e5892..bf6d045b84c 100644 --- a/gcc/shrink-wrap.c +++ b/gcc/shrink-wrap.c @@ -688,7 +688,7 @@ try_shrink_wrapping (edge *entry_edge, rtx_insn *prologue_seq) CLEAR_HARD_REG_SET (this_used); note_uses (&PATTERN (insn), record_hard_reg_uses, &this_used); AND_COMPL_HARD_REG_SET (this_used, prologue_clobbered); - IOR_HARD_REG_SET (prologue_used, this_used); + prologue_used |= this_used; note_stores (insn, record_hard_reg_sets, &prologue_clobbered); } CLEAR_HARD_REG_BIT (prologue_clobbered, STACK_POINTER_REGNUM);