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   if (flag_inline_trees
  53       /* We do not inline thunks, as (a) the backend tries to optimize
  54          the call to the thunkee, (b) tree based inlining breaks that
  55          optimization, (c) virtual functions are rarely inlineable,
  56          and (d) TARGET_ASM_OUTPUT_MI_THUNK is there to DTRT anyway.  */
  57       && !DECL_THUNK_P (fn))
  58     {
  59       optimize_inline_calls (fn);
  60
  61       dump_function (TDI_inlined, fn);
  62     }
  63
  64   dump_function (TDI_optimized, fn);
  65 }
  66
  67 /* Called from calls_setjmp_p via walk_tree.  */
  68
  69 static tree
  70 calls_setjmp_r (tree *tp, int *walk_subtrees ATTRIBUTE_UNUSED,
  71                 void *data ATTRIBUTE_UNUSED)
  72 {
  73   /* We're only interested in FUNCTION_DECLS.  */
  74   if (TREE_CODE (*tp) != FUNCTION_DECL)
  75     return NULL_TREE;
  76
  77   return setjmp_call_p (*tp) ? *tp : NULL_TREE;
  78 }
  79
  80 /* Returns nonzero if FN calls `setjmp' or some other function that
  81    can return more than once.  This function is conservative; it may
  82    occasionally return a nonzero value even when FN does not actually
  83    call `setjmp'.  */
  84
  85 bool
  86 calls_setjmp_p (tree fn)
  87 {
  88   return walk_tree_without_duplicates (&DECL_SAVED_TREE (fn),
  89                                        calls_setjmp_r,
  90                                        NULL) != NULL_TREE;
  91 }
  92
  93 /* CLONED_PARM is a copy of CLONE, generated for a cloned constructor
  94    or destructor.  Update it to ensure that the source-position for
  95    the cloned parameter matches that for the original, and that the
  96    debugging generation code will be able to find the original PARM.  */
  97
  98 static void
  99 update_cloned_parm (tree parm, tree cloned_parm)
 100 {
 101   DECL_ABSTRACT_ORIGIN (cloned_parm) = parm;
 102
 103   /* We may have taken its address.  */
 104   TREE_ADDRESSABLE (cloned_parm) = TREE_ADDRESSABLE (parm);
 105
 106   /* The definition might have different constness.  */
 107   TREE_READONLY (cloned_parm) = TREE_READONLY (parm);
 108
 109   TREE_USED (cloned_parm) = TREE_USED (parm);
 110
 111   /* The name may have changed from the declaration.  */
 112   DECL_NAME (cloned_parm) = DECL_NAME (parm);
 113   DECL_SOURCE_LOCATION (cloned_parm) = DECL_SOURCE_LOCATION (parm);
 114 }
 115
 116 /* FN is a function that has a complete body.  Clone the body as
 117    necessary.  Returns nonzero if there's no longer any need to
 118    process the main body.  */
 119
 120 bool
 121 maybe_clone_body (tree fn)
 122 {
 123   tree clone;
 124   bool first = true;
 125
 126   /* We only clone constructors and destructors.  */
 127   if (!DECL_MAYBE_IN_CHARGE_CONSTRUCTOR_P (fn)
 128       && !DECL_MAYBE_IN_CHARGE_DESTRUCTOR_P (fn))
 129     return 0;
 130
 131   /* Emit the DWARF1 abstract instance.  */
 132   (*debug_hooks->deferred_inline_function) (fn);
 133
 134   /* We know that any clones immediately follow FN in the TYPE_METHODS
 135      list.  */
 136   for (clone = TREE_CHAIN (fn);
 137        clone && DECL_CLONED_FUNCTION_P (clone);
 138        clone = TREE_CHAIN (clone), first = false)
 139     {
 140       tree parm;
 141       tree clone_parm;
 142       int parmno;
 143       splay_tree decl_map;
 144
 145       /* Update CLONE's source position information to match FN's.  */
 146       DECL_SOURCE_LOCATION (clone) = DECL_SOURCE_LOCATION (fn);
 147       DECL_INLINE (clone) = DECL_INLINE (fn);
 148       DECL_DECLARED_INLINE_P (clone) = DECL_DECLARED_INLINE_P (fn);
 149       DECL_COMDAT (clone) = DECL_COMDAT (fn);
 150       DECL_WEAK (clone) = DECL_WEAK (fn);
 151       DECL_ONE_ONLY (clone) = DECL_ONE_ONLY (fn);
 152       DECL_SECTION_NAME (clone) = DECL_SECTION_NAME (fn);
 153       DECL_USE_TEMPLATE (clone) = DECL_USE_TEMPLATE (fn);
 154       DECL_EXTERNAL (clone) = DECL_EXTERNAL (fn);
 155       DECL_INTERFACE_KNOWN (clone) = DECL_INTERFACE_KNOWN (fn);
 156       DECL_NOT_REALLY_EXTERN (clone) = DECL_NOT_REALLY_EXTERN (fn);
 157       TREE_PUBLIC (clone) = TREE_PUBLIC (fn);
 158
 159       /* Adjust the parameter names and locations.  */
 160       parm = DECL_ARGUMENTS (fn);
 161       clone_parm = DECL_ARGUMENTS (clone);
 162       /* Update the `this' parameter, which is always first.  */
 163       update_cloned_parm (parm, clone_parm);
 164       parm = TREE_CHAIN (parm);
 165       clone_parm = TREE_CHAIN (clone_parm);
 166       if (DECL_HAS_IN_CHARGE_PARM_P (fn))
 167         parm = TREE_CHAIN (parm);
 168       if (DECL_HAS_VTT_PARM_P (fn))
 169         parm = TREE_CHAIN (parm);
 170       if (DECL_HAS_VTT_PARM_P (clone))
 171         clone_parm = TREE_CHAIN (clone_parm);
 172       for (; parm;
 173            parm = TREE_CHAIN (parm), clone_parm = TREE_CHAIN (clone_parm))
 174         {
 175           /* Update this parameter.  */
 176           update_cloned_parm (parm, clone_parm);
 177           /* We should only give unused information for one clone.  */
 178           if (!first)
 179             TREE_USED (clone_parm) = 1;
 180         }
 181
 182       /* Start processing the function.  */
 183       push_to_top_level ();
 184       start_function (NULL_TREE, clone, NULL_TREE, SF_PRE_PARSED);
 185
 186       /* Remap the parameters.  */
 187       decl_map = splay_tree_new (splay_tree_compare_pointers, NULL, NULL);
 188       for (parmno = 0,
 189              parm = DECL_ARGUMENTS (fn),
 190              clone_parm = DECL_ARGUMENTS (clone);
 191            parm;
 192            ++parmno,
 193              parm = TREE_CHAIN (parm))
 194         {
 195           /* Map the in-charge parameter to an appropriate constant.  */
 196           if (DECL_HAS_IN_CHARGE_PARM_P (fn) && parmno == 1)
 197             {
 198               tree in_charge;
 199               in_charge = in_charge_arg_for_name (DECL_NAME (clone));
 200               splay_tree_insert (decl_map,
 201                                  (splay_tree_key) parm,
 202                                  (splay_tree_value) in_charge);
 203             }
 204           else if (DECL_ARTIFICIAL (parm)
 205                    && DECL_NAME (parm) == vtt_parm_identifier)
 206             {
 207               /* For a subobject constructor or destructor, the next
 208                  argument is the VTT parameter.  Remap the VTT_PARM
 209                  from the CLONE to this parameter.  */
 210               if (DECL_HAS_VTT_PARM_P (clone))
 211                 {
 212                   DECL_ABSTRACT_ORIGIN (clone_parm) = parm;
 213                   splay_tree_insert (decl_map,
 214                                      (splay_tree_key) parm,
 215                                      (splay_tree_value) clone_parm);
 216                   clone_parm = TREE_CHAIN (clone_parm);
 217                 }
 218               /* Otherwise, map the VTT parameter to `NULL'.  */
 219               else
 220                 {
 221                   splay_tree_insert (decl_map,
 222                                      (splay_tree_key) parm,
 223                                      (splay_tree_value) null_pointer_node);
 224                 }
 225             }
 226           /* Map other parameters to their equivalents in the cloned
 227              function.  */
 228           else
 229             {
 230               splay_tree_insert (decl_map,
 231                                  (splay_tree_key) parm,
 232                                  (splay_tree_value) clone_parm);
 233               clone_parm = TREE_CHAIN (clone_parm);
 234             }
 235         }
 236
 237       /* Clone the body.  */
 238       clone_body (clone, fn, decl_map);
 239
 240       /* There are as many statements in the clone as in the
 241          original.  */
 242       DECL_ESTIMATED_INSNS (clone) = DECL_ESTIMATED_INSNS (fn);
 243
 244       /* Clean up.  */
 245       splay_tree_delete (decl_map);
 246
 247       /* The clone can throw iff the original function can throw.  */
 248       cp_function_chain->can_throw = !TREE_NOTHROW (fn);
 249
 250       /* Now, expand this function into RTL, if appropriate.  */
 251       finish_function (0);
 252       BLOCK_ABSTRACT_ORIGIN (DECL_INITIAL (clone)) = DECL_INITIAL (fn);
 253       expand_or_defer_fn (clone);
 254       pop_from_top_level ();
 255     }
 256
 257   /* We don't need to process the original function any further.  */
 258   return 1;
 259 }
 260
 261 /* Dump FUNCTION_DECL FN as tree dump PHASE.  */
 262
 263 static void
 264 dump_function (enum tree_dump_index phase, tree fn)
 265 {
 266   FILE *stream;
 267   int flags;
 268
 269   stream = dump_begin (phase, &flags);
 270   if (stream)
 271     {
 272       fprintf (stream, "\n;; Function %s",
 273                decl_as_string (fn, TFF_DECL_SPECIFIERS));
 274       fprintf (stream, " (%s)\n",
 275                decl_as_string (DECL_ASSEMBLER_NAME (fn), 0));
 276       fprintf (stream, ";; enabled by -fdump-%s\n", dump_flag_name (phase));
 277       fprintf (stream, "\n");
 278
 279       dump_node (fn, TDF_SLIM | flags, stream);
 280       dump_end (phase, stream);
 281     }
 282 }