tm.texi.in (FUNCTION_ARG_PADDING): Mention TARGET_FUNCTION_ARG_ROUND_BOUNDARY.

	* doc/tm.texi.in (FUNCTION_ARG_PADDING): Mention
	TARGET_FUNCTION_ARG_ROUND_BOUNDARY.
	(TARGET_FUNCTION_ARG_ROUND_BOUNDARY): Add hook.
	* function.c (locate_and_pad_parm): Take it into account.
	* target.def (function_arg_round_boundary): New hook.
	* targhooks.c (default_function_arg_round_boundary): New function.
	* targhooks.h (default_function_arg_round_boundary): Declare.
	* doc/tm.texi: Regenerate.

From-SVN: r176207

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index d519a80a74a8dd410c2740036a35bcd55bbc30e3..903c11733d9e5264beb586702ed6b6176d256d99 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,14 @@
+2011-07-12  Bernd Schmidt  <bernds@codesourcery.com>
+
+       * doc/tm.texi.in (FUNCTION_ARG_PADDING): Mention
+       TARGET_FUNCTION_ARG_ROUND_BOUNDARY.
+       (TARGET_FUNCTION_ARG_ROUND_BOUNDARY): Add hook.
+       * function.c (locate_and_pad_parm): Take it into account.
+       * target.def (function_arg_round_boundary): New hook.
+       * targhooks.c (default_function_arg_round_boundary): New function.
+       * targhooks.h (default_function_arg_round_boundary): Declare.
+       * doc/tm.texi: Regenerate.
+
 2011-07-12  Richard Guenther  <rguenther@suse.de>
 
        * tree-ssa-copyrename.c (rename_ssa_copies): Zero statistics.

diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi
index c0648a5657cc2cae6701c7ddf30688f6ca209895..faf8b6c66f8017c0d349509a3f28a185d7d638d6 100644 (file)
--- a/gcc/doc/tm.texi
+++ b/gcc/doc/tm.texi
@@ -4180,9 +4180,9 @@ to pad out an argument with extra space.  The value should be of type
 @code{enum direction}: either @code{upward} to pad above the argument,
 @code{downward} to pad below, or @code{none} to inhibit padding.
 
-The @emph{amount} of padding is always just enough to reach the next
-multiple of @code{TARGET_FUNCTION_ARG_BOUNDARY}; this macro does not
-control it.
+The @emph{amount} of padding is not controlled by this macro, but by the
+target hook @code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}.  It is
+always just enough to reach the next multiple of that boundary. 
 
 This macro has a default definition which is right for most systems.
 For little-endian machines, the default is to pad upward.  For
@@ -4215,6 +4215,13 @@ with the specified mode and type.  The default hook returns
 @code{PARM_BOUNDARY} for all arguments.
 @end deftypefn
 
+@deftypefn {Target Hook} {unsigned int} TARGET_FUNCTION_ARG_ROUND_BOUNDARY (enum machine_mode @var{mode}, const_tree @var{type})
+Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},
+which is the default value for this hook.  You can define this hook to
+return a different value if an argument size must be rounded to a larger
+value.
+@end deftypefn
+
 @defmac FUNCTION_ARG_REGNO_P (@var{regno})
 A C expression that is nonzero if @var{regno} is the number of a hard
 register in which function arguments are sometimes passed.  This does

diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in
index 3660d36d7b56de9fb18176e312654bfdd6a73720..d823faeed538a70e1f95214d65bdf176e3e764c9 100644 (file)
--- a/gcc/doc/tm.texi.in
+++ b/gcc/doc/tm.texi.in
@@ -4166,9 +4166,9 @@ to pad out an argument with extra space.  The value should be of type
 @code{enum direction}: either @code{upward} to pad above the argument,
 @code{downward} to pad below, or @code{none} to inhibit padding.
 
-The @emph{amount} of padding is always just enough to reach the next
-multiple of @code{TARGET_FUNCTION_ARG_BOUNDARY}; this macro does not
-control it.
+The @emph{amount} of padding is not controlled by this macro, but by the
+target hook @code{TARGET_FUNCTION_ARG_ROUND_BOUNDARY}.  It is
+always just enough to reach the next multiple of that boundary. 
 
 This macro has a default definition which is right for most systems.
 For little-endian machines, the default is to pad upward.  For
@@ -4201,6 +4201,8 @@ with the specified mode and type.  The default hook returns
 @code{PARM_BOUNDARY} for all arguments.
 @end deftypefn
 
+@hook TARGET_FUNCTION_ARG_ROUND_BOUNDARY
+
 @defmac FUNCTION_ARG_REGNO_P (@var{regno})
 A C expression that is nonzero if @var{regno} is the number of a hard
 register in which function arguments are sometimes passed.  This does

