gcc/gimplify-me.c

   1 /* Tree lowering to gimple for middle end use only.
   2    This converts the GENERIC functions-as-trees tree representation into
   3    the GIMPLE form.
   4    Copyright (C) 2013-2015 Free Software Foundation, Inc.
   5    Major work done by Sebastian Pop <s.pop@laposte.net>,
   6    Diego Novillo <dnovillo@redhat.com> and Jason Merrill <jason@redhat.com>.
   7
   8 This file is part of GCC.
   9
  10 GCC is free software; you can redistribute it and/or modify it under
  11 the terms of the GNU General Public License as published by the Free
  12 Software Foundation; either version 3, or (at your option) any later
  13 version.
  14
  15 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  16 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  17 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  18 for more details.
  19
  20 You should have received a copy of the GNU General Public License
  21 along with GCC; see the file COPYING3.  If not see
  22 <http://www.gnu.org/licenses/>.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "hash-set.h"
  28 #include "machmode.h"
  29 #include "vec.h"
  30 #include "double-int.h"
  31 #include "input.h"
  32 #include "alias.h"
  33 #include "symtab.h"
  34 #include "options.h"
  35 #include "wide-int.h"
  36 #include "inchash.h"
  37 #include "tree.h"
  38 #include "fold-const.h"
  39 #include "stmt.h"
  40 #include "stor-layout.h"
  41 #include "predict.h"
  42 #include "tm.h"
  43 #include "hard-reg-set.h"
  44 #include "input.h"
  45 #include "function.h"
  46 #include "basic-block.h"
  47 #include "tree-ssa-alias.h"
  48 #include "internal-fn.h"
  49 #include "tree-eh.h"
  50 #include "gimple-expr.h"
  51 #include "is-a.h"
  52 #include "gimple.h"
  53 #include "gimple-iterator.h"
  54 #include "gimplify.h"
  55 #include "gimplify-me.h"
  56 #include "gimple-ssa.h"
  57 #include "stringpool.h"
  58 #include "tree-ssanames.h"
  59
  60
  61 /* Expand EXPR to list of gimple statements STMTS.  GIMPLE_TEST_F specifies
  62    the predicate that will hold for the result.  If VAR is not NULL, make the
  63    base variable of the final destination be VAR if suitable.  */
  64
  65 tree
  66 force_gimple_operand_1 (tree expr, gimple_seq *stmts,
  67                         gimple_predicate gimple_test_f, tree var)
  68 {
  69   enum gimplify_status ret;
  70   location_t saved_location;
  71
  72   *stmts = NULL;
  73
  74   /* gimple_test_f might be more strict than is_gimple_val, make
  75      sure we pass both.  Just checking gimple_test_f doesn't work
  76      because most gimple predicates do not work recursively.  */
  77   if (is_gimple_val (expr)
  78       && (*gimple_test_f) (expr))
  79     return expr;
  80
  81   push_gimplify_context (gimple_in_ssa_p (cfun), true);
  82   saved_location = input_location;
  83   input_location = UNKNOWN_LOCATION;
  84
  85   if (var)
  86     {
  87       if (gimple_in_ssa_p (cfun) && is_gimple_reg (var))
  88         var = make_ssa_name (var);
  89       expr = build2 (MODIFY_EXPR, TREE_TYPE (var), var, expr);
  90     }
  91
  92   if (TREE_CODE (expr) != MODIFY_EXPR
  93       && TREE_TYPE (expr) == void_type_node)
  94     {
  95       gimplify_and_add (expr, stmts);
  96       expr = NULL_TREE;
  97     }
  98   else
  99     {
 100       ret = gimplify_expr (&expr, stmts, NULL, gimple_test_f, fb_rvalue);
 101       gcc_assert (ret != GS_ERROR);
 102     }
 103
 104   input_location = saved_location;
 105   pop_gimplify_context (NULL);
 106
 107   return expr;
 108 }
 109
 110 /* Expand EXPR to list of gimple statements STMTS.  If SIMPLE is true,
 111    force the result to be either ssa_name or an invariant, otherwise
 112    just force it to be a rhs expression.  If VAR is not NULL, make the
 113    base variable of the final destination be VAR if suitable.  */
 114
 115 tree
 116 force_gimple_operand (tree expr, gimple_seq *stmts, bool simple, tree var)
 117 {
 118   return force_gimple_operand_1 (expr, stmts,
 119                                  simple ? is_gimple_val : is_gimple_reg_rhs,
 120                                  var);
 121 }
 122
 123 /* Invoke force_gimple_operand_1 for EXPR with parameters GIMPLE_TEST_F
 124    and VAR.  If some statements are produced, emits them at GSI.
 125    If BEFORE is true.  the statements are appended before GSI, otherwise
 126    they are appended after it.  M specifies the way GSI moves after
 127    insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING are the usual values).  */
 128
 129 tree
 130 force_gimple_operand_gsi_1 (gimple_stmt_iterator *gsi, tree expr,
 131                             gimple_predicate gimple_test_f,
 132                             tree var, bool before,
 133                             enum gsi_iterator_update m)
 134 {
 135   gimple_seq stmts;
 136
 137   expr = force_gimple_operand_1 (expr, &stmts, gimple_test_f, var);
 138
 139   if (!gimple_seq_empty_p (stmts))
 140     {
 141       if (before)
 142         gsi_insert_seq_before (gsi, stmts, m);
 143       else
 144         gsi_insert_seq_after (gsi, stmts, m);
 145     }
 146
 147   return expr;
 148 }
 149
 150 /* Invoke force_gimple_operand_1 for EXPR with parameter VAR.
 151    If SIMPLE is true, force the result to be either ssa_name or an invariant,
 152    otherwise just force it to be a rhs expression.  If some statements are
 153    produced, emits them at GSI.  If BEFORE is true, the statements are
 154    appended before GSI, otherwise they are appended after it.  M specifies
 155    the way GSI moves after insertion (GSI_SAME_STMT or GSI_CONTINUE_LINKING
 156    are the usual values).  */
 157
 158 tree
 159 force_gimple_operand_gsi (gimple_stmt_iterator *gsi, tree expr,
 160                           bool simple_p, tree var, bool before,
 161                           enum gsi_iterator_update m)
 162 {
 163   return force_gimple_operand_gsi_1 (gsi, expr,
 164                                      simple_p
 165                                      ? is_gimple_val : is_gimple_reg_rhs,
 166                                      var, before, m);
 167 }
 168
 169 /* Some transformations like inlining may invalidate the GIMPLE form
 170    for operands.  This function traverses all the operands in STMT and
 171    gimplifies anything that is not a valid gimple operand.  Any new
 172    GIMPLE statements are inserted before *GSI_P.  */
 173
 174 void
 175 gimple_regimplify_operands (gimple stmt, gimple_stmt_iterator *gsi_p)
 176 {
 177   size_t i, num_ops;
 178   tree lhs;
 179   gimple_seq pre = NULL;
 180   gimple post_stmt = NULL;
 181
 182   push_gimplify_context (gimple_in_ssa_p (cfun));
 183
 184   switch (gimple_code (stmt))
 185     {
 186     case GIMPLE_COND:
 187       {
 188         gcond *cond_stmt = as_a <gcond *> (stmt);
 189         gimplify_expr (gimple_cond_lhs_ptr (cond_stmt), &pre, NULL,
 190                        is_gimple_val, fb_rvalue);
 191         gimplify_expr (gimple_cond_rhs_ptr (cond_stmt), &pre, NULL,
 192                        is_gimple_val, fb_rvalue);
 193       }
 194       break;
 195     case GIMPLE_SWITCH:
 196       gimplify_expr (gimple_switch_index_ptr (as_a <gswitch *> (stmt)),
 197                      &pre, NULL, is_gimple_val, fb_rvalue);
 198       break;
 199     case GIMPLE_OMP_ATOMIC_LOAD:
 200       gimplify_expr (gimple_omp_atomic_load_rhs_ptr (
 201                        as_a <gomp_atomic_load *> (stmt)),
 202                      &pre, NULL, is_gimple_val, fb_rvalue);
 203       break;
 204     case GIMPLE_ASM:
 205       {
 206         gasm *asm_stmt = as_a <gasm *> (stmt);
 207         size_t i, noutputs = gimple_asm_noutputs (asm_stmt);
 208         const char *constraint, **oconstraints;
 209         bool allows_mem, allows_reg, is_inout;
 210
 211         oconstraints
 212           = (const char **) alloca ((noutputs) * sizeof (const char *));
 213         for (i = 0; i < noutputs; i++)
 214           {
 215             tree op = gimple_asm_output_op (asm_stmt, i);
 216             constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
 217             oconstraints[i] = constraint;
 218             parse_output_constraint (&constraint, i, 0, 0, &allows_mem,
 219                                      &allows_reg, &is_inout);
 220             gimplify_expr (&TREE_VALUE (op), &pre, NULL,
 221                            is_inout ? is_gimple_min_lval : is_gimple_lvalue,
 222                            fb_lvalue | fb_mayfail);
 223           }
 224         for (i = 0; i < gimple_asm_ninputs (asm_stmt); i++)
 225           {
 226             tree op = gimple_asm_input_op (asm_stmt, i);
 227             constraint = TREE_STRING_POINTER (TREE_VALUE (TREE_PURPOSE (op)));
 228             parse_input_constraint (&constraint, 0, 0, noutputs, 0,
 229                                     oconstraints, &allows_mem, &allows_reg);
 230             if (TREE_ADDRESSABLE (TREE_TYPE (TREE_VALUE (op))) && allows_mem)
 231               allows_reg = 0;
 232             if (!allows_reg && allows_mem)
 233               gimplify_expr (&TREE_VALUE (op), &pre, NULL,
 234                              is_gimple_lvalue, fb_lvalue | fb_mayfail);
 235             else
 236               gimplify_expr (&TREE_VALUE (op), &pre, NULL,
 237                              is_gimple_asm_val, fb_rvalue);
 238           }
 239       }
 240       break;
 241     default:
 242       /* NOTE: We start gimplifying operands from last to first to
 243          make sure that side-effects on the RHS of calls, assignments
 244          and ASMs are executed before the LHS.  The ordering is not
 245          important for other statements.  */
 246       num_ops = gimple_num_ops (stmt);
 247       for (i = num_ops; i > 0; i--)
 248         {
 249           tree op = gimple_op (stmt, i - 1);
 250           if (op == NULL_TREE)
 251             continue;
 252           if (i == 1 && (is_gimple_call (stmt) || is_gimple_assign (stmt)))
 253             gimplify_expr (&op, &pre, NULL, is_gimple_lvalue, fb_lvalue);
 254           else if (i == 2
 255                    && is_gimple_assign (stmt)
 256                    && num_ops == 2
 257                    && get_gimple_rhs_class (gimple_expr_code (stmt))
 258                       == GIMPLE_SINGLE_RHS)
 259             gimplify_expr (&op, &pre, NULL,
 260                            rhs_predicate_for (gimple_assign_lhs (stmt)),
 261                            fb_rvalue);
 262           else if (i == 2 && is_gimple_call (stmt))
 263             {
 264               if (TREE_CODE (op) == FUNCTION_DECL)
 265                 continue;
 266               gimplify_expr (&op, &pre, NULL, is_gimple_call_addr, fb_rvalue);
 267             }
 268           else
 269             gimplify_expr (&op, &pre, NULL, is_gimple_val, fb_rvalue);
 270           gimple_set_op (stmt, i - 1, op);
 271         }
 272
 273       lhs = gimple_get_lhs (stmt);
 274       /* If the LHS changed it in a way that requires a simple RHS,
 275          create temporary.  */
 276       if (lhs && !is_gimple_reg (lhs))
 277         {
 278           bool need_temp = false;
 279
 280           if (is_gimple_assign (stmt)
 281               && num_ops == 2
 282               && get_gimple_rhs_class (gimple_expr_code (stmt))
 283                  == GIMPLE_SINGLE_RHS)
 284             gimplify_expr (gimple_assign_rhs1_ptr (stmt), &pre, NULL,
 285                            rhs_predicate_for (gimple_assign_lhs (stmt)),
 286                            fb_rvalue);
 287           else if (is_gimple_reg (lhs))
 288             {
 289               if (is_gimple_reg_type (TREE_TYPE (lhs)))
 290                 {
 291                   if (is_gimple_call (stmt))
 292                     {
 293                       i = gimple_call_flags (stmt);
 294                       if ((i & ECF_LOOPING_CONST_OR_PURE)
 295                           || !(i & (ECF_CONST | ECF_PURE)))
 296                         need_temp = true;
 297                     }
 298                   if (stmt_can_throw_internal (stmt))
 299                     need_temp = true;
 300                 }
 301             }
 302           else
 303             {
 304               if (is_gimple_reg_type (TREE_TYPE (lhs)))
 305                 need_temp = true;
 306               else if (TYPE_MODE (TREE_TYPE (lhs)) != BLKmode)
 307                 {
 308                   if (is_gimple_call (stmt))
 309                     {
 310                       tree fndecl = gimple_call_fndecl (stmt);
 311
 312                       if (!aggregate_value_p (TREE_TYPE (lhs), fndecl)
 313                           && !(fndecl && DECL_RESULT (fndecl)
 314                                && DECL_BY_REFERENCE (DECL_RESULT (fndecl))))
 315                         need_temp = true;
 316                     }
 317                   else
 318                     need_temp = true;
 319                 }
 320             }
 321           if (need_temp)
 322             {
 323               tree temp = create_tmp_reg (TREE_TYPE (lhs));
 324               if (gimple_in_ssa_p (cfun))
 325                 temp = make_ssa_name (temp);
 326               gimple_set_lhs (stmt, temp);
 327               post_stmt = gimple_build_assign (lhs, temp);
 328             }
 329         }
 330       break;
 331     }
 332
 333   if (!gimple_seq_empty_p (pre))
 334     gsi_insert_seq_before (gsi_p, pre, GSI_SAME_STMT);
 335   if (post_stmt)
 336     gsi_insert_after (gsi_p, post_stmt, GSI_NEW_STMT);
 337
 338   pop_gimplify_context (NULL);
 339
 340   update_stmt (stmt);
 341 }
 342
 343