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