OpenCores
URL https://opencores.org/ocsvn/openrisc_me/openrisc_me/trunk

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.5.1/] [gcc/] [gimple-low.c] - Blame information for rev 280

Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.