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