* calls.c (initialize_argument_information): Add CALL_FROM_THUNK_P

	parameter.  Use it instead of current_function_is_thunk.
	* function.h (struct function): Update documentation for is_thunk.
	* tree.h (CALL_FROM_THUNK_P): New macro.
	* config/alpha/alpha.c (alpha_sa_mask): Do not check
	no_new_pseudos when testing current_function_is_thunk.
	* config/rs6000/rs6000.c (rs6000_ra_ever_killed): Likeiwse.

	* decl.c (cxx_push_function_context): Do not set
	current_function_is_thunk.
	* method.c (use_thunk): Set CALL_FROM_THUNK on the call to the
	actual function.

git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@77244 138bc75d-0d04-0410-961f-82ee72b054a4

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 3412b03..a75edd9 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,13 @@
+2004-02-04  Mark Mitchell  <mark@codesourcery.com>
+
+       * calls.c (initialize_argument_information): Add CALL_FROM_THUNK_P
+       parameter.  Use it instead of current_function_is_thunk.
+       * function.h (struct function): Update documentation for is_thunk.
+       * tree.h (CALL_FROM_THUNK_P): New macro.
+       * config/alpha/alpha.c (alpha_sa_mask): Do not check
+       no_new_pseudos when testing current_function_is_thunk.
+       * config/rs6000/rs6000.c (rs6000_ra_ever_killed): Likeiwse.
+
 2004-02-04  Kazu Hirata  <kazu@cs.umass.edu>
 
        * doc/tm.texi: Replace SETUP_INCOMING_VARARGS with