diff --git a/gcc/function.c b/gcc/function.c
index 0b2f5aa5c378616a09d150df2b652a3520eafb6c..894930f75bb34fa76b55b74728d50ad4a371394e 100644 (file)
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -3705,7 +3705,7 @@ locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs,
 {
   tree sizetree;
   enum direction where_pad;
-  unsigned int boundary;
+  unsigned int boundary, round_boundary;
   int reg_parm_stack_space = 0;
   int part_size_in_regs;
 
@@ -3737,6 +3737,8 @@ locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs,
     = type ? size_in_bytes (type) : size_int (GET_MODE_SIZE (passed_mode));
   where_pad = FUNCTION_ARG_PADDING (passed_mode, type);
   boundary = targetm.calls.function_arg_boundary (passed_mode, type);
+  round_boundary = targetm.calls.function_arg_round_boundary (passed_mode,
+                                                             type);
   locate->where_pad = where_pad;
 
   /* Alignment can't exceed MAX_SUPPORTED_STACK_ALIGNMENT.  */
@@ -3783,8 +3785,8 @@ locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs,
     tree s2 = sizetree;
     if (where_pad != none
        && (!host_integerp (sizetree, 1)
-           || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
-      s2 = round_up (s2, PARM_BOUNDARY / BITS_PER_UNIT);
+           || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % round_boundary))
+      s2 = round_up (s2, round_boundary / BITS_PER_UNIT);
     SUB_PARM_SIZE (locate->slot_offset, s2);
   }
 
@@ -3836,8 +3838,8 @@ locate_and_pad_parm (enum machine_mode passed_mode, tree type, int in_regs,
 
   if (where_pad != none
       && (!host_integerp (sizetree, 1)
-         || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % PARM_BOUNDARY))
-    sizetree = round_up (sizetree, PARM_BOUNDARY / BITS_PER_UNIT);
+         || (tree_low_cst (sizetree, 1) * BITS_PER_UNIT) % round_boundary))
+    sizetree = round_up (sizetree, round_boundary / BITS_PER_UNIT);
 
   ADD_PARM_SIZE (locate->size, sizetree);
 

diff --git a/gcc/target.def b/gcc/target.def
index c67f0bacf7f82c45f9dd677b27540fbfeaac5e06..9f03ac922ac5678157cb5eeb0dee9bd7df5b1a39 100644 (file)
--- a/gcc/target.def
+++ b/gcc/target.def
@@ -2021,6 +2021,15 @@ DEFHOOK
  unsigned int, (enum machine_mode mode, const_tree type),
  default_function_arg_boundary)
 
+DEFHOOK
+(function_arg_round_boundary,
+ "Normally, the size of an argument is rounded up to @code{PARM_BOUNDARY},\n\
+which is the default value for this hook.  You can define this hook to\n\
+return a different value if an argument size must be rounded to a larger\n\
+value.",
+ unsigned int, (enum machine_mode mode, const_tree type),
+ default_function_arg_round_boundary)
+
 /* Return the diagnostic message string if function without a prototype
    is not allowed for this 'val' argument; NULL otherwise. */
 DEFHOOK

diff --git a/gcc/targhooks.c b/gcc/targhooks.c
index bcb8a12bc4e35afd0f40ee1f6357d96ce5cf0f86..f69b39626a66650b25ff0ab7cf50c6cbc7395ac1 100644 (file)
--- a/gcc/targhooks.c
+++ b/gcc/targhooks.c
@@ -614,6 +614,13 @@ default_function_arg_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
   return PARM_BOUNDARY;
 }
 
+unsigned int
+default_function_arg_round_boundary (enum machine_mode mode ATTRIBUTE_UNUSED,
+                                    const_tree type ATTRIBUTE_UNUSED)
+{
+  return PARM_BOUNDARY;
+}
+
 void
 hook_void_bitmap (bitmap regs ATTRIBUTE_UNUSED)
 {

diff --git a/gcc/targhooks.h b/gcc/targhooks.h
index ce89d32afca7814733be64a6a9f2cb3b27894873..62e888445bb6a68983b5e9fad6ec5f81bb4aa909 100644 (file)
--- a/gcc/targhooks.h
+++ b/gcc/targhooks.h
@@ -115,6 +115,8 @@ extern rtx default_function_incoming_arg
   (cumulative_args_t, enum machine_mode, const_tree, bool);
 extern unsigned int default_function_arg_boundary (enum machine_mode,
                                                   const_tree);
+extern unsigned int default_function_arg_round_boundary (enum machine_mode,
+                                                        const_tree);
 extern bool hook_bool_const_rtx_commutative_p (const_rtx, int);
 extern rtx default_function_value (const_tree, const_tree, bool);
 extern rtx default_libcall_value (enum machine_mode, const_rtx);