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