From patchwork Fri Oct 8 13:58:23 2010 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Nathan Froyd X-Patchwork-Id: 67219 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from sourceware.org (server1.sourceware.org [209.132.180.131]) by ozlabs.org (Postfix) with SMTP id 38952B70B8 for ; Sat, 9 Oct 2010 01:05:18 +1100 (EST) Received: (qmail 21519 invoked by alias); 8 Oct 2010 14:05:15 -0000 Received: (qmail 21507 invoked by uid 22791); 8 Oct 2010 14:05:13 -0000 X-SWARE-Spam-Status: No, hits=-1.8 required=5.0 tests=AWL, BAYES_00, T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from mail.codesourcery.com (HELO mail.codesourcery.com) (38.113.113.100) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Fri, 08 Oct 2010 14:05:07 +0000 Received: (qmail 30854 invoked from network); 8 Oct 2010 13:58:25 -0000 Received: from unknown (HELO codesourcery.com) (froydnj@127.0.0.2) by mail.codesourcery.com with ESMTPA; 8 Oct 2010 13:58:25 -0000 From: Nathan Froyd To: gcc-patches@gcc.gnu.org Cc: hp@axis.com Subject: [cris] hookize FUNCTION_ARG &co. Date: Fri, 8 Oct 2010 09:58:23 -0400 Message-Id: <1286546303-17408-1-git-send-email-froydnj@codesourcery.com> X-IsSubscribed: yes 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 The patch below hookizes FUNCTION_ARG and related macros for the cris backend. Nothing special here. Tested by inspection with cross to cris-elf. I plan to commit this under the obvious rule after waiting a week for comments/approval. * config/cris/cris.h (FUNCTION_ARG, FUNCTION_INCOMING_ARG): Delete. (FUNCTION_ARG_ADVANCE): Delete. * config/cris/cris.c (cris_function_arg_1, cris_function_arg): New functions. (cris_function_incoming_arg, cris_function_arg_advance): New functions. (TARGET_FUNCTION_ARG, TARGET_FUNCTION_INCOMING_ARG): Define. (TARGET_FUNCTION_ARG_ADVANCE): Define. --- gcc/config/cris/cris.c | 45 +++++++++++++++++++++++++++++++++++++++++++++ gcc/config/cris/cris.h | 18 ------------------ 2 files changed, 45 insertions(+), 18 deletions(-) diff --git a/gcc/config/cris/cris.c b/gcc/config/cris/cris.c index 3163022..e76568a 100644 --- a/gcc/config/cris/cris.c +++ b/gcc/config/cris/cris.c @@ -129,6 +129,12 @@ static bool cris_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode, const_tree, bool); static int cris_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode, tree, bool); +static rtx cris_function_arg (CUMULATIVE_ARGS *, enum machine_mode, + const_tree, bool); +static rtx cris_function_incoming_arg (CUMULATIVE_ARGS *, + enum machine_mode, const_tree, bool); +static void cris_function_arg_advance (CUMULATIVE_ARGS *, enum machine_mode, + const_tree, bool); static tree cris_md_asm_clobbers (tree, tree, tree); static bool cris_handle_option (size_t, const char *, int); @@ -207,6 +213,12 @@ int cris_cpu_version = CRIS_DEFAULT_CPU_VERSION; #define TARGET_PASS_BY_REFERENCE cris_pass_by_reference #undef TARGET_ARG_PARTIAL_BYTES #define TARGET_ARG_PARTIAL_BYTES cris_arg_partial_bytes +#undef TARGET_FUNCTION_ARG +#define TARGET_FUNCTION_ARG cris_function_arg +#undef TARGET_FUNCTION_INCOMING_ARG +#define TARGET_FUNCTION_INCOMING_ARG cris_function_incoming_arg +#undef TARGET_FUNCTION_ARG_ADVANCE +#define TARGET_FUNCTION_ARG_ADVANCE cris_function_arg_advance #undef TARGET_MD_ASM_CLOBBERS #define TARGET_MD_ASM_CLOBBERS cris_md_asm_clobbers #undef TARGET_DEFAULT_TARGET_FLAGS @@ -3893,6 +3905,39 @@ cris_arg_partial_bytes (CUMULATIVE_ARGS *ca, enum machine_mode mode, return 0; } +static rtx +cris_function_arg_1 (const CUMULATIVE_ARGS *ca, + enum machine_mode mode ATTRIBUTE_UNUSED, + const_tree type ATTRIBUTE_UNUSED, + bool named, bool incoming) +{ + if ((!incoming || named) && ca->regs < CRIS_MAX_ARGS_IN_REGS) + return gen_rtx_REG (mode, CRIS_FIRST_ARG_REG + ca->regs); + else + return NULL_RTX; +} + +static rtx +cris_function_arg (CUMULATIVE_ARGS *ca, enum machine_mode mode, + const_tree type, bool named) +{ + return cris_function_arg_1 (ca, mode, type, named, false); +} + +static rtx +cris_function_incoming_arg (CUMULATIVE_ARGS *ca, enum machine_mode mode, + const_tree type, bool named) +{ + return cris_function_arg_1 (ca, mode, type, named, true); +} + +static void +cris_function_arg_advance (CUMULATIVE_ARGS *ca, enum machine_mode mode, + const_tree type, bool named ATTRIBUTE_UNUSED) +{ + ca->regs += (3 + CRIS_FUNCTION_ARG_SIZE (mode, type)) / 4; +} + /* Worker function for TARGET_MD_ASM_CLOBBERS. */ static tree diff --git a/gcc/config/cris/cris.h b/gcc/config/cris/cris.h index 090bcd1..776c44e 100644 --- a/gcc/config/cris/cris.h +++ b/gcc/config/cris/cris.h @@ -848,21 +848,6 @@ enum reg_class /* Node: Register Arguments */ -/* The void_type_node is sent as a "closing" call. */ -#define FUNCTION_ARG(CUM, MODE, TYPE, NAMED) \ - ((CUM).regs < CRIS_MAX_ARGS_IN_REGS \ - ? gen_rtx_REG (MODE, (CRIS_FIRST_ARG_REG) + (CUM).regs) \ - : NULL_RTX) - -/* The differences between this and the previous, is that this one checks - that an argument is named, since incoming stdarg/varargs arguments are - pushed onto the stack, and we don't have to check against the "closing" - void_type_node TYPE parameter. */ -#define FUNCTION_INCOMING_ARG(CUM, MODE, TYPE, NAMED) \ - ((NAMED) && (CUM).regs < CRIS_MAX_ARGS_IN_REGS \ - ? gen_rtx_REG (MODE, CRIS_FIRST_ARG_REG + (CUM).regs) \ - : NULL_RTX) - /* Contrary to what you'd believe, defining FUNCTION_ARG_CALLEE_COPIES seems like a (small total) loss, at least for gcc-2.7.2 compiling and running gcc-2.1 (small win in size, small loss running -- 100.1%), @@ -880,9 +865,6 @@ struct cum_args {int regs;}; #define INIT_CUMULATIVE_ARGS(CUM, FNTYPE, LIBNAME, FNDECL, N_NAMED_ARGS) \ ((CUM).regs = 0) -#define FUNCTION_ARG_ADVANCE(CUM, MODE, TYPE, NAMED) \ - ((CUM).regs += (3 + CRIS_FUNCTION_ARG_SIZE (MODE, TYPE)) / 4) - #define FUNCTION_ARG_REGNO_P(REGNO) \ ((REGNO) >= CRIS_FIRST_ARG_REG \ && (REGNO) < CRIS_FIRST_ARG_REG + (CRIS_MAX_ARGS_IN_REGS))