From patchwork Mon Sep 9 16:00:26 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 1159844 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=pass (mailfrom) smtp.mailfrom=gcc.gnu.org (client-ip=209.132.180.131; helo=sourceware.org; envelope-from=gcc-patches-return-508673-incoming=patchwork.ozlabs.org@gcc.gnu.org; receiver=) Authentication-Results: ozlabs.org; dmarc=none (p=none dis=none) header.from=arm.com Authentication-Results: ozlabs.org; dkim=pass (1024-bit key; unprotected) header.d=gcc.gnu.org header.i=@gcc.gnu.org header.b="k7Rpqkqf"; dkim-atps=neutral Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ozlabs.org (Postfix) with ESMTPS id 46RtDY3WV0z9s00 for ; Tue, 10 Sep 2019 02:00:45 +1000 (AEST) DomainKey-Signature: a=rsa-sha1; c=nofws; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:references:date:in-reply-to:message-id:mime-version :content-type; q=dns; s=default; b=CSro0Ig0LIL5o9dYEuEo2v+upUCQC lj0ov1jAvOKXveItui7Np0aiWjD6SQYPcIs6A8CK8lo7AfUmLs+ABANbcVrMoA7O X0WDFLXQIf+gfSjlTy47whgPkADeJ0Ij4gzFnuLH3wSonJMN1YJ3RX+CK8bJ86o7 GNbu3dCnBLiBPk= DKIM-Signature: v=1; a=rsa-sha1; c=relaxed; d=gcc.gnu.org; h=list-id :list-unsubscribe:list-archive:list-post:list-help:sender:from :to:subject:references:date:in-reply-to:message-id:mime-version :content-type; s=default; bh=UGJZEl9UyVDXzt+QJwoDP/hBizY=; b=k7R pqkqfMz4O3Mk/BeEvjdlHG5QZbwFDC8fyviQXw3FR5IreAXXsVrEbgRL9c2BhlgH 9Q435Uwn7W41bUHHHGdT+vfOCTCjSTNqHFj7HpEI0qsjK8eSzNSUTQY7ZPXbqqlK vL+6oXnVHsfHsFhu1KgFf3ZnR9BGc3Yygb0rzV8Q= Received: (qmail 35293 invoked by alias); 9 Sep 2019 16:00:36 -0000 Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Unsubscribe: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org Delivered-To: mailing list gcc-patches@gcc.gnu.org Received: (qmail 35266 invoked by uid 89); 9 Sep 2019 16:00:35 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-8.7 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS autolearn=ham version=3.3.1 spammy=bli, 6258, Join X-HELO: foss.arm.com Received: from foss.arm.com (HELO foss.arm.com) (217.140.110.172) by sourceware.org (qpsmtpd/0.93/v0.84-503-g423c35a) with ESMTP; Mon, 09 Sep 2019 16:00:30 +0000 Received: from usa-sjc-imap-foss1.foss.arm.com (unknown [10.121.207.14]) by usa-sjc-mx-foss1.foss.arm.com (Postfix) with ESMTP id A2405169E for ; Mon, 9 Sep 2019 09:00:28 -0700 (PDT) Received: from localhost (e121540-lin.manchester.arm.com [10.32.99.62]) by usa-sjc-imap-foss1.foss.arm.com (Postfix) with ESMTPSA id 127713F59C for ; Mon, 9 Sep 2019 09:00:27 -0700 (PDT) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@arm.com Subject: [5/9] Remove IOR_HARD_REG_SET References: Date: Mon, 09 Sep 2019 17:00:26 +0100 In-Reply-To: (Richard Sandiford's message of "Mon, 09 Sep 2019 16:52:04 +0100") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.1 (gnu/linux) MIME-Version: 1.0 X-IsSubscribed: yes 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. Index: gcc/hard-reg-set.h =================================================================== --- gcc/hard-reg-set.h 2019-09-09 16:07:28.372726754 +0100 +++ gcc/hard-reg-set.h 2019-09-09 16:08:54.788113807 +0100 @@ -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 @@ #define HARD_CONST(X) ((HARD_REG_ELT_TYP 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 @@ #define TEST_HARD_REG_BIT(SET, BIT) \ #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)) @@ -210,13 +224,6 @@ AND_COMPL_HARD_REG_SET (HARD_REG_SET &to } 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) { for (unsigned int i = 0; i < ARRAY_SIZE (to.elts); ++i) Index: gcc/config/gcn/gcn.c =================================================================== --- gcc/config/gcn/gcn.c 2019-09-09 16:07:28.364726810 +0100 +++ gcc/config/gcn/gcn.c 2019-09-09 16:08:54.784113835 +0100 @@ -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); } Index: gcc/config/m32c/m32c.c =================================================================== --- gcc/config/m32c/m32c.c 2019-09-09 16:07:28.364726810 +0100 +++ gcc/config/m32c/m32c.c 2019-09-09 16:08:54.784113835 +0100 @@ -2151,8 +2151,7 @@ m32c_register_move_cost (machine_mode mo 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])) Index: gcc/config/s390/s390.c =================================================================== --- gcc/config/s390/s390.c 2019-09-09 12:27:14.254372318 +0100 +++ gcc/config/s390/s390.c 2019-09-09 16:08:54.788113807 +0100 @@ -14073,7 +14073,7 @@ s390_adjust_loop_scan_osc (struct 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* return false; find_all_hard_reg_sets (insn, &newregs, true); - IOR_HARD_REG_SET (modregs, newregs); + modregs |= newregs; set = single_set (insn); if (!set) Index: gcc/final.c =================================================================== --- gcc/final.c 2019-09-09 16:07:28.372726754 +0100 +++ gcc/final.c 2019-09-09 16:08:54.788113807 +0100 @@ -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 Index: gcc/hw-doloop.c =================================================================== --- gcc/hw-doloop.c 2019-03-08 18:15:33.664751891 +0000 +++ gcc/hw-doloop.c 2019-09-09 16:08:54.788113807 +0100 @@ -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 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; Index: gcc/ira-build.c =================================================================== --- gcc/ira-build.c 2019-09-09 16:06:17.649228402 +0100 +++ gcc/ira-build.c 2019-09-09 16:08:54.792113779 +0100 @@ -602,10 +602,10 @@ merge_hard_reg_conflicts (ira_allocno_t 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, 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_al 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 += 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; Index: gcc/ira-color.c =================================================================== --- gcc/ira-color.c 2019-09-09 16:07:28.372726754 +0100 +++ gcc/ira-color.c 2019-09-09 16:08:54.792113779 +0100 @@ -397,7 +397,7 @@ add_allocno_hard_regs_to_forest (allocno 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 r 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, { 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_pseud 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); Index: gcc/ira-conflicts.c =================================================================== --- gcc/ira-conflicts.c 2019-09-09 16:07:28.372726754 +0100 +++ gcc/ira-conflicts.c 2019-09-09 16:08:54.792113779 +0100 @@ -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 Index: gcc/ira-lives.c =================================================================== --- gcc/ira-lives.c 2019-07-01 09:58:36.789742995 +0100 +++ gcc/ira-lives.c 2019-09-09 16:08:54.792113779 +0100 @@ -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 /* 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_nod } 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_nod /* 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)++; Index: gcc/ira.c =================================================================== --- gcc/ira.c 2019-09-09 16:07:28.372726754 +0100 +++ gcc/ira.c 2019-09-09 16:08:54.792113779 +0100 @@ -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++) { Index: gcc/lra-assigns.c =================================================================== --- gcc/lra-assigns.c 2019-09-09 16:06:54.724965420 +0100 +++ gcc/lra-assigns.c 2019-09-09 16:08:54.792113779 +0100 @@ -495,16 +495,13 @@ find_hard_regno_for_1 (int regno, int *c 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 } } 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) Index: gcc/lra-constraints.c =================================================================== --- gcc/lra-constraints.c 2019-09-09 16:06:54.724965420 +0100 +++ gcc/lra-constraints.c 2019-09-09 16:08:54.796113751 +0100 @@ -2373,14 +2373,12 @@ process_alt_operands (int only_alternati 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 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 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 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 /* 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 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)) Index: gcc/lra-eliminations.c =================================================================== --- gcc/lra-eliminations.c 2019-07-10 19:41:21.623936245 +0100 +++ gcc/lra-eliminations.c 2019-09-09 16:08:54.796113751 +0100 @@ -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_ 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; Index: gcc/lra-lives.c =================================================================== --- gcc/lra-lives.c 2019-09-09 16:06:17.653228374 +0100 +++ gcc/lra-lives.c 2019-09-09 16:08:54.796113751 +0100 @@ -327,7 +327,7 @@ mark_pseudo_live (int regno) 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 re 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 &c 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, Index: gcc/lra-spills.c =================================================================== --- gcc/lra-spills.c 2019-09-09 16:06:17.653228374 +0100 +++ gcc/lra-spills.c 2019-09-09 16:08:54.796113751 +0100 @@ -277,7 +277,7 @@ assign_spill_hard_regs (int *pseudo_regn 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++) Index: gcc/postreload.c =================================================================== --- gcc/postreload.c 2019-09-09 16:06:17.653228374 +0100 +++ gcc/postreload.c 2019-09-09 16:08:54.796113751 +0100 @@ -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; } } Index: gcc/reginfo.c =================================================================== --- gcc/reginfo.c 2019-09-09 16:07:28.372726754 +0100 +++ gcc/reginfo.c 2019-09-09 16:08:54.796113751 +0100 @@ -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; Index: gcc/regrename.c =================================================================== --- gcc/regrename.c 2019-09-09 16:06:17.653228374 +0100 +++ gcc/regrename.c 2019-09-09 16:08:54.796113751 +0100 @@ -292,7 +292,7 @@ merge_overlapping_regs (HARD_REG_SET *ps { 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, en 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; Index: gcc/reload1.c =================================================================== --- gcc/reload1.c 2019-09-09 16:07:28.376726726 +0100 +++ gcc/reload1.c 2019-09-09 16:08:54.800113722 +0100 @@ -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 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 o 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 *chai } 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_chai { 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 *cha } } } - 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. Index: gcc/reorg.c =================================================================== --- gcc/reorg.c 2019-07-01 09:37:05.096542274 +0100 +++ gcc/reorg.c 2019-09-09 16:08:54.800113722 +0100 @@ -1575,7 +1575,7 @@ redundant_insn (rtx insn, rtx_insn *targ /* 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. */ Index: gcc/resource.c =================================================================== --- gcc/resource.c 2019-09-09 16:07:28.376726726 +0100 +++ gcc/resource.c 2019-09-09 16:08:54.800113722 +0100 @@ -581,7 +581,7 @@ find_dead_or_set_registers (rtx_insn *ta 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 resour 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, 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, 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, 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) Index: gcc/rtlanal.c =================================================================== --- gcc/rtlanal.c 2019-09-09 12:27:14.262372261 +0100 +++ gcc/rtlanal.c 2019-09-09 16:08:54.800113722 +0100 @@ -1478,7 +1478,7 @@ find_all_hard_reg_sets (const rtx_insn * 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); Index: gcc/sched-deps.c =================================================================== --- gcc/sched-deps.c 2019-09-09 12:27:14.266372233 +0100 +++ gcc/sched-deps.c 2019-09-09 16:08:54.800113722 +0100 @@ -2901,7 +2901,7 @@ sched_analyze_insn (class deps_desc *dep { 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) Index: gcc/sel-sched.c =================================================================== --- gcc/sel-sched.c 2019-09-09 16:07:28.376726726 +0100 +++ gcc/sel-sched.c 2019-09-09 16:08:54.804113694 +0100 @@ -1221,15 +1221,13 @@ mark_unavailable_hard_regs (def_t def, s 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, bli /* 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); Index: gcc/shrink-wrap.c =================================================================== --- gcc/shrink-wrap.c 2019-09-09 16:04:49.265855317 +0100 +++ gcc/shrink-wrap.c 2019-09-09 16:08:54.804113694 +0100 @@ -688,7 +688,7 @@ try_shrink_wrapping (edge *entry_edge, r 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);