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