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    return false.  */
 225
 226 bool
 227 gimple_check_call_args (gimple stmt)
 228 {
 229   tree fndecl, parms, p;
 230   unsigned int i, nargs;
 231
 232   nargs = gimple_call_num_args (stmt);
 233
 234   /* Get argument types for verification.  */
 235   fndecl = gimple_call_fndecl (stmt);
 236   parms = NULL_TREE;
 237   if (fndecl)
 238     parms = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
 239   else if (POINTER_TYPE_P (TREE_TYPE (gimple_call_fn (stmt))))
 240     parms = TYPE_ARG_TYPES (TREE_TYPE (TREE_TYPE (gimple_call_fn (stmt))));
 241
 242   /* Verify if the type of the argument matches that of the function
 243      declaration.  If we cannot verify this or there is a mismatch,
 244      return false.  */
 245   if (fndecl && DECL_ARGUMENTS (fndecl))
 246     {
 247       for (i = 0, p = DECL_ARGUMENTS (fndecl);
 248            i < nargs;
 249            i++, p = TREE_CHAIN (p))
 250         {
 251           /* We cannot distinguish a varargs function from the case
 252              of excess parameters, still deferring the inlining decision
 253              to the callee is possible.  */
 254           if (!p)
 255             break;
 256           if (p == error_mark_node
 257               || gimple_call_arg (stmt, i) == error_mark_node
 258               || !fold_convertible_p (DECL_ARG_TYPE (p),
 259                                       gimple_call_arg (stmt, i)))
 260             return false;
 261         }
 262     }
 263   else if (parms)
 264     {
 265       for (i = 0, p = parms; i < nargs; i++, p = TREE_CHAIN (p))
 266         {
 267           /* If this is a varargs function defer inlining decision
 268              to callee.  */
 269           if (!p)
 270             break;
 271           if (TREE_VALUE (p) == error_mark_node
 272               || gimple_call_arg (stmt, i) == error_mark_node
 273               || TREE_CODE (TREE_VALUE (p)) == VOID_TYPE
 274               || !fold_convertible_p (TREE_VALUE (p),
 275                                       gimple_call_arg (stmt, i)))
 276             return false;
 277         }
 278     }
 279   else
 280     {
 281       if (nargs != 0)
 282         return false;
 283     }
 284   return true;
 285 }
 286
 287
 288 /* Lower sequence SEQ.  Unlike gimplification the statements are not relowered
 289    when they are changed -- if this has to be done, the lowering routine must
 290    do it explicitly.  DATA is passed through the recursion.  */
 291
 292 static void
 293 lower_sequence (gimple_seq seq, struct lower_data *data)
 294 {
 295   gimple_stmt_iterator gsi;
 296
 297   for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
 298     lower_stmt (&gsi, data);
 299 }
 300
 301
 302 /* Lower the OpenMP directive statement pointed by GSI.  DATA is
 303    passed through the recursion.  */
 304
 305 static void
 306 lower_omp_directive (gimple_stmt_iterator *gsi, struct lower_data *data)
 307 {
 308   gimple stmt;
 309
 310   stmt = gsi_stmt (*gsi);
 311
 312   lower_sequence (gimple_omp_body (stmt), data);
 313   gsi_insert_before (gsi, stmt, GSI_SAME_STMT);
 314   gsi_insert_seq_before (gsi, gimple_omp_body (stmt), GSI_SAME_STMT);
 315   gimple_omp_set_body (stmt, NULL);
 316   gsi_remove (gsi, false);
 317 }
 318
 319
 320 /* Lower statement GSI.  DATA is passed through the recursion.  */
 321
 322 static void
 323 lower_stmt (gimple_stmt_iterator *gsi, struct lower_data *data)
 324 {
 325   gimple stmt = gsi_stmt (*gsi);
 326
 327   gimple_set_block (stmt, data->block);
 328
 329   switch (gimple_code (stmt))
 330     {
 331     case GIMPLE_BIND:
 332       lower_gimple_bind (gsi, data);
 333       return;
 334
 335     case GIMPLE_COND:
 336       /* The gimplifier has already lowered this into gotos.  */
 337       break;
 338
 339     case GIMPLE_RETURN:
 340       lower_gimple_return (gsi, data);
 341       return;
 342
 343     case GIMPLE_TRY:
 344       lower_sequence (gimple_try_eval (stmt), data);
 345       lower_sequence (gimple_try_cleanup (stmt), data);
 346       break;
 347
 348     case GIMPLE_CATCH:
 349       lower_sequence (gimple_catch_handler (stmt), data);
 350       break;
 351
 352     case GIMPLE_EH_FILTER:
 353       lower_sequence (gimple_eh_filter_failure (stmt), data);
 354       break;
 355
 356     case GIMPLE_NOP:
 357     case GIMPLE_ASM:
 358     case GIMPLE_ASSIGN:
 359     case GIMPLE_GOTO:
 360     case GIMPLE_PREDICT:
 361     case GIMPLE_LABEL:
 362     case GIMPLE_SWITCH:
 363     case GIMPLE_EH_MUST_NOT_THROW:
 364     case GIMPLE_OMP_FOR:
 365     case GIMPLE_OMP_SECTIONS:
 366     case GIMPLE_OMP_SECTIONS_SWITCH:
 367     case GIMPLE_OMP_SECTION:
 368     case GIMPLE_OMP_SINGLE:
 369     case GIMPLE_OMP_MASTER:
 370     case GIMPLE_OMP_ORDERED:
 371     case GIMPLE_OMP_CRITICAL:
 372     case GIMPLE_OMP_RETURN:
 373     case GIMPLE_OMP_ATOMIC_LOAD:
 374     case GIMPLE_OMP_ATOMIC_STORE:
 375     case GIMPLE_OMP_CONTINUE:
 376       break;
 377
 378     case GIMPLE_CALL:
 379       {
 380         tree decl = gimple_call_fndecl (stmt);
 381
 382         if (decl
 383             && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
 384             && DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
 385           {
 386             data->calls_builtin_setjmp = true;
 387             lower_builtin_setjmp (gsi);
 388             return;
 389           }
 390
 391         /* After a noreturn call, remove a subsequent GOTO or RETURN that might
 392            have been mechanically added; this will prevent the EH lowering pass
 393            from adding useless edges and thus complicating the initial CFG.  */
 394         if (decl && (flags_from_decl_or_type (decl) & ECF_NORETURN))
 395           {
 396             gsi_next (gsi);
 397             if (!gsi_end_p (*gsi)
 398                 && (gimple_code (gsi_stmt (*gsi)) == GIMPLE_GOTO
 399                     || gimple_code (gsi_stmt (*gsi)) == GIMPLE_RETURN))
 400               gsi_remove (gsi, false);
 401             return;
 402           }
 403       }
 404       break;
 405
 406     case GIMPLE_OMP_PARALLEL:
 407     case GIMPLE_OMP_TASK:
 408       lower_omp_directive (gsi, data);
 409       return;
 410
 411     default:
 412       gcc_unreachable ();
 413     }
 414
 415   gsi_next (gsi);
 416 }
 417
 418 /* Lower a bind_expr TSI.  DATA is passed through the recursion.  */
 419
 420 static void
 421 lower_gimple_bind (gimple_stmt_iterator *gsi, struct lower_data *data)
 422 {
 423   tree old_block = data->block;
 424   gimple stmt = gsi_stmt (*gsi);
 425   tree new_block = gimple_bind_block (stmt);
 426
 427   if (new_block)
 428     {
 429       if (new_block == old_block)
 430         {
 431           /* The outermost block of the original function may not be the
 432              outermost statement chain of the gimplified function.  So we
 433              may see the outermost block just inside the function.  */
 434           gcc_assert (new_block == DECL_INITIAL (current_function_decl));
 435           new_block = NULL;
 436         }
 437       else
 438         {
 439           /* We do not expect to handle duplicate blocks.  */
 440           gcc_assert (!TREE_ASM_WRITTEN (new_block));
 441           TREE_ASM_WRITTEN (new_block) = 1;
 442
 443           /* Block tree may get clobbered by inlining.  Normally this would
 444              be fixed in rest_of_decl_compilation using block notes, but
 445              since we are not going to emit them, it is up to us.  */
 446           BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (old_block);
 447           BLOCK_SUBBLOCKS (old_block) = new_block;
 448           BLOCK_SUBBLOCKS (new_block) = NULL_TREE;
 449           BLOCK_SUPERCONTEXT (new_block) = old_block;
 450
 451           data->block = new_block;
 452         }
 453     }
 454
 455   record_vars (gimple_bind_vars (stmt));
 456   lower_sequence (gimple_bind_body (stmt), data);
 457
 458   if (new_block)
 459     {
 460       gcc_assert (data->block == new_block);
 461
 462       BLOCK_SUBBLOCKS (new_block)
 463         = blocks_nreverse (BLOCK_SUBBLOCKS (new_block));
 464       data->block = old_block;
 465     }
 466
 467   /* The GIMPLE_BIND no longer carries any useful information -- kill it.  */
 468   gsi_insert_seq_before (gsi, gimple_bind_body (stmt), GSI_SAME_STMT);
 469   gsi_remove (gsi, false);
 470 }
 471
 472 /* Try to determine whether a TRY_CATCH expression can fall through.
 473    This is a subroutine of block_may_fallthru.  */
 474
 475 static bool
 476 try_catch_may_fallthru (const_tree stmt)
 477 {
 478   tree_stmt_iterator i;
 479
 480   /* If the TRY block can fall through, the whole TRY_CATCH can
 481      fall through.  */
 482   if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
 483     return true;
 484
 485   i = tsi_start (TREE_OPERAND (stmt, 1));
 486   switch (TREE_CODE (tsi_stmt (i)))
 487     {
 488     case CATCH_EXPR:
 489       /* We expect to see a sequence of CATCH_EXPR trees, each with a
 490          catch expression and a body.  The whole TRY_CATCH may fall
 491          through iff any of the catch bodies falls through.  */
 492       for (; !tsi_end_p (i); tsi_next (&i))
 493         {
 494           if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
 495             return true;
 496         }
 497       return false;
 498
 499     case EH_FILTER_EXPR:
 500       /* The exception filter expression only matters if there is an
 501          exception.  If the exception does not match EH_FILTER_TYPES,
 502          we will execute EH_FILTER_FAILURE, and we will fall through
 503          if that falls through.  If the exception does match
 504          EH_FILTER_TYPES, the stack unwinder will continue up the
 505          stack, so we will not fall through.  We don't know whether we
 506          will throw an exception which matches EH_FILTER_TYPES or not,
 507          so we just ignore EH_FILTER_TYPES and assume that we might
 508          throw an exception which doesn't match.  */
 509       return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
 510
 511     default:
 512       /* This case represents statements to be executed when an
 513          exception occurs.  Those statements are implicitly followed
 514          by a RESX statement to resume execution after the exception.
 515          So in this case the TRY_CATCH never falls through.  */
 516       return false;
 517     }
 518 }
 519
 520
 521 /* Same as above, but for a GIMPLE_TRY_CATCH.  */
 522
 523 static bool
 524 gimple_try_catch_may_fallthru (gimple stmt)
 525 {
 526   gimple_stmt_iterator i;
 527
 528   /* We don't handle GIMPLE_TRY_FINALLY.  */
 529   gcc_assert (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH);
 530
 531   /* If the TRY block can fall through, the whole TRY_CATCH can
 532      fall through.  */
 533   if (gimple_seq_may_fallthru (gimple_try_eval (stmt)))
 534     return true;
 535
 536   i = gsi_start (gimple_try_cleanup (stmt));
 537   switch (gimple_code (gsi_stmt (i)))
 538     {
 539     case GIMPLE_CATCH:
 540       /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
 541          catch expression and a body.  The whole try/catch may fall
 542          through iff any of the catch bodies falls through.  */
 543       for (; !gsi_end_p (i); gsi_next (&i))
 544         {
 545           if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i))))
 546             return true;
 547         }
 548       return false;
 549
 550     case GIMPLE_EH_FILTER:
 551       /* The exception filter expression only matters if there is an
 552          exception.  If the exception does not match EH_FILTER_TYPES,
 553          we will execute EH_FILTER_FAILURE, and we will fall through
 554          if that falls through.  If the exception does match
 555          EH_FILTER_TYPES, the stack unwinder will continue up the
 556          stack, so we will not fall through.  We don't know whether we
 557          will throw an exception which matches EH_FILTER_TYPES or not,
 558          so we just ignore EH_FILTER_TYPES and assume that we might
 559          throw an exception which doesn't match.  */
 560       return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i)));
 561
 562     default:
 563       /* This case represents statements to be executed when an
 564          exception occurs.  Those statements are implicitly followed
 565          by a GIMPLE_RESX to resume execution after the exception.  So
 566          in this case the try/catch never falls through.  */
 567       return false;
 568     }
 569 }
 570
 571
 572 /* Try to determine if we can fall out of the bottom of BLOCK.  This guess
 573    need not be 100% accurate; simply be conservative and return true if we
 574    don't know.  This is used only to avoid stupidly generating extra code.
 575    If we're wrong, we'll just delete the extra code later.  */
 576
 577 bool
 578 block_may_fallthru (const_tree block)
 579 {
 580   /* This CONST_CAST is okay because expr_last returns its argument
 581      unmodified and we assign it to a const_tree.  */
 582   const_tree stmt = expr_last (CONST_CAST_TREE(block));
 583
 584   switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
 585     {
 586     case GOTO_EXPR:
 587     case RETURN_EXPR:
 588       /* Easy cases.  If the last statement of the block implies
 589          control transfer, then we can't fall through.  */
 590       return false;
 591
 592     case SWITCH_EXPR:
 593       /* If SWITCH_LABELS is set, this is lowered, and represents a
 594          branch to a selected label and hence can not fall through.
 595          Otherwise SWITCH_BODY is set, and the switch can fall
 596          through.  */
 597       return SWITCH_LABELS (stmt) == NULL_TREE;
 598
 599     case COND_EXPR:
 600       if (block_may_fallthru (COND_EXPR_THEN (stmt)))
 601         return true;
 602       return block_may_fallthru (COND_EXPR_ELSE (stmt));
 603
 604     case BIND_EXPR:
 605       return block_may_fallthru (BIND_EXPR_BODY (stmt));
 606
 607     case TRY_CATCH_EXPR:
 608       return try_catch_may_fallthru (stmt);
 609
 610     case TRY_FINALLY_EXPR:
 611       /* The finally clause is always executed after the try clause,
 612          so if it does not fall through, then the try-finally will not
 613          fall through.  Otherwise, if the try clause does not fall
 614          through, then when the finally clause falls through it will
 615          resume execution wherever the try clause was going.  So the
 616          whole try-finally will only fall through if both the try
 617          clause and the finally clause fall through.  */
 618       return (block_may_fallthru (TREE_OPERAND (stmt, 0))
 619               && block_may_fallthru (TREE_OPERAND (stmt, 1)));
 620
 621     case MODIFY_EXPR:
 622       if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
 623         stmt = TREE_OPERAND (stmt, 1);
 624       else
 625         return true;
 626       /* FALLTHRU */
 627
 628     case CALL_EXPR:
 629       /* Functions that do not return do not fall through.  */
 630       return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
 631
 632     case CLEANUP_POINT_EXPR:
 633       return block_may_fallthru (TREE_OPERAND (stmt, 0));
 634
 635     default:
 636       return true;
 637     }
 638 }
 639
 640
 641 /* Try to determine if we can continue executing the statement
 642    immediately following STMT.  This guess need not be 100% accurate;
 643    simply be conservative and return true if we don't know.  This is
 644    used only to avoid stupidly generating extra code. If we're wrong,
 645    we'll just delete the extra code later.  */
 646
 647 bool
 648 gimple_stmt_may_fallthru (gimple stmt)
 649 {
 650   if (!stmt)
 651     return true;
 652
 653   switch (gimple_code (stmt))
 654     {
 655     case GIMPLE_GOTO:
 656     case GIMPLE_RETURN:
 657     case GIMPLE_RESX:
 658       /* Easy cases.  If the last statement of the seq implies
 659          control transfer, then we can't fall through.  */
 660       return false;
 661
 662     case GIMPLE_SWITCH:
 663       /* Switch has already been lowered and represents a
 664          branch to a selected label and hence can not fall through.  */
 665       return true;
 666
 667     case GIMPLE_COND:
 668       /* GIMPLE_COND's are already lowered into a two-way branch.  They
 669          can't fall through.  */
 670       return false;
 671
 672     case GIMPLE_BIND:
 673       return gimple_seq_may_fallthru (gimple_bind_body (stmt));
 674
 675     case GIMPLE_TRY:
 676       if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
 677         return gimple_try_catch_may_fallthru (stmt);
 678
 679       /* It must be a GIMPLE_TRY_FINALLY.  */
 680
 681       /* The finally clause is always executed after the try clause,
 682          so if it does not fall through, then the try-finally will not
 683          fall through.  Otherwise, if the try clause does not fall
 684          through, then when the finally clause falls through it will
 685          resume execution wherever the try clause was going.  So the
 686          whole try-finally will only fall through if both the try
 687          clause and the finally clause fall through.  */
 688       return (gimple_seq_may_fallthru (gimple_try_eval (stmt))
 689               && gimple_seq_may_fallthru (gimple_try_cleanup (stmt)));
 690
 691     case GIMPLE_ASSIGN:
 692       return true;
 693
 694     case GIMPLE_CALL:
 695       /* Functions that do not return do not fall through.  */
 696       return (gimple_call_flags (stmt) & ECF_NORETURN) == 0;
 697
 698     default:
 699       return true;
 700     }
 701 }
 702
 703
 704 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ.  */
 705
 706 bool
 707 gimple_seq_may_fallthru (gimple_seq seq)
 708 {
 709   return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq));
 710 }
 711
 712
 713 /* Lower a GIMPLE_RETURN GSI.  DATA is passed through the recursion.  */
 714
 715 static void
 716 lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data)
 717 {
 718   gimple stmt = gsi_stmt (*gsi);
 719   gimple t;
 720   int i;
 721   return_statements_t tmp_rs;
 722
 723   /* Match this up with an existing return statement that's been created.  */
 724   for (i = VEC_length (return_statements_t, data->return_statements) - 1;
 725        i >= 0; i--)
 726     {
 727       tmp_rs = *VEC_index (return_statements_t, data->return_statements, i);
 728
 729       if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt))
 730         goto found;
 731     }
 732
 733   /* Not found.  Create a new label and record the return statement.  */
 734   tmp_rs.label = create_artificial_label (cfun->function_end_locus);
 735   tmp_rs.stmt = stmt;
 736   VEC_safe_push (return_statements_t, heap, data->return_statements, &tmp_rs);
 737
 738   /* Generate a goto statement and remove the return statement.  */
 739  found:
 740   t = gimple_build_goto (tmp_rs.label);
 741   gimple_set_location (t, gimple_location (stmt));
 742   gimple_set_block (t, gimple_block (stmt));
 743   gsi_insert_before (gsi, t, GSI_SAME_STMT);
 744   gsi_remove (gsi, false);
 745 }
 746
 747 /* Lower a __builtin_setjmp TSI.
 748
 749    __builtin_setjmp is passed a pointer to an array of five words (not
 750    all will be used on all machines).  It operates similarly to the C
 751    library function of the same name, but is more efficient.
 752
 753    It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
 754    __builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
 755    __builtin_setjmp_dispatcher shared among all the instances; that's
 756    why it is only emitted at the end by lower_function_body.
 757
 758    After full lowering, the body of the function should look like:
 759
 760     {
 761       void * setjmpvar.0;
 762       int D.1844;
 763       int D.2844;
 764
 765       [...]
 766
 767       __builtin_setjmp_setup (&buf, &<D1847>);
 768       D.1844 = 0;
 769       goto <D1846>;
 770       <D1847>:;
 771       __builtin_setjmp_receiver (&<D1847>);
 772       D.1844 = 1;
 773       <D1846>:;
 774       if (D.1844 == 0) goto <D1848>; else goto <D1849>;
 775
 776       [...]
 777
 778       __builtin_setjmp_setup (&buf, &<D2847>);
 779       D.2844 = 0;
 780       goto <D2846>;
 781       <D2847>:;
 782       __builtin_setjmp_receiver (&<D2847>);
 783       D.2844 = 1;
 784       <D2846>:;
 785       if (D.2844 == 0) goto <D2848>; else goto <D2849>;
 786
 787       [...]
 788
 789       <D3850>:;
 790       return;
 791       <D3853>: [non-local];
 792       setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
 793       goto setjmpvar.0;
 794     }
 795
 796    The dispatcher block will be both the unique destination of all the
 797    abnormal call edges and the unique source of all the abnormal edges
 798    to the receivers, thus keeping the complexity explosion localized.  */
 799
 800 static void
 801 lower_builtin_setjmp (gimple_stmt_iterator *gsi)
 802 {
 803   gimple stmt = gsi_stmt (*gsi);
 804   location_t loc = gimple_location (stmt);
 805   tree cont_label = create_artificial_label (loc);
 806   tree next_label = create_artificial_label (loc);
 807   tree dest, t, arg;
 808   gimple g;
 809
 810   /* NEXT_LABEL is the label __builtin_longjmp will jump to.  Its address is
 811      passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver.  */
 812   FORCED_LABEL (next_label) = 1;
 813
 814   dest = gimple_call_lhs (stmt);
 815
 816   /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert.  */
 817   arg = build_addr (next_label, current_function_decl);
 818   t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
 819   g = gimple_build_call (t, 2, gimple_call_arg (stmt, 0), arg);
 820   gimple_set_location (g, loc);
 821   gimple_set_block (g, gimple_block (stmt));
 822   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 823
 824   /* Build 'DEST = 0' and insert.  */
 825   if (dest)
 826     {
 827       g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
 828                                                        integer_zero_node));
 829       gimple_set_location (g, loc);
 830       gimple_set_block (g, gimple_block (stmt));
 831       gsi_insert_before (gsi, g, GSI_SAME_STMT);
 832     }
 833
 834   /* Build 'goto CONT_LABEL' and insert.  */
 835   g = gimple_build_goto (cont_label);
 836   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 837
 838   /* Build 'NEXT_LABEL:' and insert.  */
 839   g = gimple_build_label (next_label);
 840   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 841
 842   /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert.  */
 843   arg = build_addr (next_label, current_function_decl);
 844   t = implicit_built_in_decls[BUILT_IN_SETJMP_RECEIVER];
 845   g = gimple_build_call (t, 1, arg);
 846   gimple_set_location (g, loc);
 847   gimple_set_block (g, gimple_block (stmt));
 848   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 849
 850   /* Build 'DEST = 1' and insert.  */
 851   if (dest)
 852     {
 853       g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
 854                                                        integer_one_node));
 855       gimple_set_location (g, loc);
 856       gimple_set_block (g, gimple_block (stmt));
 857       gsi_insert_before (gsi, g, GSI_SAME_STMT);
 858     }
 859
 860   /* Build 'CONT_LABEL:' and insert.  */
 861   g = gimple_build_label (cont_label);
 862   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 863
 864   /* Remove the call to __builtin_setjmp.  */
 865   gsi_remove (gsi, false);
 866 }
 867 \f
 868
 869 /* Record the variables in VARS into function FN.  */
 870
 871 void
 872 record_vars_into (tree vars, tree fn)
 873 {
 874   if (fn != current_function_decl)
 875     push_cfun (DECL_STRUCT_FUNCTION (fn));
 876
 877   for (; vars; vars = TREE_CHAIN (vars))
 878     {
 879       tree var = vars;
 880
 881       /* BIND_EXPRs contains also function/type/constant declarations
 882          we don't need to care about.  */
 883       if (TREE_CODE (var) != VAR_DECL)
 884         continue;
 885
 886       /* Nothing to do in this case.  */
 887       if (DECL_EXTERNAL (var))
 888         continue;
 889
 890       /* Record the variable.  */
 891       cfun->local_decls = tree_cons (NULL_TREE, var,
 892                                              cfun->local_decls);
 893     }
 894
 895   if (fn != current_function_decl)
 896     pop_cfun ();
 897 }
 898
 899
 900 /* Record the variables in VARS into current_function_decl.  */
 901
 902 void
 903 record_vars (tree vars)
 904 {
 905   record_vars_into (vars, current_function_decl);
 906 }