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