Re: Can we speed up the gcc_target structure?

[Ian Lance Taylor <ian@wasabisystems.com>]

"Kaveh R. Ghazi" <ghazi@caip.rutgers.edu> 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