* configure.ac: Determine Sun ld version numbers.

[pf3gnuchains/gcc-fork.git] / gcc / integrate.c

diff --git a/gcc/integrate.c b/gcc/integrate.c
index 9876935..e3decfb 100644 (file)
--- a/gcc/integrate.c
+++ b/gcc/integrate.c
@@ -1,13 +1,14 @@
 /* Procedure integration for GCC.
    Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
 /* Procedure integration for GCC.
    Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,

-   2000, 2001, 2002, 2003, 2004, 2005 Free Software Foundation, Inc.
+   2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
+   Free Software Foundation, Inc.

    Contributed by Michael Tiemann (tiemann@cygnus.com)
 
 This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free
    Contributed by Michael Tiemann (tiemann@cygnus.com)
 
 This file is part of GCC.
 
 GCC is free software; you can redistribute it and/or modify it under
 the terms of the GNU General Public License as published by the Free

-Software Foundation; either version 2, or (at your option) any later
+Software Foundation; either version 3, or (at your option) any later

 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
 version.
 
 GCC is distributed in the hope that it will be useful, but WITHOUT ANY


@@ -16,9 +17,8 @@ FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License
 for more details.
 
 You should have received a copy of the GNU General Public License

-along with GCC; see the file COPYING.  If not, write to the Free
-Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
-02110-1301, USA.  */
+along with GCC; see the file COPYING3.  If not see
+<http://www.gnu.org/licenses/>.  */

 
 #include "config.h"
 #include "system.h"
 
 #include "config.h"
 #include "system.h"


@@ -36,7 +36,6 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #include "output.h"
 #include "recog.h"
 #include "integrate.h"
 #include "output.h"
 #include "recog.h"
 #include "integrate.h"

-#include "real.h"

 #include "except.h"
 #include "function.h"
 #include "toplev.h"
 #include "except.h"
 #include "function.h"
 #include "toplev.h"


@@ -46,17 +45,18 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
 #include "target.h"
 #include "langhooks.h"
 #include "tree-pass.h"
 #include "target.h"
 #include "langhooks.h"
 #include "tree-pass.h"

+#include "df.h"

 
 /* Round to the next highest integer that meets the alignment.  */
 #define CEIL_ROUND(VALUE,ALIGN)        (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
 \f
 
 /* Private type used by {get/has}_hard_reg_initial_val.  */
 
 /* Round to the next highest integer that meets the alignment.  */
 #define CEIL_ROUND(VALUE,ALIGN)        (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
 \f
 
 /* Private type used by {get/has}_hard_reg_initial_val.  */

-typedef struct initial_value_pair GTY(()) {
+typedef struct GTY(()) initial_value_pair {

   rtx hard_reg;
   rtx pseudo;
 } initial_value_pair;
   rtx hard_reg;
   rtx pseudo;
 } initial_value_pair;

