gcc/cp/optimize.c

   1 /* Perform optimizations on tree structure.
   2    Copyright (C) 1998, 1999, 2000, 2001 Free Software Foundation, Inc.
   3    Written by Mark Michell (mark@codesourcery.com).
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify it
   8 under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful, but
  13 WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "tree.h"
  25 #include "cp-tree.h"
  26 #include "rtl.h"
  27 #include "insn-config.h"
  28 #include "input.h"
  29 #include "integrate.h"
  30 #include "toplev.h"
  31 #include "varray.h"
  32 #include "ggc.h"
  33 #include "params.h"
  34 #include "hashtab.h"
  35 #include "debug.h"
  36 #include "tree-inline.h"
  37
  38 /* Prototypes.  */
  39
  40 static tree calls_setjmp_r PARAMS ((tree *, int *, void *));
  41 static void update_cloned_parm PARAMS ((tree, tree));
  42 static void dump_function PARAMS ((enum tree_dump_index, tree));
  43
  44 /* Optimize the body of FN. */
  45
  46 void
  47 optimize_function (fn)
  48      tree fn;
  49 {
  50   dump_function (TDI_original, fn);
  51
  52   /* While in this function, we may choose to go off and compile
  53      another function.  For example, we might instantiate a function
  54      in the hopes of inlining it.  Normally, that wouldn't trigger any
  55      actual RTL code-generation -- but it will if the template is
  56      actually needed.  (For example, if it's address is taken, or if
  57      some other function already refers to the template.)  If
  58      code-generation occurs, then garbage collection will occur, so we
  59      must protect ourselves, just as we do while building up the body
  60      of the function.  */
  61   ++function_depth;
  62
  63   if (flag_inline_trees
  64       /* We do not inline thunks, as (a) the backend tries to optimize
  65          the call to the thunkee, (b) tree based inlining breaks that
  66          optimization, (c) virtual functions are rarely inlineable,
  67          and (d) ASM_OUTPUT_MI_THUNK is there to DTRT anyway.  */
  68       && !DECL_THUNK_P (fn))
  69     {
  70       optimize_inline_calls (fn);
  71
  72       dump_function (TDI_inlined, fn);
  73     }
  74
  75   /* Undo the call to ggc_push_context above.  */
  76   --function_depth;
  77
  78   dump_function (TDI_optimized, fn);
  79 }
  80
  81 /* Called from calls_setjmp_p via walk_tree.  */
  82
  83 static tree
  84 calls_setjmp_r (tp, walk_subtrees, data)
  85      tree *tp;
  86      int *walk_subtrees ATTRIBUTE_UNUSED;
  87      void *data ATTRIBUTE_UNUSED;
  88 {
  89   /* We're only interested in FUNCTION_DECLS.  */
  90   if (TREE_CODE (*tp) != FUNCTION_DECL)
  91     return NULL_TREE;
  92
  93   return setjmp_call_p (*tp) ? *tp : NULL_TREE;
  94 }
  95
  96 /* Returns non-zero if FN calls `setjmp' or some other function that
  97    can return more than once.  This function is conservative; it may
  98    occasionally return a non-zero value even when FN does not actually
  99    call `setjmp'.  */
 100
 101 int
 102 calls_setjmp_p (fn)
 103      tree fn;
 104 {
 105   return walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
 106                                        calls_setjmp_r,
 107                                        NULL) != NULL_TREE;
 108 }
 109
 110 /* CLONED_PARM is a copy of CLONE, generated for a cloned constructor
 111    or destructor.  Update it to ensure that the source-position for
 112    the cloned parameter matches that for the original, and that the
 113    debugging generation code will be able to find the original PARM.  */
 114
 115 static void
 116 update_cloned_parm (parm, cloned_parm)
 117      tree parm;
 118      tree cloned_parm;
 119 {
 120   DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;
 121
 122   /* We may have taken its address. */
 123   TREE_ADDRESSABLE (cloned_parm) = TREE_ADDRESSABLE (parm);
 124
 125   /* The definition might have different constness. */
 126   TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
 127
 128   TREE_USED (cloned_parm) = TREE_USED (parm);
 129
 130   /* The name may have changed from the declaration. */
 131   DECL_NAME (cloned_parm) = DECL_NAME (parm);
 132   DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
 133 }
 134
 135 /* FN is a function that has a complete body.  Clone the body as
 136    necessary.  Returns non-zero if there's no longer any need to
 137    process the main body.  */
 138
 139 int
 140 maybe_clone_body (fn)
 141      tree fn;
 142 {
 143   tree clone;
 144   int first = 1;
 145
 146   /* We only clone constructors and destructors.  */
 147   if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
 148       && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
 149     return 0;
 150
 151   /* Emit the DWARF1 abstract instance.  */
 152   (*debug_hooks->deferred_inline_function) (fn);
 153
 154   /* We know that any clones immediately follow FN in the TYPE_METHODS
 155      list.  */
 156   for (clone = TREE_CHAIN (fn);
 157        clone && DECL_CLONED_FUNCTION_P (clone);
 158        clone = TREE_CHAIN (clone), first = 0)
 159     {
 160       tree parm;
 161       tree clone_parm;
 162       int parmno;
 163       splay_tree decl_map;
 164
 165       /* Update CLONE's source position information to match FN's.  */
 166       DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (fn);
 167       DECL_INLINE (clone) = DECL_INLINE (fn);
 168       DECL_DECLARED_INLINE_P (clone) = DECL_DECLARED_INLINE_P (fn);
 169       DECL_COMDAT (clone) = DECL_COMDAT (fn);
 170       DECL_WEAK (clone) = DECL_WEAK (fn);
 171       DECL_ONE_ONLY (clone) = DECL_ONE_ONLY (fn);
 172       DECL_SECTION_NAME (clone) = DECL_SECTION_NAME (fn);
 173       DECL_USE_TEMPLATE (clone) = DECL_USE_TEMPLATE (fn);
 174       DECL_EXTERNAL (clone) = DECL_EXTERNAL (fn);
 175       DECL_INTERFACE_KNOWN (clone) = DECL_INTERFACE_KNOWN (fn);
 176       DECL_NOT_REALLY_EXTERN (clone) = DECL_NOT_REALLY_EXTERN (fn);
 177       TREE_PUBLIC (clone) = TREE_PUBLIC (fn);
 178
 179       /* Adjust the parameter names and locations. */
 180       parm = DECL_ARGUMENTS (fn);
 181       clone_parm = DECL_ARGUMENTS (clone);
 182       /* Update the `this' parameter, which is always first.  */
 183       update_cloned_parm (parm, clone_parm);
 184       parm = TREE_CHAIN (parm);
 185       clone_parm = TREE_CHAIN (clone_parm);
 186       if (DECL_HAS_IN_CHARGE_PARM_P (fn))
 187         parm = TREE_CHAIN (parm);
 188       if (DECL_HAS_VTT_PARM_P (fn))
 189         parm = TREE_CHAIN (parm);
 190       if (DECL_HAS_VTT_PARM_P (clone))
 191         clone_parm = TREE_CHAIN (clone_parm);
 192       for (; parm;
 193            parm = TREE_CHAIN (parm), clone_parm = TREE_CHAIN (clone_parm))
 194         {
 195           /* Update this parameter.  */
 196           update_cloned_parm (parm, clone_parm);
 197           /* We should only give unused information for one clone. */
 198           if (!first)
 199             TREE_USED (clone_parm) = 1;
 200         }
 201
 202       /* Start processing the function.  */
 203       push_to_top_level ();
 204       start_function (NULL_TREE, clone, NULL_TREE, SF_PRE_PARSED);
 205
 206       /* Remap the parameters.  */
 207       decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
 208       for (parmno = 0,
 209              parm = DECL_ARGUMENTS (fn),
 210              clone_parm = DECL_ARGUMENTS (clone);
 211            parm;
 212            ++parmno,
 213              parm = TREE_CHAIN (parm))
 214         {
 215           /* Map the in-charge parameter to an appropriate constant.  */
 216           if (DECL_HAS_IN_CHARGE_PARM_P (fn) && parmno == 1)
 217             {
 218               tree in_charge;
 219               in_charge = in_charge_arg_for_name (DECL_NAME (clone));
 220               splay_tree_insert (decl_map,
 221                                  (splay_tree_key) parm,
 222                                  (splay_tree_value) in_charge);
 223             }
 224           else if (DECL_ARTIFICIAL (parm)
 225                    && DECL_NAME (parm) == vtt_parm_identifier)
 226             {
 227               /* For a subobject constructor or destructor, the next
 228                  argument is the VTT parameter.  Remap the VTT_PARM
 229                  from the CLONE to this parameter.  */
 230               if (DECL_HAS_VTT_PARM_P (clone))
 231                 {
 232                   DECL_ABSTRACT_ORIGIN (clone_parm) = parm;
 233                   splay_tree_insert (decl_map,
 234                                      (splay_tree_key) parm,
 235                                      (splay_tree_value) clone_parm);
 236                   clone_parm = TREE_CHAIN (clone_parm);
 237                 }
 238               /* Otherwise, map the VTT parameter to `NULL'.  */
 239               else
 240                 {
 241                   splay_tree_insert (decl_map,
 242                                      (splay_tree_key) parm,
 243                                      (splay_tree_value) null_pointer_node);
 244                 }
 245             }
 246           /* Map other parameters to their equivalents in the cloned
 247              function.  */
 248           else
 249             {
 250               splay_tree_insert (decl_map,
 251                                  (splay_tree_key) parm,
 252                                  (splay_tree_value) clone_parm);
 253               clone_parm = TREE_CHAIN (clone_parm);
 254             }
 255         }
 256
 257       /* Clone the body.  */
 258       clone_body (clone, fn, decl_map);
 259
 260       /* There are as many statements in the clone as in the
 261          original.  */
 262       DECL_NUM_STMTS (clone) = DECL_NUM_STMTS (fn);
 263
 264       /* Clean up.  */
 265       splay_tree_delete (decl_map);
 266
 267       /* Now, expand this function into RTL, if appropriate.  */
 268       finish_function (0);
 269       BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone)) = DECL_INITIAL (fn);
 270       expand_body (clone);
 271       pop_from_top_level ();
 272     }
 273
 274   /* We don't need to process the original function any further.  */
 275   return 1;
 276 }
 277
 278 /* Dump FUNCTION_DECL FN as tree dump PHASE. */
 279
 280 static void
 281 dump_function (phase, fn)
 282      enum tree_dump_index phase;
 283      tree fn;
 284 {
 285   FILE *stream;
 286   int flags;
 287
 288   stream = dump_begin (phase, &flags);
 289   if (stream)
 290     {
 291       fprintf (stream, "\n;; Function %s",
 292                decl_as_string (fn, TFF_DECL_SPECIFIERS));
 293       fprintf (stream, " (%s)\n",
 294                decl_as_string (DECL_ASSEMBLER_NAME (fn), 0));
 295       fprintf (stream, ";; enabled by -%s\n", dump_flag_name (phase));
 296       fprintf (stream, "\n");
 297
 298       dump_node (fn, TDF_SLIM | flags, stream);
 299       dump_end (phase, stream);
 300     }
 301 }