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