gcc/gimple-low.c

   1 /* GIMPLE lowering pass.  Converts High GIMPLE into Low GIMPLE.
   2
   3    Copyright (C) 2003, 2004, 2005, 2006, 2007, 2008, 2009
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "tree.h"
  27 #include "rtl.h"
  28 #include "varray.h"
  29 #include "gimple.h"
  30 #include "tree-iterator.h"
  31 #include "tree-inline.h"
  32 #include "diagnostic.h"
  33 #include "langhooks.h"
  34 #include "langhooks-def.h"
  35 #include "tree-flow.h"
  36 #include "timevar.h"
  37 #include "except.h"
  38 #include "hashtab.h"
  39 #include "flags.h"
  40 #include "function.h"
  41 #include "expr.h"
  42 #include "toplev.h"
  43 #include "tree-pass.h"
  44
  45 /* The differences between High GIMPLE and Low GIMPLE are the
  46    following:
  47
  48    1- Lexical scopes are removed (i.e., GIMPLE_BIND disappears).
  49
  50    2- GIMPLE_TRY and GIMPLE_CATCH are converted to abnormal control
  51       flow and exception regions are built as an on-the-side region
  52       hierarchy (See tree-eh.c:lower_eh_constructs).
  53
  54    3- Multiple identical return statements are grouped into a single
  55       return and gotos to the unique return site.  */
  56
  57 /* Match a return statement with a label.  During lowering, we identify
  58    identical return statements and replace duplicates with a jump to
  59    the corresponding label.  */
  60 struct return_statements_t
  61 {
  62   tree label;
  63   gimple stmt;
  64 };
  65 typedef struct return_statements_t return_statements_t;
  66
  67 DEF_VEC_O(return_statements_t);
  68 DEF_VEC_ALLOC_O(return_statements_t,heap);
  69
  70 struct lower_data
  71 {
  72   /* Block the current statement belongs to.  */
  73   tree block;
  74
  75   /* A vector of label and return statements to be moved to the end
  76      of the function.  */
  77   VEC(return_statements_t,heap) *return_statements;
  78
  79   /* True if the function calls __builtin_setjmp.  */
  80   bool calls_builtin_setjmp;
  81 };
  82
  83 static void lower_stmt (gimple_stmt_iterator *, struct lower_data *);
  84 static void lower_gimple_bind (gimple_stmt_iterator *, struct lower_data *);
  85 static void lower_gimple_return (gimple_stmt_iterator *, struct lower_data *);
  86 static void lower_builtin_setjmp (gimple_stmt_iterator *);
  87
  88
  89 /* Lower the body of current_function_decl from High GIMPLE into Low
  90    GIMPLE.  */
  91
  92 static unsigned int
  93 lower_function_body (void)
  94 {
  95   struct lower_data data;
  96   gimple_seq body = gimple_body (current_function_decl);
  97   gimple_seq lowered_body;
  98   gimple_stmt_iterator i;
  99   gimple bind;
 100   tree t;
 101   gimple x;
 102
 103   /* The gimplifier should've left a body of exactly one statement,
 104      namely a GIMPLE_BIND.  */
 105   gcc_assert (gimple_seq_first (body) == gimple_seq_last (body)
 106               && gimple_code (gimple_seq_first_stmt (body)) == GIMPLE_BIND);
 107
 108   memset (&data, 0, sizeof (data));
 109   data.block = DECL_INITIAL (current_function_decl);
 110   BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
 111   BLOCK_CHAIN (data.block) = NULL_TREE;
 112   TREE_ASM_WRITTEN (data.block) = 1;
 113   data.return_statements = VEC_alloc (return_statements_t, heap, 8);
 114
 115   bind = gimple_seq_first_stmt (body);
 116   lowered_body = NULL;
 117   gimple_seq_add_stmt (&lowered_body, bind);
 118   i = gsi_start (lowered_body);
 119   lower_gimple_bind (&i, &data);
 120
 121   /* Once the old body has been lowered, replace it with the new
 122      lowered sequence.  */
 123   gimple_set_body (current_function_decl, lowered_body);
 124
 125   i = gsi_last (lowered_body);
 126
 127   /* If the function falls off the end, we need a null return statement.
 128      If we've already got one in the return_statements vector, we don't
 129      need to do anything special.  Otherwise build one by hand.  */
 130   if (gimple_seq_may_fallthru (lowered_body)
 131       && (VEC_empty (return_statements_t, data.return_statements)
 132           || gimple_return_retval (VEC_last (return_statements_t,
 133                                    data.return_statements)->stmt) != NULL))
 134     {
 135       x = gimple_build_return (NULL);
 136       gimple_set_location (x, cfun->function_end_locus);
 137       gimple_set_block (x, DECL_INITIAL (current_function_decl));
 138       gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
 139     }
 140
 141   /* If we lowered any return statements, emit the representative
 142      at the end of the function.  */
 143   while (!VEC_empty (return_statements_t, data.return_statements))
 144     {
 145       return_statements_t t;
 146
 147       /* Unfortunately, we can't use VEC_pop because it returns void for
 148          objects.  */
 149       t = *VEC_last (return_statements_t, data.return_statements);
 150       VEC_truncate (return_statements_t,
 151                     data.return_statements,
 152                     VEC_length (return_statements_t,
 153                                 data.return_statements) - 1);
 154
 155       x = gimple_build_label (t.label);
 156       gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
 157
 158       /* Remove the line number from the representative return statement.
 159          It now fills in for many such returns.  Failure to remove this
 160          will result in incorrect results for coverage analysis.  */
 161       gimple_set_location (t.stmt, UNKNOWN_LOCATION);
 162       gsi_insert_after (&i, t.stmt, GSI_CONTINUE_LINKING);
 163     }
 164
 165   /* If the function calls __builtin_setjmp, we need to emit the computed
 166      goto that will serve as the unique dispatcher for all the receivers.  */
 167   if (data.calls_builtin_setjmp)
 168     {
 169       tree disp_label, disp_var, arg;
 170
 171       /* Build 'DISP_LABEL:' and insert.  */
 172       disp_label = create_artificial_label (cfun->function_end_locus);
 173       /* This mark will create forward edges from every call site.  */
 174       DECL_NONLOCAL (disp_label) = 1;
 175       cfun->has_nonlocal_label = 1;
 176       x = gimple_build_label (disp_label);
 177       gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
 178
 179       /* Build 'DISP_VAR = __builtin_setjmp_dispatcher (DISP_LABEL);'
 180          and insert.  */
 181       disp_var = create_tmp_var (ptr_type_node, "setjmpvar");
 182       arg = build_addr (disp_label, current_function_decl);
 183       t = implicit_built_in_decls[BUILT_IN_SETJMP_DISPATCHER];
 184       x = gimple_build_call (t, 1, arg);
 185       gimple_call_set_lhs (x, disp_var);
 186
 187       /* Build 'goto DISP_VAR;' and insert.  */
 188       gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
 189       x = gimple_build_goto (disp_var);
 190       gsi_insert_after (&i, x, GSI_CONTINUE_LINKING);
 191     }
 192
 193   gcc_assert (data.block == DECL_INITIAL (current_function_decl));
 194   BLOCK_SUBBLOCKS (data.block)
 195     = blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
 196
 197   clear_block_marks (data.block);
 198   VEC_free(return_statements_t, heap, data.return_statements);
 199   return 0;
 200 }
 201
 202 struct gimple_opt_pass pass_lower_cf =
 203 {
 204  {
 205   GIMPLE_PASS,
 206   "lower",                              /* name */
 207   NULL,                                 /* gate */
 208   lower_function_body,                  /* execute */
 209   NULL,                                 /* sub */
 210   NULL,                                 /* next */
 211   0,                                    /* static_pass_number */
 212   TV_NONE,                              /* tv_id */
 213   PROP_gimple_any,                      /* properties_required */
 214   PROP_gimple_lcf,                      /* properties_provided */
 215   0,                                    /* properties_destroyed */
 216   0,                                    /* todo_flags_start */
 217   TODO_dump_func                        /* todo_flags_finish */
 218  }
 219 };
 220
 221
 222 /* Verify if the type of the argument matches that of the function
 223    declaration.  If we cannot verify this or there is a mismatch,
 224    mark the call expression so it doesn't get inlined later.  */
 225
 226 static void
 227 check_call_args (gimple stmt)
 228 {
 229   tree fndecl, parms, p;
 230   unsigned int i, nargs;
 231
 232   if (gimple_call_cannot_inline_p (stmt))
 233     return;
 234
 235   nargs = gimple_call_num_args (stmt);
 236
 237   /* Get argument types for verification.  */
 238   fndecl = gimple_call_fndecl (stmt);
 239   parms = NULL_TREE;
 240   if (fndecl)
 241     parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
 242   else if (POINTER_TYPE_P (TREE_TYPE (gimple_call_fn (stmt))))
 243     parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt))));
 244
 245   /* Verify if the type of the argument matches that of the function
 246      declaration.  If we cannot verify this or there is a mismatch,
 247      mark the call expression so it doesn't get inlined later.  */
 248   if (fndecl && DECL_ARGUMENTS (fndecl))
 249     {
 250       for (i = 0, p = DECL_ARGUMENTS (fndecl);
 251            i < nargs;
 252            i++, p = TREE_CHAIN (p))
 253         {
 254           /* We cannot distinguish a varargs function from the case
 255              of excess parameters, still deferring the inlining decision
 256              to the callee is possible.  */
 257           if (!p)
 258             break;
 259           if (p == error_mark_node
 260               || gimple_call_arg (stmt, i) == error_mark_node
 261               || !fold_convertible_p (DECL_ARG_TYPE (p),
 262                                       gimple_call_arg (stmt, i)))
 263             {
 264               gimple_call_set_cannot_inline (stmt, true);
 265               break;
 266             }
 267         }
 268     }
 269   else if (parms)
 270     {
 271       for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
 272         {
 273           /* If this is a varargs function defer inlining decision
 274              to callee.  */
 275           if (!p)
 276             break;
 277           if (TREE_VALUE (p) == error_mark_node
 278               || gimple_call_arg (stmt, i) == error_mark_node
 279               || TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
 280               || !fold_convertible_p (TREE_VALUE (p),
 281                                       gimple_call_arg (stmt, i)))
 282             {
 283               gimple_call_set_cannot_inline (stmt, true);
 284               break;
 285             }
 286         }
 287     }
 288   else
 289     {
 290       if (nargs != 0)
 291         gimple_call_set_cannot_inline (stmt, true);
 292     }
 293 }
 294
 295
 296 /* Lower sequence SEQ.  Unlike gimplification the statements are not relowered
 297    when they are changed -- if this has to be done, the lowering routine must
 298    do it explicitly.  DATA is passed through the recursion.  */
 299
 300 static void
 301 lower_sequence (gimple_seq seq, struct lower_data *data)
 302 {
 303   gimple_stmt_iterator gsi;
 304
 305   for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
 306     lower_stmt (&gsi, data);
 307 }
 308
 309
 310 /* Lower the OpenMP directive statement pointed by GSI.  DATA is
 311    passed through the recursion.  */
 312
 313 static void
 314 lower_omp_directive (gimple_stmt_iterator *gsi, struct lower_data *data)
 315 {
 316   gimple stmt;
 317
 318   stmt = gsi_stmt (*gsi);
 319
 320   lower_sequence (gimple_omp_body (stmt), data);
 321   gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
 322   gsi_insert_seq_before (gsi, gimple_omp_body (stmt), GSI_SAME_STMT);
 323   gimple_omp_set_body (stmt, NULL);
 324   gsi_remove (gsi, false);
 325 }
 326
 327
 328 /* Lower statement GSI.  DATA is passed through the recursion.  */
 329
 330 static void
 331 lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
 332 {
 333   gimple stmt = gsi_stmt (*gsi);
 334
 335   gimple_set_block (stmt, data->block);
 336
 337   switch (gimple_code (stmt))
 338     {
 339     case GIMPLE_BIND:
 340       lower_gimple_bind (gsi, data);
 341       return;
 342
 343     case GIMPLE_COND:
 344       /* The gimplifier has already lowered this into gotos.  */
 345       break;
 346
 347     case GIMPLE_RETURN:
 348       lower_gimple_return (gsi, data);
 349       return;
 350
 351     case GIMPLE_TRY:
 352       lower_sequence (gimple_try_eval (stmt), data);
 353       lower_sequence (gimple_try_cleanup (stmt), data);
 354       break;
 355
 356     case GIMPLE_CATCH:
 357       lower_sequence (gimple_catch_handler (stmt), data);
 358       break;
 359
 360     case GIMPLE_EH_FILTER:
 361       lower_sequence (gimple_eh_filter_failure (stmt), data);
 362       break;
 363
 364     case GIMPLE_NOP:
 365     case GIMPLE_ASM:
 366     case GIMPLE_ASSIGN:
 367     case GIMPLE_GOTO:
 368     case GIMPLE_PREDICT:
 369     case GIMPLE_LABEL:
 370     case GIMPLE_SWITCH:
 371     case GIMPLE_OMP_FOR:
 372     case GIMPLE_OMP_SECTIONS:
 373     case GIMPLE_OMP_SECTIONS_SWITCH:
 374     case GIMPLE_OMP_SECTION:
 375     case GIMPLE_OMP_SINGLE:
 376     case GIMPLE_OMP_MASTER:
 377     case GIMPLE_OMP_ORDERED:
 378     case GIMPLE_OMP_CRITICAL:
 379     case GIMPLE_OMP_RETURN:
 380     case GIMPLE_OMP_ATOMIC_LOAD:
 381     case GIMPLE_OMP_ATOMIC_STORE:
 382     case GIMPLE_OMP_CONTINUE:
 383       break;
 384
 385     case GIMPLE_CALL:
 386       {
 387         tree decl = gimple_call_fndecl (stmt);
 388
 389         if (decl
 390             && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
 391             && DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
 392           {
 393             data->calls_builtin_setjmp = true;
 394             lower_builtin_setjmp (gsi);
 395             return;
 396           }
 397         check_call_args (stmt);
 398       }
 399       break;
 400
 401     case GIMPLE_OMP_PARALLEL:
 402     case GIMPLE_OMP_TASK:
 403       lower_omp_directive (gsi, data);
 404       return;
 405
 406     default:
 407       gcc_unreachable ();
 408     }
 409
 410   gsi_next (gsi);
 411 }
 412
 413 /* Lower a bind_expr TSI.  DATA is passed through the recursion.  */
 414
 415 static void
 416 lower_gimple_bind (gimple_stmt_iterator *gsi, struct lower_data *data)
 417 {
 418   tree old_block = data->block;
 419   gimple stmt = gsi_stmt (*gsi);
 420   tree new_block = gimple_bind_block (stmt);
 421
 422   if (new_block)
 423     {
 424       if (new_block == old_block)
 425         {
 426           /* The outermost block of the original function may not be the
 427              outermost statement chain of the gimplified function.  So we
 428              may see the outermost block just inside the function.  */
 429           gcc_assert (new_block == DECL_INITIAL (current_function_decl));
 430           new_block = NULL;
 431         }
 432       else
 433         {
 434           /* We do not expect to handle duplicate blocks.  */
 435           gcc_assert (!TREE_ASM_WRITTEN (new_block));
 436           TREE_ASM_WRITTEN (new_block) = 1;
 437
 438           /* Block tree may get clobbered by inlining.  Normally this would
 439              be fixed in rest_of_decl_compilation using block notes, but
 440              since we are not going to emit them, it is up to us.  */
 441           BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (old_block);
 442           BLOCK_SUBBLOCKS (old_block) = new_block;
 443           BLOCK_SUBBLOCKS (new_block) = NULL_TREE;
 444           BLOCK_SUPERCONTEXT (new_block) = old_block;
 445
 446           data->block = new_block;
 447         }
 448     }
 449
 450   record_vars (gimple_bind_vars (stmt));
 451   lower_sequence (gimple_bind_body (stmt), data);
 452
 453   if (new_block)
 454     {
 455       gcc_assert (data->block == new_block);
 456
 457       BLOCK_SUBBLOCKS (new_block)
 458         = blocks_nreverse (BLOCK_SUBBLOCKS (new_block));
 459       data->block = old_block;
 460     }
 461
 462   /* The GIMPLE_BIND no longer carries any useful information -- kill it.  */
 463   gsi_insert_seq_before (gsi, gimple_bind_body (stmt), GSI_SAME_STMT);
 464   gsi_remove (gsi, false);
 465 }
 466
 467 /* Try to determine whether a TRY_CATCH expression can fall through.
 468    This is a subroutine of block_may_fallthru.  */
 469
 470 static bool
 471 try_catch_may_fallthru (const_tree stmt)
 472 {
 473   tree_stmt_iterator i;
 474
 475   /* If the TRY block can fall through, the whole TRY_CATCH can
 476      fall through.  */
 477   if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
 478     return true;
 479
 480   i = tsi_start (TREE_OPERAND (stmt, 1));
 481   switch (TREE_CODE (tsi_stmt (i)))
 482     {
 483     case CATCH_EXPR:
 484       /* We expect to see a sequence of CATCH_EXPR trees, each with a
 485          catch expression and a body.  The whole TRY_CATCH may fall
 486          through iff any of the catch bodies falls through.  */
 487       for (; !tsi_end_p (i); tsi_next (&i))
 488         {
 489           if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
 490             return true;
 491         }
 492       return false;
 493
 494     case EH_FILTER_EXPR:
 495       /* The exception filter expression only matters if there is an
 496          exception.  If the exception does not match EH_FILTER_TYPES,
 497          we will execute EH_FILTER_FAILURE, and we will fall through
 498          if that falls through.  If the exception does match
 499          EH_FILTER_TYPES, the stack unwinder will continue up the
 500          stack, so we will not fall through.  We don't know whether we
 501          will throw an exception which matches EH_FILTER_TYPES or not,
 502          so we just ignore EH_FILTER_TYPES and assume that we might
 503          throw an exception which doesn't match.  */
 504       return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
 505
 506     default:
 507       /* This case represents statements to be executed when an
 508          exception occurs.  Those statements are implicitly followed
 509          by a RESX_EXPR to resume execution after the exception.  So
 510          in this case the TRY_CATCH never falls through.  */
 511       return false;
 512     }
 513 }
 514
 515
 516 /* Same as above, but for a GIMPLE_TRY_CATCH.  */
 517
 518 static bool
 519 gimple_try_catch_may_fallthru (gimple stmt)
 520 {
 521   gimple_stmt_iterator i;
 522
 523   /* We don't handle GIMPLE_TRY_FINALLY.  */
 524   gcc_assert (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH);
 525
 526   /* If the TRY block can fall through, the whole TRY_CATCH can
 527      fall through.  */
 528   if (gimple_seq_may_fallthru (gimple_try_eval (stmt)))
 529     return true;
 530
 531   i = gsi_start (gimple_try_cleanup (stmt));
 532   switch (gimple_code (gsi_stmt (i)))
 533     {
 534     case GIMPLE_CATCH:
 535       /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
 536          catch expression and a body.  The whole try/catch may fall
 537          through iff any of the catch bodies falls through.  */
 538       for (; !gsi_end_p (i); gsi_next (&i))
 539         {
 540           if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i))))
 541             return true;
 542         }
 543       return false;
 544
 545     case GIMPLE_EH_FILTER:
 546       /* The exception filter expression only matters if there is an
 547          exception.  If the exception does not match EH_FILTER_TYPES,
 548          we will execute EH_FILTER_FAILURE, and we will fall through
 549          if that falls through.  If the exception does match
 550          EH_FILTER_TYPES, the stack unwinder will continue up the
 551          stack, so we will not fall through.  We don't know whether we
 552          will throw an exception which matches EH_FILTER_TYPES or not,
 553          so we just ignore EH_FILTER_TYPES and assume that we might
 554          throw an exception which doesn't match.  */
 555       return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i)));
 556
 557     default:
 558       /* This case represents statements to be executed when an
 559          exception occurs.  Those statements are implicitly followed
 560          by a GIMPLE_RESX to resume execution after the exception.  So
 561          in this case the try/catch never falls through.  */
 562       return false;
 563     }
 564 }
 565
 566
 567 /* Try to determine if we can fall out of the bottom of BLOCK.  This guess
 568    need not be 100% accurate; simply be conservative and return true if we
 569    don't know.  This is used only to avoid stupidly generating extra code.
 570    If we're wrong, we'll just delete the extra code later.  */
 571
 572 bool
 573 block_may_fallthru (const_tree block)
 574 {
 575   /* This CONST_CAST is okay because expr_last returns its argument
 576      unmodified and we assign it to a const_tree.  */
 577   const_tree stmt = expr_last (CONST_CAST_TREE(block));
 578
 579   switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
 580     {
 581     case GOTO_EXPR:
 582     case RETURN_EXPR:
 583     case RESX_EXPR:
 584       /* Easy cases.  If the last statement of the block implies
 585          control transfer, then we can't fall through.  */
 586       return false;
 587
 588     case SWITCH_EXPR:
 589       /* If SWITCH_LABELS is set, this is lowered, and represents a
 590          branch to a selected label and hence can not fall through.
 591          Otherwise SWITCH_BODY is set, and the switch can fall
 592          through.  */
 593       return SWITCH_LABELS (stmt) == NULL_TREE;
 594
 595     case COND_EXPR:
 596       if (block_may_fallthru (COND_EXPR_THEN (stmt)))
 597         return true;
 598       return block_may_fallthru (COND_EXPR_ELSE (stmt));
 599
 600     case BIND_EXPR:
 601       return block_may_fallthru (BIND_EXPR_BODY (stmt));
 602
 603     case TRY_CATCH_EXPR:
 604       return try_catch_may_fallthru (stmt);
 605
 606     case TRY_FINALLY_EXPR:
 607       /* The finally clause is always executed after the try clause,
 608          so if it does not fall through, then the try-finally will not
 609          fall through.  Otherwise, if the try clause does not fall
 610          through, then when the finally clause falls through it will
 611          resume execution wherever the try clause was going.  So the
 612          whole try-finally will only fall through if both the try
 613          clause and the finally clause fall through.  */
 614       return (block_may_fallthru (TREE_OPERAND (stmt, 0))
 615               && block_may_fallthru (TREE_OPERAND (stmt, 1)));
 616
 617     case MODIFY_EXPR:
 618       if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
 619         stmt = TREE_OPERAND (stmt, 1);
 620       else
 621         return true;
 622       /* FALLTHRU */
 623
 624     case CALL_EXPR:
 625       /* Functions that do not return do not fall through.  */
 626       return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
 627
 628     case CLEANUP_POINT_EXPR:
 629       return block_may_fallthru (TREE_OPERAND (stmt, 0));
 630
 631     default:
 632       return true;
 633     }
 634 }
 635
 636
 637 /* Try to determine if we can continue executing the statement
 638    immediately following STMT.  This guess need not be 100% accurate;
 639    simply be conservative and return true if we don't know.  This is
 640    used only to avoid stupidly generating extra code. If we're wrong,
 641    we'll just delete the extra code later.  */
 642
 643 bool
 644 gimple_stmt_may_fallthru (gimple stmt)
 645 {
 646   if (!stmt)
 647     return true;
 648
 649   switch (gimple_code (stmt))
 650     {
 651     case GIMPLE_GOTO:
 652     case GIMPLE_RETURN:
 653     case GIMPLE_RESX:
 654       /* Easy cases.  If the last statement of the seq implies
 655          control transfer, then we can't fall through.  */
 656       return false;
 657
 658     case GIMPLE_SWITCH:
 659       /* Switch has already been lowered and represents a
 660          branch to a selected label and hence can not fall through.  */
 661       return true;
 662
 663     case GIMPLE_COND:
 664       /* GIMPLE_COND's are already lowered into a two-way branch.  They
 665          can't fall through.  */
 666       return false;
 667
 668     case GIMPLE_BIND:
 669       return gimple_seq_may_fallthru (gimple_bind_body (stmt));
 670
 671     case GIMPLE_TRY:
 672       if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
 673         return gimple_try_catch_may_fallthru (stmt);
 674
 675       /* It must be a GIMPLE_TRY_FINALLY.  */
 676
 677       /* The finally clause is always executed after the try clause,
 678          so if it does not fall through, then the try-finally will not
 679          fall through.  Otherwise, if the try clause does not fall
 680          through, then when the finally clause falls through it will
 681          resume execution wherever the try clause was going.  So the
 682          whole try-finally will only fall through if both the try
 683          clause and the finally clause fall through.  */
 684       return (gimple_seq_may_fallthru (gimple_try_eval (stmt))
 685               && gimple_seq_may_fallthru (gimple_try_cleanup (stmt)));
 686
 687     case GIMPLE_ASSIGN:
 688       return true;
 689
 690     case GIMPLE_CALL:
 691       /* Functions that do not return do not fall through.  */
 692       return (gimple_call_flags (stmt) & ECF_NORETURN) == 0;
 693
 694     default:
 695       return true;
 696     }
 697 }
 698
 699
 700 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ.  */
 701
 702 bool
 703 gimple_seq_may_fallthru (gimple_seq seq)
 704 {
 705   return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq));
 706 }
 707
 708
 709 /* Lower a GIMPLE_RETURN GSI.  DATA is passed through the recursion.  */
 710
 711 static void
 712 lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data)
 713 {
 714   gimple stmt = gsi_stmt (*gsi);
 715   gimple t;
 716   int i;
 717   return_statements_t tmp_rs;
 718
 719   /* Match this up with an existing return statement that's been created.  */
 720   for (i = VEC_length (return_statements_t, data->return_statements) - 1;
 721        i >= 0; i--)
 722     {
 723       tmp_rs = *VEC_index (return_statements_t, data->return_statements, i);
 724
 725       if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt))
 726         goto found;
 727     }
 728
 729   /* Not found.  Create a new label and record the return statement.  */
 730   tmp_rs.label = create_artificial_label (cfun->function_end_locus);
 731   tmp_rs.stmt = stmt;
 732   VEC_safe_push (return_statements_t, heap, data->return_statements, &tmp_rs);
 733
 734   /* Generate a goto statement and remove the return statement.  */
 735  found:
 736   t = gimple_build_goto (tmp_rs.label);
 737   gimple_set_location (t, gimple_location (stmt));
 738   gimple_set_block (t, gimple_block (stmt));
 739   gsi_insert_before (gsi, t, GSI_SAME_STMT);
 740   gsi_remove (gsi, false);
 741 }
 742
 743 /* Lower a __builtin_setjmp TSI.
 744
 745    __builtin_setjmp is passed a pointer to an array of five words (not
 746    all will be used on all machines).  It operates similarly to the C
 747    library function of the same name, but is more efficient.
 748
 749    It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
 750    __builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
 751    __builtin_setjmp_dispatcher shared among all the instances; that's
 752    why it is only emitted at the end by lower_function_body.
 753
 754    After full lowering, the body of the function should look like:
 755
 756     {
 757       void * setjmpvar.0;
 758       int D.1844;
 759       int D.2844;
 760
 761       [...]
 762
 763       __builtin_setjmp_setup (&buf, &<D1847>);
 764       D.1844 = 0;
 765       goto <D1846>;
 766       <D1847>:;
 767       __builtin_setjmp_receiver (&<D1847>);
 768       D.1844 = 1;
 769       <D1846>:;
 770       if (D.1844 == 0) goto <D1848>; else goto <D1849>;
 771
 772       [...]
 773
 774       __builtin_setjmp_setup (&buf, &<D2847>);
 775       D.2844 = 0;
 776       goto <D2846>;
 777       <D2847>:;
 778       __builtin_setjmp_receiver (&<D2847>);
 779       D.2844 = 1;
 780       <D2846>:;
 781       if (D.2844 == 0) goto <D2848>; else goto <D2849>;
 782
 783       [...]
 784
 785       <D3850>:;
 786       return;
 787       <D3853>: [non-local];
 788       setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
 789       goto setjmpvar.0;
 790     }
 791
 792    The dispatcher block will be both the unique destination of all the
 793    abnormal call edges and the unique source of all the abnormal edges
 794    to the receivers, thus keeping the complexity explosion localized.  */
 795
 796 static void
 797 lower_builtin_setjmp (gimple_stmt_iterator *gsi)
 798 {
 799   gimple stmt = gsi_stmt (*gsi);
 800   location_t loc = gimple_location (stmt);
 801   tree cont_label = create_artificial_label (loc);
 802   tree next_label = create_artificial_label (loc);
 803   tree dest, t, arg;
 804   gimple g;
 805
 806   /* NEXT_LABEL is the label __builtin_longjmp will jump to.  Its address is
 807      passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver.  */
 808   FORCED_LABEL (next_label) = 1;
 809
 810   dest = gimple_call_lhs (stmt);
 811
 812   /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert.  */
 813   arg = build_addr (next_label, current_function_decl);
 814   t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
 815   g = gimple_build_call (t, 2, gimple_call_arg (stmt, 0), arg);
 816   gimple_set_location (g, loc);
 817   gimple_set_block (g, gimple_block (stmt));
 818   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 819
 820   /* Build 'DEST = 0' and insert.  */
 821   if (dest)
 822     {
 823       g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
 824                                                        integer_zero_node));
 825       gimple_set_location (g, loc);
 826       gimple_set_block (g, gimple_block (stmt));
 827       gsi_insert_before (gsi, g, GSI_SAME_STMT);
 828     }
 829
 830   /* Build 'goto CONT_LABEL' and insert.  */
 831   g = gimple_build_goto (cont_label);
 832   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 833
 834   /* Build 'NEXT_LABEL:' and insert.  */
 835   g = gimple_build_label (next_label);
 836   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 837
 838   /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert.  */
 839   arg = build_addr (next_label, current_function_decl);
 840   t = implicit_built_in_decls[BUILT_IN_SETJMP_RECEIVER];
 841   g = gimple_build_call (t, 1, arg);
 842   gimple_set_location (g, loc);
 843   gimple_set_block (g, gimple_block (stmt));
 844   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 845
 846   /* Build 'DEST = 1' and insert.  */
 847   if (dest)
 848     {
 849       g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
 850                                                        integer_one_node));
 851       gimple_set_location (g, loc);
 852       gimple_set_block (g, gimple_block (stmt));
 853       gsi_insert_before (gsi, g, GSI_SAME_STMT);
 854     }
 855
 856   /* Build 'CONT_LABEL:' and insert.  */
 857   g = gimple_build_label (cont_label);
 858   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 859
 860   /* Remove the call to __builtin_setjmp.  */
 861   gsi_remove (gsi, false);
 862 }
 863 \f
 864
 865 /* Record the variables in VARS into function FN.  */
 866
 867 void
 868 record_vars_into (tree vars, tree fn)
 869 {
 870   if (fn != current_function_decl)
 871     push_cfun (DECL_STRUCT_FUNCTION (fn));
 872
 873   for (; vars; vars = TREE_CHAIN (vars))
 874     {
 875       tree var = vars;
 876
 877       /* BIND_EXPRs contains also function/type/constant declarations
 878          we don't need to care about.  */
 879       if (TREE_CODE (var) != VAR_DECL)
 880         continue;
 881
 882       /* Nothing to do in this case.  */
 883       if (DECL_EXTERNAL (var))
 884         continue;
 885
 886       /* Record the variable.  */
 887       cfun->local_decls = tree_cons (NULL_TREE, var,
 888                                              cfun->local_decls);
 889     }
 890
 891   if (fn != current_function_decl)
 892     pop_cfun ();
 893 }
 894
 895
 896 /* Record the variables in VARS into current_function_decl.  */
 897
 898 void
 899 record_vars (tree vars)
 900 {
 901   record_vars_into (vars, current_function_decl);
 902 }