gcc/integrate.c

   1 /* Procedure integration for GCC.
   2    Copyright (C) 1988, 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5    Contributed by Michael Tiemann (tiemann@cygnus.com)
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify it under
  10 the terms of the GNU General Public License as published by the Free
  11 Software Foundation; either version 3, or (at your option) any later
  12 version.
  13
  14 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  15 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  17 for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27
  28 #include "rtl.h"
  29 #include "tree.h"
  30 #include "tm_p.h"
  31 #include "regs.h"
  32 #include "flags.h"
  33 #include "debug.h"
  34 #include "insn-config.h"
  35 #include "expr.h"
  36 #include "output.h"
  37 #include "recog.h"
  38 #include "integrate.h"
  39 #include "except.h"
  40 #include "function.h"
  41 #include "diagnostic-core.h"
  42 #include "toplev.h"
  43 #include "intl.h"
  44 #include "params.h"
  45 #include "ggc.h"
  46 #include "target.h"
  47 #include "langhooks.h"
  48 #include "tree-pass.h"
  49 #include "df.h"
  50
  51 /* Round to the next highest integer that meets the alignment.  */
  52 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
  53 \f
  54
  55 /* Private type used by {get/has}_hard_reg_initial_val.  */
  56 typedef struct GTY(()) initial_value_pair {
  57   rtx hard_reg;
  58   rtx pseudo;
  59 } initial_value_pair;
  60 typedef struct GTY(()) initial_value_struct {
  61   int num_entries;
  62   int max_entries;
  63   initial_value_pair * GTY ((length ("%h.num_entries"))) entries;
  64 } initial_value_struct;
  65
  66 static void set_block_origin_self (tree);
  67 static void set_block_abstract_flags (tree, int);
  68 \f
  69
  70 /* Return false if the function FNDECL cannot be inlined on account of its
  71    attributes, true otherwise.  */
  72 bool
  73 function_attribute_inlinable_p (const_tree fndecl)
  74 {
  75   if (targetm.attribute_table)
  76     {
  77       const_tree a;
  78
  79       for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a))
  80         {
  81           const_tree name = TREE_PURPOSE (a);
  82           int i;
  83
  84           for (i = 0; targetm.attribute_table[i].name != NULL; i++)
  85             if (is_attribute_p (targetm.attribute_table[i].name, name))
  86               return targetm.function_attribute_inlinable_p (fndecl);
  87         }
  88     }
  89
  90   return true;
  91 }
  92 \f
  93 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
  94    given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
  95    that it points to the node itself, thus indicating that the node is its
  96    own (abstract) origin.  Additionally, if the BLOCK_ABSTRACT_ORIGIN for
  97    the given node is NULL, recursively descend the decl/block tree which
  98    it is the root of, and for each other ..._DECL or BLOCK node contained
  99    therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
 100    still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
 101    values to point to themselves.  */
 102
 103 static void
 104 set_block_origin_self (tree stmt)
 105 {
 106   if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
 107     {
 108       BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
 109
 110       {
 111         tree local_decl;
 112
 113         for (local_decl = BLOCK_VARS (stmt);
 114              local_decl != NULL_TREE;
 115              local_decl = DECL_CHAIN (local_decl))
 116           set_decl_origin_self (local_decl);    /* Potential recursion.  */
 117       }
 118
 119       {
 120         tree subblock;
 121
 122         for (subblock = BLOCK_SUBBLOCKS (stmt);
 123              subblock != NULL_TREE;
 124              subblock = BLOCK_CHAIN (subblock))
 125           set_block_origin_self (subblock);     /* Recurse.  */
 126       }
 127     }
 128 }
 129
 130 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
 131    the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
 132    node to so that it points to the node itself, thus indicating that the
 133    node represents its own (abstract) origin.  Additionally, if the
 134    DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
 135    the decl/block tree of which the given node is the root of, and for
 136    each other ..._DECL or BLOCK node contained therein whose
 137    DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
 138    set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
 139    point to themselves.  */
 140
 141 void
 142 set_decl_origin_self (tree decl)
 143 {
 144   if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
 145     {
 146       DECL_ABSTRACT_ORIGIN (decl) = decl;
 147       if (TREE_CODE (decl) == FUNCTION_DECL)
 148         {
 149           tree arg;
 150
 151           for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg))
 152             DECL_ABSTRACT_ORIGIN (arg) = arg;
 153           if (DECL_INITIAL (decl) != NULL_TREE
 154               && DECL_INITIAL (decl) != error_mark_node)
 155             set_block_origin_self (DECL_INITIAL (decl));
 156         }
 157     }
 158 }
 159 \f
 160 /* Given a pointer to some BLOCK node, and a boolean value to set the
 161    "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
 162    the given block, and for all local decls and all local sub-blocks
 163    (recursively) which are contained therein.  */
 164
 165 static void
 166 set_block_abstract_flags (tree stmt, int setting)
 167 {
 168   tree local_decl;
 169   tree subblock;
 170   unsigned int i;
 171
 172   BLOCK_ABSTRACT (stmt) = setting;
 173
 174   for (local_decl = BLOCK_VARS (stmt);
 175        local_decl != NULL_TREE;
 176        local_decl = DECL_CHAIN (local_decl))
 177     set_decl_abstract_flags (local_decl, setting);
 178
 179   for (i = 0; i < BLOCK_NUM_NONLOCALIZED_VARS (stmt); i++)
 180     {
 181       local_decl = BLOCK_NONLOCALIZED_VAR (stmt, i);
 182       if ((TREE_CODE (local_decl) == VAR_DECL && !TREE_STATIC (local_decl))
 183           || TREE_CODE (local_decl) == PARM_DECL)
 184         set_decl_abstract_flags (local_decl, setting);
 185     }
 186
 187   for (subblock = BLOCK_SUBBLOCKS (stmt);
 188        subblock != NULL_TREE;
 189        subblock = BLOCK_CHAIN (subblock))
 190     set_block_abstract_flags (subblock, setting);
 191 }
 192
 193 /* Given a pointer to some ..._DECL node, and a boolean value to set the
 194    "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
 195    given decl, and (in the case where the decl is a FUNCTION_DECL) also
 196    set the abstract flags for all of the parameters, local vars, local
 197    blocks and sub-blocks (recursively) to the same setting.  */
 198
 199 void
 200 set_decl_abstract_flags (tree decl, int setting)
 201 {
 202   DECL_ABSTRACT (decl) = setting;
 203   if (TREE_CODE (decl) == FUNCTION_DECL)
 204     {
 205       tree arg;
 206
 207       for (arg = DECL_ARGUMENTS (decl); arg; arg = DECL_CHAIN (arg))
 208         DECL_ABSTRACT (arg) = setting;
 209       if (DECL_INITIAL (decl) != NULL_TREE
 210           && DECL_INITIAL (decl) != error_mark_node)
 211         set_block_abstract_flags (DECL_INITIAL (decl), setting);
 212     }
 213 }
 214 \f
 215 /* Functions to keep track of the values hard regs had at the start of
 216    the function.  */
 217
 218 rtx
 219 get_hard_reg_initial_reg (rtx reg)
 220 {
 221   struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
 222   int i;
 223
 224   if (ivs == 0)
 225     return NULL_RTX;
 226
 227   for (i = 0; i < ivs->num_entries; i++)
 228     if (rtx_equal_p (ivs->entries[i].pseudo, reg))
 229       return ivs->entries[i].hard_reg;
 230
 231   return NULL_RTX;
 232 }
 233
 234 /* Make sure that there's a pseudo register of mode MODE that stores the
 235    initial value of hard register REGNO.  Return an rtx for such a pseudo.  */
 236
 237 rtx
 238 get_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
 239 {
 240   struct initial_value_struct *ivs;
 241   rtx rv;
 242
 243   rv = has_hard_reg_initial_val (mode, regno);
 244   if (rv)
 245     return rv;
 246
 247   ivs = crtl->hard_reg_initial_vals;
 248   if (ivs == 0)
 249     {
 250       ivs = ggc_alloc_initial_value_struct ();
 251       ivs->num_entries = 0;
 252       ivs->max_entries = 5;
 253       ivs->entries = ggc_alloc_vec_initial_value_pair (5);
 254       crtl->hard_reg_initial_vals = ivs;
 255     }
 256
 257   if (ivs->num_entries >= ivs->max_entries)
 258     {
 259       ivs->max_entries += 5;
 260       ivs->entries = GGC_RESIZEVEC (initial_value_pair, ivs->entries,
 261                                     ivs->max_entries);
 262     }
 263
 264   ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno);
 265   ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (mode);
 266
 267   return ivs->entries[ivs->num_entries++].pseudo;
 268 }
 269
 270 /* See if get_hard_reg_initial_val has been used to create a pseudo
 271    for the initial value of hard register REGNO in mode MODE.  Return
 272    the associated pseudo if so, otherwise return NULL.  */
 273
 274 rtx
 275 has_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
 276 {
 277   struct initial_value_struct *ivs;
 278   int i;
 279
 280   ivs = crtl->hard_reg_initial_vals;
 281   if (ivs != 0)
 282     for (i = 0; i < ivs->num_entries; i++)
 283       if (GET_MODE (ivs->entries[i].hard_reg) == mode
 284           && REGNO (ivs->entries[i].hard_reg) == regno)
 285         return ivs->entries[i].pseudo;
 286
 287   return NULL_RTX;
 288 }
 289
 290 unsigned int
 291 emit_initial_value_sets (void)
 292 {
 293   struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
 294   int i;
 295   rtx seq;
 296
 297   if (ivs == 0)
 298     return 0;
 299
 300   start_sequence ();
 301   for (i = 0; i < ivs->num_entries; i++)
 302     emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg);
 303   seq = get_insns ();
 304   end_sequence ();
 305
 306   emit_insn_at_entry (seq);
 307   return 0;
 308 }
 309
 310 struct rtl_opt_pass pass_initial_value_sets =
 311 {
 312  {
 313   RTL_PASS,
 314   "initvals",                           /* name */
 315   NULL,                                 /* gate */
 316   emit_initial_value_sets,              /* execute */
 317   NULL,                                 /* sub */
 318   NULL,                                 /* next */
 319   0,                                    /* static_pass_number */
 320   TV_NONE,                              /* tv_id */
 321   0,                                    /* properties_required */
 322   0,                                    /* properties_provided */
 323   0,                                    /* properties_destroyed */
 324   0,                                    /* todo_flags_start */
 325   TODO_dump_func                        /* todo_flags_finish */
 326  }
 327 };
 328
 329 /* If the backend knows where to allocate pseudos for hard
 330    register initial values, register these allocations now.  */
 331 void
 332 allocate_initial_values (rtx *reg_equiv_memory_loc)
 333 {
 334   if (targetm.allocate_initial_value)
 335     {
 336       struct initial_value_struct *ivs = crtl->hard_reg_initial_vals;
 337       int i;
 338
 339       if (ivs == 0)
 340         return;
 341
 342       for (i = 0; i < ivs->num_entries; i++)
 343         {
 344           int regno = REGNO (ivs->entries[i].pseudo);
 345           rtx x = targetm.allocate_initial_value (ivs->entries[i].hard_reg);
 346
 347           if (x && REG_N_SETS (REGNO (ivs->entries[i].pseudo)) <= 1)
 348             {
 349               if (MEM_P (x))
 350                 reg_equiv_memory_loc[regno] = x;
 351               else
 352                 {
 353                   basic_block bb;
 354                   int new_regno;
 355
 356                   gcc_assert (REG_P (x));
 357                   new_regno = REGNO (x);
 358                   reg_renumber[regno] = new_regno;
 359                   /* Poke the regno right into regno_reg_rtx so that even
 360                      fixed regs are accepted.  */
 361                   SET_REGNO (ivs->entries[i].pseudo, new_regno);
 362                   /* Update global register liveness information.  */
 363                   FOR_EACH_BB (bb)
 364                     {
 365                       if (REGNO_REG_SET_P(df_get_live_in (bb), regno))
 366                         SET_REGNO_REG_SET (df_get_live_in (bb), new_regno);
 367                       if (REGNO_REG_SET_P(df_get_live_out (bb), regno))
 368                         SET_REGNO_REG_SET (df_get_live_out (bb), new_regno);
 369                     }
 370                 }
 371             }
 372         }
 373     }
 374 }
 375
 376 #include "gt-integrate.h"