gcc/cp/optimize.c

   1 /* Perform optimizations on tree structure.
   2    Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   3    Written by Mark Michell (mark@codesourcery.com).
   4
   5 This file is part of GCC.
   6
   7 GCC 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 GCC 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 GCC; 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 "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "cp-tree.h"
  28 #include "rtl.h"
  29 #include "insn-config.h"
  30 #include "input.h"
  31 #include "integrate.h"
  32 #include "toplev.h"
  33 #include "varray.h"
  34 #include "params.h"
  35 #include "hashtab.h"
  36 #include "debug.h"
  37 #include "tree-inline.h"
  38
  39 /* Prototypes.  */
  40
  41 static tree calls_setjmp_r (tree *, int *, void *);
  42 static void update_cloned_parm (tree, tree);
  43 static void dump_function (enum tree_dump_index, tree);
  44
  45 /* Optimize the body of FN.  */
  46
  47 void
  48 optimize_function (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) TARGET_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 (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
  85                 void *data ATTRIBUTE_UNUSED)
  86 {
  87   /* We're only interested in FUNCTION_DECLS.  */
  88   if (TREE_CODE (*tp) != FUNCTION_DECL)
  89     return NULL_TREE;
  90
  91   return setjmp_call_p (*tp) ? *tp : NULL_TREE;
  92 }
  93
  94 /* Returns nonzero if FN calls `setjmp' or some other function that
  95    can return more than once.  This function is conservative; it may
  96    occasionally return a nonzero value even when FN does not actually
  97    call `setjmp'.  */
  98
  99 bool
 100 calls_setjmp_p (tree fn)
 101 {
 102   return walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
 103                                        calls_setjmp_r,
 104                                        NULL) != NULL_TREE;
 105 }
 106
 107 /* CLONED_PARM is a copy of CLONE, generated for a cloned constructor
 108    or destructor.  Update it to ensure that the source-position for
 109    the cloned parameter matches that for the original, and that the
 110    debugging generation code will be able to find the original PARM.  */
 111
 112 static void
 113 update_cloned_parm (tree parm, tree cloned_parm)
 114 {
 115   DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;
 116
 117   /* We may have taken its address.  */
 118   TREE_ADDRESSABLE (cloned_parm) = TREE_ADDRESSABLE (parm);
 119
 120   /* The definition might have different constness.  */
 121   TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
 122
 123   TREE_USED (cloned_parm) = TREE_USED (parm);
 124
 125   /* The name may have changed from the declaration.  */
 126   DECL_NAME (cloned_parm) = DECL_NAME (parm);
 127   DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
 128 }
 129
 130 /* FN is a function that has a complete body.  Clone the body as
 131    necessary.  Returns nonzero if there's no longer any need to
 132    process the main body.  */
 133
 134 bool
 135 maybe_clone_body (tree fn)
 136 {
 137   tree clone;
 138   bool first = true;
 139
 140   /* We only clone constructors and destructors.  */
 141   if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
 142       && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
 143     return 0;
 144
 145   /* Emit the DWARF1 abstract instance.  */
 146   (*debug_hooks->deferred_inline_function) (fn);
 147
 148   /* We know that any clones immediately follow FN in the TYPE_METHODS
 149      list.  */
 150   for (clone = TREE_CHAIN (fn);
 151        clone && DECL_CLONED_FUNCTION_P (clone);
 152        clone = TREE_CHAIN (clone), first = false)
 153     {
 154       tree parm;
 155       tree clone_parm;
 156       int parmno;
 157       splay_tree decl_map;
 158
 159       /* Update CLONE's source position information to match FN's.  */
 160       DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (fn);
 161       DECL_INLINE (clone) = DECL_INLINE (fn);
 162       DECL_DECLARED_INLINE_P (clone) = DECL_DECLARED_INLINE_P (fn);
 163       DECL_COMDAT (clone) = DECL_COMDAT (fn);
 164       DECL_WEAK (clone) = DECL_WEAK (fn);
 165       DECL_ONE_ONLY (clone) = DECL_ONE_ONLY (fn);
 166       DECL_SECTION_NAME (clone) = DECL_SECTION_NAME (fn);
 167       DECL_USE_TEMPLATE (clone) = DECL_USE_TEMPLATE (fn);
 168       DECL_EXTERNAL (clone) = DECL_EXTERNAL (fn);
 169       DECL_INTERFACE_KNOWN (clone) = DECL_INTERFACE_KNOWN (fn);
 170       DECL_NOT_REALLY_EXTERN (clone) = DECL_NOT_REALLY_EXTERN (fn);
 171       TREE_PUBLIC (clone) = TREE_PUBLIC (fn);
 172
 173       /* Adjust the parameter names and locations.  */
 174       parm = DECL_ARGUMENTS (fn);
 175       clone_parm = DECL_ARGUMENTS (clone);
 176       /* Update the `this' parameter, which is always first.  */
 177       update_cloned_parm (parm, clone_parm);
 178       parm = TREE_CHAIN (parm);
 179       clone_parm = TREE_CHAIN (clone_parm);
 180       if (DECL_HAS_IN_CHARGE_PARM_P (fn))
 181         parm = TREE_CHAIN (parm);
 182       if (DECL_HAS_VTT_PARM_P (fn))
 183         parm = TREE_CHAIN (parm);
 184       if (DECL_HAS_VTT_PARM_P (clone))
 185         clone_parm = TREE_CHAIN (clone_parm);
 186       for (; parm;
 187            parm = TREE_CHAIN (parm), clone_parm = TREE_CHAIN (clone_parm))
 188         {
 189           /* Update this parameter.  */
 190           update_cloned_parm (parm, clone_parm);
 191           /* We should only give unused information for one clone.  */
 192           if (!first)
 193             TREE_USED (clone_parm) = 1;
 194         }
 195
 196       /* Start processing the function.  */
 197       push_to_top_level ();
 198       start_function (NULL_TREE, clone, NULL_TREE, SF_PRE_PARSED);
 199
 200       /* Remap the parameters.  */
 201       decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
 202       for (parmno = 0,
 203              parm = DECL_ARGUMENTS (fn),
 204              clone_parm = DECL_ARGUMENTS (clone);
 205            parm;
 206            ++parmno,
 207              parm = TREE_CHAIN (parm))
 208         {
 209           /* Map the in-charge parameter to an appropriate constant.  */
 210           if (DECL_HAS_IN_CHARGE_PARM_P (fn) && parmno == 1)
 211             {
 212               tree in_charge;
 213               in_charge = in_charge_arg_for_name (DECL_NAME (clone));
 214               splay_tree_insert (decl_map,
 215                                  (splay_tree_key) parm,
 216                                  (splay_tree_value) in_charge);
 217             }
 218           else if (DECL_ARTIFICIAL (parm)
 219                    && DECL_NAME (parm) == vtt_parm_identifier)
 220             {
 221               /* For a subobject constructor or destructor, the next
 222                  argument is the VTT parameter.  Remap the VTT_PARM
 223                  from the CLONE to this parameter.  */
 224               if (DECL_HAS_VTT_PARM_P (clone))
 225                 {
 226                   DECL_ABSTRACT_ORIGIN (clone_parm) = parm;
 227                   splay_tree_insert (decl_map,
 228                                      (splay_tree_key) parm,
 229                                      (splay_tree_value) clone_parm);
 230                   clone_parm = TREE_CHAIN (clone_parm);
 231                 }
 232               /* Otherwise, map the VTT parameter to `NULL'.  */
 233               else
 234                 {
 235                   splay_tree_insert (decl_map,
 236                                      (splay_tree_key) parm,
 237                                      (splay_tree_value) null_pointer_node);
 238                 }
 239             }
 240           /* Map other parameters to their equivalents in the cloned
 241              function.  */
 242           else
 243             {
 244               splay_tree_insert (decl_map,
 245                                  (splay_tree_key) parm,
 246                                  (splay_tree_value) clone_parm);
 247               clone_parm = TREE_CHAIN (clone_parm);
 248             }
 249         }
 250
 251       /* Clone the body.  */
 252       clone_body (clone, fn, decl_map);
 253
 254       /* There are as many statements in the clone as in the
 255          original.  */
 256       DECL_ESTIMATED_INSNS (clone) = DECL_ESTIMATED_INSNS (fn);
 257
 258       /* Clean up.  */
 259       splay_tree_delete (decl_map);
 260
 261       /* The clone can throw iff the original function can throw.  */
 262       cp_function_chain->can_throw = !TREE_NOTHROW (fn);
 263
 264       /* Now, expand this function into RTL, if appropriate.  */
 265       finish_function (0);
 266       BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone)) = DECL_INITIAL (fn);
 267       expand_or_defer_fn (clone);
 268       pop_from_top_level ();
 269     }
 270
 271   /* We don't need to process the original function any further.  */
 272   return 1;
 273 }
 274
 275 /* Dump FUNCTION_DECL FN as tree dump PHASE.  */
 276
 277 static void
 278 dump_function (enum tree_dump_index phase, tree fn)
 279 {
 280   FILE *stream;
 281   int flags;
 282
 283   stream = dump_begin (phase, &flags);
 284   if (stream)
 285     {
 286       fprintf (stream, "\n;; Function %s",
 287                decl_as_string (fn, TFF_DECL_SPECIFIERS));
 288       fprintf (stream, " (%s)\n",
 289                decl_as_string (DECL_ASSEMBLER_NAME (fn), 0));
 290       fprintf (stream, ";; enabled by -fdump-%s\n", dump_flag_name (phase));
 291       fprintf (stream, "\n");
 292
 293       dump_node (fn, TDF_SLIM | flags, stream);
 294       dump_end (phase, stream);
 295     }
 296 }