-typedef struct initial_value_struct GTY(()) {
+typedef struct GTY(()) initial_value_struct {

   int num_entries;
   int max_entries;
   initial_value_pair * GTY ((length ("%h.num_entries"))) entries;
   int num_entries;
   int max_entries;
   initial_value_pair * GTY ((length ("%h.num_entries"))) entries;


@@ -69,15 +69,15 @@ static void set_block_abstract_flags (tree, int);
 /* Return false if the function FNDECL cannot be inlined on account of its
    attributes, true otherwise.  */
 bool
 /* Return false if the function FNDECL cannot be inlined on account of its
    attributes, true otherwise.  */
 bool

-function_attribute_inlinable_p (tree fndecl)
+function_attribute_inlinable_p (const_tree fndecl)

 {
   if (targetm.attribute_table)
     {
 {
   if (targetm.attribute_table)
     {

-      tree a;
+      const_tree a;

 
       for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a))
        {
 
       for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a))
        {

-         tree name = TREE_PURPOSE (a);
+         const_tree name = TREE_PURPOSE (a);

          int i;
 
          for (i = 0; targetm.attribute_table[i].name != NULL; i++)
          int i;
 
          for (i = 0; targetm.attribute_table[i].name != NULL; i++)


@@ -166,6 +166,7 @@ set_block_abstract_flags (tree stmt, int setting)
 {
   tree local_decl;
   tree subblock;
 {
   tree local_decl;
   tree subblock;

+  unsigned int i;

 
   BLOCK_ABSTRACT (stmt) = setting;
 
 
   BLOCK_ABSTRACT (stmt) = setting;
 


@@ -174,6 +175,14 @@ set_block_abstract_flags (tree stmt, int setting)
        local_decl = TREE_CHAIN (local_decl))
     set_decl_abstract_flags (local_decl, setting);
 
        local_decl = TREE_CHAIN (local_decl))
     set_decl_abstract_flags (local_decl, setting);
 

+  for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
+    {
+      local_decl = BLOCK_NONLOCALIZED_VAR (stmt, i);
+      if ((TREE_CODE (local_decl) == VAR_DECL && !TREE_STATIC (local_decl))
+         || TREE_CODE (local_decl) == PARM_DECL)
+       set_decl_abstract_flags (local_decl, setting);
+    }
+

   for (subblock = BLOCK_SUBBLOCKS (stmt);
        subblock != NULL_TREE;
        subblock = BLOCK_CHAIN (subblock))
   for (subblock = BLOCK_SUBBLOCKS (stmt);
        subblock != NULL_TREE;
        subblock = BLOCK_CHAIN (subblock))


@@ -206,9 +215,9 @@ set_decl_abstract_flags (tree decl, int setting)
    the function.  */
 
 rtx
    the function.  */
 
 rtx

-get_hard_reg_initial_reg (struct function *fun, rtx reg)
+get_hard_reg_initial_reg (rtx reg)

 {
 {

-  struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
+  struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;

   int i;
 
   if (ivs == 0)
   int i;
 
   if (ivs == 0)


@@ -234,22 +243,21 @@ get_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
   if (rv)
     return rv;
 
   if (rv)
     return rv;
 

-  ivs = cfun->hard_reg_initial_vals;
+  ivs = crtl->hard_reg_initial_vals;

   if (ivs == 0)
     {
   if (ivs == 0)
     {

-      ivs = ggc_alloc (sizeof (initial_value_struct));
+      ivs = GGC_NEW (initial_value_struct);

       ivs->num_entries = 0;
       ivs->max_entries = 5;
       ivs->num_entries = 0;
       ivs->max_entries = 5;

-      ivs->entries = ggc_alloc (5 * sizeof (initial_value_pair));
-      cfun->hard_reg_initial_vals = ivs;
+      ivs->entries = GGC_NEWVEC (initial_value_pair, 5);
+      crtl->hard_reg_initial_vals = ivs;

     }
 
   if (ivs->num_entries >= ivs->max_entries)
     {
       ivs->max_entries += 5;
     }
 
   if (ivs->num_entries >= ivs->max_entries)
     {
       ivs->max_entries += 5;

-      ivs->entries = ggc_realloc (ivs->entries,
-                                 ivs->max_entries
-                                 * sizeof (initial_value_pair));
+      ivs->entries = GGC_RESIZEVEC (initial_value_pair, ivs->entries,
+                                   ivs->max_entries);

     }
 
   ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno);
     }
 
   ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno);


@@ -268,7 +276,7 @@ has_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
   struct initial_value_struct *ivs;
   int i;
 
   struct initial_value_struct *ivs;
   int i;
 

-  ivs = cfun->hard_reg_initial_vals;
+  ivs = crtl->hard_reg_initial_vals;

   if (ivs != 0)
     for (i = 0; i < ivs->num_entries; i++)
       if (GET_MODE (ivs->entries[i].hard_reg) == mode
   if (ivs != 0)
     for (i = 0; i < ivs->num_entries; i++)
       if (GET_MODE (ivs->entries[i].hard_reg) == mode


@@ -281,7 +289,7 @@ has_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
 unsigned int
 emit_initial_value_sets (void)
 {
 unsigned int
 emit_initial_value_sets (void)
 {

-  struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
+  struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;

   int i;
   rtx seq;
 
   int i;
   rtx seq;
 


@@ -294,35 +302,37 @@ emit_initial_value_sets (void)
   seq = get_insns ();
   end_sequence ();
 
   seq = get_insns ();
   end_sequence ();
 

-  emit_insn_after (seq, entry_of_function ());
+  emit_insn_at_entry (seq);

   return 0;
 }
 
   return 0;
 }
 

-struct tree_opt_pass pass_initial_value_sets =
+struct rtl_opt_pass pass_initial_value_sets =

 {
 {

+ {
+  RTL_PASS,

   "initvals",                           /* name */
   NULL,                                 /* gate */
   emit_initial_value_sets,              /* execute */
   NULL,                                 /* sub */
   NULL,                                 /* next */
   0,                                    /* static_pass_number */
   "initvals",                           /* name */
   NULL,                                 /* gate */
   emit_initial_value_sets,              /* execute */
   NULL,                                 /* sub */
   NULL,                                 /* next */
   0,                                    /* static_pass_number */

-  0,                                    /* tv_id */
+  TV_NONE,                              /* tv_id */

   0,                                    /* properties_required */
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */
   0,                                    /* properties_required */
   0,                                    /* properties_provided */
   0,                                    /* properties_destroyed */
   0,                                    /* todo_flags_start */

-  TODO_dump_func,                       /* todo_flags_finish */
-  0                                     /* letter */
+  TODO_dump_func                        /* todo_flags_finish */
+ }

 };
 
 /* If the backend knows where to allocate pseudos for hard
    register initial values, register these allocations now.  */
 void
 };
 
 /* If the backend knows where to allocate pseudos for hard
    register initial values, register these allocations now.  */
 void

-allocate_initial_values (rtx *reg_equiv_memory_loc ATTRIBUTE_UNUSED)
+allocate_initial_values (rtx *reg_equiv_memory_loc)

 {
   if (targetm.allocate_initial_value)
     {
 {
   if (targetm.allocate_initial_value)
     {

-      struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
+      struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;

       int i;
 
       if (ivs == 0)
       int i;
 
       if (ivs == 0)


@@ -332,7 +342,7 @@ allocate_initial_values (rtx *reg_equiv_memory_loc ATTRIBUTE_UNUSED)
        {
          int regno = REGNO (ivs->entries[i].pseudo);
          rtx x = targetm.allocate_initial_value (ivs->entries[i].hard_reg);
        {
          int regno = REGNO (ivs->entries[i].pseudo);
          rtx x = targetm.allocate_initial_value (ivs->entries[i].hard_reg);

-  
+

          if (x && REG_N_SETS (REGNO (ivs->entries[i].pseudo)) <= 1)
            {
              if (MEM_P (x))
          if (x && REG_N_SETS (REGNO (ivs->entries[i].pseudo)) <= 1)
            {
              if (MEM_P (x))


@@ -347,18 +357,14 @@ allocate_initial_values (rtx *reg_equiv_memory_loc ATTRIBUTE_UNUSED)
                  reg_renumber[regno] = new_regno;
                  /* Poke the regno right into regno_reg_rtx so that even
                     fixed regs are accepted.  */
                  reg_renumber[regno] = new_regno;
                  /* Poke the regno right into regno_reg_rtx so that even
                     fixed regs are accepted.  */

-                 REGNO (ivs->entries[i].pseudo) = new_regno;
+                 SET_REGNO (ivs->entries[i].pseudo, new_regno);

                  /* Update global register liveness information.  */
                  FOR_EACH_BB (bb)
                    {
                  /* Update global register liveness information.  */
                  FOR_EACH_BB (bb)
                    {

-                     struct rtl_bb_info *info = bb->il.rtl;
-
-                     if (REGNO_REG_SET_P(info->global_live_at_start, regno))
-                       SET_REGNO_REG_SET (info->global_live_at_start,
-                                          new_regno);
-                     if (REGNO_REG_SET_P(info->global_live_at_end, regno))
-                       SET_REGNO_REG_SET (info->global_live_at_end,
-                                          new_regno);
+                     if (REGNO_REG_SET_P(df_get_live_in (bb), regno))
+                       SET_REGNO_REG_SET (df_get_live_in (bb), new_regno);
+                     if (REGNO_REG_SET_P(df_get_live_out (bb), regno))
+                       SET_REGNO_REG_SET (df_get_live_out (bb), new_regno);

                    }
                }
            }
                    }
                }
            }