diff --git a/gcc/calls.c b/gcc/calls.c
index 7960bbc..607911c 100644 (file)
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -133,7 +133,8 @@ static int compute_argument_block_size (int, struct args_size *, int);
 static void initialize_argument_information (int, struct arg_data *,
                                             struct args_size *, int, tree,
                                             tree, CUMULATIVE_ARGS *, int,
-                                            rtx *, int *, int *, int *);
+                                            rtx *, int *, int *, int *,
+                                            bool);
 static void compute_argument_addresses (struct arg_data *, rtx, int);
 static rtx rtx_for_function_call (tree, tree);
 static void load_register_parameters (struct arg_data *, int, rtx *, int,
@@ -1023,7 +1024,10 @@ store_unaligned_arguments_into_pseudos (struct arg_data *args, int num_actuals)
    and may be modified by this routine.
 
    OLD_PENDING_ADJ, MUST_PREALLOCATE and FLAGS are pointers to integer
-   flags which may may be modified by this routine.  */
+   flags which may may be modified by this routine. 
+
+   CALL_FROM_THUNK_P is true if this call is the jump from a thunk to
+   the thunked-to function.  */
 
 static void
 initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
@@ -1034,7 +1038,8 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
                                 CUMULATIVE_ARGS *args_so_far,
                                 int reg_parm_stack_space,
                                 rtx *old_stack_level, int *old_pending_adj,
-                                int *must_preallocate, int *ecf_flags)
+                                int *must_preallocate, int *ecf_flags,
+                                bool call_from_thunk_p)
 {
   /* 1 if scanning parms front to back, -1 if scanning back to front.  */
   int inc;
@@ -1107,7 +1112,7 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
        {
          /* If we're compiling a thunk, pass through invisible
              references instead of making a copy.  */
-         if (current_function_is_thunk
+         if (call_from_thunk_p
 #ifdef FUNCTION_ARG_CALLEE_COPIES
              || (FUNCTION_ARG_CALLEE_COPIES (*args_so_far, TYPE_MODE (type),
                                             type, argpos < n_named_args)
@@ -2444,7 +2449,8 @@ expand_call (tree exp, rtx target, int ignore)
                                   n_named_args, actparms, fndecl,
                                   &args_so_far, reg_parm_stack_space,
                                   &old_stack_level, &old_pending_adj,
-                                  &must_preallocate, &flags);
+                                  &must_preallocate, &flags,
+                                  CALL_FROM_THUNK_P (exp));
 
   if (args_size.var)
     {

diff --git a/gcc/config/alpha/alpha.c b/gcc/config/alpha/alpha.c
index 7038c3e..b1eb7f6 100644 (file)
--- a/gcc/config/alpha/alpha.c
+++ b/gcc/config/alpha/alpha.c
@@ -6735,13 +6735,10 @@ alpha_sa_mask (unsigned long *imaskP, unsigned long *fmaskP)
   unsigned long fmask = 0;
   unsigned int i;
 
-  /* Irritatingly, there are two kinds of thunks -- those created with
-     TARGET_ASM_OUTPUT_MI_THUNK and those with DECL_THUNK_P that go
-     through the regular part of the compiler.  In the
-     TARGET_ASM_OUTPUT_MI_THUNK case we don't have valid register life
-     info, but assemble_start_function wants to output .frame and
-     .mask directives.  */
-  if (current_function_is_thunk && !no_new_pseudos)
+  /* When outputting a thunk, we don't have valid register life info,
+     but assemble_start_function wants to output .frame and .mask
+     directives.  */
+  if (current_function_is_thunk)
     {
       *imaskP = 0;
       *fmaskP = 0;

diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c
index a96ec6f..27aef80 100644 (file)
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -11000,11 +11000,7 @@ rs6000_ra_ever_killed (void)
   rtx reg;
   rtx insn;
 
-  /* Irritatingly, there are two kinds of thunks -- those created with
-     TARGET_ASM_OUTPUT_MI_THUNK and those with DECL_THUNK_P that go
-     through the regular part of the compiler.  This is a very hacky
-     way to tell them apart.  */
-  if (current_function_is_thunk && !no_new_pseudos)
+  if (current_function_is_thunk)
     return 0;
 
   /* regs_ever_live has LR marked as used if any sibcalls are present,

diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog
index 4e63000..4ef866f 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,10 @@
+2004-02-04  Mark Mitchell  <mark@codesourcery.com>
+
+       * decl.c (cxx_push_function_context): Do not set
+       current_function_is_thunk.
+       * method.c (use_thunk): Set CALL_FROM_THUNK on the call to the
+       actual function.
+
 2003-02-04  Giovanni Bajo  <giovannibajo@gcc.gnu.org>
 
        PR c++/13997

diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c
index a70a2fa..cc30957 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -11197,8 +11197,6 @@ cxx_push_function_context (struct function * f)
     {
       tree fn = f->decl;
 
-      current_function_is_thunk = DECL_THUNK_P (fn);
-
       if (DECL_SAVED_FUNCTION_DATA (fn))
        {
          /* If we already parsed this function, and we're just expanding it

diff --git a/gcc/cp/method.c b/gcc/cp/method.c
index 6acab3a..802bf1d 100644 (file)
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -487,6 +487,7 @@ use_thunk (tree thunk_fndecl, bool emit_p)
        t = tree_cons (NULL_TREE, a, t);
       t = nreverse (t);
       t = build_call (alias, t);
+      CALL_FROM_THUNK_P (t) = 1;
       
       if (VOID_TYPE_P (TREE_TYPE (t)))
        finish_expr_stmt (t);

diff --git a/gcc/function.h b/gcc/function.h
index 2bf68ca..1e5c56f 100644 (file)
--- a/gcc/function.h
+++ b/gcc/function.h
@@ -457,9 +457,10 @@ struct function GTY(())
   /* Nonzero if the function being compiled issues a computed jump.  */
   unsigned int has_computed_jump : 1;
 
-  /* Nonzero if the current function is a thunk (a lightweight function that
-     just adjusts one of its arguments and forwards to another function), so
-     we should try to cut corners where we can.  */
+  /* Nonzero if the current function is a thunk, i.e., a lightweight
+     function implemented by the output_mi_thunk hook) that just
+     adjusts one of its arguments and forwards to another
+     function.  */
   unsigned int is_thunk : 1;
 
   /* This bit is used by the exception handling logic.  It is set if all

diff --git a/gcc/tree.h b/gcc/tree.h
index 3f97099..6c3bc71 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -210,6 +210,8 @@ struct tree_common GTY(())
        TREE_PROTECTED in
            BLOCK
           ..._DECL
+       CALL_FROM_THUNK_P in
+           CALL_EXPR 
 
    side_effects_flag:
 
@@ -265,6 +267,7 @@ struct tree_common GTY(())
 
        TREE_DEPRECATED in
           ..._DECL
+
 */
 
 /* Define accessors for the fields that all tree nodes have
@@ -623,6 +626,10 @@ extern void tree_operand_check_failed (int, enum tree_code,
    argument list.  */
 #define CALL_EXPR_HAS_RETURN_SLOT_ADDR(NODE) ((NODE)->common.private_flag)
 
+/* In a CALL_EXPR, means that the call is the jump from a thunk to the
+   thunked-to function.  */
+#define CALL_FROM_THUNK_P(NODE) ((NODE)->common.protected_flag)
+
 /* In a type, nonzero means that all objects of the type are guaranteed by the
    language or front-end to be properly aligned, so we can indicate that a MEM
    of this type is aligned at least to the alignment of the type, even if it