gcc/config/mips/frame-header-opt.c

   1 /* Analyze functions to determine if callers need to allocate a frame header
   2    on the stack.  The frame header is used by callees to save their arguments.
   3    This optimization is specific to TARGET_OLDABI targets.  For TARGET_NEWABI
   4    targets, if a frame header is required, it is allocated by the callee.
   5
   6
   7    Copyright (C) 2015-2016 Free Software Foundation, Inc.
   8
   9 This file is part of GCC.
  10
  11 GCC is free software; you can redistribute it and/or modify it
  12 under the terms of the GNU General Public License as published by the
  13 Free Software Foundation; either version 3, or (at your option) any
  14 later version.
  15
  16 GCC is distributed in the hope that it will be useful, but WITHOUT
  17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  18 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  19 for more details.
  20
  21 You should have received a copy of the GNU General Public License
  22 along with GCC; see the file COPYING3.  If not see
  23 <http://www.gnu.org/licenses/>.  */
  24
  25
  26 #include "config.h"
  27 #include "system.h"
  28 #include "context.h"
  29 #include "coretypes.h"
  30 #include "tree.h"
  31 #include "tree-core.h"
  32 #include "tree-pass.h"
  33 #include "target.h"
  34 #include "target-globals.h"
  35 #include "cfg.h"
  36 #include "cgraph.h"
  37 #include "function.h"
  38 #include "basic-block.h"
  39 #include "gimple.h"
  40 #include "gimple-iterator.h"
  41 #include "gimple-walk.h"
  42
  43 static unsigned int frame_header_opt (void);
  44
  45 namespace {
  46
  47 const pass_data pass_data_ipa_frame_header_opt =
  48 {
  49   IPA_PASS, /* type */
  50   "frame-header-opt", /* name */
  51   OPTGROUP_NONE, /* optinfo_flags */
  52   TV_CGRAPHOPT, /* tv_id */
  53   0, /* properties_required */
  54   0, /* properties_provided */
  55   0, /* properties_destroyed */
  56   0, /* todo_flags_start */
  57   0, /* todo_flags_finish */
  58 };
  59
  60 class pass_ipa_frame_header_opt : public ipa_opt_pass_d
  61 {
  62 public:
  63   pass_ipa_frame_header_opt (gcc::context *ctxt)
  64     : ipa_opt_pass_d (pass_data_ipa_frame_header_opt, ctxt,
  65                       NULL, /* generate_summary */
  66                       NULL, /* write_summary */
  67                       NULL, /* read_summary */
  68                       NULL, /* write_optimization_summary */
  69                       NULL, /* read_optimization_summary */
  70                       NULL, /* stmt_fixup */
  71                       0, /* function_transform_todo_flags_start */
  72                       NULL, /* function_transform */
  73                       NULL) /* variable_transform */
  74   {}
  75
  76   /* opt_pass methods: */
  77   virtual bool gate (function *)
  78     {
  79       /* This optimization has no affect if TARGET_NEWABI.   If optimize
  80          is not at least 1 then the data needed for the optimization is
  81          not available and nothing will be done anyway.  */
  82       return TARGET_OLDABI && flag_frame_header_optimization && optimize > 0;
  83     }
  84
  85   virtual unsigned int execute (function *) { return frame_header_opt (); }
  86
  87 }; // class pass_ipa_frame_header_opt
  88
  89 } // anon namespace
  90
  91 static ipa_opt_pass_d *
  92 make_pass_ipa_frame_header_opt (gcc::context *ctxt)
  93 {
  94   return new pass_ipa_frame_header_opt (ctxt);
  95 }
  96
  97 void
  98 mips_register_frame_header_opt (void)
  99 {
 100   opt_pass *p = make_pass_ipa_frame_header_opt (g);
 101   static struct register_pass_info f =
 102     {p, "comdats", 1, PASS_POS_INSERT_AFTER };
 103   register_pass (&f);
 104 }
 105
 106
 107 /* Return true if it is certain that this is a leaf function.  False if it is
 108    not a leaf function or if it is impossible to tell.  */
 109
 110 static bool
 111 is_leaf_function (function *fn)
 112 {
 113   basic_block bb;
 114   gimple_stmt_iterator gsi;
 115
 116   /* If we do not have a cfg for this function be conservative and assume
 117      it is not a leaf function.  */
 118   if (fn->cfg == NULL)
 119     return false;
 120
 121   FOR_EACH_BB_FN (bb, fn)
 122     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 123       if (is_gimple_call (gsi_stmt (gsi)))
 124         return false;
 125   return true;
 126 }
 127
 128 /* Return true if this function has inline assembly code or if we cannot
 129    be certain that it does not.  False if we know that there is no inline
 130    assembly.  */
 131
 132 static bool
 133 has_inlined_assembly (function *fn)
 134 {
 135   basic_block bb;
 136   gimple_stmt_iterator gsi;
 137
 138   /* If we do not have a cfg for this function be conservative and assume
 139      it is may have inline assembly.  */
 140   if (fn->cfg == NULL)
 141     return true;
 142
 143   FOR_EACH_BB_FN (bb, fn)
 144     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 145       if (gimple_code (gsi_stmt (gsi)) == GIMPLE_ASM)
 146         return true;
 147
 148   return false;
 149 }
 150
 151 /* Return true if this function will use the stack space allocated by its
 152    caller or if we cannot determine for certain that it does not.  */
 153
 154 static bool
 155 needs_frame_header_p (function *fn)
 156 {
 157   tree t;
 158
 159   if (fn->decl == NULL)
 160     return true;
 161
 162   if (fn->stdarg)
 163     return true;
 164
 165   for (t = DECL_ARGUMENTS (fn->decl); t; t = TREE_CHAIN (t))
 166     {
 167       if (!use_register_for_decl (t))
 168         return true;
 169
 170       /* Some 64-bit types may get copied to general registers using the frame
 171          header, see mips_output_64bit_xfer.  Checking for SImode only may be
 172          overly restrictive but it is guaranteed to be safe. */
 173       if (DECL_MODE (t) != SImode)
 174         return true;
 175     }
 176
 177   return false;
 178 }
 179
 180 /* Return true if the argument stack space allocated by function FN is used.
 181    Return false if the space is needed or if the need for the space cannot
 182    be determined.  */
 183
 184 static bool
 185 callees_functions_use_frame_header (function *fn)
 186 {
 187   basic_block bb;
 188   gimple_stmt_iterator gsi;
 189   gimple *stmt;
 190   tree called_fn_tree;
 191   function *called_fn;
 192
 193   if (fn->cfg == NULL)
 194     return true;
 195
 196   FOR_EACH_BB_FN (bb, fn)
 197     {
 198       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 199         {
 200           stmt = gsi_stmt (gsi);
 201           if (is_gimple_call (stmt))
 202             {
 203               called_fn_tree = gimple_call_fndecl (stmt);
 204               if (called_fn_tree != NULL)
 205                 {
 206                   called_fn = DECL_STRUCT_FUNCTION (called_fn_tree);
 207                   if (called_fn == NULL
 208                       || DECL_WEAK (called_fn_tree)
 209                       || has_inlined_assembly (called_fn)
 210                       || !is_leaf_function (called_fn)
 211                       || !called_fn->machine->does_not_use_frame_header)
 212                     return true;
 213                 }
 214               else
 215                 return true;
 216             }
 217         }
 218     }
 219   return false;
 220 }
 221
 222 /* Set the callers_may_not_allocate_frame flag for any function which
 223    function FN calls because FN may not allocate a frame header.  */
 224
 225 static void
 226 set_callers_may_not_allocate_frame (function *fn)
 227 {
 228   basic_block bb;
 229   gimple_stmt_iterator gsi;
 230   gimple *stmt;
 231   tree called_fn_tree;
 232   function *called_fn;
 233
 234   if (fn->cfg == NULL)
 235     return;
 236
 237   FOR_EACH_BB_FN (bb, fn)
 238     {
 239       for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
 240         {
 241           stmt = gsi_stmt (gsi);
 242           if (is_gimple_call (stmt))
 243             {
 244               called_fn_tree = gimple_call_fndecl (stmt);
 245               if (called_fn_tree != NULL)
 246                 {
 247                   called_fn = DECL_STRUCT_FUNCTION (called_fn_tree);
 248                   if (called_fn != NULL)
 249                     called_fn->machine->callers_may_not_allocate_frame = true;
 250                 }
 251             }
 252         }
 253     }
 254   return;
 255 }
 256
 257 /* Scan each function to determine those that need its frame headers.  Perform
 258    a second scan to determine if the allocation can be skipped because none of
 259    their callees require the frame header.  */
 260
 261 static unsigned int
 262 frame_header_opt ()
 263 {
 264   struct cgraph_node *node;
 265   function *fn;
 266
 267   FOR_EACH_DEFINED_FUNCTION (node)
 268     {
 269       fn = node->get_fun ();
 270       if (fn != NULL)
 271         fn->machine->does_not_use_frame_header = !needs_frame_header_p (fn);
 272     }
 273
 274   FOR_EACH_DEFINED_FUNCTION (node)
 275     {
 276       fn = node->get_fun ();
 277       if (fn != NULL)
 278         fn->machine->optimize_call_stack
 279           = !callees_functions_use_frame_header (fn) && !is_leaf_function (fn);
 280     }
 281
 282   FOR_EACH_DEFINED_FUNCTION (node)
 283     {
 284       fn = node->get_fun ();
 285       if (fn != NULL && fn->machine->optimize_call_stack)
 286         set_callers_may_not_allocate_frame (fn);
 287     }
 288
 289   return 0;
 290 }