From patchwork Tue Sep 10 16:36:16 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Richard Sandiford X-Patchwork-Id: 1160477 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-508781-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="uSJuvKaE"; 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 46SVzV22W8z9s4Y for ; Wed, 11 Sep 2019 02:36:36 +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=sk6OK2sgb9m6RVAc507v7XIxbLZZf eUGbpHx8LAjPLaYfWmA/q6nzCEZZkpR+x40c4Tc59jQ6RL2M6qM1/uUzI5jeTNJX g+8fkYmUaqD5SYSsx9XpFj1Vb9TK2xc+cxKxYKDixjGmU8sN97Pg8W2hN5lVG8+E ubZnypnasqIPOU= 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=BRgK8oYlzWspK3oS3SkIc5pRNek=; b=uSJ uvKaEM9jJQUXuswEYIM96z8typ/61hfv++Dz39Npg6xwFA45BlyCYKshqVlipIlC ggLshywaCioG63oqcpB/OnY1LP2Izf2zf9zeypZ5PWYh7vjfE0olRJzyesXeYd2p EBTKf329fh8751cjAbRc6DgG5ukG3yldPZ5TwWCo= Received: (qmail 46567 invoked by alias); 10 Sep 2019 16:36:26 -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 46559 invoked by uid 89); 10 Sep 2019 16:36:26 -0000 Authentication-Results: sourceware.org; auth=none X-Spam-SWARE-Status: No, score=-11.3 required=5.0 tests=AWL, BAYES_00, GIT_PATCH_1, GIT_PATCH_2, GIT_PATCH_3, KAM_ASCII_DIVIDERS, SPF_PASS autolearn=ham version=3.3.1 spammy=reserves, Raise 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; Tue, 10 Sep 2019 16:36:19 +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 510D61000 for ; Tue, 10 Sep 2019 09:36:18 -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 B47593F71F for ; Tue, 10 Sep 2019 09:36:17 -0700 (PDT) From: Richard Sandiford To: gcc-patches@gcc.gnu.org Mail-Followup-To: gcc-patches@gcc.gnu.org, richard.sandiford@arm.com Subject: [9/9] Remove call_really_used_regs References: Date: Tue, 10 Sep 2019 17:36:16 +0100 In-Reply-To: (Richard Sandiford's message of "Tue, 10 Sep 2019 17:26:13 +0100") Message-ID: User-Agent: Gnus/5.13 (Gnus v5.13) Emacs/26.1 (gnu/linux) MIME-Version: 1.0 X-IsSubscribed: yes After previous patches, it's now possible for call_used_regs to be the "real" set of call-clobbered registers, without any special handling for fixed registers. This patch therefore removes the separate call_really_used_regs and updates the targets that define CALL_REALLY_USED_REGISTERS so that they handle call_used_regs in the same way that they used to handle call_really_used_regs. With this change, it's no longer necessary for targets that define CALL_REALLY_USED_REGISTERS to define CALL_USED_REGISTER as well. 2019-09-10 Richard Sandiford gcc/ * doc/tm.texi.in: Document that exactly one of CALL_USED_REGISTERS and CALL_REALLY_USED_REGISTERS must be defined, and that CALL_REALLY_USED_REGISTERS is preferred. * doc/tm.texi: Regenerate. * hard-reg-set.h (target_hard_regs::x_call_really_used_regs): Delete. (call_really_used_regs): Likewise. * reginfo.c: Raise an #error if both CALL_USED_REGISTERS and CALL_REALLY_USED_REGISTERS are defined. (initial_call_used_regs): Use CALL_REALLY_USED_REGISTERS as the initial value if defined. (initial_call_really_used_regs): Delete. (saved_call_really_used_regs): Likewise. (CALL_REALLY_USED_REGNO_P): Likewise. (init_reg_sets): Remove handling of call_really_used_regs. (save_register_info, restore_register_info, globalize_reg): Likewise. (init_reg_sets_1): Likewise. Use call_used_regs instead of CALL_REALLY_USED_REGNO_P. Don't set call_used_regs for registers outside operand_reg_set. (fix_register): Don't change call_used_regs if CALL_REALLY_USED_REGISTERS is defined. * config/csky/csky.h (CALL_USED_REGISTERS): Delete. * config/csky/csky.c (get_csky_live_regs): Use call_used_regs instead of call_really_used_regs. (csky_conditional_register_usage): Remove the old handling of call_used_regs and change the handling of call_really_used_regs to use call_used_regs instead. * config/ia64/ia64.h (CALL_USED_REGISTERS): Delete. * config/ia64/ia64.c (fix_range): Don't set call_used_regs when making a register fixed. * config/m32r/m32r.h (CALL_USED_REGISTERS): Delete. * config/m32r/m32r.c (MUST_SAVE_REGISTER): Use call_used_regs instead of call_really_used_regs. (m32r_conditional_register_usage): Don't set call_used_regs when making a register fixed. * config/mips/mips.h (CALL_USED_REGISTERS): Delete. * config/mips/mips.c (mips_global_pointer): Use call_used_regs instead of call_really_used_regs. (mips_interrupt_extra_call_saved_reg_p): Likewise. (mips_cfun_call_saved_reg_p): Likewise. (mips_swap_registers): Remove the old handling of call_used_regs and change the handling of call_really_used_regs to use call_used_regs instead. (mips_conditional_register_usage): Likewise. * config/mn10300/mn10300.h (CALL_USED_REGISTERS): Delete. * config/mn10300/mn10300.c (fp_regs_to_save): Use call_used_regs instead of call_really_used_regs. (mn10300_get_live_callee_saved_regs): Likewise. (mn10300_expand_prologue, mn10300_expand_epilogue): Likewise. (mn10300_conditional_register_usage): Don't set call_used_regs when making a register fixed. * config/rs6000/rs6000.h (CALL_USED_REGISTERS): Delete. * config/rs6000/rs6000.c (rs6000_conditional_register_usage): Remove the old handling of call_used_regs and change the handling of call_really_used_regs to use call_used_regs instead. * config/s390/s390.h (CALL_USED_REGISTERS): Delete. * config/s390/s390.c (s390_regs_ever_clobbered): Use call_used_regs instead of call_really_used_regs. (s390_register_info_gprtofpr, s390_register_info): Likewise. (s390_hard_regno_rename_ok, s390_hard_regno_scratch_ok): Likewise. (s390_emit_prologue, s300_set_up_by_prologue): Likewise. (s390_can_use_return_insn, s390_optimize_prologue): Likewise. (s390_conditional_register_usage): Remove the old handling of call_used_regs and change the handling of call_really_used_regs to use call_used_regs instead. * config/sh/sh.h (CALL_USED_REGISTERS): Delete. * config/sh/sh.c (output_stack_adjust, calc_live_regs): Likewise. (sh_fix_range, reg_unused_after): Likewise. (sh_conditional_register_usage): Remove the old handling of call_used_regs and change the handling of call_really_used_regs to use call_used_regs instead. * config/sparc/sparc.h (CALL_USED_REGISTERS): Delete. * config/sparc/sparc.c (sparc_conditional_register_usage): Don't set call_used_regs when making a register fixed. * config/tilegx/tilegx.h (CALL_USED_REGISTERS): Delete. * config/tilegx/tilegx.c (tilegx_conditional_register_usage): Don't set call_used_regs when making a register fixed. * config/tilepro/tilepro.h (CALL_USED_REGISTERS): Delete. * config/tilepro/tilepro.c (tilepro_conditional_register_usage): Don't set call_used_regs when making a register fixed. * config/visium/visium.h (CALL_USED_REGISTERS): Delete. * config/visium/visium.c (visium_conditional_register_usage): Remove the old handling of call_used_regs and change the handling of call_really_used_regs to use call_used_regs instead. Index: gcc/doc/tm.texi.in =================================================================== --- gcc/doc/tm.texi.in 2019-09-09 17:51:55.848574716 +0100 +++ gcc/doc/tm.texi.in 2019-09-10 17:23:08.730251493 +0100 @@ -1689,6 +1689,9 @@ function calls. If a register has 0 in @code{CALL_USED_REGISTERS}, the compiler automatically saves it on function entry and restores it on function exit, if the register is used within the function. + +Exactly one of @code{CALL_USED_REGISTERS} and @code{CALL_REALLY_USED_REGISTERS} +must be defined. Modern ports should define @code{CALL_REALLY_USED_REGISTERS}. @end defmac @defmac CALL_REALLY_USED_REGISTERS @@ -1698,8 +1701,9 @@ exit, if the register is used within the Like @code{CALL_USED_REGISTERS} except this macro doesn't require that the entire set of @code{FIXED_REGISTERS} be included. (@code{CALL_USED_REGISTERS} must be a superset of @code{FIXED_REGISTERS}). -This macro is optional. If not specified, it defaults to the value -of @code{CALL_USED_REGISTERS}. + +Exactly one of @code{CALL_USED_REGISTERS} and @code{CALL_REALLY_USED_REGISTERS} +must be defined. Modern ports should define @code{CALL_REALLY_USED_REGISTERS}. @end defmac @cindex call-used register Index: gcc/doc/tm.texi =================================================================== --- gcc/doc/tm.texi 2019-09-09 17:51:55.844574745 +0100 +++ gcc/doc/tm.texi 2019-09-10 17:23:08.730251493 +0100 @@ -1878,6 +1878,9 @@ function calls. If a register has 0 in @code{CALL_USED_REGISTERS}, the compiler automatically saves it on function entry and restores it on function exit, if the register is used within the function. + +Exactly one of @code{CALL_USED_REGISTERS} and @code{CALL_REALLY_USED_REGISTERS} +must be defined. Modern ports should define @code{CALL_REALLY_USED_REGISTERS}. @end defmac @defmac CALL_REALLY_USED_REGISTERS @@ -1887,8 +1890,9 @@ exit, if the register is used within the Like @code{CALL_USED_REGISTERS} except this macro doesn't require that the entire set of @code{FIXED_REGISTERS} be included. (@code{CALL_USED_REGISTERS} must be a superset of @code{FIXED_REGISTERS}). -This macro is optional. If not specified, it defaults to the value -of @code{CALL_USED_REGISTERS}. + +Exactly one of @code{CALL_USED_REGISTERS} and @code{CALL_REALLY_USED_REGISTERS} +must be defined. Modern ports should define @code{CALL_REALLY_USED_REGISTERS}. @end defmac @cindex call-used register Index: gcc/hard-reg-set.h =================================================================== --- gcc/hard-reg-set.h 2019-09-10 17:23:04.278282749 +0100 +++ gcc/hard-reg-set.h 2019-09-10 17:23:08.730251493 +0100 @@ -395,8 +395,6 @@ struct target_hard_regs { a pseudo reg whose life crosses calls. */ char x_call_used_regs[FIRST_PSEUDO_REGISTER]; - char x_call_really_used_regs[FIRST_PSEUDO_REGISTER]; - /* For targets that use reload rather than LRA, this is the set of registers that we are able to save and restore around calls (i.e. those for which we know a suitable mode and set of @@ -477,8 +475,6 @@ #define fixed_nonglobal_reg_set \ #define call_used_regs \ (this_target_hard_regs->x_call_used_regs) #endif -#define call_really_used_regs \ - (this_target_hard_regs->x_call_really_used_regs) #define savable_regs \ (this_target_hard_regs->x_savable_regs) #define regs_invalidated_by_call \ Index: gcc/reginfo.c =================================================================== --- gcc/reginfo.c 2019-09-10 17:23:04.278282749 +0100 +++ gcc/reginfo.c 2019-09-10 17:23:08.730251493 +0100 @@ -73,17 +73,13 @@ #define call_used_regs \ static const char initial_fixed_regs[] = FIXED_REGISTERS; /* Data for initializing call_used_regs. */ -static const char initial_call_used_regs[] = CALL_USED_REGISTERS; - #ifdef CALL_REALLY_USED_REGISTERS -/* Data for initializing call_really_used_regs. */ -static const char initial_call_really_used_regs[] = CALL_REALLY_USED_REGISTERS; +#ifdef CALL_USED_REGISTERS +#error CALL_USED_REGISTERS and CALL_REALLY_USED_REGISTERS are both defined #endif - -#ifdef CALL_REALLY_USED_REGISTERS -#define CALL_REALLY_USED_REGNO_P(X) call_really_used_regs[X] +static const char initial_call_used_regs[] = CALL_REALLY_USED_REGISTERS; #else -#define CALL_REALLY_USED_REGNO_P(X) call_used_regs[X] +static const char initial_call_used_regs[] = CALL_USED_REGISTERS; #endif /* Indexed by hard register number, contains 1 for registers @@ -164,10 +160,6 @@ init_reg_sets (void) CALL_USED_REGISTERS had the right number of initializers. */ gcc_assert (sizeof fixed_regs == sizeof initial_fixed_regs); gcc_assert (sizeof call_used_regs == sizeof initial_call_used_regs); -#ifdef CALL_REALLY_USED_REGISTERS - gcc_assert (sizeof call_really_used_regs - == sizeof initial_call_really_used_regs); -#endif #ifdef REG_ALLOC_ORDER gcc_assert (sizeof reg_alloc_order == sizeof initial_reg_alloc_order); #endif @@ -175,10 +167,6 @@ init_reg_sets (void) memcpy (fixed_regs, initial_fixed_regs, sizeof fixed_regs); memcpy (call_used_regs, initial_call_used_regs, sizeof call_used_regs); -#ifdef CALL_REALLY_USED_REGISTERS - memcpy (call_really_used_regs, initial_call_really_used_regs, - sizeof call_really_used_regs); -#endif #ifdef REG_ALLOC_ORDER memcpy (reg_alloc_order, initial_reg_alloc_order, sizeof reg_alloc_order); #endif @@ -193,9 +181,6 @@ init_reg_sets (void) subsequent back-end reinitialization. */ static char saved_fixed_regs[FIRST_PSEUDO_REGISTER]; static char saved_call_used_regs[FIRST_PSEUDO_REGISTER]; -#ifdef CALL_REALLY_USED_REGISTERS -static char saved_call_really_used_regs[FIRST_PSEUDO_REGISTER]; -#endif static const char *saved_reg_names[FIRST_PSEUDO_REGISTER]; static HARD_REG_SET saved_accessible_reg_set; static HARD_REG_SET saved_operand_reg_set; @@ -211,14 +196,6 @@ save_register_info (void) memcpy (saved_fixed_regs, fixed_regs, sizeof fixed_regs); memcpy (saved_call_used_regs, call_used_regs, sizeof call_used_regs); - /* Likewise for call_really_used_regs. */ -#ifdef CALL_REALLY_USED_REGISTERS - gcc_assert (sizeof call_really_used_regs - == sizeof saved_call_really_used_regs); - memcpy (saved_call_really_used_regs, call_really_used_regs, - sizeof call_really_used_regs); -#endif - /* And similarly for reg_names. */ gcc_assert (sizeof reg_names == sizeof saved_reg_names); memcpy (saved_reg_names, reg_names, sizeof reg_names); @@ -233,11 +210,6 @@ restore_register_info (void) memcpy (fixed_regs, saved_fixed_regs, sizeof fixed_regs); memcpy (call_used_regs, saved_call_used_regs, sizeof call_used_regs); -#ifdef CALL_REALLY_USED_REGISTERS - memcpy (call_really_used_regs, saved_call_really_used_regs, - sizeof call_really_used_regs); -#endif - memcpy (reg_names, saved_reg_names, sizeof reg_names); accessible_reg_set = saved_accessible_reg_set; operand_reg_set = saved_operand_reg_set; @@ -371,17 +343,7 @@ init_reg_sets_1 (void) /* If a register is too limited to be treated as a register operand, then it should never be allocated to a pseudo. */ if (!TEST_HARD_REG_BIT (operand_reg_set, i)) - { - fixed_regs[i] = 1; - call_used_regs[i] = 1; - } - - /* call_used_regs must include fixed_regs. */ - gcc_assert (!fixed_regs[i] || call_used_regs[i]); -#ifdef CALL_REALLY_USED_REGISTERS - /* call_used_regs must include call_really_used_regs. */ - gcc_assert (!call_really_used_regs[i] || call_used_regs[i]); -#endif + fixed_regs[i] = 1; if (fixed_regs[i]) SET_HARD_REG_BIT (fixed_reg_set, i); @@ -411,7 +373,7 @@ init_reg_sets_1 (void) else if (!PIC_OFFSET_TABLE_REG_CALL_CLOBBERED && i == (unsigned) PIC_OFFSET_TABLE_REGNUM && fixed_regs[i]) ; - else if (CALL_REALLY_USED_REGNO_P (i)) + else if (call_used_regs[i]) SET_HARD_REG_BIT (regs_invalidated_by_call, i); } @@ -713,10 +675,11 @@ fix_register (const char *name, int fixe else { fixed_regs[i] = fixed; - call_used_regs[i] = call_used; #ifdef CALL_REALLY_USED_REGISTERS if (fixed == 0) - call_really_used_regs[i] = call_used; + call_used_regs[i] = call_used; +#else + call_used_regs[i] = call_used; #endif } } @@ -772,9 +735,6 @@ globalize_reg (tree decl, int i) return; fixed_regs[i] = call_used_regs[i] = 1; -#ifdef CALL_REALLY_USED_REGISTERS - call_really_used_regs[i] = 1; -#endif SET_HARD_REG_BIT (fixed_reg_set, i); Index: gcc/config/csky/csky.h =================================================================== --- gcc/config/csky/csky.h 2019-03-08 18:15:39.172730955 +0000 +++ gcc/config/csky/csky.h 2019-09-10 17:23:08.706251661 +0100 @@ -428,34 +428,6 @@ #define FIXED_REGISTERS \ 1 \ } -/* 1 for registers that is clobbered (in general) by function calls. - If a register has 0, the compiler automatically saves it on - function entry and restores it on function exit, if the register - is used within the function. */ -#define CALL_USED_REGISTERS \ - /* r0 r1 r2 r3 r4 r5 r6 r7 */ \ -{ 1, 1, 1, 1, 0, 0, 0, 0, \ - /* r8 r9 r10 r11 r12 r13 r14 r15 */ \ - 0, 0, 0, 0, 1, 1, 1, 0, \ - /* r16 r17 r18 r19 r20 r21 r22 r23 */ \ - 0, 0, 1, 1, 1, 1, 1, 1, \ - /* r24 r25 r26 r27 r28 r29 r30 r31 */ \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - /* reserved c hi lo */ \ - 1, 1, 1, 1, \ - /* reserved */ \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - /* vr0 vr1 vr2 vr3 vr4 vr5 vr6 vr7 */ \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - /* vr8 vr9 vr10 vr11 vr12 vr13 vr14 vr15 */ \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - /* reserved */ \ - 1, 1, \ - /* epc */ \ - 1 \ -} - /* Like `CALL_USED_REGISTERS' but used to overcome a historical problem which makes CALL_USED_REGISTERS *always* include all the FIXED_REGISTERS. Until this problem has been Index: gcc/config/csky/csky.c =================================================================== --- gcc/config/csky/csky.c 2019-08-20 09:53:06.626416200 +0100 +++ gcc/config/csky/csky.c 2019-09-10 17:23:08.706251661 +0100 @@ -1655,7 +1655,7 @@ get_csky_live_regs (int *count) break; /* Caller-saved registers marked as used. */ - if (df_regs_ever_live_p (reg) && !call_really_used_regs[reg]) + if (df_regs_ever_live_p (reg) && !call_used_regs[reg]) save = true; /* Frame pointer marked used. */ @@ -2074,7 +2074,6 @@ csky_conditional_register_usage (void) { fixed_regs[i] = 1; call_used_regs[i] = 1; - call_really_used_regs[i] = 1; } } /* For some targets, the high registers are not supported. @@ -2090,7 +2089,6 @@ csky_conditional_register_usage (void) { fixed_regs[i] = 1; call_used_regs[i] = 1; - call_really_used_regs[i] = 1; } } @@ -2103,8 +2101,7 @@ csky_conditional_register_usage (void) if (CSKY_TARGET_ARCH (CK801) || CSKY_TARGET_ARCH (CK802)) { fixed_regs[CSKY_LR_REGNUM] = 1; - call_used_regs[CSKY_LR_REGNUM] = 1; - call_really_used_regs[CSKY_LR_REGNUM] = 0; + call_used_regs[CSKY_LR_REGNUM] = 0; } /* The hi/lo registers are only supported in dsp mode. */ @@ -2112,11 +2109,9 @@ csky_conditional_register_usage (void) { fixed_regs[CSKY_HI_REGNUM] = 1; call_used_regs[CSKY_HI_REGNUM] = 1; - call_really_used_regs[CSKY_HI_REGNUM] = 1; fixed_regs[CSKY_LO_REGNUM] = 1; call_used_regs[CSKY_LO_REGNUM] = 1; - call_really_used_regs[CSKY_LO_REGNUM] = 1; } /* The V_REGS are only supported in hard float mode. */ @@ -2129,18 +2124,16 @@ csky_conditional_register_usage (void) { fixed_regs[regno] = 1; call_used_regs[regno] = 1; - call_really_used_regs[regno] = 1; } } /* In pic mode, the gb register is not available for register allocation. Since gb is not clobbered by function - calls, set its call_really_used_regs to 0. */ + calls, set its call_used_regs to 0. */ if (flag_pic) { fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - call_really_used_regs[PIC_OFFSET_TABLE_REGNUM] = 0; + call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 0; } } Index: gcc/config/ia64/ia64.h =================================================================== --- gcc/config/ia64/ia64.h 2019-03-08 18:15:38.016735349 +0000 +++ gcc/config/ia64/ia64.h 2019-09-10 17:23:08.710251633 +0100 @@ -371,41 +371,6 @@ #define FIXED_REGISTERS \ 1, 1, 1, 1, 1, 1 \ } -/* Like `FIXED_REGISTERS' but has 1 for each register that is clobbered - (in general) by function calls as well as for fixed registers. This - macro therefore identifies the registers that are not available for - general allocation of values that must live across function calls. */ - -#define CALL_USED_REGISTERS \ -{ /* General registers. */ \ - 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, \ - /* Floating-point registers. */ \ - 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - /* Predicate registers. */ \ - 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - /* Branch registers. */ \ - 1, 0, 0, 0, 0, 0, 1, 1, \ - /*FP CCV UNAT PFS LC EC */ \ - 1, 1, 1, 1, 1, 1 \ -} - /* Like `CALL_USED_REGISTERS' but used to overcome a historical problem which makes CALL_USED_REGISTERS *always* include all the FIXED_REGISTERS. Until this problem has been Index: gcc/config/ia64/ia64.c =================================================================== --- gcc/config/ia64/ia64.c 2019-09-10 17:22:54.050354133 +0100 +++ gcc/config/ia64/ia64.c 2019-09-10 17:23:08.710251633 +0100 @@ -6054,7 +6054,7 @@ fix_range (const char *const_str) } for (i = first; i <= last; ++i) - fixed_regs[i] = call_used_regs[i] = 1; + fixed_regs[i] = 1; if (!comma) break; Index: gcc/config/m32r/m32r.h =================================================================== --- gcc/config/m32r/m32r.h 2019-03-08 18:15:37.040739057 +0000 +++ gcc/config/m32r/m32r.h 2019-09-10 17:23:08.710251633 +0100 @@ -348,7 +348,7 @@ #define FIXED_REGISTERS \ #define SUBTARGET_CALL_USED_REGISTERS #endif -#define CALL_USED_REGISTERS \ +#define CALL_REALLY_USED_REGISTERS \ { \ 1, 1, 1, 1, 1, 1, 1, 1, \ 0, 0, 0, 0, 0, 0, 1, 1, \ @@ -356,8 +356,6 @@ #define CALL_USED_REGISTERS \ SUBTARGET_CALL_USED_REGISTERS \ } -#define CALL_REALLY_USED_REGISTERS CALL_USED_REGISTERS - /* If defined, an initializer for a vector of integers, containing the numbers of hard registers in the order in which GCC should prefer to use them (from most preferred to least). */ Index: gcc/config/m32r/m32r.c =================================================================== --- gcc/config/m32r/m32r.c 2019-08-20 09:53:06.634416142 +0100 +++ gcc/config/m32r/m32r.c 2019-09-10 17:23:08.710251633 +0100 @@ -1526,7 +1526,7 @@ #define RETURN_ADDR_MASK (1 << (RETURN Don't consider them here. */ #define MUST_SAVE_REGISTER(regno, interrupt_p) \ ((regno) != RETURN_ADDR_REGNUM && (regno) != FRAME_POINTER_REGNUM \ - && (df_regs_ever_live_p (regno) && (!call_really_used_regs[regno] || interrupt_p))) + && (df_regs_ever_live_p (regno) && (!call_used_regs[regno] || interrupt_p))) #define MUST_SAVE_FRAME_POINTER (df_regs_ever_live_p (FRAME_POINTER_REGNUM)) #define MUST_SAVE_RETURN_ADDR (df_regs_ever_live_p (RETURN_ADDR_REGNUM) || crtl->profile) @@ -2927,10 +2927,7 @@ m32r_legitimate_address_p (machine_mode m32r_conditional_register_usage (void) { if (flag_pic) - { - fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - } + fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; } /* Implement TARGET_LEGITIMATE_CONSTANT_P Index: gcc/config/mips/mips.h =================================================================== --- gcc/config/mips/mips.h 2019-07-01 09:37:07.300523814 +0100 +++ gcc/config/mips/mips.h 2019-09-10 17:23:08.718251576 +0100 @@ -1817,29 +1817,6 @@ #define FIXED_REGISTERS \ called function in tact. EPILOGUE_USES says that $31 is useful to the called function. */ -#define CALL_USED_REGISTERS \ -{ \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - /* COP0 registers */ \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - /* COP2 registers */ \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - /* COP3 registers */ \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ - /* 6 DSP accumulator registers & 6 control registers */ \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 \ -} - - -/* Define this since $28, though fixed, is call-saved in many ABIs. */ - #define CALL_REALLY_USED_REGISTERS \ { /* General registers. */ \ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ Index: gcc/config/mips/mips.c =================================================================== --- gcc/config/mips/mips.c 2019-09-09 18:59:20.852063281 +0100 +++ gcc/config/mips/mips.c 2019-09-10 17:23:08.718251576 +0100 @@ -10636,7 +10636,7 @@ mips_global_pointer (void) if (TARGET_CALL_SAVED_GP && crtl->is_leaf) for (regno = GP_REG_FIRST; regno <= GP_REG_LAST; regno++) if (!df_regs_ever_live_p (regno) - && call_really_used_regs[regno] + && call_used_regs[regno] && !fixed_regs[regno] && regno != PIC_FUNCTION_ADDR_REGNUM) return regno; @@ -10789,7 +10789,7 @@ mips_interrupt_extra_call_saved_reg_p (u /* Otherwise, return true for registers that aren't ordinarily call-clobbered. */ - return call_really_used_regs[regno]; + return call_used_regs[regno]; } return false; @@ -10812,12 +10812,12 @@ mips_cfun_call_saved_reg_p (unsigned int return true; /* call_insns preserve $28 unless they explicitly say otherwise, - so call_really_used_regs[] treats $28 as call-saved. However, + so call_used_regs[] treats $28 as call-saved. However, we want the ABI property rather than the default call_insn property here. */ return (regno == GLOBAL_POINTER_REGNUM ? TARGET_CALL_SAVED_GP - : !call_really_used_regs[regno]); + : !call_used_regs[regno]); } /* Return true if the function body might clobber register REGNO. @@ -20411,7 +20411,6 @@ #define SWAP_STRING(X, Y) (tmps = (X), ( SWAP_INT (fixed_regs[i], fixed_regs[i + 1]); SWAP_INT (call_used_regs[i], call_used_regs[i + 1]); - SWAP_INT (call_really_used_regs[i], call_really_used_regs[i + 1]); SWAP_STRING (reg_names[i], reg_names[i + 1]); #undef SWAP_STRING @@ -20447,7 +20446,7 @@ mips_conditional_register_usage (void) accessible_reg_set &= ~reg_class_contents[ST_REGS]; if (!ISA_HAS_CCF) SET_HARD_REG_BIT (accessible_reg_set, FPSW_REGNUM); - fixed_regs[FPSW_REGNUM] = call_used_regs[FPSW_REGNUM] = 1; + fixed_regs[FPSW_REGNUM] = 1; } if (TARGET_MIPS16) { @@ -20462,25 +20461,25 @@ mips_conditional_register_usage (void) and $25 (t9) because it is used as the function call address in SVR4 PIC code. */ - fixed_regs[18] = call_used_regs[18] = 1; - fixed_regs[19] = call_used_regs[19] = 1; - fixed_regs[20] = call_used_regs[20] = 1; - fixed_regs[21] = call_used_regs[21] = 1; - fixed_regs[22] = call_used_regs[22] = 1; - fixed_regs[23] = call_used_regs[23] = 1; - fixed_regs[26] = call_used_regs[26] = 1; - fixed_regs[27] = call_used_regs[27] = 1; - fixed_regs[30] = call_used_regs[30] = 1; + fixed_regs[18] = 1; + fixed_regs[19] = 1; + fixed_regs[20] = 1; + fixed_regs[21] = 1; + fixed_regs[22] = 1; + fixed_regs[23] = 1; + fixed_regs[26] = 1; + fixed_regs[27] = 1; + fixed_regs[30] = 1; if (optimize_size) { - fixed_regs[8] = call_used_regs[8] = 1; - fixed_regs[9] = call_used_regs[9] = 1; - fixed_regs[10] = call_used_regs[10] = 1; - fixed_regs[11] = call_used_regs[11] = 1; - fixed_regs[12] = call_used_regs[12] = 1; - fixed_regs[13] = call_used_regs[13] = 1; - fixed_regs[14] = call_used_regs[14] = 1; - fixed_regs[15] = call_used_regs[15] = 1; + fixed_regs[8] = 1; + fixed_regs[9] = 1; + fixed_regs[10] = 1; + fixed_regs[11] = 1; + fixed_regs[12] = 1; + fixed_regs[13] = 1; + fixed_regs[14] = 1; + fixed_regs[15] = 1; } /* Do not allow HI and LO to be treated as register operands. @@ -20493,7 +20492,7 @@ mips_conditional_register_usage (void) { int regno; for (regno = FP_REG_FIRST + 20; regno < FP_REG_FIRST + 24; regno++) - call_really_used_regs[regno] = call_used_regs[regno] = 1; + call_used_regs[regno] = 1; } /* Odd registers in the range $f21-$f31 (inclusive) are call-clobbered for n32 and o32 FP64. */ @@ -20503,7 +20502,7 @@ mips_conditional_register_usage (void) { int regno; for (regno = FP_REG_FIRST + 21; regno <= FP_REG_FIRST + 31; regno+=2) - call_really_used_regs[regno] = call_used_regs[regno] = 1; + call_used_regs[regno] = 1; } /* Make sure that double-register accumulator values are correctly ordered for the current endianness. */ Index: gcc/config/mn10300/mn10300.h =================================================================== --- gcc/config/mn10300/mn10300.h 2019-03-08 18:15:37.904735774 +0000 +++ gcc/config/mn10300/mn10300.h 2019-09-10 17:23:08.718251576 +0100 @@ -197,7 +197,7 @@ #define FIXED_REGISTERS \ Aside from that, you can include as many other registers as you like. */ -#define CALL_USED_REGISTERS \ +#define CALL_REALLY_USED_REGISTERS \ { 1, 1, 0, 0, /* data regs */ \ 1, 1, 0, 0, /* addr regs */ \ 1, /* arg reg */ \ @@ -211,13 +211,6 @@ #define CALL_USED_REGISTERS \ 1 /* cc reg */ \ } -/* Note: The definition of CALL_REALLY_USED_REGISTERS is not - redundant. It is needed when compiling in PIC mode because - the a2 register becomes fixed (and hence must be marked as - call_used) but in order to preserve the ABI it is not marked - as call_really_used. */ -#define CALL_REALLY_USED_REGISTERS CALL_USED_REGISTERS - #define REG_ALLOC_ORDER \ { 0, 1, 4, 5, 2, 3, 6, 7, 10, 11, 12, 13, 14, 15, 16, 17, 8, 9 \ , 42, 43, 44, 45, 46, 47, 48, 49, 34, 35, 36, 37, 38, 39, 40, 41 \ Index: gcc/config/mn10300/mn10300.c =================================================================== --- gcc/config/mn10300/mn10300.c 2019-08-20 09:53:16.214346430 +0100 +++ gcc/config/mn10300/mn10300.c 2019-09-10 17:23:08.718251576 +0100 @@ -552,7 +552,7 @@ fp_regs_to_save (void) return 0; for (i = FIRST_FP_REGNUM; i <= LAST_FP_REGNUM; ++i) - if (df_regs_ever_live_p (i) && ! call_really_used_regs[i]) + if (df_regs_ever_live_p (i) && ! call_used_regs[i]) ++n; return n; @@ -640,7 +640,7 @@ mn10300_get_live_callee_saved_regs (unsi count = mask = 0; for (i = 0; i <= LAST_EXTENDED_REGNUM; i++) - if (df_regs_ever_live_p (i) && ! call_really_used_regs[i]) + if (df_regs_ever_live_p (i) && ! call_used_regs[i]) { mask |= (1 << i); ++ count; @@ -878,7 +878,7 @@ #define SIZE_FMOV_SP(S,N) (SIZE_FMOV_SP_ frame pointer, size is nonzero and the user hasn't changed the calling conventions of a0. */ if (! frame_pointer_needed && size - && call_really_used_regs [FIRST_ADDRESS_REGNUM] + && call_used_regs[FIRST_ADDRESS_REGNUM] && ! fixed_regs[FIRST_ADDRESS_REGNUM]) { /* Insn: add -(size + 4 * num_regs_to_save), sp. */ @@ -902,7 +902,7 @@ #define SIZE_FMOV_SP(S,N) (SIZE_FMOV_SP_ /* Consider alternative save_a0_no_merge if the user hasn't changed the calling conventions of a0. */ - if (call_really_used_regs [FIRST_ADDRESS_REGNUM] + if (call_used_regs[FIRST_ADDRESS_REGNUM] && ! fixed_regs[FIRST_ADDRESS_REGNUM]) { /* Insn: add -4 * num_regs_to_save, sp. */ @@ -984,7 +984,7 @@ #define SIZE_FMOV_SP(S,N) (SIZE_FMOV_SP_ /* Now actually save the FP registers. */ for (i = FIRST_FP_REGNUM; i <= LAST_FP_REGNUM; ++i) - if (df_regs_ever_live_p (i) && ! call_really_used_regs [i]) + if (df_regs_ever_live_p (i) && ! call_used_regs[i]) { rtx addr; @@ -1118,7 +1118,7 @@ mn10300_expand_epilogue (void) /* Consider using a1 in post-increment mode, as long as the user hasn't changed the calling conventions of a1. */ - if (call_really_used_regs [FIRST_ADDRESS_REGNUM + 1] + if (call_used_regs[FIRST_ADDRESS_REGNUM + 1] && ! fixed_regs[FIRST_ADDRESS_REGNUM+1]) { /* Insn: mov sp,a1. */ @@ -1186,7 +1186,7 @@ mn10300_expand_epilogue (void) reg = gen_rtx_POST_INC (SImode, reg); for (i = FIRST_FP_REGNUM; i <= LAST_FP_REGNUM; ++i) - if (df_regs_ever_live_p (i) && ! call_really_used_regs [i]) + if (df_regs_ever_live_p (i) && ! call_used_regs[i]) { rtx addr; @@ -2830,17 +2830,16 @@ mn10300_conditional_register_usage (void { for (i = FIRST_EXTENDED_REGNUM; i <= LAST_EXTENDED_REGNUM; i++) - fixed_regs[i] = call_used_regs[i] = 1; + fixed_regs[i] = 1; } if (!TARGET_AM33_2) { for (i = FIRST_FP_REGNUM; i <= LAST_FP_REGNUM; i++) - fixed_regs[i] = call_used_regs[i] = 1; + fixed_regs[i] = 1; } if (flag_pic) - fixed_regs[PIC_OFFSET_TABLE_REGNUM] = - call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; + fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; } /* Worker function for TARGET_MD_ASM_ADJUST. Index: gcc/config/rs6000/rs6000.h =================================================================== --- gcc/config/rs6000/rs6000.h 2019-08-05 17:46:20.813722877 +0100 +++ gcc/config/rs6000/rs6000.h 2019-09-10 17:23:08.722251548 +0100 @@ -882,31 +882,6 @@ #define FIXED_REGISTERS \ 1, 1, 1 \ } -/* 1 for registers not available across function calls. - These must include the FIXED_REGISTERS and also any - registers that can be used without being saved. - The latter must include the registers where values are returned - and the register where structure-value addresses are passed. - Aside from that, you can include as many other registers as you like. */ - -#define CALL_USED_REGISTERS \ - {/* GPRs */ \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, FIXED_R13, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - /* FPRs */ \ - 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - /* VRs */ \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ - /* lr ctr ca ap */ \ - 1, 1, 1, 1, \ - /* cr0..cr7 */ \ - 1, 1, 0, 0, 0, 1, 1, 1, \ - /* vrsave vscr sfp */ \ - 1, 1, 1 \ -} - /* Like `CALL_USED_REGISTERS' except this macro doesn't require that the entire set of `FIXED_REGISTERS' be included. (`CALL_USED_REGISTERS' must be a superset of `FIXED_REGISTERS'). Index: gcc/config/rs6000/rs6000.c =================================================================== --- gcc/config/rs6000/rs6000.c 2019-09-10 17:22:54.078353939 +0100 +++ gcc/config/rs6000/rs6000.c 2019-09-10 17:23:08.722251548 +0100 @@ -8904,42 +8904,37 @@ rs6000_conditional_register_usage (void) /* 64-bit AIX and Linux reserve GPR13 for thread-private data. */ if (TARGET_64BIT) - fixed_regs[13] = call_used_regs[13] - = call_really_used_regs[13] = 1; + fixed_regs[13] = call_used_regs[13] = 1; /* Conditionally disable FPRs. */ if (TARGET_SOFT_FLOAT) for (i = 32; i < 64; i++) - fixed_regs[i] = call_used_regs[i] - = call_really_used_regs[i] = 1; + fixed_regs[i] = call_used_regs[i] = 1; /* The TOC register is not killed across calls in a way that is visible to the compiler. */ if (DEFAULT_ABI == ABI_AIX || DEFAULT_ABI == ABI_ELFv2) - call_really_used_regs[2] = 0; + call_used_regs[2] = 0; if (DEFAULT_ABI == ABI_V4 && flag_pic == 2) fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1; if (DEFAULT_ABI == ABI_V4 && flag_pic == 1) fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] - = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] - = call_really_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1; + = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1; if (DEFAULT_ABI == ABI_DARWIN && flag_pic) fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] - = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] - = call_really_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1; + = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1; if (TARGET_TOC && TARGET_MINIMAL_TOC) - fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] - = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1; + fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1; if (!TARGET_ALTIVEC && !TARGET_VSX) { for (i = FIRST_ALTIVEC_REGNO; i <= LAST_ALTIVEC_REGNO; ++i) - fixed_regs[i] = call_used_regs[i] = call_really_used_regs[i] = 1; - call_really_used_regs[VRSAVE_REGNO] = 1; + fixed_regs[i] = call_used_regs[i] = 1; + call_used_regs[VRSAVE_REGNO] = 1; } if (TARGET_ALTIVEC || TARGET_VSX) @@ -8948,12 +8943,12 @@ rs6000_conditional_register_usage (void) if (TARGET_ALTIVEC_ABI) { for (i = FIRST_ALTIVEC_REGNO; i < FIRST_ALTIVEC_REGNO + 20; ++i) - call_used_regs[i] = call_really_used_regs[i] = 1; + call_used_regs[i] = 1; /* AIX reserves VR20:31 in non-extended ABI mode. */ if (TARGET_XCOFF) for (i = FIRST_ALTIVEC_REGNO + 20; i < FIRST_ALTIVEC_REGNO + 32; ++i) - fixed_regs[i] = call_used_regs[i] = call_really_used_regs[i] = 1; + fixed_regs[i] = call_used_regs[i] = 1; } } Index: gcc/config/s390/s390.h =================================================================== --- gcc/config/s390/s390.h 2019-04-18 13:28:51.035821466 +0100 +++ gcc/config/s390/s390.h 2019-09-10 17:23:08.726251519 +0100 @@ -453,22 +453,6 @@ #define FIXED_REGISTERS \ 0, 0, 0, 0, \ 0, 0, 0, 0 } -#define CALL_USED_REGISTERS \ -{ 1, 1, 1, 1, \ - 1, 1, 0, 0, \ - 0, 0, 0, 0, \ - 0, 1, 1, 1, \ - 1, 1, 1, 1, \ - 1, 1, 1, 1, \ - 1, 1, 1, 1, \ - 1, 1, 1, 1, \ - 1, 1, 1, 1, \ - 1, 1, \ - 1, 1, 1, 1, \ - 1, 1, 1, 1, \ - 1, 1, 1, 1, \ - 1, 1, 1, 1 } - #define CALL_REALLY_USED_REGISTERS \ { 1, 1, 1, 1, /* r0 - r15 */ \ 1, 1, 0, 0, \ Index: gcc/config/s390/s390.c =================================================================== --- gcc/config/s390/s390.c 2019-09-10 17:22:54.082353911 +0100 +++ gcc/config/s390/s390.c 2019-09-10 17:23:08.722251548 +0100 @@ -9416,7 +9416,7 @@ s390_regs_ever_clobbered (char regs_ever if (!crtl->is_leaf) { for (i = 0; i < 32; i++) - regs_ever_clobbered[i] = call_really_used_regs[i]; + regs_ever_clobbered[i] = call_used_regs[i]; } /* Make the "magic" eh_return registers live if necessary. For regs_ever_live @@ -9438,7 +9438,7 @@ s390_regs_ever_clobbered (char regs_ever reload. */ if (crtl->saves_all_registers) for (i = 0; i < 32; i++) - if (!call_really_used_regs[i]) + if (!call_used_regs[i]) regs_ever_clobbered[i] = 1; FOR_EACH_BB_FN (cur_bb, cfun) @@ -9552,7 +9552,7 @@ s390_register_info_gprtofpr () /* Advance to the next FP register which can be used as a GPR save slot. */ - while ((!call_really_used_regs[save_reg_slot] + while ((!call_used_regs[save_reg_slot] || df_regs_ever_live_p (save_reg_slot) || cfun_fpr_save_p (save_reg_slot)) && FP_REGNO_P (save_reg_slot)) @@ -9711,7 +9711,7 @@ s390_register_info () cfun_frame_layout.fpr_bitmap = 0; cfun_frame_layout.high_fprs = 0; for (i = FPR0_REGNUM; i <= FPR15_REGNUM; i++) - if (clobbered_regs[i] && !call_really_used_regs[i]) + if (clobbered_regs[i] && !call_used_regs[i]) { cfun_set_fpr_save (i); if (i >= FPR8_REGNUM) @@ -10269,7 +10269,7 @@ s390_hard_regno_rename_ok (unsigned int df_regs_ever_live. Since we have our own routine we have to tell regrename manually about it. */ if (GENERAL_REGNO_P (new_reg) - && !call_really_used_regs[new_reg] + && !call_used_regs[new_reg] && cfun_gpr_save_slot (new_reg) == SAVE_SLOT_NONE) return false; @@ -10284,7 +10284,7 @@ s390_hard_regno_scratch_ok (unsigned int { /* See s390_hard_regno_rename_ok. */ if (GENERAL_REGNO_P (regno) - && !call_really_used_regs[regno] + && !call_used_regs[regno] && cfun_gpr_save_slot (regno) == SAVE_SLOT_NONE) return false; @@ -11129,10 +11129,10 @@ s390_emit_prologue (void) /* If f4 and f6 are call clobbered they are saved due to stdargs and therefore are not frame related. */ - if (!call_really_used_regs[i]) + if (!call_used_regs[i]) RTX_FRAME_RELATED_P (insn) = 1; } - else if (!TARGET_PACKED_STACK || call_really_used_regs[i]) + else if (!TARGET_PACKED_STACK || call_used_regs[i]) offset += 8; } @@ -11585,7 +11585,7 @@ s390_emit_epilogue (bool sibcall) s300_set_up_by_prologue (hard_reg_set_container *regs) { if (cfun->machine->base_reg - && !call_really_used_regs[REGNO (cfun->machine->base_reg)]) + && !call_used_regs[REGNO (cfun->machine->base_reg)]) SET_HARD_REG_BIT (regs->set, REGNO (cfun->machine->base_reg)); } @@ -11786,7 +11786,7 @@ s390_can_use_return_insn (void) return false; if (cfun->machine->base_reg - && !call_really_used_regs[REGNO (cfun->machine->base_reg)]) + && !call_used_regs[REGNO (cfun->machine->base_reg)]) return false; return cfun_frame_layout.frame_size == 0; @@ -13543,36 +13543,31 @@ s390_conditional_register_usage (void) int i; if (flag_pic) - { - fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - } + fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; fixed_regs[BASE_REGNUM] = 0; - call_used_regs[BASE_REGNUM] = 0; fixed_regs[RETURN_REGNUM] = 0; - call_used_regs[RETURN_REGNUM] = 0; if (TARGET_64BIT) { for (i = FPR8_REGNUM; i <= FPR15_REGNUM; i++) - call_used_regs[i] = call_really_used_regs[i] = 0; + call_used_regs[i] = 0; } else { - call_used_regs[FPR4_REGNUM] = call_really_used_regs[FPR4_REGNUM] = 0; - call_used_regs[FPR6_REGNUM] = call_really_used_regs[FPR6_REGNUM] = 0; + call_used_regs[FPR4_REGNUM] = 0; + call_used_regs[FPR6_REGNUM] = 0; } if (TARGET_SOFT_FLOAT) { for (i = FPR0_REGNUM; i <= FPR15_REGNUM; i++) - call_used_regs[i] = fixed_regs[i] = 1; + fixed_regs[i] = 1; } /* Disable v16 - v31 for non-vector target. */ if (!TARGET_VX) { for (i = VR16_REGNUM; i <= VR31_REGNUM; i++) - fixed_regs[i] = call_used_regs[i] = call_really_used_regs[i] = 1; + fixed_regs[i] = call_used_regs[i] = 1; } } @@ -13662,8 +13657,8 @@ s390_optimize_prologue (void) fpr_regno = FP_REGNO_P (src_regno) ? src_regno : dest_regno; /* GPR must be call-saved, FPR must be call-clobbered. */ - if (!call_really_used_regs[fpr_regno] - || call_really_used_regs[gpr_regno]) + if (!call_used_regs[fpr_regno] + || call_used_regs[gpr_regno]) continue; /* It must not happen that what we once saved in an FPR now Index: gcc/config/sh/sh.h =================================================================== --- gcc/config/sh/sh.h 2019-03-08 18:15:37.560737082 +0000 +++ gcc/config/sh/sh.h 2019-09-10 17:23:08.726251519 +0100 @@ -732,45 +732,6 @@ #define FIXED_REGISTERS \ 1, 1, 1, 1, \ } -/* 1 for registers not available across function calls. - These must include the FIXED_REGISTERS and also any - registers that can be used without being saved. - The latter must include the registers where values are returned - and the register where structure-value addresses are passed. - Aside from that, you can include as many other registers as you like. */ -#define CALL_USED_REGISTERS \ -{ \ -/* Regular registers. */ \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - /* R8 and R9 are call-clobbered on SH5, but not on earlier SH ABIs. \ - Only the lower 32bits of R10-R14 are guaranteed to be preserved \ - across SH5 function calls. */ \ - 0, 0, 0, 0, 0, 0, 0, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 0, 0, 0, 0, \ - 0, 0, 0, 0, 1, 1, 1, 1, \ - 1, 1, 1, 1, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 1, 1, 1, 1, \ -/* FP registers. */ \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 0, 0, 0, 0, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 0, \ -/* Branch target registers. */ \ - 1, 1, 1, 1, 1, 0, 0, 0, \ -/* XD registers. */ \ - 1, 1, 1, 1, 1, 1, 0, 0, \ -/*"gbr", "ap", "pr", "t", "mach", "macl", "fpul", "fpscr", */ \ - 1, 1, 1, 1, 1, 1, 1, 1, \ -/*"rap", "sfp","fpscr0","fpscr1" */ \ - 1, 1, 1, 1, \ -} - /* CALL_REALLY_USED_REGISTERS is used as a default setting, which is then overridden by -fcall-saved-* and -fcall-used-* options and then by TARGET_CONDITIONAL_REGISTER_USAGE. There we might want to make a Index: gcc/config/sh/sh.c =================================================================== --- gcc/config/sh/sh.c 2019-09-10 17:22:54.086353882 +0100 +++ gcc/config/sh/sh.c 2019-09-10 17:23:08.726251519 +0100 @@ -6703,7 +6703,7 @@ output_stack_adjust (int size, rtx reg, to handle this case, so just die when we see it. */ if (epilogue_p < 0 || current_function_interrupt - || ! call_really_used_regs[temp] || fixed_regs[temp]) + || ! call_used_regs[temp] || fixed_regs[temp]) temp = -1; if (temp < 0 && ! current_function_interrupt && epilogue_p >= 0) { @@ -7009,7 +7009,7 @@ calc_live_regs (HARD_REG_SET *live_regs_ else if (TARGET_FPU_DOUBLE && TARGET_FMOVD && TARGET_FPU_SINGLE) for (int count = 0, reg = FIRST_FP_REG; reg <= LAST_FP_REG; reg += 2) if (df_regs_ever_live_p (reg) && df_regs_ever_live_p (reg+1) - && (! call_really_used_regs[reg] + && (! call_used_regs[reg] || interrupt_handler) && ++count > 2) { @@ -7040,7 +7040,7 @@ calc_live_regs (HARD_REG_SET *live_regs_ : interrupt_handler ? (/* Need to save all the regs ever live. */ (df_regs_ever_live_p (reg) - || (call_really_used_regs[reg] + || (call_used_regs[reg] && (! fixed_regs[reg] || reg == MACH_REG || reg == MACL_REG || reg == PIC_OFFSET_TABLE_REGNUM) && has_call)) @@ -7053,7 +7053,7 @@ calc_live_regs (HARD_REG_SET *live_regs_ : (/* Only push those regs which are used and need to be saved. */ (false) || (df_regs_ever_live_p (reg) - && ((!call_really_used_regs[reg] + && ((!call_used_regs[reg] && !(reg != PIC_OFFSET_TABLE_REGNUM && fixed_regs[reg] && call_used_or_fixed_reg_p (reg))) @@ -8289,7 +8289,7 @@ sh_fix_range (const char *const_str) } for (int i = first; i <= last; ++i) - fixed_regs[i] = call_used_regs[i] = 1; + fixed_regs[i] = 1; if (!comma) break; @@ -8809,7 +8809,7 @@ reg_unused_after (rtx reg, rtx_insn *ins if (set == NULL && reg_overlap_mentioned_p (reg, PATTERN (insn))) return false; - if (code == CALL_INSN && call_really_used_regs[REGNO (reg)]) + if (code == CALL_INSN && call_used_regs[REGNO (reg)]) return true; } return true; @@ -11447,32 +11447,28 @@ sh_conditional_register_usage (void) { for (int regno = 0; regno < FIRST_PSEUDO_REGISTER; regno ++) if (! VALID_REGISTER_P (regno)) - fixed_regs[regno] = call_used_regs[regno] = 1; + fixed_regs[regno] = 1; /* R8 and R9 are call-clobbered on SH5, but not on earlier SH ABIs. */ if (flag_pic) - { - fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - } + fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; if (TARGET_FDPIC) { fixed_regs[PIC_REG] = 1; call_used_regs[PIC_REG] = 1; - call_really_used_regs[PIC_REG] = 1; } /* Renesas saves and restores mac registers on call. */ if (TARGET_HITACHI && ! TARGET_NOMACSAVE) { - call_really_used_regs[MACH_REG] = 0; - call_really_used_regs[MACL_REG] = 0; + call_used_regs[MACH_REG] = 0; + call_used_regs[MACL_REG] = 0; } for (int regno = FIRST_GENERAL_REG; regno <= LAST_GENERAL_REG; regno++) - if (! fixed_regs[regno] && call_really_used_regs[regno]) + if (! fixed_regs[regno] && call_used_regs[regno]) SET_HARD_REG_BIT (reg_class_contents[SIBCALL_REGS], regno); - call_really_used_regs[FPSCR_MODES_REG] = 0; - call_really_used_regs[FPSCR_STAT_REG] = 0; + call_used_regs[FPSCR_MODES_REG] = 0; + call_used_regs[FPSCR_STAT_REG] = 0; } /* Implement TARGET_LEGITIMATE_CONSTANT_P Index: gcc/config/sparc/sparc.h =================================================================== --- gcc/config/sparc/sparc.h 2019-07-01 09:37:06.052534266 +0100 +++ gcc/config/sparc/sparc.h 2019-09-10 17:23:08.726251519 +0100 @@ -678,31 +678,6 @@ #define FIXED_REGISTERS \ 0, 0, 0, 0, 1, 1, 1} /* 1 for registers not available across function calls. - These must include the FIXED_REGISTERS and also any - registers that can be used without being saved. - The latter must include the registers where values are returned - and the register where structure-value addresses are passed. - Aside from that, you can include as many other registers as you like. */ - -#define CALL_USED_REGISTERS \ - {1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 0, 0, 0, 0, 0, 0, 0, 0, \ - 0, 0, 0, 0, 0, 0, 0, 1, \ - \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - 1, 1, 1, 1, 1, 1, 1, 1, \ - \ - 1, 1, 1, 1, 1, 1, 1} - -/* 1 for registers not available across function calls. Unlike the above, this need not include the FIXED_REGISTERS, but any registers that can be used without being saved. The latter must include the registers where values are returned Index: gcc/config/sparc/sparc.c =================================================================== --- gcc/config/sparc/sparc.c 2019-09-10 17:22:54.086353882 +0100 +++ gcc/config/sparc/sparc.c 2019-09-10 17:23:08.726251519 +0100 @@ -13008,10 +13008,7 @@ sparc_can_eliminate (const int from ATTR sparc_conditional_register_usage (void) { if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM) - { - fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - } + fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; /* If the user has passed -f{fixed,call-{used,saved}}-g5 */ /* then honor it. */ if (TARGET_ARCH32 && fixed_regs[5]) Index: gcc/config/tilegx/tilegx.h =================================================================== --- gcc/config/tilegx/tilegx.h 2019-03-08 18:15:37.460737462 +0000 +++ gcc/config/tilegx/tilegx.h 2019-09-10 17:23:08.726251519 +0100 @@ -114,16 +114,13 @@ #define FIXED_REGISTERS \ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1, 1} -#define CALL_USED_REGISTERS \ +#define CALL_REALLY_USED_REGISTERS \ {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1, 1} -#define CALL_REALLY_USED_REGISTERS \ - CALL_USED_REGISTERS - #define REG_ALLOC_ORDER { \ 10, 11, 12, 13, 14, /* call used */ \ 15, 16, 17, 18, 19, \ Index: gcc/config/tilegx/tilegx.c =================================================================== --- gcc/config/tilegx/tilegx.c 2019-09-10 17:23:00.794307202 +0100 +++ gcc/config/tilegx/tilegx.c 2019-09-10 17:23:08.726251519 +0100 @@ -4341,20 +4341,11 @@ tilegx_eh_return_handler_rtx (void) tilegx_conditional_register_usage (void) { global_regs[TILEGX_NETORDER_REGNUM] = 1; - /* TILEGX_PIC_TEXT_LABEL_REGNUM is conditionally used. It is a - member of fixed_regs, and therefore must be member of - call_used_regs, but it is not a member of call_really_used_regs[] - because it is not clobbered by a call. */ + /* TILEGX_PIC_TEXT_LABEL_REGNUM is conditionally used. */ if (TILEGX_PIC_TEXT_LABEL_REGNUM != INVALID_REGNUM) - { - fixed_regs[TILEGX_PIC_TEXT_LABEL_REGNUM] = 1; - call_used_regs[TILEGX_PIC_TEXT_LABEL_REGNUM] = 1; - } + fixed_regs[TILEGX_PIC_TEXT_LABEL_REGNUM] = 1; if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM) - { - fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - } + fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; } Index: gcc/config/tilepro/tilepro.h =================================================================== --- gcc/config/tilepro/tilepro.h 2019-03-08 18:15:38.568733251 +0000 +++ gcc/config/tilepro/tilepro.h 2019-09-10 17:23:08.730251493 +0100 @@ -79,16 +79,13 @@ #define FIXED_REGISTERS \ 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1} -#define CALL_USED_REGISTERS \ +#define CALL_REALLY_USED_REGISTERS \ {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1} -#define CALL_REALLY_USED_REGISTERS \ - CALL_USED_REGISTERS - #define REG_ALLOC_ORDER { \ 10, 11, 12, 13, 14, /* call used */ \ 15, 16, 17, 18, 19, \ Index: gcc/config/tilepro/tilepro.c =================================================================== --- gcc/config/tilepro/tilepro.c 2019-09-10 17:23:00.794307202 +0100 +++ gcc/config/tilepro/tilepro.c 2019-09-10 17:23:08.730251493 +0100 @@ -3864,20 +3864,11 @@ tilepro_eh_return_handler_rtx (void) tilepro_conditional_register_usage (void) { global_regs[TILEPRO_NETORDER_REGNUM] = 1; - /* TILEPRO_PIC_TEXT_LABEL_REGNUM is conditionally used. It is a - member of fixed_regs, and therefore must be member of - call_used_regs, but it is not a member of call_really_used_regs[] - because it is not clobbered by a call. */ + /* TILEPRO_PIC_TEXT_LABEL_REGNUM is conditionally used. */ if (TILEPRO_PIC_TEXT_LABEL_REGNUM != INVALID_REGNUM) - { - fixed_regs[TILEPRO_PIC_TEXT_LABEL_REGNUM] = 1; - call_used_regs[TILEPRO_PIC_TEXT_LABEL_REGNUM] = 1; - } + fixed_regs[TILEPRO_PIC_TEXT_LABEL_REGNUM] = 1; if (PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM) - { - fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; - } + fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1; } Index: gcc/config/visium/visium.h =================================================================== --- gcc/config/visium/visium.h 2019-07-01 09:37:07.312523714 +0100 +++ gcc/config/visium/visium.h 2019-09-10 17:23:08.730251493 +0100 @@ -488,27 +488,6 @@ #define FIXED_REGISTERS \ 0, 0, 0, 0, 0, 0, 0, 0, /* f8 .. f15 */ \ 1, 1, 1 } /* flags, arg, frame */ -/* `CALL_USED_REGISTERS' - - Like `FIXED_REGISTERS' but has 1 for each register that is - clobbered (in general) by function calls as well as for fixed - registers. This macro therefore identifies the registers that are - not available for general allocation of values that must live - across function calls. - - If a register has 0 in `CALL_USED_REGISTERS', the compiler - automatically saves it on function entry and restores it on - function exit, if the register is used within the function. */ -#define CALL_USED_REGISTERS \ - { 1, 1, 1, 1, 1, 1, 1, 1, /* r0 .. r7 */ \ - 1, 1, 1, 0, 0, 0, 0, 0, /* r8 .. r15 */ \ - 0, 0, 0, 0, 1, 1, 0, 1, /* r16 .. r23 */ \ - 1, 1, 1, 1, 1, 1, 1, 1, /* r24 .. r31 */ \ - 1, 1, /* mdb, mdc */ \ - 1, 1, 1, 1, 1, 1, 1, 1, /* f0 .. f7 */ \ - 1, 0, 0, 0, 0, 0, 0, 0, /* f8 .. f15 */ \ - 1, 1, 1 } /* flags, arg, frame */ - /* Like `CALL_USED_REGISTERS' except this macro doesn't require that the entire set of `FIXED_REGISTERS' be included. (`CALL_USED_REGISTERS' must be a superset of `FIXED_REGISTERS'). Index: gcc/config/visium/visium.c =================================================================== --- gcc/config/visium/visium.c 2019-09-10 17:22:54.090353853 +0100 +++ gcc/config/visium/visium.c 2019-09-10 17:23:08.730251493 +0100 @@ -754,20 +754,20 @@ visium_conditional_register_usage (void) { if (visium_cpu_and_features == PROCESSOR_GR5) { - fixed_regs[24] = call_used_regs[24] = 1; - fixed_regs[25] = call_used_regs[25] = 1; - fixed_regs[26] = call_used_regs[26] = 1; - fixed_regs[27] = call_used_regs[27] = 1; - fixed_regs[28] = call_used_regs[28] = 1; - call_really_used_regs[24] = 0; - call_really_used_regs[25] = 0; - call_really_used_regs[26] = 0; - call_really_used_regs[27] = 0; - call_really_used_regs[28] = 0; + fixed_regs[24] = 1; + fixed_regs[25] = 1; + fixed_regs[26] = 1; + fixed_regs[27] = 1; + fixed_regs[28] = 1; + call_used_regs[24] = 0; + call_used_regs[25] = 0; + call_used_regs[26] = 0; + call_used_regs[27] = 0; + call_used_regs[28] = 0; } - fixed_regs[31] = call_used_regs[31] = 1; - call_really_used_regs[31] = 0; + fixed_regs[31] = 1; + call_used_regs[31] = 0; /* We also need to change the long-branch register. */ if (visium_cpu_and_features == PROCESSOR_GR5) @@ -781,8 +781,8 @@ visium_conditional_register_usage (void) { for (int i = FP_FIRST_REGNUM; i <= FP_LAST_REGNUM; i++) { - fixed_regs[i] = call_used_regs[i] = 1; - call_really_used_regs[i] = 0; + fixed_regs[i] = 1; + call_used_regs[i] = 0; } } }