gcc/gimple-low.c

   1 /* Tree lowering pass.  Lowers GIMPLE into unstructured form.
   2
   3    Copyright (C) 2003, 2005 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  20 02110-1301, USA.  */
  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 "tree-gimple.h"
  30 #include "tree-inline.h"
  31 #include "diagnostic.h"
  32 #include "langhooks.h"
  33 #include "langhooks-def.h"
  34 #include "tree-flow.h"
  35 #include "timevar.h"
  36 #include "except.h"
  37 #include "hashtab.h"
  38 #include "flags.h"
  39 #include "function.h"
  40 #include "expr.h"
  41 #include "toplev.h"
  42 #include "tree-pass.h"
  43
  44 struct lower_data
  45 {
  46   /* Block the current statement belongs to.  */
  47   tree block;
  48
  49   /* A TREE_LIST of label and return statements to be moved to the end
  50      of the function.  */
  51   tree return_statements;
  52
  53   /* True if the function calls __builtin_setjmp.  */
  54   bool calls_builtin_setjmp;
  55 };
  56
  57 static void lower_stmt (tree_stmt_iterator *, struct lower_data *);
  58 static void lower_bind_expr (tree_stmt_iterator *, struct lower_data *);
  59 static void lower_cond_expr (tree_stmt_iterator *, struct lower_data *);
  60 static void lower_return_expr (tree_stmt_iterator *, struct lower_data *);
  61 static void lower_builtin_setjmp (tree_stmt_iterator *);
  62
  63 /* Lower the body of current_function_decl.  */
  64
  65 static unsigned int
  66 lower_function_body (void)
  67 {
  68   struct lower_data data;
  69   tree *body_p = &DECL_SAVED_TREE (current_function_decl);
  70   tree bind = *body_p;
  71   tree_stmt_iterator i;
  72   tree t, x;
  73
  74   gcc_assert (TREE_CODE (bind) == BIND_EXPR);
  75
  76   memset (&data, 0, sizeof (data));
  77   data.block = DECL_INITIAL (current_function_decl);
  78   BLOCK_SUBBLOCKS (data.block) = NULL_TREE;
  79   BLOCK_CHAIN (data.block) = NULL_TREE;
  80   TREE_ASM_WRITTEN (data.block) = 1;
  81
  82   *body_p = alloc_stmt_list ();
  83   i = tsi_start (*body_p);
  84   tsi_link_after (&i, bind, TSI_NEW_STMT);
  85   lower_bind_expr (&i, &data);
  86
  87   i = tsi_last (*body_p);
  88
  89   /* If the function falls off the end, we need a null return statement.
  90      If we've already got one in the return_statements list, we don't
  91      need to do anything special.  Otherwise build one by hand.  */
  92   if (block_may_fallthru (*body_p)
  93       && (data.return_statements == NULL
  94           || TREE_OPERAND (TREE_VALUE (data.return_statements), 0) != NULL))
  95     {
  96       x = build1 (RETURN_EXPR, void_type_node, NULL);
  97       SET_EXPR_LOCATION (x, cfun->function_end_locus);
  98       tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
  99     }
 100
 101   /* If we lowered any return statements, emit the representative
 102      at the end of the function.  */
 103   for (t = data.return_statements ; t ; t = TREE_CHAIN (t))
 104     {
 105       x = build1 (LABEL_EXPR, void_type_node, TREE_PURPOSE (t));
 106       tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
 107
 108       /* Remove the line number from the representative return statement.
 109          It now fills in for many such returns.  Failure to remove this
 110          will result in incorrect results for coverage analysis.  */
 111       x = TREE_VALUE (t);
 112 #ifdef USE_MAPPED_LOCATION
 113       SET_EXPR_LOCATION (x, UNKNOWN_LOCATION);
 114 #else
 115       SET_EXPR_LOCUS (x, NULL);
 116 #endif
 117       tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
 118     }
 119
 120   /* If the function calls __builtin_setjmp, we need to emit the computed
 121      goto that will serve as the unique dispatcher for all the receivers.  */
 122   if (data.calls_builtin_setjmp)
 123     {
 124       tree disp_label, disp_var, arg;
 125
 126       /* Build 'DISP_LABEL:' and insert.  */
 127       disp_label = create_artificial_label ();
 128       /* This mark will create forward edges from every call site.  */
 129       DECL_NONLOCAL (disp_label) = 1;
 130       current_function_has_nonlocal_label = 1;
 131       x = build1 (LABEL_EXPR, void_type_node, disp_label);
 132       tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
 133
 134       /* Build 'DISP_VAR = __builtin_setjmp_dispatcher (DISP_LABEL);'
 135          and insert.  */
 136       disp_var = create_tmp_var (ptr_type_node, "setjmpvar");
 137       t = build_addr (disp_label, current_function_decl);
 138       arg = tree_cons (NULL, t, NULL);
 139       t = implicit_built_in_decls[BUILT_IN_SETJMP_DISPATCHER];
 140       t = build_function_call_expr (t,arg);
 141       x = build2 (GIMPLE_MODIFY_STMT, void_type_node, disp_var, t);
 142
 143       /* Build 'goto DISP_VAR;' and insert.  */
 144       tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
 145       x = build1 (GOTO_EXPR, void_type_node, disp_var);
 146       tsi_link_after (&i, x, TSI_CONTINUE_LINKING);
 147     }
 148
 149   gcc_assert (data.block == DECL_INITIAL (current_function_decl));
 150   BLOCK_SUBBLOCKS (data.block)
 151     = blocks_nreverse (BLOCK_SUBBLOCKS (data.block));
 152
 153   clear_block_marks (data.block);
 154   return 0;
 155 }
 156
 157 struct tree_opt_pass pass_lower_cf =
 158 {
 159   "lower",                              /* name */
 160   NULL,                                 /* gate */
 161   lower_function_body,                  /* execute */
 162   NULL,                                 /* sub */
 163   NULL,                                 /* next */
 164   0,                                    /* static_pass_number */
 165   0,                                    /* tv_id */
 166   PROP_gimple_any,                      /* properties_required */
 167   PROP_gimple_lcf,                      /* properties_provided */
 168   0,                                    /* properties_destroyed */
 169   0,                                    /* todo_flags_start */
 170   TODO_dump_func,                       /* todo_flags_finish */
 171   0                                     /* letter */
 172 };
 173
 174
 175 /* Lower the EXPR.  Unlike gimplification the statements are not relowered
 176    when they are changed -- if this has to be done, the lowering routine must
 177    do it explicitly.  DATA is passed through the recursion.  */
 178
 179 static void
 180 lower_stmt_body (tree expr, struct lower_data *data)
 181 {
 182   tree_stmt_iterator tsi;
 183
 184   for (tsi = tsi_start (expr); !tsi_end_p (tsi); )
 185     lower_stmt (&tsi, data);
 186 }
 187
 188
 189 /* Lower the OpenMP directive statement pointed by TSI.  DATA is
 190    passed through the recursion.  */
 191
 192 static void
 193 lower_omp_directive (tree_stmt_iterator *tsi, struct lower_data *data)
 194 {
 195   tree stmt;
 196
 197   stmt = tsi_stmt (*tsi);
 198
 199   lower_stmt_body (OMP_BODY (stmt), data);
 200   tsi_link_before (tsi, stmt, TSI_SAME_STMT);
 201   tsi_link_before (tsi, OMP_BODY (stmt), TSI_SAME_STMT);
 202   OMP_BODY (stmt) = NULL_TREE;
 203   tsi_delink (tsi);
 204 }
 205
 206
 207 /* Lower statement TSI.  DATA is passed through the recursion.  */
 208
 209 static void
 210 lower_stmt (tree_stmt_iterator *tsi, struct lower_data *data)
 211 {
 212   tree stmt = tsi_stmt (*tsi);
 213
 214   if (EXPR_HAS_LOCATION (stmt) && data)
 215     TREE_BLOCK (stmt) = data->block;
 216
 217   switch (TREE_CODE (stmt))
 218     {
 219     case BIND_EXPR:
 220       lower_bind_expr (tsi, data);
 221       return;
 222     case COND_EXPR:
 223       lower_cond_expr (tsi, data);
 224       return;
 225     case RETURN_EXPR:
 226       lower_return_expr (tsi, data);
 227       return;
 228
 229     case TRY_FINALLY_EXPR:
 230     case TRY_CATCH_EXPR:
 231       lower_stmt_body (TREE_OPERAND (stmt, 0), data);
 232       lower_stmt_body (TREE_OPERAND (stmt, 1), data);
 233       break;
 234     case CATCH_EXPR:
 235       lower_stmt_body (CATCH_BODY (stmt), data);
 236       break;
 237     case EH_FILTER_EXPR:
 238       lower_stmt_body (EH_FILTER_FAILURE (stmt), data);
 239       break;
 240
 241     case NOP_EXPR:
 242     case ASM_EXPR:
 243     case GOTO_EXPR:
 244     case LABEL_EXPR:
 245     case SWITCH_EXPR:
 246     case OMP_FOR:
 247     case OMP_SECTIONS:
 248     case OMP_SECTION:
 249     case OMP_SINGLE:
 250     case OMP_MASTER:
 251     case OMP_ORDERED:
 252     case OMP_CRITICAL:
 253     case OMP_RETURN:
 254     case OMP_CONTINUE:
 255       break;
 256
 257     case GIMPLE_MODIFY_STMT:
 258       if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == CALL_EXPR)
 259         stmt = GIMPLE_STMT_OPERAND (stmt, 1);
 260       else
 261         break;
 262       /* FALLTHRU */
 263
 264     case CALL_EXPR:
 265       {
 266         tree decl = get_callee_fndecl (stmt);
 267         if (decl
 268             && DECL_BUILT_IN_CLASS (decl) == BUILT_IN_NORMAL
 269             && DECL_FUNCTION_CODE (decl) == BUILT_IN_SETJMP)
 270           {
 271             data->calls_builtin_setjmp = true;
 272             lower_builtin_setjmp (tsi);
 273             return;
 274           }
 275       }
 276       break;
 277
 278     case OMP_PARALLEL:
 279       lower_omp_directive (tsi, data);
 280       return;
 281
 282     default:
 283       gcc_unreachable ();
 284     }
 285
 286   tsi_next (tsi);
 287 }
 288
 289 /* Lower a bind_expr TSI.  DATA is passed through the recursion.  */
 290
 291 static void
 292 lower_bind_expr (tree_stmt_iterator *tsi, struct lower_data *data)
 293 {
 294   tree old_block = data->block;
 295   tree stmt = tsi_stmt (*tsi);
 296   tree new_block = BIND_EXPR_BLOCK (stmt);
 297
 298   if (new_block)
 299     {
 300       if (new_block == old_block)
 301         {
 302           /* The outermost block of the original function may not be the
 303              outermost statement chain of the gimplified function.  So we
 304              may see the outermost block just inside the function.  */
 305           gcc_assert (new_block == DECL_INITIAL (current_function_decl));
 306           new_block = NULL;
 307         }
 308       else
 309         {
 310           /* We do not expect to handle duplicate blocks.  */
 311           gcc_assert (!TREE_ASM_WRITTEN (new_block));
 312           TREE_ASM_WRITTEN (new_block) = 1;
 313
 314           /* Block tree may get clobbered by inlining.  Normally this would
 315              be fixed in rest_of_decl_compilation using block notes, but
 316              since we are not going to emit them, it is up to us.  */
 317           BLOCK_CHAIN (new_block) = BLOCK_SUBBLOCKS (old_block);
 318           BLOCK_SUBBLOCKS (old_block) = new_block;
 319           BLOCK_SUBBLOCKS (new_block) = NULL_TREE;
 320           BLOCK_SUPERCONTEXT (new_block) = old_block;
 321
 322           data->block = new_block;
 323         }
 324     }
 325
 326   record_vars (BIND_EXPR_VARS (stmt));
 327   lower_stmt_body (BIND_EXPR_BODY (stmt), data);
 328
 329   if (new_block)
 330     {
 331       gcc_assert (data->block == new_block);
 332
 333       BLOCK_SUBBLOCKS (new_block)
 334         = blocks_nreverse (BLOCK_SUBBLOCKS (new_block));
 335       data->block = old_block;
 336     }
 337
 338   /* The BIND_EXPR no longer carries any useful information -- kill it.  */
 339   tsi_link_before (tsi, BIND_EXPR_BODY (stmt), TSI_SAME_STMT);
 340   tsi_delink (tsi);
 341 }
 342
 343 /* Try to determine whether a TRY_CATCH expression can fall through.
 344    This is a subroutine of block_may_fallthru.  */
 345
 346 static bool
 347 try_catch_may_fallthru (tree stmt)
 348 {
 349   tree_stmt_iterator i;
 350
 351   /* If the TRY block can fall through, the whole TRY_CATCH can
 352      fall through.  */
 353   if (block_may_fallthru (TREE_OPERAND (stmt, 0)))
 354     return true;
 355
 356   i = tsi_start (TREE_OPERAND (stmt, 1));
 357   switch (TREE_CODE (tsi_stmt (i)))
 358     {
 359     case CATCH_EXPR:
 360       /* We expect to see a sequence of CATCH_EXPR trees, each with a
 361          catch expression and a body.  The whole TRY_CATCH may fall
 362          through iff any of the catch bodies falls through.  */
 363       for (; !tsi_end_p (i); tsi_next (&i))
 364         {
 365           if (block_may_fallthru (CATCH_BODY (tsi_stmt (i))))
 366             return true;
 367         }
 368       return false;
 369
 370     case EH_FILTER_EXPR:
 371       /* The exception filter expression only matters if there is an
 372          exception.  If the exception does not match EH_FILTER_TYPES,
 373          we will execute EH_FILTER_FAILURE, and we will fall through
 374          if that falls through.  If the exception does match
 375          EH_FILTER_TYPES, the stack unwinder will continue up the
 376          stack, so we will not fall through.  We don't know whether we
 377          will throw an exception which matches EH_FILTER_TYPES or not,
 378          so we just ignore EH_FILTER_TYPES and assume that we might
 379          throw an exception which doesn't match.  */
 380       return block_may_fallthru (EH_FILTER_FAILURE (tsi_stmt (i)));
 381
 382     default:
 383       /* This case represents statements to be executed when an
 384          exception occurs.  Those statements are implicitly followed
 385          by a RESX_EXPR to resume execution after the exception.  So
 386          in this case the TRY_CATCH never falls through.  */
 387       return false;
 388     }
 389 }
 390
 391 /* Try to determine if we can fall out of the bottom of BLOCK.  This guess
 392    need not be 100% accurate; simply be conservative and return true if we
 393    don't know.  This is used only to avoid stupidly generating extra code.
 394    If we're wrong, we'll just delete the extra code later.  */
 395
 396 bool
 397 block_may_fallthru (tree block)
 398 {
 399   tree stmt = expr_last (block);
 400
 401   switch (stmt ? TREE_CODE (stmt) : ERROR_MARK)
 402     {
 403     case GOTO_EXPR:
 404     case RETURN_EXPR:
 405     case RESX_EXPR:
 406       /* Easy cases.  If the last statement of the block implies
 407          control transfer, then we can't fall through.  */
 408       return false;
 409
 410     case SWITCH_EXPR:
 411       /* If SWITCH_LABELS is set, this is lowered, and represents a
 412          branch to a selected label and hence can not fall through.
 413          Otherwise SWITCH_BODY is set, and the switch can fall
 414          through.  */
 415       return SWITCH_LABELS (stmt) == NULL_TREE;
 416
 417     case COND_EXPR:
 418       if (block_may_fallthru (COND_EXPR_THEN (stmt)))
 419         return true;
 420       return block_may_fallthru (COND_EXPR_ELSE (stmt));
 421
 422     case BIND_EXPR:
 423       return block_may_fallthru (BIND_EXPR_BODY (stmt));
 424
 425     case TRY_CATCH_EXPR:
 426       return try_catch_may_fallthru (stmt);
 427
 428     case TRY_FINALLY_EXPR:
 429       /* The finally clause is always executed after the try clause,
 430          so if it does not fall through, then the try-finally will not
 431          fall through.  Otherwise, if the try clause does not fall
 432          through, then when the finally clause falls through it will
 433          resume execution wherever the try clause was going.  So the
 434          whole try-finally will only fall through if both the try
 435          clause and the finally clause fall through.  */
 436       return (block_may_fallthru (TREE_OPERAND (stmt, 0))
 437               && block_may_fallthru (TREE_OPERAND (stmt, 1)));
 438
 439     case GIMPLE_MODIFY_STMT:
 440       if (TREE_CODE (GIMPLE_STMT_OPERAND (stmt, 1)) == CALL_EXPR)
 441         stmt = GIMPLE_STMT_OPERAND (stmt, 1);
 442       else
 443         return true;
 444       /* FALLTHRU */
 445
 446     case CALL_EXPR:
 447       /* Functions that do not return do not fall through.  */
 448       return (call_expr_flags (stmt) & ECF_NORETURN) == 0;
 449
 450     case CLEANUP_POINT_EXPR:
 451       return block_may_fallthru (TREE_OPERAND (stmt, 0));
 452
 453     default:
 454       return true;
 455     }
 456 }
 457
 458 /* Lower a cond_expr TSI.  DATA is passed through the recursion.  */
 459
 460 static void
 461 lower_cond_expr (tree_stmt_iterator *tsi, struct lower_data *data)
 462 {
 463   tree stmt = tsi_stmt (*tsi);
 464   bool then_is_goto, else_is_goto;
 465   tree then_branch, else_branch;
 466   tree then_goto, else_goto;
 467
 468   then_branch = COND_EXPR_THEN (stmt);
 469   else_branch = COND_EXPR_ELSE (stmt);
 470
 471   lower_stmt_body (then_branch, data);
 472   lower_stmt_body (else_branch, data);
 473
 474   then_goto = expr_only (then_branch);
 475   then_is_goto = then_goto && simple_goto_p (then_goto);
 476
 477   else_goto = expr_only (else_branch);
 478   else_is_goto = else_goto && simple_goto_p (else_goto);
 479
 480   if (!then_is_goto || !else_is_goto)
 481     {
 482       tree then_label, else_label, end_label, t;
 483
 484       then_label = NULL_TREE;
 485       else_label = NULL_TREE;
 486       end_label = NULL_TREE;
 487
 488       /* Replace the cond_expr with explicit gotos.  */
 489       if (!then_is_goto)
 490         {
 491           t = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
 492           if (TREE_SIDE_EFFECTS (then_branch))
 493             then_label = t;
 494           else
 495             end_label = t;
 496           then_goto = build_and_jump (&LABEL_EXPR_LABEL (t));
 497         }
 498
 499       if (!else_is_goto)
 500         {
 501           t = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
 502           if (TREE_SIDE_EFFECTS (else_branch))
 503             else_label = t;
 504           else
 505             {
 506               /* Both THEN and ELSE can be no-ops if one or both contained an
 507                  empty BIND_EXPR that was associated with the toplevel block
 508                  of an inlined function.  In that case remove_useless_stmts
 509                  can't have cleaned things up for us; kill the whole
 510                  conditional now.  */
 511               if (end_label)
 512                 {
 513                   tsi_delink (tsi);
 514                   return;
 515                 }
 516               else
 517                 end_label = t;
 518             }
 519           else_goto = build_and_jump (&LABEL_EXPR_LABEL (t));
 520         }
 521
 522       if (then_label)
 523         {
 524           bool may_fallthru = block_may_fallthru (then_branch);
 525
 526           tsi_link_after (tsi, then_label, TSI_CONTINUE_LINKING);
 527           tsi_link_after (tsi, then_branch, TSI_CONTINUE_LINKING);
 528
 529           if (else_label && may_fallthru)
 530             {
 531               end_label = build1 (LABEL_EXPR, void_type_node, NULL_TREE);
 532               t = build_and_jump (&LABEL_EXPR_LABEL (end_label));
 533               tsi_link_after (tsi, t, TSI_CONTINUE_LINKING);
 534             }
 535         }
 536
 537       if (else_label)
 538         {
 539           tsi_link_after (tsi, else_label, TSI_CONTINUE_LINKING);
 540           tsi_link_after (tsi, else_branch, TSI_CONTINUE_LINKING);
 541         }
 542
 543       if (end_label)
 544         tsi_link_after (tsi, end_label, TSI_CONTINUE_LINKING);
 545     }
 546
 547   COND_EXPR_THEN (stmt) = then_goto;
 548   COND_EXPR_ELSE (stmt) = else_goto;
 549
 550   tsi_next (tsi);
 551 }
 552
 553 /* Lower a return_expr TSI.  DATA is passed through the recursion.  */
 554
 555 static void
 556 lower_return_expr (tree_stmt_iterator *tsi, struct lower_data *data)
 557 {
 558   tree stmt = tsi_stmt (*tsi);
 559   tree value, t, label;
 560
 561   /* Extract the value being returned.  */
 562   value = TREE_OPERAND (stmt, 0);
 563   if (value && TREE_CODE (value) == GIMPLE_MODIFY_STMT)
 564     value = GIMPLE_STMT_OPERAND (value, 1);
 565
 566   /* Match this up with an existing return statement that's been created.  */
 567   for (t = data->return_statements; t ; t = TREE_CHAIN (t))
 568     {
 569       tree tvalue = TREE_OPERAND (TREE_VALUE (t), 0);
 570       if (tvalue && TREE_CODE (tvalue) == GIMPLE_MODIFY_STMT)
 571         tvalue = GIMPLE_STMT_OPERAND (tvalue, 1);
 572
 573       if (value == tvalue)
 574         {
 575           label = TREE_PURPOSE (t);
 576           goto found;
 577         }
 578     }
 579
 580   /* Not found.  Create a new label and record the return statement.  */
 581   label = create_artificial_label ();
 582   data->return_statements = tree_cons (label, stmt, data->return_statements);
 583
 584   /* Generate a goto statement and remove the return statement.  */
 585  found:
 586   t = build1 (GOTO_EXPR, void_type_node, label);
 587   SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
 588   tsi_link_before (tsi, t, TSI_SAME_STMT);
 589   tsi_delink (tsi);
 590 }
 591
 592 /* Lower a __builtin_setjmp TSI.
 593
 594    __builtin_setjmp is passed a pointer to an array of five words (not
 595    all will be used on all machines).  It operates similarly to the C
 596    library function of the same name, but is more efficient.
 597
 598    It is lowered into 3 other builtins, namely __builtin_setjmp_setup,
 599    __builtin_setjmp_dispatcher and __builtin_setjmp_receiver, but with
 600    __builtin_setjmp_dispatcher shared among all the instances; that's
 601    why it is only emitted at the end by lower_function_body.
 602
 603    After full lowering, the body of the function should look like:
 604
 605     {
 606       void * setjmpvar.0;
 607       int D.1844;
 608       int D.2844;
 609
 610       [...]
 611
 612       __builtin_setjmp_setup (&buf, &<D1847>);
 613       D.1844 = 0;
 614       goto <D1846>;
 615       <D1847>:;
 616       __builtin_setjmp_receiver (&<D1847>);
 617       D.1844 = 1;
 618       <D1846>:;
 619       if (D.1844 == 0) goto <D1848>; else goto <D1849>;
 620
 621       [...]
 622
 623       __builtin_setjmp_setup (&buf, &<D2847>);
 624       D.2844 = 0;
 625       goto <D2846>;
 626       <D2847>:;
 627       __builtin_setjmp_receiver (&<D2847>);
 628       D.2844 = 1;
 629       <D2846>:;
 630       if (D.2844 == 0) goto <D2848>; else goto <D2849>;
 631
 632       [...]
 633
 634       <D3850>:;
 635       return;
 636       <D3853>: [non-local];
 637       setjmpvar.0 = __builtin_setjmp_dispatcher (&<D3853>);
 638       goto setjmpvar.0;
 639     }
 640
 641    The dispatcher block will be both the unique destination of all the
 642    abnormal call edges and the unique source of all the abnormal edges
 643    to the receivers, thus keeping the complexity explosion localized.  */
 644
 645 static void
 646 lower_builtin_setjmp (tree_stmt_iterator *tsi)
 647 {
 648   tree stmt = tsi_stmt (*tsi);
 649   tree cont_label = create_artificial_label ();
 650   tree next_label = create_artificial_label ();
 651   tree dest, t, arg;
 652
 653   /* NEXT_LABEL is the label __builtin_longjmp will jump to.  Its address is
 654      passed to both __builtin_setjmp_setup and __builtin_setjmp_receiver.  */
 655   FORCED_LABEL (next_label) = 1;
 656
 657   if (TREE_CODE (stmt) == GIMPLE_MODIFY_STMT)
 658     {
 659       dest = GIMPLE_STMT_OPERAND (stmt, 0);
 660       stmt = GIMPLE_STMT_OPERAND (stmt, 1);
 661     }
 662   else
 663     dest = NULL_TREE;
 664
 665   /* Build '__builtin_setjmp_setup (BUF, NEXT_LABEL)' and insert.  */
 666   t = build_addr (next_label, current_function_decl);
 667   arg = tree_cons (NULL, t, NULL);
 668   t = TREE_VALUE (GENERIC_TREE_OPERAND (stmt, 1));
 669   arg = tree_cons (NULL, t, arg);
 670   t = implicit_built_in_decls[BUILT_IN_SETJMP_SETUP];
 671   t = build_function_call_expr (t, arg);
 672   SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
 673   tsi_link_before (tsi, t, TSI_SAME_STMT);
 674
 675   /* Build 'DEST = 0' and insert.  */
 676   if (dest)
 677     {
 678       t = build2 (GIMPLE_MODIFY_STMT, void_type_node, dest, integer_zero_node);
 679       SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
 680       tsi_link_before (tsi, t, TSI_SAME_STMT);
 681     }
 682
 683   /* Build 'goto CONT_LABEL' and insert.  */
 684   t = build1 (GOTO_EXPR, void_type_node, cont_label);
 685   tsi_link_before (tsi, t, TSI_SAME_STMT);
 686
 687   /* Build 'NEXT_LABEL:' and insert.  */
 688   t = build1 (LABEL_EXPR, void_type_node, next_label);
 689   tsi_link_before (tsi, t, TSI_SAME_STMT);
 690
 691   /* Build '__builtin_setjmp_receiver (NEXT_LABEL)' and insert.  */
 692   t = build_addr (next_label, current_function_decl);
 693   arg = tree_cons (NULL, t, NULL);
 694   t = implicit_built_in_decls[BUILT_IN_SETJMP_RECEIVER];
 695   t = build_function_call_expr (t, arg);
 696   SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
 697   tsi_link_before (tsi, t, TSI_SAME_STMT);
 698
 699   /* Build 'DEST = 1' and insert.  */
 700   if (dest)
 701     {
 702       t = build2 (GIMPLE_MODIFY_STMT, void_type_node, dest, integer_one_node);
 703       SET_EXPR_LOCUS (t, EXPR_LOCUS (stmt));
 704       tsi_link_before (tsi, t, TSI_SAME_STMT);
 705     }
 706
 707   /* Build 'CONT_LABEL:' and insert.  */
 708   t = build1 (LABEL_EXPR, void_type_node, cont_label);
 709   tsi_link_before (tsi, t, TSI_SAME_STMT);
 710
 711   /* Remove the call to __builtin_setjmp.  */
 712   tsi_delink (tsi);
 713 }
 714 \f
 715
 716 /* Record the variables in VARS into function FN.  */
 717
 718 void
 719 record_vars_into (tree vars, tree fn)
 720 {
 721   struct function *saved_cfun = cfun;
 722
 723   if (fn != current_function_decl)
 724     cfun = DECL_STRUCT_FUNCTION (fn);
 725
 726   for (; vars; vars = TREE_CHAIN (vars))
 727     {
 728       tree var = vars;
 729
 730       /* BIND_EXPRs contains also function/type/constant declarations
 731          we don't need to care about.  */
 732       if (TREE_CODE (var) != VAR_DECL)
 733         continue;
 734
 735       /* Nothing to do in this case.  */
 736       if (DECL_EXTERNAL (var))
 737         continue;
 738
 739       /* Record the variable.  */
 740       cfun->unexpanded_var_list = tree_cons (NULL_TREE, var,
 741                                              cfun->unexpanded_var_list);
 742     }
 743
 744   if (fn != current_function_decl)
 745     cfun = saved_cfun;
 746 }
 747
 748
 749 /* Record the variables in VARS into current_function_decl.  */
 750
 751 void
 752 record_vars (tree vars)
 753 {
 754   record_vars_into (vars, current_function_decl);
 755 }
 756
 757
 758 /* Mark BLOCK used if it has a used variable in it, then recurse over its
 759    subblocks.  */
 760
 761 static void
 762 mark_blocks_with_used_vars (tree block)
 763 {
 764   tree var;
 765   tree subblock;
 766
 767   if (!TREE_USED (block))
 768     {
 769       for (var = BLOCK_VARS (block);
 770            var;
 771            var = TREE_CHAIN (var))
 772         {
 773           if (TREE_USED (var))
 774             {
 775               TREE_USED (block) = true;
 776               break;
 777             }
 778         }
 779     }
 780   for (subblock = BLOCK_SUBBLOCKS (block);
 781        subblock;
 782        subblock = BLOCK_CHAIN (subblock))
 783     mark_blocks_with_used_vars (subblock);
 784 }
 785
 786 /* Mark the used attribute on blocks correctly.  */
 787
 788 static unsigned int
 789 mark_used_blocks (void)
 790 {
 791   mark_blocks_with_used_vars (DECL_INITIAL (current_function_decl));
 792   return 0;
 793 }
 794
 795
 796 struct tree_opt_pass pass_mark_used_blocks =
 797 {
 798   "blocks",                             /* name */
 799   NULL,                                 /* gate */
 800   mark_used_blocks,                     /* execute */
 801   NULL,                                 /* sub */
 802   NULL,                                 /* next */
 803   0,                                    /* static_pass_number */
 804   0,                                    /* tv_id */
 805   0,                                    /* properties_required */
 806   0,                                    /* properties_provided */
 807   0,                                    /* properties_destroyed */
 808   0,                                    /* todo_flags_start */
 809   TODO_dump_func,                       /* todo_flags_finish */
 810   0                                     /* letter */
 811 };