From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 1401 invoked by alias); 18 Jan 2004 19:54:39 -0000 Mailing-List: contact gcc-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Archive: List-Post: List-Help: Sender: gcc-owner@gcc.gnu.org Received: (qmail 1390 invoked from network); 18 Jan 2004 19:54:36 -0000 Received: from unknown (HELO yosemite.airs.com) (209.128.65.135) by sources.redhat.com with SMTP; 18 Jan 2004 19:54:36 -0000 Received: (qmail 4061 invoked by uid 10); 18 Jan 2004 19:54:36 -0000 Received: (qmail 21936 invoked by uid 500); 18 Jan 2004 19:54:29 -0000 From: Ian Lance Taylor To: "Kaveh R. Ghazi" Cc: gcc@gcc.gnu.org Subject: Re: Can we speed up the gcc_target structure? References: <20040118083738.10772.qmail@gossamer.airs.com> <200401181357.i0IDvpWF004706@caip.rutgers.edu> Date: Sun, 18 Jan 2004 19:54:00 -0000 In-Reply-To: <200401181357.i0IDvpWF004706@caip.rutgers.edu> Message-ID: User-Agent: Gnus/5.09 (Gnus v5.9.0) Emacs/21.2 MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii X-SW-Source: 2004-01/txt/msg01186.txt.bz2 "Kaveh R. Ghazi" writes: > I recently had an offline discussion with Zack et al where I tried to > prove the same point. I did almost exactly the same thing you did, > however my results showed only a 0.3% diff, about one tenth the impact > you saw. > > Beyond the difference in hardware, I'd like to know if anything else > might explain how your results vary so much from mine. I've included > some detail from the original offline message below so that my results > are reproducible. > > E.g. I'd like to know what you compiled and at what optimization level > when you measured the speed change. > > Since my results were so small, I didn't bother suggesting we undo or > "fix" it. However your if your results are more typical we may want > to consider doing something to reduce the impact. I have to admit that testing with some test cases from Bugzilla I'm only seeing about a 1% improvement. I see that with, e.g., the C++ test case from PR 2692. For only 1%, I don't know whether this is worth pursuing. On the other hand, I only converted part of the target vector, and the problem is likely to get worse over time. This is compiling without optimization. I've appended the patch I'm using. Note that I would expect better results from this patch than from yours, since I'm actually eliminating function calls entirely and replacing them with constants. Ian Index: builtins.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/builtins.c,v retrieving revision 1.275 diff -p -u -r1.275 builtins.c --- builtins.c 15 Jan 2004 07:25:21 -0000 1.275 +++ builtins.c 18 Jan 2004 19:11:16 -0000 @@ -924,7 +924,7 @@ apply_args_size (void) /* The second value is the structure value address unless this is passed as an "invisible" first argument. */ - if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0)) + if (TARGETM_CALLS_STRUCT_VALUE_RTX (cfun ? TREE_TYPE (cfun->decl) : 0, 0)) size += GET_MODE_SIZE (Pmode); for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++) @@ -1099,7 +1099,7 @@ expand_builtin_apply_args_1 (void) rtx registers, tem; int size, align, regno; enum machine_mode mode; - rtx struct_incoming_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 1); + rtx struct_incoming_value = TARGETM_CALLS_STRUCT_VALUE_RTX (cfun ? TREE_TYPE (cfun->decl) : 0, 1); /* Create a block where the arg-pointer, structure value address, and argument registers can be saved. */ @@ -1107,7 +1107,7 @@ expand_builtin_apply_args_1 (void) /* Walk past the arg-pointer and structure value address. */ size = GET_MODE_SIZE (Pmode); - if (targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0)) + if (TARGETM_CALLS_STRUCT_VALUE_RTX (cfun ? TREE_TYPE (cfun->decl) : 0, 0)) size += GET_MODE_SIZE (Pmode); /* Save each register used in calling a function to the block. */ @@ -1201,7 +1201,7 @@ expand_builtin_apply (rtx function, rtx rtx incoming_args, result, reg, dest, src, call_insn; rtx old_stack_level = 0; rtx call_fusage = 0; - rtx struct_value = targetm.calls.struct_value_rtx (cfun ? TREE_TYPE (cfun->decl) : 0, 0); + rtx struct_value = TARGETM_CALLS_STRUCT_VALUE_RTX (cfun ? TREE_TYPE (cfun->decl) : 0, 0); arguments = convert_memory_address (Pmode, arguments); @@ -3792,7 +3792,7 @@ expand_builtin_saveregs (void) start_sequence (); /* Do whatever the machine needs done in this case. */ - val = targetm.calls.expand_builtin_saveregs (); + val = TARGETM_CALLS_EXPAND_BUILTIN_SAVEREGS (); seq = get_insns (); end_sequence (); Index: c-decl.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/c-decl.c,v retrieving revision 1.470 diff -p -u -r1.470 c-decl.c --- c-decl.c 13 Jan 2004 02:52:33 -0000 1.470 +++ c-decl.c 18 Jan 2004 19:11:18 -0000 @@ -2669,7 +2669,7 @@ start_decl (tree declarator, tree declsp decl_attributes (&decl, attributes, 0); if (TREE_CODE (decl) == FUNCTION_DECL - && targetm.calls.promote_prototypes (TREE_TYPE (decl))) + && TARGETM_CALLS_PROMOTE_PROTOTYPES (TREE_TYPE (decl))) { tree ce = declarator; @@ -5908,7 +5908,7 @@ store_parm_decls_oldstyle (void) useful for argument types like uid_t. */ DECL_ARG_TYPE (parm) = TREE_TYPE (parm); - if (targetm.calls.promote_prototypes (TREE_TYPE (current_function_decl)) + if (TARGETM_CALLS_PROMOTE_PROTOTYPES (TREE_TYPE (current_function_decl)) && INTEGRAL_TYPE_P (TREE_TYPE (parm)) && TYPE_PRECISION (TREE_TYPE (parm)) < TYPE_PRECISION (integer_type_node)) @@ -6061,7 +6061,7 @@ finish_function (void) } if (TREE_CODE (fndecl) == FUNCTION_DECL - && targetm.calls.promote_prototypes (TREE_TYPE (fndecl))) + && TARGETM_CALLS_PROMOTE_PROTOTYPES (TREE_TYPE (fndecl))) { tree args = DECL_ARGUMENTS (fndecl); for (; args; args = TREE_CHAIN (args)) Index: c-typeck.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/c-typeck.c,v retrieving revision 1.272 diff -p -u -r1.272 c-typeck.c --- c-typeck.c 16 Jan 2004 07:20:28 -0000 1.272 +++ c-typeck.c 18 Jan 2004 19:11:20 -0000 @@ -1915,7 +1915,7 @@ convert_arguments (tree typelist, tree v (char *) 0, /* arg passing */ fundecl, name, parmnum + 1); - if (targetm.calls.promote_prototypes (fundecl ? TREE_TYPE (fundecl) : 0) + if (TARGETM_CALLS_PROMOTE_PROTOTYPES (fundecl ? TREE_TYPE (fundecl) : 0) && INTEGRAL_TYPE_P (type) && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) parmval = default_conversion (parmval); @@ -3683,7 +3683,7 @@ c_convert_parm_for_inlining (tree parm, ret = convert_for_assignment (type, value, (char *) 0 /* arg passing */, fn, DECL_NAME (fn), argnum); - if (targetm.calls.promote_prototypes (TREE_TYPE (fn)) + if (TARGETM_CALLS_PROMOTE_PROTOTYPES (TREE_TYPE (fn)) && INTEGRAL_TYPE_P (type) && (TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node))) ret = default_conversion (ret); Index: calls.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/calls.c,v retrieving revision 1.315 diff -p -u -r1.315 calls.c --- calls.c 16 Jan 2004 01:44:06 -0000 1.315 +++ calls.c 18 Jan 2004 19:11:21 -0000 @@ -1192,7 +1192,7 @@ initialize_argument_information (int num mode = TYPE_MODE (type); unsignedp = TREE_UNSIGNED (type); - if (targetm.calls.promote_function_args (fndecl ? TREE_TYPE (fndecl) : 0)) + if (TARGETM_CALLS_PROMOTE_FUNCTION_ARGS (fndecl ? TREE_TYPE (fndecl) : 0)) mode = promote_mode (type, mode, &unsignedp, 1); args[i].unsignedp = unsignedp; @@ -2030,7 +2030,7 @@ fix_unsafe_tree (tree t) static bool shift_returned_value (tree type, rtx *value) { - if (targetm.calls.return_in_msb (type)) + if (TARGETM_CALLS_RETURN_IN_MSB (type)) { HOST_WIDE_INT shift; @@ -2226,7 +2226,7 @@ expand_call (tree exp, rtx target, int i flags |= flags_from_decl_or_type (TREE_TYPE (TREE_TYPE (p))); } - struct_value = targetm.calls.struct_value_rtx (fndecl ? TREE_TYPE (fndecl) : 0, 0); + struct_value = TARGETM_CALLS_STRUCT_VALUE_RTX (fndecl ? TREE_TYPE (fndecl) : 0, 0); /* Warn if this value is an aggregate type, regardless of which calling convention we are using for it. */ @@ -2406,28 +2406,28 @@ expand_call (tree exp, rtx target, int i /* Compute number of named args. Normally, don't include the last named arg if anonymous args follow. We do include the last named arg if - targetm.calls.strict_argument_naming() returns nonzero. + TARGETM_CALLS_STRICT_ARGUMENT_NAMING() returns nonzero. (If no anonymous args follow, the result of list_length is actually one too large. This is harmless.) - If targetm.calls.pretend_outgoing_varargs_named() returns - nonzero, and targetm.calls.strict_argument_naming() returns zero, + If TARGETM_CALLS_PRETEND_OUTGOING_VARARGS_NAMED() returns + nonzero, and TARGETM_CALLS_STRICT_ARGUMENT_NAMING() returns zero, this machine will be able to place unnamed args that were passed in registers into the stack. So treat all args as named. This allows the insns emitting for a specific argument list to be independent of the function declaration. - If targetm.calls.pretend_outgoing_varargs_named() returns zero, + If TARGETM_CALLS_PRETEND_OUTGOING_VARARGS_NAMED() returns zero, we do not have any reliable way to pass unnamed args in registers, so we must force them into memory. */ - if ((targetm.calls.strict_argument_naming (&args_so_far) - || ! targetm.calls.pretend_outgoing_varargs_named (&args_so_far)) + if ((TARGETM_CALLS_STRICT_ARGUMENT_NAMING (&args_so_far) + || ! TARGETM_CALLS_PRETEND_OUTGOING_VARARGS_NAMED (&args_so_far)) && type_arg_types != 0) n_named_args = (list_length (type_arg_types) /* Don't include the last named arg. */ - - (targetm.calls.strict_argument_naming (&args_so_far) ? 0 : 1) + - (TARGETM_CALLS_STRICT_ARGUMENT_NAMING (&args_so_far) ? 0 : 1) /* Count the struct value address, if it is passed as a parm. */ + structure_value_addr_parm); else @@ -3344,7 +3344,7 @@ expand_call (tree exp, rtx target, int i target = copy_to_reg (valreg); } - if (targetm.calls.promote_function_return(funtype)) + if (TARGETM_CALLS_PROMOTE_FUNCTION_RETURN(funtype)) { /* If we promoted this return value, make the proper SUBREG. TARGET might be const0_rtx here, so be careful. */ @@ -3685,7 +3685,7 @@ emit_library_call_value_1 (int retval, r int initial_highest_arg_in_use = highest_outgoing_arg_in_use; char *initial_stack_usage_map = stack_usage_map; - rtx struct_value = targetm.calls.struct_value_rtx (0, 0); + rtx struct_value = TARGETM_CALLS_STRUCT_VALUE_RTX (0, 0); #ifdef REG_PARM_STACK_SPACE #ifdef MAYBE_REG_PARM_STACK_SPACE Index: combine.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/combine.c,v retrieving revision 1.400 diff -p -u -r1.400 combine.c --- combine.c 12 Jan 2004 19:42:42 -0000 1.400 +++ combine.c 18 Jan 2004 19:11:25 -0000 @@ -806,7 +806,7 @@ setup_incoming_promotions (void) int unsignedp; rtx first = get_insns (); - if (targetm.calls.promote_function_args (TREE_TYPE (cfun->decl))) + if (TARGETM_CALLS_PROMOTE_FUNCTION_ARGS (TREE_TYPE (cfun->decl))) { #ifndef OUTGOING_REGNO #define OUTGOING_REGNO(N) N Index: expr.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/expr.c,v retrieving revision 1.615 diff -p -u -r1.615 expr.c --- expr.c 13 Jan 2004 23:13:58 -0000 1.615 +++ expr.c 18 Jan 2004 19:11:28 -0000 @@ -2137,7 +2137,7 @@ copy_blkmode_from_reg (rtx tgtblk, rtx s holds if the structure is returned at the most significant end of the register. */ if (bytes % UNITS_PER_WORD != 0 - && (targetm.calls.return_in_msb (type) + && (TARGETM_CALLS_RETURN_IN_MSB (type) ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)) padding_correction Index: final.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/final.c,v retrieving revision 1.304 diff -p -u -r1.304 final.c --- final.c 9 Jan 2004 20:03:53 -0000 1.304 +++ final.c 18 Jan 2004 19:11:29 -0000 @@ -1406,7 +1406,7 @@ profile_function (FILE *file ATTRIBUTE_U #endif #if defined(ASM_OUTPUT_REG_PUSH) int sval = current_function_returns_struct; - rtx svrtx = targetm.calls.struct_value_rtx (TREE_TYPE (current_function_decl), 1); + rtx svrtx = TARGETM_CALLS_STRUCT_VALUE_RTX (TREE_TYPE (current_function_decl), 1); #if defined(STATIC_CHAIN_INCOMING_REGNUM) || defined(STATIC_CHAIN_REGNUM) int cxt = current_function_needs_context; #endif Index: function.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/function.c,v retrieving revision 1.483 diff -p -u -r1.483 function.c --- function.c 13 Jan 2004 01:58:35 -0000 1.483 +++ function.c 18 Jan 2004 19:11:31 -0000 @@ -4242,7 +4242,7 @@ aggregate_value_p (tree exp, tree fntype if (TREE_CODE (type) == VOID_TYPE) return 0; - if (targetm.calls.return_in_memory (type, fntype)) + if (TARGETM_CALLS_RETURN_IN_MEMORY (type, fntype)) return 1; /* Types that are TREE_ADDRESSABLE must be constructed in memory, and thus can't be returned in registers. */ @@ -4321,7 +4321,7 @@ assign_parms (tree fndecl) /* If struct value address is treated as the first argument, make it so. */ if (aggregate_value_p (DECL_RESULT (fndecl), fndecl) && ! current_function_returns_pcc_struct - && targetm.calls.struct_value_rtx (TREE_TYPE (fndecl), 1) == 0) + && TARGETM_CALLS_STRUCT_VALUE_RTX (TREE_TYPE (fndecl), 1) == 0) { tree type = build_pointer_type (TREE_TYPE (fntype)); @@ -4391,7 +4391,7 @@ assign_parms (tree fndecl) /* Set NAMED_ARG if this arg should be treated as a named arg. For most machines, if this is a varargs/stdarg function, then we treat the last named arg as if it were anonymous too. */ - named_arg = targetm.calls.strict_argument_naming (&args_so_far) ? 1 : ! last_named; + named_arg = TARGETM_CALLS_STRICT_ARGUMENT_NAMING (&args_so_far) ? 1 : ! last_named; if (TREE_TYPE (parm) == error_mark_node /* This can happen after weird syntax errors @@ -4456,7 +4456,7 @@ assign_parms (tree fndecl) promoted_mode = passed_mode; - if (targetm.calls.promote_function_args (TREE_TYPE (fndecl))) + if (TARGETM_CALLS_PROMOTE_FUNCTION_ARGS (TREE_TYPE (fndecl))) { /* Compute the mode in which the arg is actually extended to. */ unsignedp = TREE_UNSIGNED (passed_type); @@ -4489,7 +4489,7 @@ assign_parms (tree fndecl) if (last_named && !varargs_setup) { int varargs_pretend_bytes = 0; - targetm.calls.setup_incoming_varargs (&args_so_far, promoted_mode, + TARGETM_CALLS_SETUP_INCOMING_VARARGS (&args_so_far, promoted_mode, passed_type, &varargs_pretend_bytes, 0); varargs_setup = 1; @@ -4520,7 +4520,7 @@ assign_parms (tree fndecl) if (!in_regs && !named_arg) { int pretend_named = - targetm.calls.pretend_outgoing_varargs_named (&args_so_far); + TARGETM_CALLS_PRETEND_OUTGOING_VARARGS_NAMED (&args_so_far); if (pretend_named) { #ifdef FUNCTION_INCOMING_ARG Index: stmt.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/stmt.c,v retrieving revision 1.342 diff -p -u -r1.342 stmt.c --- stmt.c 16 Jan 2004 07:20:28 -0000 1.342 +++ stmt.c 18 Jan 2004 19:11:35 -0000 @@ -2963,7 +2963,7 @@ shift_return_value (rtx val) tree type; type = TREE_TYPE (DECL_RESULT (current_function_decl)); - if (targetm.calls.return_in_msb (type)) + if (TARGETM_CALLS_RETURN_IN_MSB (type)) { rtx target; HOST_WIDE_INT shift; @@ -3010,7 +3010,7 @@ expand_value_return (rtx val) if (return_reg != val) { tree type = TREE_TYPE (DECL_RESULT (current_function_decl)); - if (targetm.calls.promote_function_return (TREE_TYPE (current_function_decl))) + if (TARGETM_CALLS_PROMOTE_FUNCTION_RETURN (TREE_TYPE (current_function_decl))) { int unsignedp = TREE_UNSIGNED (type); enum machine_mode old_mode @@ -3172,7 +3172,7 @@ expand_return (tree retval) holds if the structure is returned at the most significant end of the register. */ if (bytes % UNITS_PER_WORD != 0 - && (targetm.calls.return_in_msb (TREE_TYPE (retval_rhs)) + && (TARGETM_CALLS_RETURN_IN_MSB (TREE_TYPE (retval_rhs)) ? !BYTES_BIG_ENDIAN : BYTES_BIG_ENDIAN)) padding_correction = (BITS_PER_WORD - ((bytes % UNITS_PER_WORD) Index: target.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/target.h,v retrieving revision 1.74 diff -p -u -r1.74 target.h --- target.h 14 Jan 2004 21:59:30 -0000 1.74 +++ target.h 18 Jan 2004 19:11:35 -0000 @@ -433,9 +434,63 @@ struct gcc_target tree type, int *pretend_arg_size, int second_time); bool (*strict_argument_naming) (CUMULATIVE_ARGS *ca); /* Returns true if we should use SETUP_INCOMING_VARARGS and/or - targetm.calls.strict_argument_naming(). */ + TARGETM_CALLS_STRICT_ARGUMENT_NAMING(). */ bool (*pretend_outgoing_varargs_named) (CUMULATIVE_ARGS *ca); } calls; }; extern struct gcc_target targetm; + +#ifndef TARGETM_CALLS_PROMOTE_FUNCTION_ARGS +#define TARGETM_CALLS_PROMOTE_FUNCTION_ARGS(FNTYPE) \ + targetm.calls.promote_function_args ((FNTYPE)) +#endif + +#ifndef TARGETM_CALLS_PROMOTE_FUNCTION_RETURN +#define TARGETM_CALLS_PROMOTE_FUNCTION_RETURN(FNTYPE) \ + targetm.calls.promote_function_return ((FNTYPE)) +#endif + +#ifndef TARGETM_CALLS_PROMOTE_PROTOTYPES +#define TARGETM_CALLS_PROMOTE_PROTOTYPES(FNTYPE) \ + targetm.calls.promote_prototypes ((FNTYPE)) +#endif + +#ifndef TARGETM_CALLS_STRUCT_VALUE_RTX +#define TARGETM_CALLS_STRUCT_VALUE_RTX(FNDECL, INCOMING) \ + targetm.calls.struct_value_rtx ((FNDECL), (INCOMING)) +#endif + +#ifndef TARGETM_CALLS_RETURN_IN_MEMORY +#define TARGETM_CALLS_RETURN_IN_MEMORY(TYPE, FNDECL) \ + targetm.calls.return_in_memory ((TYPE), (FNDECL)) +#endif + +#ifndef TARGETM_CALLS_RETURN_IN_MSB +#define TARGETM_CALLS_RETURN_IN_MSB(TYPE) \ + targetm.calls.return_in_msb ((TYPE)) +#endif + +#ifndef TARGETM_CALLS_EXPAND_BUILTIN_SAVEREGS +#define TARGETM_CALLS_EXPAND_BUILTIN_SAVEREGS() \ + targetm.calls.expand_builtin_saveregs () +#endif + +#ifndef TARGETM_CALLS_SETUP_INCOMING_VARARGS +#define TARGETM_CALLS_SETUP_INCOMING_VARARGS(CA, MODE, TYPE, \ + PRETEND_ARG_SIZE, \ + SECOND_TIME) \ + targetm.calls.setup_incoming_varargs ((CA), (MODE), (TYPE), \ + (PRETEND_ARG_SIZE), \ + (SECOND_TIME)) +#endif + +#ifndef TARGETM_CALLS_STRICT_ARGUMENT_NAMING +#define TARGETM_CALLS_STRICT_ARGUMENT_NAMING(CA) \ + targetm.calls.strict_argument_naming((CA)) +#endif + +#ifndef TARGETM_CALLS_PRETEND_OUTGOING_VARARGS_NAMED +#define TARGETM_CALLS_PRETEND_OUTGOING_VARARGS_NAMED(CA) \ + targetm.calls.pretend_outgoing_varargs_named((CA)) +#endif Index: targhooks.c =================================================================== RCS file: /cvs/gcc/gcc/gcc/targhooks.c,v retrieving revision 2.12 diff -p -u -r2.12 targhooks.c --- targhooks.c 15 Jan 2004 07:21:03 -0000 2.12 +++ targhooks.c 18 Jan 2004 19:11:35 -0000 @@ -184,7 +184,7 @@ default_pretend_outgoing_varargs_named(C #ifdef SETUP_INCOMING_VARARGS return 1; #else - return (targetm.calls.setup_incoming_varargs != default_setup_incoming_varargs); + return (TARGETM_CALLS_SETUP_INCOMING_VARARGS != default_setup_incoming_varargs); #endif } Index: config/i386/i386.h =================================================================== RCS file: /cvs/gcc/gcc/gcc/config/i386/i386.h,v retrieving revision 1.368 diff -p -u -r1.368 i386.h --- config/i386/i386.h 14 Jan 2004 23:07:04 -0000 1.368 +++ config/i386/i386.h 18 Jan 2004 19:11:39 -0000 @@ -3172,6 +3172,21 @@ struct machine_function GTY(()) #define X86_FILE_START_VERSION_DIRECTIVE false #define X86_FILE_START_FLTUSED false +#define TARGETM_CALLS_PROMOTE_FUNCTION_ARGS(FNTYPE) false +#define TARGETM_CALLS_PROMOTE_FUNCTION_RETURN(FNTYPE) false +#define TARGETM_CALLS_PROMOTE_PROTOTYPES(FNTYPE) true +#define TARGETM_CALLS_STRUCT_VALUE_RTX(FNDECL, INCOMING) 0 +#define TARGETM_CALLS_RETURN_IN_MEMORY(TYPE, FNDECL) RETURN_IN_MEMORY (type) +#define TARGETM_CALLS_RETURN_IN_MSB(TYPE) false +#define TARGETM_CALLS_SETUP_INCOMING_VARARGS(CA, MODE, TYPE, \ + PRETEND_ARG_SIZE, \ + SECOND_TIME) \ + SETUP_INCOMING_VARARGS ((*CA), (MODE), (TYPE), (*PRETEND_ARG_SIZE), \ + (SECOND_TIME)) +#define TARGETM_CALLS_STRICT_ARGUMENT_NAMING(CA) 0 +#define TARGETM_CALLS_PRETEND_OUTGOING_VARARGS_NAMED(CA) 1 + + /* Local variables: version-control: t