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