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