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 = implicit_built_in_decls[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_NOP:
 400     case GIMPLE_ASM:
 401     case GIMPLE_ASSIGN:
 402     case GIMPLE_PREDICT:
 403     case GIMPLE_LABEL:
 404     case GIMPLE_EH_MUST_NOT_THROW:
 405     case GIMPLE_OMP_FOR:
 406     case GIMPLE_OMP_SECTIONS:
 407     case GIMPLE_OMP_SECTIONS_SWITCH:
 408     case GIMPLE_OMP_SECTION:
 409     case GIMPLE_OMP_SINGLE:
 410     case GIMPLE_OMP_MASTER:
 411     case GIMPLE_OMP_ORDERED:
 412     case GIMPLE_OMP_CRITICAL:
 413     case GIMPLE_OMP_RETURN:
 414     case GIMPLE_OMP_ATOMIC_LOAD:
 415     case GIMPLE_OMP_ATOMIC_STORE:
 416     case GIMPLE_OMP_CONTINUE:
 417       break;
 418
 419     case GIMPLE_CALL:
 420       {
 421         tree decl = gimple_call_fndecl (stmt);
 422
 423         if (decl
 424             && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
 425             && DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
 426           {
 427             lower_builtin_setjmp (gsi);
 428             data->cannot_fallthru = false;
 429             data->calls_builtin_setjmp = true;
 430             return;
 431           }
 432
 433         if (decl && (flags_from_decl_or_type (decl) & ECF_NORETURN))
 434           {
 435             data->cannot_fallthru = true;
 436             gsi_next (gsi);
 437             return;
 438           }
 439       }
 440       break;
 441
 442     case GIMPLE_OMP_PARALLEL:
 443     case GIMPLE_OMP_TASK:
 444       data->cannot_fallthru = false;
 445       lower_omp_directive (gsi, data);
 446       data->cannot_fallthru = false;
 447       return;
 448
 449     default:
 450       gcc_unreachable ();
 451     }
 452
 453   data->cannot_fallthru = false;
 454   gsi_next (gsi);
 455 }
 456
 457 /* Lower a bind_expr TSI.  DATA is passed through the recursion.  */
 458
 459 static void
 460 lower_gimple_bind (gimple_stmt_iterator *gsi, struct lower_data *data)
 461 {
 462   tree old_block = data->block;
 463   gimple stmt = gsi_stmt (*gsi);
 464   tree new_block = gimple_bind_block (stmt);
 465
 466   if (new_block)
 467     {
 468       if (new_block == old_block)
 469         {
 470           /* The outermost block of the original function may not be the
 471              outermost statement chain of the gimplified function.  So we
 472              may see the outermost block just inside the function.  */
 473           gcc_assert (new_block == DECL_INITIAL (current_function_decl));
 474           new_block = NULL;
 475         }
 476       else
 477         {
 478           /* We do not expect to handle duplicate blocks.  */
 479           gcc_assert (!TREE_ASM_WRITTEN (new_block));
 480           TREE_ASM_WRITTEN (new_block) = 1;
 481
 482           /* Block tree may get clobbered by inlining.  Normally this would
 483              be fixed in rest_of_decl_compilation using block notes, but
 484              since we are not going to emit them, it is up to us.  */
 485           BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (old_block);
 486           BLOCK_SUBBLOCKS (old_block) = new_block;
 487           BLOCK_SUBBLOCKS (new_block) = NULL_TREE;
 488           BLOCK_SUPERCONTEXT (new_block) = old_block;
 489
 490           data->block = new_block;
 491         }
 492     }
 493
 494   record_vars (gimple_bind_vars (stmt));
 495   lower_sequence (gimple_bind_body (stmt), data);
 496
 497   if (new_block)
 498     {
 499       gcc_assert (data->block == new_block);
 500
 501       BLOCK_SUBBLOCKS (new_block)
 502         = blocks_nreverse (BLOCK_SUBBLOCKS (new_block));
 503       data->block = old_block;
 504     }
 505
 506   /* The GIMPLE_BIND no longer carries any useful information -- kill it.  */
 507   gsi_insert_seq_before (gsi, gimple_bind_body (stmt), GSI_SAME_STMT);
 508   gsi_remove (gsi, false);
 509 }
 510
 511 /* Try to determine whether a TRY_CATCH expression can fall through.
 512    This is a subroutine of block_may_fallthru.  */
 513
 514 static bool
 515 try_catch_may_fallthru (const_tree stmt)
 516 {
 517   tree_stmt_iterator i;
 518
 519   /* If the TRY block can fall through, the whole TRY_CATCH can
 520      fall through.  */
 521   if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
 522     return true;
 523
 524   i = tsi_start (TREE_OPERAND (stmt, 1));
 525   switch (TREE_CODE (tsi_stmt (i)))
 526     {
 527     case CATCH_EXPR:
 528       /* We expect to see a sequence of CATCH_EXPR trees, each with a
 529          catch expression and a body.  The whole TRY_CATCH may fall
 530          through iff any of the catch bodies falls through.  */
 531       for (; !tsi_end_p (i); tsi_next (&i))
 532         {
 533           if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
 534             return true;
 535         }
 536       return false;
 537
 538     case EH_FILTER_EXPR:
 539       /* The exception filter expression only matters if there is an
 540          exception.  If the exception does not match EH_FILTER_TYPES,
 541          we will execute EH_FILTER_FAILURE, and we will fall through
 542          if that falls through.  If the exception does match
 543          EH_FILTER_TYPES, the stack unwinder will continue up the
 544          stack, so we will not fall through.  We don't know whether we
 545          will throw an exception which matches EH_FILTER_TYPES or not,
 546          so we just ignore EH_FILTER_TYPES and assume that we might
 547          throw an exception which doesn't match.  */
 548       return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
 549
 550     default:
 551       /* This case represents statements to be executed when an
 552          exception occurs.  Those statements are implicitly followed
 553          by a RESX statement to resume execution after the exception.
 554          So in this case the TRY_CATCH never falls through.  */
 555       return false;
 556     }
 557 }
 558
 559
 560 /* Same as above, but for a GIMPLE_TRY_CATCH.  */
 561
 562 static bool
 563 gimple_try_catch_may_fallthru (gimple stmt)
 564 {
 565   gimple_stmt_iterator i;
 566
 567   /* We don't handle GIMPLE_TRY_FINALLY.  */
 568   gcc_assert (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH);
 569
 570   /* If the TRY block can fall through, the whole TRY_CATCH can
 571      fall through.  */
 572   if (gimple_seq_may_fallthru (gimple_try_eval (stmt)))
 573     return true;
 574
 575   i = gsi_start (gimple_try_cleanup (stmt));
 576   switch (gimple_code (gsi_stmt (i)))
 577     {
 578     case GIMPLE_CATCH:
 579       /* We expect to see a sequence of GIMPLE_CATCH stmts, each with a
 580          catch expression and a body.  The whole try/catch may fall
 581          through iff any of the catch bodies falls through.  */
 582       for (; !gsi_end_p (i); gsi_next (&i))
 583         {
 584           if (gimple_seq_may_fallthru (gimple_catch_handler (gsi_stmt (i))))
 585             return true;
 586         }
 587       return false;
 588
 589     case GIMPLE_EH_FILTER:
 590       /* The exception filter expression only matters if there is an
 591          exception.  If the exception does not match EH_FILTER_TYPES,
 592          we will execute EH_FILTER_FAILURE, and we will fall through
 593          if that falls through.  If the exception does match
 594          EH_FILTER_TYPES, the stack unwinder will continue up the
 595          stack, so we will not fall through.  We don't know whether we
 596          will throw an exception which matches EH_FILTER_TYPES or not,
 597          so we just ignore EH_FILTER_TYPES and assume that we might
 598          throw an exception which doesn't match.  */
 599       return gimple_seq_may_fallthru (gimple_eh_filter_failure (gsi_stmt (i)));
 600
 601     default:
 602       /* This case represents statements to be executed when an
 603          exception occurs.  Those statements are implicitly followed
 604          by a GIMPLE_RESX to resume execution after the exception.  So
 605          in this case the try/catch never falls through.  */
 606       return false;
 607     }
 608 }
 609
 610
 611 /* Try to determine if we can fall out of the bottom of BLOCK.  This guess
 612    need not be 100% accurate; simply be conservative and return true if we
 613    don't know.  This is used only to avoid stupidly generating extra code.
 614    If we're wrong, we'll just delete the extra code later.  */
 615
 616 bool
 617 block_may_fallthru (const_tree block)
 618 {
 619   /* This CONST_CAST is okay because expr_last returns its argument
 620      unmodified and we assign it to a const_tree.  */
 621   const_tree stmt = expr_last (CONST_CAST_TREE(block));
 622
 623   switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
 624     {
 625     case GOTO_EXPR:
 626     case RETURN_EXPR:
 627       /* Easy cases.  If the last statement of the block implies
 628          control transfer, then we can't fall through.  */
 629       return false;
 630
 631     case SWITCH_EXPR:
 632       /* If SWITCH_LABELS is set, this is lowered, and represents a
 633          branch to a selected label and hence can not fall through.
 634          Otherwise SWITCH_BODY is set, and the switch can fall
 635          through.  */
 636       return SWITCH_LABELS (stmt) == NULL_TREE;
 637
 638     case COND_EXPR:
 639       if (block_may_fallthru (COND_EXPR_THEN (stmt)))
 640         return true;
 641       return block_may_fallthru (COND_EXPR_ELSE (stmt));
 642
 643     case BIND_EXPR:
 644       return block_may_fallthru (BIND_EXPR_BODY (stmt));
 645
 646     case TRY_CATCH_EXPR:
 647       return try_catch_may_fallthru (stmt);
 648
 649     case TRY_FINALLY_EXPR:
 650       /* The finally clause is always executed after the try clause,
 651          so if it does not fall through, then the try-finally will not
 652          fall through.  Otherwise, if the try clause does not fall
 653          through, then when the finally clause falls through it will
 654          resume execution wherever the try clause was going.  So the
 655          whole try-finally will only fall through if both the try
 656          clause and the finally clause fall through.  */
 657       return (block_may_fallthru (TREE_OPERAND (stmt, 0))
 658               && block_may_fallthru (TREE_OPERAND (stmt, 1)));
 659
 660     case MODIFY_EXPR:
 661       if (TREE_CODE (TREE_OPERAND (stmt, 1)) == CALL_EXPR)
 662         stmt = TREE_OPERAND (stmt, 1);
 663       else
 664         return true;
 665       /* FALLTHRU */
 666
 667     case CALL_EXPR:
 668       /* Functions that do not return do not fall through.  */
 669       return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
 670
 671     case CLEANUP_POINT_EXPR:
 672       return block_may_fallthru (TREE_OPERAND (stmt, 0));
 673
 674     default:
 675       return true;
 676     }
 677 }
 678
 679
 680 /* Try to determine if we can continue executing the statement
 681    immediately following STMT.  This guess need not be 100% accurate;
 682    simply be conservative and return true if we don't know.  This is
 683    used only to avoid stupidly generating extra code. If we're wrong,
 684    we'll just delete the extra code later.  */
 685
 686 bool
 687 gimple_stmt_may_fallthru (gimple stmt)
 688 {
 689   if (!stmt)
 690     return true;
 691
 692   switch (gimple_code (stmt))
 693     {
 694     case GIMPLE_GOTO:
 695     case GIMPLE_RETURN:
 696     case GIMPLE_RESX:
 697       /* Easy cases.  If the last statement of the seq implies
 698          control transfer, then we can't fall through.  */
 699       return false;
 700
 701     case GIMPLE_SWITCH:
 702       /* Switch has already been lowered and represents a branch
 703          to a selected label and hence can't fall through.  */
 704       return false;
 705
 706     case GIMPLE_COND:
 707       /* GIMPLE_COND's are already lowered into a two-way branch.  They
 708          can't fall through.  */
 709       return false;
 710
 711     case GIMPLE_BIND:
 712       return gimple_seq_may_fallthru (gimple_bind_body (stmt));
 713
 714     case GIMPLE_TRY:
 715       if (gimple_try_kind (stmt) == GIMPLE_TRY_CATCH)
 716         return gimple_try_catch_may_fallthru (stmt);
 717
 718       /* It must be a GIMPLE_TRY_FINALLY.  */
 719
 720       /* The finally clause is always executed after the try clause,
 721          so if it does not fall through, then the try-finally will not
 722          fall through.  Otherwise, if the try clause does not fall
 723          through, then when the finally clause falls through it will
 724          resume execution wherever the try clause was going.  So the
 725          whole try-finally will only fall through if both the try
 726          clause and the finally clause fall through.  */
 727       return (gimple_seq_may_fallthru (gimple_try_eval (stmt))
 728               && gimple_seq_may_fallthru (gimple_try_cleanup (stmt)));
 729
 730     case GIMPLE_CALL:
 731       /* Functions that do not return do not fall through.  */
 732       return (gimple_call_flags (stmt) & ECF_NORETURN) == 0;
 733
 734     default:
 735       return true;
 736     }
 737 }
 738
 739
 740 /* Same as gimple_stmt_may_fallthru, but for the gimple sequence SEQ.  */
 741
 742 bool
 743 gimple_seq_may_fallthru (gimple_seq seq)
 744 {
 745   return gimple_stmt_may_fallthru (gimple_seq_last_stmt (seq));
 746 }
 747
 748
 749 /* Lower a GIMPLE_RETURN GSI.  DATA is passed through the recursion.  */
 750
 751 static void
 752 lower_gimple_return (gimple_stmt_iterator *gsi, struct lower_data *data)
 753 {
 754   gimple stmt = gsi_stmt (*gsi);
 755   gimple t;
 756   int i;
 757   return_statements_t tmp_rs;
 758
 759   /* Match this up with an existing return statement that's been created.  */
 760   for (i = VEC_length (return_statements_t, data->return_statements) - 1;
 761        i >= 0; i--)
 762     {
 763       tmp_rs = *VEC_index (return_statements_t, data->return_statements, i);
 764
 765       if (gimple_return_retval (stmt) == gimple_return_retval (tmp_rs.stmt))
 766         {
 767           /* Remove the line number from the representative return statement.
 768              It now fills in for many such returns.  Failure to remove this
 769              will result in incorrect results for coverage analysis.  */
 770           gimple_set_location (tmp_rs.stmt, UNKNOWN_LOCATION);
 771
 772           goto found;
 773         }
 774     }
 775
 776   /* Not found.  Create a new label and record the return statement.  */
 777   tmp_rs.label = create_artificial_label (cfun->function_end_locus);
 778   tmp_rs.stmt = stmt;
 779   VEC_safe_push (return_statements_t, heap, data->return_statements, &tmp_rs);
 780
 781   /* Generate a goto statement and remove the return statement.  */
 782  found:
 783   /* When not optimizing, make sure user returns are preserved.  */
 784   if (!optimize && gimple_has_location (stmt))
 785     DECL_ARTIFICIAL (tmp_rs.label) = 0;
 786   t = gimple_build_goto (tmp_rs.label);
 787   gimple_set_location (t, gimple_location (stmt));
 788   gimple_set_block (t, gimple_block (stmt));
 789   gsi_insert_before (gsi, t, GSI_SAME_STMT);
 790   gsi_remove (gsi, false);
 791 }
 792
 793 /* Lower a __builtin_setjmp GSI.
 794
 795    __builtin_setjmp is passed a pointer to an array of five words (not
 796    all will be used on all machines).  It operates similarly to the C
 797    library function of the same name, but is more efficient.
 798
 799    It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
 800    __builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
 801    __builtin_setjmp_dispatcher shared among all the instances; that's
 802    why it is only emitted at the end by lower_function_body.
 803
 804    After full lowering, the body of the function should look like:
 805
 806     {
 807       void * setjmpvar.0;
 808       int D.1844;
 809       int D.2844;
 810
 811       [...]
 812
 813       __builtin_setjmp_setup (&buf, &<D1847>);
 814       D.1844 = 0;
 815       goto <D1846>;
 816       <D1847>:;
 817       __builtin_setjmp_receiver (&<D1847>);
 818       D.1844 = 1;
 819       <D1846>:;
 820       if (D.1844 == 0) goto <D1848>; else goto <D1849>;
 821
 822       [...]
 823
 824       __builtin_setjmp_setup (&buf, &<D2847>);
 825       D.2844 = 0;
 826       goto <D2846>;
 827       <D2847>:;
 828       __builtin_setjmp_receiver (&<D2847>);
 829       D.2844 = 1;
 830       <D2846>:;
 831       if (D.2844 == 0) goto <D2848>; else goto <D2849>;
 832
 833       [...]
 834
 835       <D3850>:;
 836       return;
 837       <D3853>: [non-local];
 838       setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
 839       goto setjmpvar.0;
 840     }
 841
 842    The dispatcher block will be both the unique destination of all the
 843    abnormal call edges and the unique source of all the abnormal edges
 844    to the receivers, thus keeping the complexity explosion localized.  */
 845
 846 static void
 847 lower_builtin_setjmp (gimple_stmt_iterator *gsi)
 848 {
 849   gimple stmt = gsi_stmt (*gsi);
 850   location_t loc = gimple_location (stmt);
 851   tree cont_label = create_artificial_label (loc);
 852   tree next_label = create_artificial_label (loc);
 853   tree dest, t, arg;
 854   gimple g;
 855
 856   /* NEXT_LABEL is the label __builtin_longjmp will jump to.  Its address is
 857      passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver.  */
 858   FORCED_LABEL (next_label) = 1;
 859
 860   dest = gimple_call_lhs (stmt);
 861
 862   /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert.  */
 863   arg = build_addr (next_label, current_function_decl);
 864   t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
 865   g = gimple_build_call (t, 2, gimple_call_arg (stmt, 0), arg);
 866   gimple_set_location (g, loc);
 867   gimple_set_block (g, gimple_block (stmt));
 868   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 869
 870   /* Build 'DEST = 0' and insert.  */
 871   if (dest)
 872     {
 873       g = gimple_build_assign (dest, build_zero_cst (TREE_TYPE (dest)));
 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 'goto CONT_LABEL' and insert.  */
 880   g = gimple_build_goto (cont_label);
 881   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 882
 883   /* Build 'NEXT_LABEL:' and insert.  */
 884   g = gimple_build_label (next_label);
 885   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 886
 887   /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert.  */
 888   arg = build_addr (next_label, current_function_decl);
 889   t = implicit_built_in_decls[BUILT_IN_SETJMP_RECEIVER];
 890   g = gimple_build_call (t, 1, arg);
 891   gimple_set_location (g, loc);
 892   gimple_set_block (g, gimple_block (stmt));
 893   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 894
 895   /* Build 'DEST = 1' and insert.  */
 896   if (dest)
 897     {
 898       g = gimple_build_assign (dest, fold_convert_loc (loc, TREE_TYPE (dest),
 899                                                        integer_one_node));
 900       gimple_set_location (g, loc);
 901       gimple_set_block (g, gimple_block (stmt));
 902       gsi_insert_before (gsi, g, GSI_SAME_STMT);
 903     }
 904
 905   /* Build 'CONT_LABEL:' and insert.  */
 906   g = gimple_build_label (cont_label);
 907   gsi_insert_before (gsi, g, GSI_SAME_STMT);
 908
 909   /* Remove the call to __builtin_setjmp.  */
 910   gsi_remove (gsi, false);
 911 }
 912 \f
 913
 914 /* Record the variables in VARS into function FN.  */
 915
 916 void
 917 record_vars_into (tree vars, tree fn)
 918 {
 919   if (fn != current_function_decl)
 920     push_cfun (DECL_STRUCT_FUNCTION (fn));
 921
 922   for (; vars; vars = DECL_CHAIN (vars))
 923     {
 924       tree var = vars;
 925
 926       /* BIND_EXPRs contains also function/type/constant declarations
 927          we don't need to care about.  */
 928       if (TREE_CODE (var) != VAR_DECL)
 929         continue;
 930
 931       /* Nothing to do in this case.  */
 932       if (DECL_EXTERNAL (var))
 933         continue;
 934
 935       /* Record the variable.  */
 936       add_local_decl (cfun, var);
 937       if (gimple_referenced_vars (cfun))
 938         add_referenced_var (var);
 939     }
 940
 941   if (fn != current_function_decl)
 942     pop_cfun ();
 943 }
 944
 945
 946 /* Record the variables in VARS into current_function_decl.  */
 947
 948 void
 949 record_vars (tree vars)
 950 {
 951   record_vars_into (vars, current_function_decl);
 952 }