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 Free Software Foundation, Inc.
   4    Contributed by Michael Tiemann (tiemann@cygnus.com)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to the Free
  20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  21 02110-1301, USA.  */
  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 "real.h"
  40 #include "except.h"
  41 #include "function.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
  50 /* Round to the next highest integer that meets the alignment.  */
  51 #define CEIL_ROUND(VALUE,ALIGN) (((VALUE) + (ALIGN) - 1) & ~((ALIGN)- 1))
  52 \f
  53
  54 /* Private type used by {get/has}_hard_reg_initial_val.  */
  55 typedef struct initial_value_pair GTY(()) {
  56   rtx hard_reg;
  57   rtx pseudo;
  58 } initial_value_pair;
  59 typedef struct initial_value_struct GTY(()) {
  60   int num_entries;
  61   int max_entries;
  62   initial_value_pair * GTY ((length ("%h.num_entries"))) entries;
  63 } initial_value_struct;
  64
  65 static void set_block_origin_self (tree);
  66 static void set_block_abstract_flags (tree, int);
  67 \f
  68
  69 /* Return false if the function FNDECL cannot be inlined on account of its
  70    attributes, true otherwise.  */
  71 bool
  72 function_attribute_inlinable_p (tree fndecl)
  73 {
  74   if (targetm.attribute_table)
  75     {
  76       tree a;
  77
  78       for (a = DECL_ATTRIBUTES (fndecl); a; a = TREE_CHAIN (a))
  79         {
  80           tree name = TREE_PURPOSE (a);
  81           int i;
  82
  83           for (i = 0; targetm.attribute_table[i].name != NULL; i++)
  84             if (is_attribute_p (targetm.attribute_table[i].name, name))
  85               return targetm.function_attribute_inlinable_p (fndecl);
  86         }
  87     }
  88
  89   return true;
  90 }
  91 \f
  92 /* Copy NODE (which must be a DECL).  The DECL originally was in the FROM_FN,
  93    but now it will be in the TO_FN.  */
  94
  95 tree
  96 copy_decl_for_inlining (tree decl, tree from_fn, tree to_fn)
  97 {
  98   tree copy;
  99
 100   /* Copy the declaration.  */
 101   if (TREE_CODE (decl) == PARM_DECL || TREE_CODE (decl) == RESULT_DECL)
 102     {
 103       tree type = TREE_TYPE (decl);
 104
 105       /* For a parameter or result, we must make an equivalent VAR_DECL, not a
 106          new PARM_DECL.  */
 107       copy = build_decl (VAR_DECL, DECL_NAME (decl), type);
 108       TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (decl);
 109       TREE_READONLY (copy) = TREE_READONLY (decl);
 110       TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (decl);
 111       DECL_COMPLEX_GIMPLE_REG_P (copy) = DECL_COMPLEX_GIMPLE_REG_P (decl);
 112     }
 113   else
 114     {
 115       copy = copy_node (decl);
 116       /* The COPY is not abstract; it will be generated in TO_FN.  */
 117       DECL_ABSTRACT (copy) = 0;
 118       lang_hooks.dup_lang_specific_decl (copy);
 119
 120       /* TREE_ADDRESSABLE isn't used to indicate that a label's
 121          address has been taken; it's for internal bookkeeping in
 122          expand_goto_internal.  */
 123       if (TREE_CODE (copy) == LABEL_DECL)
 124         {
 125           TREE_ADDRESSABLE (copy) = 0;
 126           LABEL_DECL_UID (copy) = -1;
 127         }
 128     }
 129
 130   /* Don't generate debug information for the copy if we wouldn't have
 131      generated it for the copy either.  */
 132   DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (decl);
 133   DECL_IGNORED_P (copy) = DECL_IGNORED_P (decl);
 134
 135   /* Set the DECL_ABSTRACT_ORIGIN so the debugging routines know what
 136      declaration inspired this copy.  */
 137   DECL_ABSTRACT_ORIGIN (copy) = DECL_ORIGIN (decl);
 138
 139   /* The new variable/label has no RTL, yet.  */
 140   if (!TREE_STATIC (copy) && !DECL_EXTERNAL (copy))
 141     SET_DECL_RTL (copy, NULL_RTX);
 142
 143   /* These args would always appear unused, if not for this.  */
 144   TREE_USED (copy) = 1;
 145
 146   /* Set the context for the new declaration.  */
 147   if (!DECL_CONTEXT (decl))
 148     /* Globals stay global.  */
 149     ;
 150   else if (DECL_CONTEXT (decl) != from_fn)
 151     /* Things that weren't in the scope of the function we're inlining
 152        from aren't in the scope we're inlining to, either.  */
 153     ;
 154   else if (TREE_STATIC (decl))
 155     /* Function-scoped static variables should stay in the original
 156        function.  */
 157     ;
 158   else
 159     /* Ordinary automatic local variables are now in the scope of the
 160        new function.  */
 161     DECL_CONTEXT (copy) = to_fn;
 162
 163   return copy;
 164 }
 165
 166 \f
 167 /* Given a pointer to some BLOCK node, if the BLOCK_ABSTRACT_ORIGIN for the
 168    given BLOCK node is NULL, set the BLOCK_ABSTRACT_ORIGIN for the node so
 169    that it points to the node itself, thus indicating that the node is its
 170    own (abstract) origin.  Additionally, if the BLOCK_ABSTRACT_ORIGIN for
 171    the given node is NULL, recursively descend the decl/block tree which
 172    it is the root of, and for each other ..._DECL or BLOCK node contained
 173    therein whose DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also
 174    still NULL, set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN
 175    values to point to themselves.  */
 176
 177 static void
 178 set_block_origin_self (tree stmt)
 179 {
 180   if (BLOCK_ABSTRACT_ORIGIN (stmt) == NULL_TREE)
 181     {
 182       BLOCK_ABSTRACT_ORIGIN (stmt) = stmt;
 183
 184       {
 185         tree local_decl;
 186
 187         for (local_decl = BLOCK_VARS (stmt);
 188              local_decl != NULL_TREE;
 189              local_decl = TREE_CHAIN (local_decl))
 190           set_decl_origin_self (local_decl);    /* Potential recursion.  */
 191       }
 192
 193       {
 194         tree subblock;
 195
 196         for (subblock = BLOCK_SUBBLOCKS (stmt);
 197              subblock != NULL_TREE;
 198              subblock = BLOCK_CHAIN (subblock))
 199           set_block_origin_self (subblock);     /* Recurse.  */
 200       }
 201     }
 202 }
 203
 204 /* Given a pointer to some ..._DECL node, if the DECL_ABSTRACT_ORIGIN for
 205    the given ..._DECL node is NULL, set the DECL_ABSTRACT_ORIGIN for the
 206    node to so that it points to the node itself, thus indicating that the
 207    node represents its own (abstract) origin.  Additionally, if the
 208    DECL_ABSTRACT_ORIGIN for the given node is NULL, recursively descend
 209    the decl/block tree of which the given node is the root of, and for
 210    each other ..._DECL or BLOCK node contained therein whose
 211    DECL_ABSTRACT_ORIGINs or BLOCK_ABSTRACT_ORIGINs are also still NULL,
 212    set *their* DECL_ABSTRACT_ORIGIN or BLOCK_ABSTRACT_ORIGIN values to
 213    point to themselves.  */
 214
 215 void
 216 set_decl_origin_self (tree decl)
 217 {
 218   if (DECL_ABSTRACT_ORIGIN (decl) == NULL_TREE)
 219     {
 220       DECL_ABSTRACT_ORIGIN (decl) = decl;
 221       if (TREE_CODE (decl) == FUNCTION_DECL)
 222         {
 223           tree arg;
 224
 225           for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
 226             DECL_ABSTRACT_ORIGIN (arg) = arg;
 227           if (DECL_INITIAL (decl) != NULL_TREE
 228               && DECL_INITIAL (decl) != error_mark_node)
 229             set_block_origin_self (DECL_INITIAL (decl));
 230         }
 231     }
 232 }
 233 \f
 234 /* Given a pointer to some BLOCK node, and a boolean value to set the
 235    "abstract" flags to, set that value into the BLOCK_ABSTRACT flag for
 236    the given block, and for all local decls and all local sub-blocks
 237    (recursively) which are contained therein.  */
 238
 239 static void
 240 set_block_abstract_flags (tree stmt, int setting)
 241 {
 242   tree local_decl;
 243   tree subblock;
 244
 245   BLOCK_ABSTRACT (stmt) = setting;
 246
 247   for (local_decl = BLOCK_VARS (stmt);
 248        local_decl != NULL_TREE;
 249        local_decl = TREE_CHAIN (local_decl))
 250     set_decl_abstract_flags (local_decl, setting);
 251
 252   for (subblock = BLOCK_SUBBLOCKS (stmt);
 253        subblock != NULL_TREE;
 254        subblock = BLOCK_CHAIN (subblock))
 255     set_block_abstract_flags (subblock, setting);
 256 }
 257
 258 /* Given a pointer to some ..._DECL node, and a boolean value to set the
 259    "abstract" flags to, set that value into the DECL_ABSTRACT flag for the
 260    given decl, and (in the case where the decl is a FUNCTION_DECL) also
 261    set the abstract flags for all of the parameters, local vars, local
 262    blocks and sub-blocks (recursively) to the same setting.  */
 263
 264 void
 265 set_decl_abstract_flags (tree decl, int setting)
 266 {
 267   DECL_ABSTRACT (decl) = setting;
 268   if (TREE_CODE (decl) == FUNCTION_DECL)
 269     {
 270       tree arg;
 271
 272       for (arg = DECL_ARGUMENTS (decl); arg; arg = TREE_CHAIN (arg))
 273         DECL_ABSTRACT (arg) = setting;
 274       if (DECL_INITIAL (decl) != NULL_TREE
 275           && DECL_INITIAL (decl) != error_mark_node)
 276         set_block_abstract_flags (DECL_INITIAL (decl), setting);
 277     }
 278 }
 279 \f
 280 /* Functions to keep track of the values hard regs had at the start of
 281    the function.  */
 282
 283 rtx
 284 get_hard_reg_initial_reg (struct function *fun, rtx reg)
 285 {
 286   struct initial_value_struct *ivs = fun->hard_reg_initial_vals;
 287   int i;
 288
 289   if (ivs == 0)
 290     return NULL_RTX;
 291
 292   for (i = 0; i < ivs->num_entries; i++)
 293     if (rtx_equal_p (ivs->entries[i].pseudo, reg))
 294       return ivs->entries[i].hard_reg;
 295
 296   return NULL_RTX;
 297 }
 298
 299 /* Make sure that there's a pseudo register of mode MODE that stores the
 300    initial value of hard register REGNO.  Return an rtx for such a pseudo.  */
 301
 302 rtx
 303 get_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
 304 {
 305   struct initial_value_struct *ivs;
 306   rtx rv;
 307
 308   rv = has_hard_reg_initial_val (mode, regno);
 309   if (rv)
 310     return rv;
 311
 312   ivs = cfun->hard_reg_initial_vals;
 313   if (ivs == 0)
 314     {
 315       ivs = ggc_alloc (sizeof (initial_value_struct));
 316       ivs->num_entries = 0;
 317       ivs->max_entries = 5;
 318       ivs->entries = ggc_alloc (5 * sizeof (initial_value_pair));
 319       cfun->hard_reg_initial_vals = ivs;
 320     }
 321
 322   if (ivs->num_entries >= ivs->max_entries)
 323     {
 324       ivs->max_entries += 5;
 325       ivs->entries = ggc_realloc (ivs->entries,
 326                                   ivs->max_entries
 327                                   * sizeof (initial_value_pair));
 328     }
 329
 330   ivs->entries[ivs->num_entries].hard_reg = gen_rtx_REG (mode, regno);
 331   ivs->entries[ivs->num_entries].pseudo = gen_reg_rtx (mode);
 332
 333   return ivs->entries[ivs->num_entries++].pseudo;
 334 }
 335
 336 /* See if get_hard_reg_initial_val has been used to create a pseudo
 337    for the initial value of hard register REGNO in mode MODE.  Return
 338    the associated pseudo if so, otherwise return NULL.  */
 339
 340 rtx
 341 has_hard_reg_initial_val (enum machine_mode mode, unsigned int regno)
 342 {
 343   struct initial_value_struct *ivs;
 344   int i;
 345
 346   ivs = cfun->hard_reg_initial_vals;
 347   if (ivs != 0)
 348     for (i = 0; i < ivs->num_entries; i++)
 349       if (GET_MODE (ivs->entries[i].hard_reg) == mode
 350           && REGNO (ivs->entries[i].hard_reg) == regno)
 351         return ivs->entries[i].pseudo;
 352
 353   return NULL_RTX;
 354 }
 355
 356 void
 357 emit_initial_value_sets (void)
 358 {
 359   struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
 360   int i;
 361   rtx seq;
 362
 363   if (ivs == 0)
 364     return;
 365
 366   start_sequence ();
 367   for (i = 0; i < ivs->num_entries; i++)
 368     emit_move_insn (ivs->entries[i].pseudo, ivs->entries[i].hard_reg);
 369   seq = get_insns ();
 370   end_sequence ();
 371
 372   emit_insn_after (seq, entry_of_function ());
 373 }
 374
 375 struct tree_opt_pass pass_initial_value_sets =
 376 {
 377   NULL,                                 /* name */
 378   NULL,                                 /* gate */
 379   emit_initial_value_sets,              /* execute */
 380   NULL,                                 /* sub */
 381   NULL,                                 /* next */
 382   0,                                    /* static_pass_number */
 383   0,                                    /* tv_id */
 384   0,                                    /* properties_required */
 385   0,                                    /* properties_provided */
 386   0,                                    /* properties_destroyed */
 387   0,                                    /* todo_flags_start */
 388   0,                                    /* todo_flags_finish */
 389   0                                     /* letter */
 390 };
 391
 392 /* If the backend knows where to allocate pseudos for hard
 393    register initial values, register these allocations now.  */
 394 void
 395 allocate_initial_values (rtx *reg_equiv_memory_loc ATTRIBUTE_UNUSED)
 396 {
 397   if (targetm.allocate_initial_value)
 398     {
 399       struct initial_value_struct *ivs = cfun->hard_reg_initial_vals;
 400       int i;
 401
 402       if (ivs == 0)
 403         return;
 404
 405       for (i = 0; i < ivs->num_entries; i++)
 406         {
 407           int regno = REGNO (ivs->entries[i].pseudo);
 408           rtx x = targetm.allocate_initial_value (ivs->entries[i].hard_reg);
 409
 410           if (x && REG_N_SETS (REGNO (ivs->entries[i].pseudo)) <= 1)
 411             {
 412               if (MEM_P (x))
 413                 reg_equiv_memory_loc[regno] = x;
 414               else
 415                 {
 416                   basic_block bb;
 417                   int new_regno;
 418
 419                   gcc_assert (REG_P (x));
 420                   new_regno = REGNO (x);
 421                   reg_renumber[regno] = new_regno;
 422                   /* Poke the regno right into regno_reg_rtx so that even
 423                      fixed regs are accepted.  */
 424                   REGNO (ivs->entries[i].pseudo) = new_regno;
 425                   /* Update global register liveness information.  */
 426                   FOR_EACH_BB (bb)
 427                     {
 428                       struct rtl_bb_info *info = bb->il.rtl;
 429
 430                       if (REGNO_REG_SET_P(info->global_live_at_start, regno))
 431                         SET_REGNO_REG_SET (info->global_live_at_start,
 432                                            new_regno);
 433                       if (REGNO_REG_SET_P(info->global_live_at_end, regno))
 434                         SET_REGNO_REG_SET (info->global_live_at_end,
 435                                            new_regno);
 436                     }
 437                 }
 438             }
 439         }
 440     }
 441 }
 442
 443 #include "gt-integrate.h"