Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / gimple.c
1 /* Gimple IR support functions.
2
3    Copyright (C) 2007-2015 Free Software Foundation, Inc.
4    Contributed by Aldy Hernandez <aldyh@redhat.com>
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 "target.h"
27 #include "hash-set.h"
28 #include "machmode.h"
29 #include "vec.h"
30 #include "double-int.h"
31 #include "input.h"
32 #include "alias.h"
33 #include "symtab.h"
34 #include "wide-int.h"
35 #include "inchash.h"
36 #include "tree.h"
37 #include "fold-const.h"
38 #include "calls.h"
39 #include "stmt.h"
40 #include "stor-layout.h"
41 #include "hard-reg-set.h"
42 #include "predict.h"
43 #include "input.h"
44 #include "function.h"
45 #include "dominance.h"
46 #include "cfg.h"
47 #include "basic-block.h"
48 #include "tree-ssa-alias.h"
49 #include "internal-fn.h"
50 #include "tree-eh.h"
51 #include "gimple-expr.h"
52 #include "is-a.h"
53 #include "gimple.h"
54 #include "gimple-iterator.h"
55 #include "gimple-walk.h"
56 #include "gimple.h"
57 #include "gimplify.h"
58 #include "diagnostic.h"
59 #include "value-prof.h"
60 #include "flags.h"
61 #include "alias.h"
62 #include "demangle.h"
63 #include "langhooks.h"
64 #include "bitmap.h"
65 #include "stringpool.h"
66 #include "tree-ssanames.h"
67 #include "ipa-ref.h"
68 #include "lto-streamer.h"
69 #include "cgraph.h"
70
71
72 /* All the tuples have their operand vector (if present) at the very bottom
73    of the structure.  Therefore, the offset required to find the
74    operands vector the size of the structure minus the size of the 1
75    element tree array at the end (see gimple_ops).  */
76 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) \
77         (HAS_TREE_OP ? sizeof (struct STRUCT) - sizeof (tree) : 0),
78 EXPORTED_CONST size_t gimple_ops_offset_[] = {
79 #include "gsstruct.def"
80 };
81 #undef DEFGSSTRUCT
82
83 #define DEFGSSTRUCT(SYM, STRUCT, HAS_TREE_OP) sizeof (struct STRUCT),
84 static const size_t gsstruct_code_size[] = {
85 #include "gsstruct.def"
86 };
87 #undef DEFGSSTRUCT
88
89 #define DEFGSCODE(SYM, NAME, GSSCODE)   NAME,
90 const char *const gimple_code_name[] = {
91 #include "gimple.def"
92 };
93 #undef DEFGSCODE
94
95 #define DEFGSCODE(SYM, NAME, GSSCODE)   GSSCODE,
96 EXPORTED_CONST enum gimple_statement_structure_enum gss_for_code_[] = {
97 #include "gimple.def"
98 };
99 #undef DEFGSCODE
100
101 /* Gimple stats.  */
102
103 int gimple_alloc_counts[(int) gimple_alloc_kind_all];
104 int gimple_alloc_sizes[(int) gimple_alloc_kind_all];
105
106 /* Keep in sync with gimple.h:enum gimple_alloc_kind.  */
107 static const char * const gimple_alloc_kind_names[] = {
108     "assignments",
109     "phi nodes",
110     "conditionals",
111     "everything else"
112 };
113
114 /* Gimple tuple constructors.
115    Note: Any constructor taking a ``gimple_seq'' as a parameter, can
116    be passed a NULL to start with an empty sequence.  */
117
118 /* Set the code for statement G to CODE.  */
119
120 static inline void
121 gimple_set_code (gimple g, enum gimple_code code)
122 {
123   g->code = code;
124 }
125
126 /* Return the number of bytes needed to hold a GIMPLE statement with
127    code CODE.  */
128
129 static inline size_t
130 gimple_size (enum gimple_code code)
131 {
132   return gsstruct_code_size[gss_for_code (code)];
133 }
134
135 /* Allocate memory for a GIMPLE statement with code CODE and NUM_OPS
136    operands.  */
137
138 gimple
139 gimple_alloc_stat (enum gimple_code code, unsigned num_ops MEM_STAT_DECL)
140 {
141   size_t size;
142   gimple stmt;
143
144   size = gimple_size (code);
145   if (num_ops > 0)
146     size += sizeof (tree) * (num_ops - 1);
147
148   if (GATHER_STATISTICS)
149     {
150       enum gimple_alloc_kind kind = gimple_alloc_kind (code);
151       gimple_alloc_counts[(int) kind]++;
152       gimple_alloc_sizes[(int) kind] += size;
153     }
154
155   stmt = ggc_alloc_cleared_gimple_statement_stat (size PASS_MEM_STAT);
156   gimple_set_code (stmt, code);
157   gimple_set_num_ops (stmt, num_ops);
158
159   /* Do not call gimple_set_modified here as it has other side
160      effects and this tuple is still not completely built.  */
161   stmt->modified = 1;
162   gimple_init_singleton (stmt);
163
164   return stmt;
165 }
166
167 /* Set SUBCODE to be the code of the expression computed by statement G.  */
168
169 static inline void
170 gimple_set_subcode (gimple g, unsigned subcode)
171 {
172   /* We only have 16 bits for the RHS code.  Assert that we are not
173      overflowing it.  */
174   gcc_assert (subcode < (1 << 16));
175   g->subcode = subcode;
176 }
177
178
179
180 /* Build a tuple with operands.  CODE is the statement to build (which
181    must be one of the GIMPLE_WITH_OPS tuples).  SUBCODE is the subcode
182    for the new tuple.  NUM_OPS is the number of operands to allocate.  */
183
184 #define gimple_build_with_ops(c, s, n) \
185   gimple_build_with_ops_stat (c, s, n MEM_STAT_INFO)
186
187 static gimple
188 gimple_build_with_ops_stat (enum gimple_code code, unsigned subcode,
189                             unsigned num_ops MEM_STAT_DECL)
190 {
191   gimple s = gimple_alloc_stat (code, num_ops PASS_MEM_STAT);
192   gimple_set_subcode (s, subcode);
193
194   return s;
195 }
196
197
198 /* Build a GIMPLE_RETURN statement returning RETVAL.  */
199
200 greturn *
201 gimple_build_return (tree retval)
202 {
203   greturn *s
204     = as_a <greturn *> (gimple_build_with_ops (GIMPLE_RETURN, ERROR_MARK,
205                                                2));
206   if (retval)
207     gimple_return_set_retval (s, retval);
208   return s;
209 }
210
211 /* Reset alias information on call S.  */
212
213 void
214 gimple_call_reset_alias_info (gcall *s)
215 {
216   if (gimple_call_flags (s) & ECF_CONST)
217     memset (gimple_call_use_set (s), 0, sizeof (struct pt_solution));
218   else
219     pt_solution_reset (gimple_call_use_set (s));
220   if (gimple_call_flags (s) & (ECF_CONST|ECF_PURE|ECF_NOVOPS))
221     memset (gimple_call_clobber_set (s), 0, sizeof (struct pt_solution));
222   else
223     pt_solution_reset (gimple_call_clobber_set (s));
224 }
225
226 /* Helper for gimple_build_call, gimple_build_call_valist,
227    gimple_build_call_vec and gimple_build_call_from_tree.  Build the basic
228    components of a GIMPLE_CALL statement to function FN with NARGS
229    arguments.  */
230
231 static inline gcall *
232 gimple_build_call_1 (tree fn, unsigned nargs)
233 {
234   gcall *s
235     = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
236                                              nargs + 3));
237   if (TREE_CODE (fn) == FUNCTION_DECL)
238     fn = build_fold_addr_expr (fn);
239   gimple_set_op (s, 1, fn);
240   gimple_call_set_fntype (s, TREE_TYPE (TREE_TYPE (fn)));
241   gimple_call_reset_alias_info (s);
242   return s;
243 }
244
245
246 /* Build a GIMPLE_CALL statement to function FN with the arguments
247    specified in vector ARGS.  */
248
249 gcall *
250 gimple_build_call_vec (tree fn, vec<tree> args)
251 {
252   unsigned i;
253   unsigned nargs = args.length ();
254   gcall *call = gimple_build_call_1 (fn, nargs);
255
256   for (i = 0; i < nargs; i++)
257     gimple_call_set_arg (call, i, args[i]);
258
259   return call;
260 }
261
262
263 /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
264    arguments.  The ... are the arguments.  */
265
266 gcall *
267 gimple_build_call (tree fn, unsigned nargs, ...)
268 {
269   va_list ap;
270   gcall *call;
271   unsigned i;
272
273   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
274
275   call = gimple_build_call_1 (fn, nargs);
276
277   va_start (ap, nargs);
278   for (i = 0; i < nargs; i++)
279     gimple_call_set_arg (call, i, va_arg (ap, tree));
280   va_end (ap);
281
282   return call;
283 }
284
285
286 /* Build a GIMPLE_CALL statement to function FN.  NARGS is the number of
287    arguments.  AP contains the arguments.  */
288
289 gcall *
290 gimple_build_call_valist (tree fn, unsigned nargs, va_list ap)
291 {
292   gcall *call;
293   unsigned i;
294
295   gcc_assert (TREE_CODE (fn) == FUNCTION_DECL || is_gimple_call_addr (fn));
296
297   call = gimple_build_call_1 (fn, nargs);
298
299   for (i = 0; i < nargs; i++)
300     gimple_call_set_arg (call, i, va_arg (ap, tree));
301
302   return call;
303 }
304
305
306 /* Helper for gimple_build_call_internal and gimple_build_call_internal_vec.
307    Build the basic components of a GIMPLE_CALL statement to internal
308    function FN with NARGS arguments.  */
309
310 static inline gcall *
311 gimple_build_call_internal_1 (enum internal_fn fn, unsigned nargs)
312 {
313   gcall *s
314     = as_a <gcall *> (gimple_build_with_ops (GIMPLE_CALL, ERROR_MARK,
315                                              nargs + 3));
316   s->subcode |= GF_CALL_INTERNAL;
317   gimple_call_set_internal_fn (s, fn);
318   gimple_call_reset_alias_info (s);
319   return s;
320 }
321
322
323 /* Build a GIMPLE_CALL statement to internal function FN.  NARGS is
324    the number of arguments.  The ... are the arguments.  */
325
326 gcall *
327 gimple_build_call_internal (enum internal_fn fn, unsigned nargs, ...)
328 {
329   va_list ap;
330   gcall *call;
331   unsigned i;
332
333   call = gimple_build_call_internal_1 (fn, nargs);
334   va_start (ap, nargs);
335   for (i = 0; i < nargs; i++)
336     gimple_call_set_arg (call, i, va_arg (ap, tree));
337   va_end (ap);
338
339   return call;
340 }
341
342
343 /* Build a GIMPLE_CALL statement to internal function FN with the arguments
344    specified in vector ARGS.  */
345
346 gcall *
347 gimple_build_call_internal_vec (enum internal_fn fn, vec<tree> args)
348 {
349   unsigned i, nargs;
350   gcall *call;
351
352   nargs = args.length ();
353   call = gimple_build_call_internal_1 (fn, nargs);
354   for (i = 0; i < nargs; i++)
355     gimple_call_set_arg (call, i, args[i]);
356
357   return call;
358 }
359
360
361 /* Build a GIMPLE_CALL statement from CALL_EXPR T.  Note that T is
362    assumed to be in GIMPLE form already.  Minimal checking is done of
363    this fact.  */
364
365 gcall *
366 gimple_build_call_from_tree (tree t)
367 {
368   unsigned i, nargs;
369   gcall *call;
370   tree fndecl = get_callee_fndecl (t);
371
372   gcc_assert (TREE_CODE (t) == CALL_EXPR);
373
374   nargs = call_expr_nargs (t);
375   call = gimple_build_call_1 (fndecl ? fndecl : CALL_EXPR_FN (t), nargs);
376
377   for (i = 0; i < nargs; i++)
378     gimple_call_set_arg (call, i, CALL_EXPR_ARG (t, i));
379
380   gimple_set_block (call, TREE_BLOCK (t));
381
382   /* Carry all the CALL_EXPR flags to the new GIMPLE_CALL.  */
383   gimple_call_set_chain (call, CALL_EXPR_STATIC_CHAIN (t));
384   gimple_call_set_tail (call, CALL_EXPR_TAILCALL (t));
385   gimple_call_set_return_slot_opt (call, CALL_EXPR_RETURN_SLOT_OPT (t));
386   if (fndecl
387       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
388       && (DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA
389           || DECL_FUNCTION_CODE (fndecl) == BUILT_IN_ALLOCA_WITH_ALIGN))
390     gimple_call_set_alloca_for_var (call, CALL_ALLOCA_FOR_VAR_P (t));
391   else
392     gimple_call_set_from_thunk (call, CALL_FROM_THUNK_P (t));
393   gimple_call_set_va_arg_pack (call, CALL_EXPR_VA_ARG_PACK (t));
394   gimple_call_set_nothrow (call, TREE_NOTHROW (t));
395   gimple_set_no_warning (call, TREE_NO_WARNING (t));
396   gimple_call_set_with_bounds (call, CALL_WITH_BOUNDS_P (t));
397
398   return call;
399 }
400
401
402 /* Build a GIMPLE_ASSIGN statement.
403
404    LHS of the assignment.
405    RHS of the assignment which can be unary or binary.  */
406
407 gassign *
408 gimple_build_assign (tree lhs, tree rhs MEM_STAT_DECL)
409 {
410   enum tree_code subcode;
411   tree op1, op2, op3;
412
413   extract_ops_from_tree_1 (rhs, &subcode, &op1, &op2, &op3);
414   return gimple_build_assign (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
415 }
416
417
418 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
419    OP1, OP2 and OP3.  */
420
421 static inline gassign *
422 gimple_build_assign_1 (tree lhs, enum tree_code subcode, tree op1,
423                        tree op2, tree op3 MEM_STAT_DECL)
424 {
425   unsigned num_ops;
426   gassign *p;
427
428   /* Need 1 operand for LHS and 1 or 2 for the RHS (depending on the
429      code).  */
430   num_ops = get_gimple_rhs_num_ops (subcode) + 1;
431
432   p = as_a <gassign *> (
433         gimple_build_with_ops_stat (GIMPLE_ASSIGN, (unsigned)subcode, num_ops
434                                     PASS_MEM_STAT));
435   gimple_assign_set_lhs (p, lhs);
436   gimple_assign_set_rhs1 (p, op1);
437   if (op2)
438     {
439       gcc_assert (num_ops > 2);
440       gimple_assign_set_rhs2 (p, op2);
441     }
442
443   if (op3)
444     {
445       gcc_assert (num_ops > 3);
446       gimple_assign_set_rhs3 (p, op3);
447     }
448
449   return p;
450 }
451
452 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
453    OP1, OP2 and OP3.  */
454
455 gassign *
456 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
457                      tree op2, tree op3 MEM_STAT_DECL)
458 {
459   return gimple_build_assign_1 (lhs, subcode, op1, op2, op3 PASS_MEM_STAT);
460 }
461
462 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operands
463    OP1 and OP2.  */
464
465 gassign *
466 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1,
467                      tree op2 MEM_STAT_DECL)
468 {
469   return gimple_build_assign_1 (lhs, subcode, op1, op2, NULL_TREE
470                                 PASS_MEM_STAT);
471 }
472
473 /* Build a GIMPLE_ASSIGN statement with subcode SUBCODE and operand OP1.  */
474
475 gassign *
476 gimple_build_assign (tree lhs, enum tree_code subcode, tree op1 MEM_STAT_DECL)
477 {
478   return gimple_build_assign_1 (lhs, subcode, op1, NULL_TREE, NULL_TREE
479                                 PASS_MEM_STAT);
480 }
481
482
483 /* Build a GIMPLE_COND statement.
484
485    PRED is the condition used to compare LHS and the RHS.
486    T_LABEL is the label to jump to if the condition is true.
487    F_LABEL is the label to jump to otherwise.  */
488
489 gcond *
490 gimple_build_cond (enum tree_code pred_code, tree lhs, tree rhs,
491                    tree t_label, tree f_label)
492 {
493   gcond *p;
494
495   gcc_assert (TREE_CODE_CLASS (pred_code) == tcc_comparison);
496   p = as_a <gcond *> (gimple_build_with_ops (GIMPLE_COND, pred_code, 4));
497   gimple_cond_set_lhs (p, lhs);
498   gimple_cond_set_rhs (p, rhs);
499   gimple_cond_set_true_label (p, t_label);
500   gimple_cond_set_false_label (p, f_label);
501   return p;
502 }
503
504 /* Build a GIMPLE_COND statement from the conditional expression tree
505    COND.  T_LABEL and F_LABEL are as in gimple_build_cond.  */
506
507 gcond *
508 gimple_build_cond_from_tree (tree cond, tree t_label, tree f_label)
509 {
510   enum tree_code code;
511   tree lhs, rhs;
512
513   gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
514   return gimple_build_cond (code, lhs, rhs, t_label, f_label);
515 }
516
517 /* Set code, lhs, and rhs of a GIMPLE_COND from a suitable
518    boolean expression tree COND.  */
519
520 void
521 gimple_cond_set_condition_from_tree (gcond *stmt, tree cond)
522 {
523   enum tree_code code;
524   tree lhs, rhs;
525
526   gimple_cond_get_ops_from_tree (cond, &code, &lhs, &rhs);
527   gimple_cond_set_condition (stmt, code, lhs, rhs);
528 }
529
530 /* Build a GIMPLE_LABEL statement for LABEL.  */
531
532 glabel *
533 gimple_build_label (tree label)
534 {
535   glabel *p
536     = as_a <glabel *> (gimple_build_with_ops (GIMPLE_LABEL, ERROR_MARK, 1));
537   gimple_label_set_label (p, label);
538   return p;
539 }
540
541 /* Build a GIMPLE_GOTO statement to label DEST.  */
542
543 ggoto *
544 gimple_build_goto (tree dest)
545 {
546   ggoto *p
547     = as_a <ggoto *> (gimple_build_with_ops (GIMPLE_GOTO, ERROR_MARK, 1));
548   gimple_goto_set_dest (p, dest);
549   return p;
550 }
551
552
553 /* Build a GIMPLE_NOP statement.  */
554
555 gimple
556 gimple_build_nop (void)
557 {
558   return gimple_alloc (GIMPLE_NOP, 0);
559 }
560
561
562 /* Build a GIMPLE_BIND statement.
563    VARS are the variables in BODY.
564    BLOCK is the containing block.  */
565
566 gbind *
567 gimple_build_bind (tree vars, gimple_seq body, tree block)
568 {
569   gbind *p = as_a <gbind *> (gimple_alloc (GIMPLE_BIND, 0));
570   gimple_bind_set_vars (p, vars);
571   if (body)
572     gimple_bind_set_body (p, body);
573   if (block)
574     gimple_bind_set_block (p, block);
575   return p;
576 }
577
578 /* Helper function to set the simple fields of a asm stmt.
579
580    STRING is a pointer to a string that is the asm blocks assembly code.
581    NINPUT is the number of register inputs.
582    NOUTPUT is the number of register outputs.
583    NCLOBBERS is the number of clobbered registers.
584    */
585
586 static inline gasm *
587 gimple_build_asm_1 (const char *string, unsigned ninputs, unsigned noutputs,
588                     unsigned nclobbers, unsigned nlabels)
589 {
590   gasm *p;
591   int size = strlen (string);
592
593   /* ASMs with labels cannot have outputs.  This should have been
594      enforced by the front end.  */
595   gcc_assert (nlabels == 0 || noutputs == 0);
596
597   p = as_a <gasm *> (
598         gimple_build_with_ops (GIMPLE_ASM, ERROR_MARK,
599                                ninputs + noutputs + nclobbers + nlabels));
600
601   p->ni = ninputs;
602   p->no = noutputs;
603   p->nc = nclobbers;
604   p->nl = nlabels;
605   p->string = ggc_alloc_string (string, size);
606
607   if (GATHER_STATISTICS)
608     gimple_alloc_sizes[(int) gimple_alloc_kind (GIMPLE_ASM)] += size;
609
610   return p;
611 }
612
613 /* Build a GIMPLE_ASM statement.
614
615    STRING is the assembly code.
616    NINPUT is the number of register inputs.
617    NOUTPUT is the number of register outputs.
618    NCLOBBERS is the number of clobbered registers.
619    INPUTS is a vector of the input register parameters.
620    OUTPUTS is a vector of the output register parameters.
621    CLOBBERS is a vector of the clobbered register parameters.
622    LABELS is a vector of destination labels.  */
623
624 gasm *
625 gimple_build_asm_vec (const char *string, vec<tree, va_gc> *inputs,
626                       vec<tree, va_gc> *outputs, vec<tree, va_gc> *clobbers,
627                       vec<tree, va_gc> *labels)
628 {
629   gasm *p;
630   unsigned i;
631
632   p = gimple_build_asm_1 (string,
633                           vec_safe_length (inputs),
634                           vec_safe_length (outputs),
635                           vec_safe_length (clobbers),
636                           vec_safe_length (labels));
637
638   for (i = 0; i < vec_safe_length (inputs); i++)
639     gimple_asm_set_input_op (p, i, (*inputs)[i]);
640
641   for (i = 0; i < vec_safe_length (outputs); i++)
642     gimple_asm_set_output_op (p, i, (*outputs)[i]);
643
644   for (i = 0; i < vec_safe_length (clobbers); i++)
645     gimple_asm_set_clobber_op (p, i, (*clobbers)[i]);
646
647   for (i = 0; i < vec_safe_length (labels); i++)
648     gimple_asm_set_label_op (p, i, (*labels)[i]);
649
650   return p;
651 }
652
653 /* Build a GIMPLE_CATCH statement.
654
655   TYPES are the catch types.
656   HANDLER is the exception handler.  */
657
658 gcatch *
659 gimple_build_catch (tree types, gimple_seq handler)
660 {
661   gcatch *p = as_a <gcatch *> (gimple_alloc (GIMPLE_CATCH, 0));
662   gimple_catch_set_types (p, types);
663   if (handler)
664     gimple_catch_set_handler (p, handler);
665
666   return p;
667 }
668
669 /* Build a GIMPLE_EH_FILTER statement.
670
671    TYPES are the filter's types.
672    FAILURE is the filter's failure action.  */
673
674 geh_filter *
675 gimple_build_eh_filter (tree types, gimple_seq failure)
676 {
677   geh_filter *p = as_a <geh_filter *> (gimple_alloc (GIMPLE_EH_FILTER, 0));
678   gimple_eh_filter_set_types (p, types);
679   if (failure)
680     gimple_eh_filter_set_failure (p, failure);
681
682   return p;
683 }
684
685 /* Build a GIMPLE_EH_MUST_NOT_THROW statement.  */
686
687 geh_mnt *
688 gimple_build_eh_must_not_throw (tree decl)
689 {
690   geh_mnt *p = as_a <geh_mnt *> (gimple_alloc (GIMPLE_EH_MUST_NOT_THROW, 0));
691
692   gcc_assert (TREE_CODE (decl) == FUNCTION_DECL);
693   gcc_assert (flags_from_decl_or_type (decl) & ECF_NORETURN);
694   gimple_eh_must_not_throw_set_fndecl (p, decl);
695
696   return p;
697 }
698
699 /* Build a GIMPLE_EH_ELSE statement.  */
700
701 geh_else *
702 gimple_build_eh_else (gimple_seq n_body, gimple_seq e_body)
703 {
704   geh_else *p = as_a <geh_else *> (gimple_alloc (GIMPLE_EH_ELSE, 0));
705   gimple_eh_else_set_n_body (p, n_body);
706   gimple_eh_else_set_e_body (p, e_body);
707   return p;
708 }
709
710 /* Build a GIMPLE_TRY statement.
711
712    EVAL is the expression to evaluate.
713    CLEANUP is the cleanup expression.
714    KIND is either GIMPLE_TRY_CATCH or GIMPLE_TRY_FINALLY depending on
715    whether this is a try/catch or a try/finally respectively.  */
716
717 gtry *
718 gimple_build_try (gimple_seq eval, gimple_seq cleanup,
719                   enum gimple_try_flags kind)
720 {
721   gtry *p;
722
723   gcc_assert (kind == GIMPLE_TRY_CATCH || kind == GIMPLE_TRY_FINALLY);
724   p = as_a <gtry *> (gimple_alloc (GIMPLE_TRY, 0));
725   gimple_set_subcode (p, kind);
726   if (eval)
727     gimple_try_set_eval (p, eval);
728   if (cleanup)
729     gimple_try_set_cleanup (p, cleanup);
730
731   return p;
732 }
733
734 /* Construct a GIMPLE_WITH_CLEANUP_EXPR statement.
735
736    CLEANUP is the cleanup expression.  */
737
738 gimple
739 gimple_build_wce (gimple_seq cleanup)
740 {
741   gimple p = gimple_alloc (GIMPLE_WITH_CLEANUP_EXPR, 0);
742   if (cleanup)
743     gimple_wce_set_cleanup (p, cleanup);
744
745   return p;
746 }
747
748
749 /* Build a GIMPLE_RESX statement.  */
750
751 gresx *
752 gimple_build_resx (int region)
753 {
754   gresx *p
755     = as_a <gresx *> (gimple_build_with_ops (GIMPLE_RESX, ERROR_MARK, 0));
756   p->region = region;
757   return p;
758 }
759
760
761 /* The helper for constructing a gimple switch statement.
762    INDEX is the switch's index.
763    NLABELS is the number of labels in the switch excluding the default.
764    DEFAULT_LABEL is the default label for the switch statement.  */
765
766 gswitch *
767 gimple_build_switch_nlabels (unsigned nlabels, tree index, tree default_label)
768 {
769   /* nlabels + 1 default label + 1 index.  */
770   gcc_checking_assert (default_label);
771   gswitch *p = as_a <gswitch *> (gimple_build_with_ops (GIMPLE_SWITCH,
772                                                         ERROR_MARK,
773                                                         1 + 1 + nlabels));
774   gimple_switch_set_index (p, index);
775   gimple_switch_set_default_label (p, default_label);
776   return p;
777 }
778
779 /* Build a GIMPLE_SWITCH statement.
780
781    INDEX is the switch's index.
782    DEFAULT_LABEL is the default label
783    ARGS is a vector of labels excluding the default.  */
784
785 gswitch *
786 gimple_build_switch (tree index, tree default_label, vec<tree> args)
787 {
788   unsigned i, nlabels = args.length ();
789
790   gswitch *p = gimple_build_switch_nlabels (nlabels, index, default_label);
791
792   /* Copy the labels from the vector to the switch statement.  */
793   for (i = 0; i < nlabels; i++)
794     gimple_switch_set_label (p, i + 1, args[i]);
795
796   return p;
797 }
798
799 /* Build a GIMPLE_EH_DISPATCH statement.  */
800
801 geh_dispatch *
802 gimple_build_eh_dispatch (int region)
803 {
804   geh_dispatch *p
805     = as_a <geh_dispatch *> (
806         gimple_build_with_ops (GIMPLE_EH_DISPATCH, ERROR_MARK, 0));
807   p->region = region;
808   return p;
809 }
810
811 /* Build a new GIMPLE_DEBUG_BIND statement.
812
813    VAR is bound to VALUE; block and location are taken from STMT.  */
814
815 gdebug *
816 gimple_build_debug_bind_stat (tree var, tree value, gimple stmt MEM_STAT_DECL)
817 {
818   gdebug *p
819     = as_a <gdebug *> (gimple_build_with_ops_stat (GIMPLE_DEBUG,
820                                                    (unsigned)GIMPLE_DEBUG_BIND, 2
821                                                    PASS_MEM_STAT));
822   gimple_debug_bind_set_var (p, var);
823   gimple_debug_bind_set_value (p, value);
824   if (stmt)
825     gimple_set_location (p, gimple_location (stmt));
826
827   return p;
828 }
829
830
831 /* Build a new GIMPLE_DEBUG_SOURCE_BIND statement.
832
833    VAR is bound to VALUE; block and location are taken from STMT.  */
834
835 gdebug *
836 gimple_build_debug_source_bind_stat (tree var, tree value,
837                                      gimple stmt MEM_STAT_DECL)
838 {
839   gdebug *p
840     = as_a <gdebug *> (
841         gimple_build_with_ops_stat (GIMPLE_DEBUG,
842                                     (unsigned)GIMPLE_DEBUG_SOURCE_BIND, 2
843                                     PASS_MEM_STAT));
844
845   gimple_debug_source_bind_set_var (p, var);
846   gimple_debug_source_bind_set_value (p, value);
847   if (stmt)
848     gimple_set_location (p, gimple_location (stmt));
849
850   return p;
851 }
852
853
854 /* Build a GIMPLE_OMP_CRITICAL statement.
855
856    BODY is the sequence of statements for which only one thread can execute.
857    NAME is optional identifier for this critical block.  */
858
859 gomp_critical *
860 gimple_build_omp_critical (gimple_seq body, tree name)
861 {
862   gomp_critical *p
863     = as_a <gomp_critical *> (gimple_alloc (GIMPLE_OMP_CRITICAL, 0));
864   gimple_omp_critical_set_name (p, name);
865   if (body)
866     gimple_omp_set_body (p, body);
867
868   return p;
869 }
870
871 /* Build a GIMPLE_OMP_FOR statement.
872
873    BODY is sequence of statements inside the for loop.
874    KIND is the `for' variant.
875    CLAUSES, are any of the construct's clauses.
876    COLLAPSE is the collapse count.
877    PRE_BODY is the sequence of statements that are loop invariant.  */
878
879 gomp_for *
880 gimple_build_omp_for (gimple_seq body, int kind, tree clauses, size_t collapse,
881                       gimple_seq pre_body)
882 {
883   gomp_for *p = as_a <gomp_for *> (gimple_alloc (GIMPLE_OMP_FOR, 0));
884   if (body)
885     gimple_omp_set_body (p, body);
886   gimple_omp_for_set_clauses (p, clauses);
887   gimple_omp_for_set_kind (p, kind);
888   p->collapse = collapse;
889   p->iter =  ggc_cleared_vec_alloc<gimple_omp_for_iter> (collapse);
890
891   if (pre_body)
892     gimple_omp_for_set_pre_body (p, pre_body);
893
894   return p;
895 }
896
897
898 /* Build a GIMPLE_OMP_PARALLEL statement.
899
900    BODY is sequence of statements which are executed in parallel.
901    CLAUSES, are the OMP parallel construct's clauses.
902    CHILD_FN is the function created for the parallel threads to execute.
903    DATA_ARG are the shared data argument(s).  */
904
905 gomp_parallel *
906 gimple_build_omp_parallel (gimple_seq body, tree clauses, tree child_fn,
907                            tree data_arg)
908 {
909   gomp_parallel *p
910     = as_a <gomp_parallel *> (gimple_alloc (GIMPLE_OMP_PARALLEL, 0));
911   if (body)
912     gimple_omp_set_body (p, body);
913   gimple_omp_parallel_set_clauses (p, clauses);
914   gimple_omp_parallel_set_child_fn (p, child_fn);
915   gimple_omp_parallel_set_data_arg (p, data_arg);
916
917   return p;
918 }
919
920
921 /* Build a GIMPLE_OMP_TASK statement.
922
923    BODY is sequence of statements which are executed by the explicit task.
924    CLAUSES, are the OMP parallel construct's clauses.
925    CHILD_FN is the function created for the parallel threads to execute.
926    DATA_ARG are the shared data argument(s).
927    COPY_FN is the optional function for firstprivate initialization.
928    ARG_SIZE and ARG_ALIGN are size and alignment of the data block.  */
929
930 gomp_task *
931 gimple_build_omp_task (gimple_seq body, tree clauses, tree child_fn,
932                        tree data_arg, tree copy_fn, tree arg_size,
933                        tree arg_align)
934 {
935   gomp_task *p = as_a <gomp_task *> (gimple_alloc (GIMPLE_OMP_TASK, 0));
936   if (body)
937     gimple_omp_set_body (p, body);
938   gimple_omp_task_set_clauses (p, clauses);
939   gimple_omp_task_set_child_fn (p, child_fn);
940   gimple_omp_task_set_data_arg (p, data_arg);
941   gimple_omp_task_set_copy_fn (p, copy_fn);
942   gimple_omp_task_set_arg_size (p, arg_size);
943   gimple_omp_task_set_arg_align (p, arg_align);
944
945   return p;
946 }
947
948
949 /* Build a GIMPLE_OMP_SECTION statement for a sections statement.
950
951    BODY is the sequence of statements in the section.  */
952
953 gimple
954 gimple_build_omp_section (gimple_seq body)
955 {
956   gimple p = gimple_alloc (GIMPLE_OMP_SECTION, 0);
957   if (body)
958     gimple_omp_set_body (p, body);
959
960   return p;
961 }
962
963
964 /* Build a GIMPLE_OMP_MASTER statement.
965
966    BODY is the sequence of statements to be executed by just the master.  */
967
968 gimple
969 gimple_build_omp_master (gimple_seq body)
970 {
971   gimple p = gimple_alloc (GIMPLE_OMP_MASTER, 0);
972   if (body)
973     gimple_omp_set_body (p, body);
974
975   return p;
976 }
977
978
979 /* Build a GIMPLE_OMP_TASKGROUP statement.
980
981    BODY is the sequence of statements to be executed by the taskgroup
982    construct.  */
983
984 gimple
985 gimple_build_omp_taskgroup (gimple_seq body)
986 {
987   gimple p = gimple_alloc (GIMPLE_OMP_TASKGROUP, 0);
988   if (body)
989     gimple_omp_set_body (p, body);
990
991   return p;
992 }
993
994
995 /* Build a GIMPLE_OMP_CONTINUE statement.
996
997    CONTROL_DEF is the definition of the control variable.
998    CONTROL_USE is the use of the control variable.  */
999
1000 gomp_continue *
1001 gimple_build_omp_continue (tree control_def, tree control_use)
1002 {
1003   gomp_continue *p
1004     = as_a <gomp_continue *> (gimple_alloc (GIMPLE_OMP_CONTINUE, 0));
1005   gimple_omp_continue_set_control_def (p, control_def);
1006   gimple_omp_continue_set_control_use (p, control_use);
1007   return p;
1008 }
1009
1010 /* Build a GIMPLE_OMP_ORDERED statement.
1011
1012    BODY is the sequence of statements inside a loop that will executed in
1013    sequence.  */
1014
1015 gimple
1016 gimple_build_omp_ordered (gimple_seq body)
1017 {
1018   gimple p = gimple_alloc (GIMPLE_OMP_ORDERED, 0);
1019   if (body)
1020     gimple_omp_set_body (p, body);
1021
1022   return p;
1023 }
1024
1025
1026 /* Build a GIMPLE_OMP_RETURN statement.
1027    WAIT_P is true if this is a non-waiting return.  */
1028
1029 gimple
1030 gimple_build_omp_return (bool wait_p)
1031 {
1032   gimple p = gimple_alloc (GIMPLE_OMP_RETURN, 0);
1033   if (wait_p)
1034     gimple_omp_return_set_nowait (p);
1035
1036   return p;
1037 }
1038
1039
1040 /* Build a GIMPLE_OMP_SECTIONS statement.
1041
1042    BODY is a sequence of section statements.
1043    CLAUSES are any of the OMP sections contsruct's clauses: private,
1044    firstprivate, lastprivate, reduction, and nowait.  */
1045
1046 gomp_sections *
1047 gimple_build_omp_sections (gimple_seq body, tree clauses)
1048 {
1049   gomp_sections *p
1050     = as_a <gomp_sections *> (gimple_alloc (GIMPLE_OMP_SECTIONS, 0));
1051   if (body)
1052     gimple_omp_set_body (p, body);
1053   gimple_omp_sections_set_clauses (p, clauses);
1054
1055   return p;
1056 }
1057
1058
1059 /* Build a GIMPLE_OMP_SECTIONS_SWITCH.  */
1060
1061 gimple
1062 gimple_build_omp_sections_switch (void)
1063 {
1064   return gimple_alloc (GIMPLE_OMP_SECTIONS_SWITCH, 0);
1065 }
1066
1067
1068 /* Build a GIMPLE_OMP_SINGLE statement.
1069
1070    BODY is the sequence of statements that will be executed once.
1071    CLAUSES are any of the OMP single construct's clauses: private, firstprivate,
1072    copyprivate, nowait.  */
1073
1074 gomp_single *
1075 gimple_build_omp_single (gimple_seq body, tree clauses)
1076 {
1077   gomp_single *p
1078     = as_a <gomp_single *> (gimple_alloc (GIMPLE_OMP_SINGLE, 0));
1079   if (body)
1080     gimple_omp_set_body (p, body);
1081   gimple_omp_single_set_clauses (p, clauses);
1082
1083   return p;
1084 }
1085
1086
1087 /* Build a GIMPLE_OMP_TARGET statement.
1088
1089    BODY is the sequence of statements that will be executed.
1090    KIND is the kind of the region.
1091    CLAUSES are any of the construct's clauses.  */
1092
1093 gomp_target *
1094 gimple_build_omp_target (gimple_seq body, int kind, tree clauses)
1095 {
1096   gomp_target *p
1097     = as_a <gomp_target *> (gimple_alloc (GIMPLE_OMP_TARGET, 0));
1098   if (body)
1099     gimple_omp_set_body (p, body);
1100   gimple_omp_target_set_clauses (p, clauses);
1101   gimple_omp_target_set_kind (p, kind);
1102
1103   return p;
1104 }
1105
1106
1107 /* Build a GIMPLE_OMP_TEAMS statement.
1108
1109    BODY is the sequence of statements that will be executed.
1110    CLAUSES are any of the OMP teams construct's clauses.  */
1111
1112 gomp_teams *
1113 gimple_build_omp_teams (gimple_seq body, tree clauses)
1114 {
1115   gomp_teams *p = as_a <gomp_teams *> (gimple_alloc (GIMPLE_OMP_TEAMS, 0));
1116   if (body)
1117     gimple_omp_set_body (p, body);
1118   gimple_omp_teams_set_clauses (p, clauses);
1119
1120   return p;
1121 }
1122
1123
1124 /* Build a GIMPLE_OMP_ATOMIC_LOAD statement.  */
1125
1126 gomp_atomic_load *
1127 gimple_build_omp_atomic_load (tree lhs, tree rhs)
1128 {
1129   gomp_atomic_load *p
1130     = as_a <gomp_atomic_load *> (gimple_alloc (GIMPLE_OMP_ATOMIC_LOAD, 0));
1131   gimple_omp_atomic_load_set_lhs (p, lhs);
1132   gimple_omp_atomic_load_set_rhs (p, rhs);
1133   return p;
1134 }
1135
1136 /* Build a GIMPLE_OMP_ATOMIC_STORE statement.
1137
1138    VAL is the value we are storing.  */
1139
1140 gomp_atomic_store *
1141 gimple_build_omp_atomic_store (tree val)
1142 {
1143   gomp_atomic_store *p
1144     = as_a <gomp_atomic_store *> (gimple_alloc (GIMPLE_OMP_ATOMIC_STORE, 0));
1145   gimple_omp_atomic_store_set_val (p, val);
1146   return p;
1147 }
1148
1149 /* Build a GIMPLE_TRANSACTION statement.  */
1150
1151 gtransaction *
1152 gimple_build_transaction (gimple_seq body, tree label)
1153 {
1154   gtransaction *p
1155     = as_a <gtransaction *> (gimple_alloc (GIMPLE_TRANSACTION, 0));
1156   gimple_transaction_set_body (p, body);
1157   gimple_transaction_set_label (p, label);
1158   return p;
1159 }
1160
1161 /* Build a GIMPLE_PREDICT statement.  PREDICT is one of the predictors from
1162    predict.def, OUTCOME is NOT_TAKEN or TAKEN.  */
1163
1164 gimple
1165 gimple_build_predict (enum br_predictor predictor, enum prediction outcome)
1166 {
1167   gimple p = gimple_alloc (GIMPLE_PREDICT, 0);
1168   /* Ensure all the predictors fit into the lower bits of the subcode.  */
1169   gcc_assert ((int) END_PREDICTORS <= GF_PREDICT_TAKEN);
1170   gimple_predict_set_predictor (p, predictor);
1171   gimple_predict_set_outcome (p, outcome);
1172   return p;
1173 }
1174
1175 #if defined ENABLE_GIMPLE_CHECKING
1176 /* Complain of a gimple type mismatch and die.  */
1177
1178 void
1179 gimple_check_failed (const_gimple gs, const char *file, int line,
1180                      const char *function, enum gimple_code code,
1181                      enum tree_code subcode)
1182 {
1183   internal_error ("gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d",
1184                   gimple_code_name[code],
1185                   get_tree_code_name (subcode),
1186                   gimple_code_name[gimple_code (gs)],
1187                   gs->subcode > 0
1188                     ? get_tree_code_name ((enum tree_code) gs->subcode)
1189                     : "",
1190                   function, trim_filename (file), line);
1191 }
1192 #endif /* ENABLE_GIMPLE_CHECKING */
1193
1194
1195 /* Link gimple statement GS to the end of the sequence *SEQ_P.  If
1196    *SEQ_P is NULL, a new sequence is allocated.  */
1197
1198 void
1199 gimple_seq_add_stmt (gimple_seq *seq_p, gimple gs)
1200 {
1201   gimple_stmt_iterator si;
1202   if (gs == NULL)
1203     return;
1204
1205   si = gsi_last (*seq_p);
1206   gsi_insert_after (&si, gs, GSI_NEW_STMT);
1207 }
1208
1209 /* Link gimple statement GS to the end of the sequence *SEQ_P.  If
1210    *SEQ_P is NULL, a new sequence is allocated.  This function is
1211    similar to gimple_seq_add_stmt, but does not scan the operands.
1212    During gimplification, we need to manipulate statement sequences
1213    before the def/use vectors have been constructed.  */
1214
1215 void
1216 gimple_seq_add_stmt_without_update (gimple_seq *seq_p, gimple gs)
1217 {
1218   gimple_stmt_iterator si;
1219
1220   if (gs == NULL)
1221     return;
1222
1223   si = gsi_last (*seq_p);
1224   gsi_insert_after_without_update (&si, gs, GSI_NEW_STMT);
1225 }
1226
1227 /* Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
1228    NULL, a new sequence is allocated.  */
1229
1230 void
1231 gimple_seq_add_seq (gimple_seq *dst_p, gimple_seq src)
1232 {
1233   gimple_stmt_iterator si;
1234   if (src == NULL)
1235     return;
1236
1237   si = gsi_last (*dst_p);
1238   gsi_insert_seq_after (&si, src, GSI_NEW_STMT);
1239 }
1240
1241 /* Append sequence SRC to the end of sequence *DST_P.  If *DST_P is
1242    NULL, a new sequence is allocated.  This function is
1243    similar to gimple_seq_add_seq, but does not scan the operands.  */
1244
1245 void
1246 gimple_seq_add_seq_without_update (gimple_seq *dst_p, gimple_seq src)
1247 {
1248   gimple_stmt_iterator si;
1249   if (src == NULL)
1250     return;
1251
1252   si = gsi_last (*dst_p);
1253   gsi_insert_seq_after_without_update (&si, src, GSI_NEW_STMT);
1254 }
1255
1256 /* Determine whether to assign a location to the statement GS.  */
1257
1258 static bool
1259 should_carry_location_p (gimple gs)
1260 {
1261   /* Don't emit a line note for a label.  We particularly don't want to
1262      emit one for the break label, since it doesn't actually correspond
1263      to the beginning of the loop/switch.  */
1264   if (gimple_code (gs) == GIMPLE_LABEL)
1265     return false;
1266
1267   return true;
1268 }
1269
1270 /* Set the location for gimple statement GS to LOCATION.  */
1271
1272 static void
1273 annotate_one_with_location (gimple gs, location_t location)
1274 {
1275   if (!gimple_has_location (gs)
1276       && !gimple_do_not_emit_location_p (gs)
1277       && should_carry_location_p (gs))
1278     gimple_set_location (gs, location);
1279 }
1280
1281 /* Set LOCATION for all the statements after iterator GSI in sequence
1282    SEQ.  If GSI is pointing to the end of the sequence, start with the
1283    first statement in SEQ.  */
1284
1285 void
1286 annotate_all_with_location_after (gimple_seq seq, gimple_stmt_iterator gsi,
1287                                   location_t location)
1288 {
1289   if (gsi_end_p (gsi))
1290     gsi = gsi_start (seq);
1291   else
1292     gsi_next (&gsi);
1293
1294   for (; !gsi_end_p (gsi); gsi_next (&gsi))
1295     annotate_one_with_location (gsi_stmt (gsi), location);
1296 }
1297
1298 /* Set the location for all the statements in a sequence STMT_P to LOCATION.  */
1299
1300 void
1301 annotate_all_with_location (gimple_seq stmt_p, location_t location)
1302 {
1303   gimple_stmt_iterator i;
1304
1305   if (gimple_seq_empty_p (stmt_p))
1306     return;
1307
1308   for (i = gsi_start (stmt_p); !gsi_end_p (i); gsi_next (&i))
1309     {
1310       gimple gs = gsi_stmt (i);
1311       annotate_one_with_location (gs, location);
1312     }
1313 }
1314
1315 /* Helper function of empty_body_p.  Return true if STMT is an empty
1316    statement.  */
1317
1318 static bool
1319 empty_stmt_p (gimple stmt)
1320 {
1321   if (gimple_code (stmt) == GIMPLE_NOP)
1322     return true;
1323   if (gbind *bind_stmt = dyn_cast <gbind *> (stmt))
1324     return empty_body_p (gimple_bind_body (bind_stmt));
1325   return false;
1326 }
1327
1328
1329 /* Return true if BODY contains nothing but empty statements.  */
1330
1331 bool
1332 empty_body_p (gimple_seq body)
1333 {
1334   gimple_stmt_iterator i;
1335
1336   if (gimple_seq_empty_p (body))
1337     return true;
1338   for (i = gsi_start (body); !gsi_end_p (i); gsi_next (&i))
1339     if (!empty_stmt_p (gsi_stmt (i))
1340         && !is_gimple_debug (gsi_stmt (i)))
1341       return false;
1342
1343   return true;
1344 }
1345
1346
1347 /* Perform a deep copy of sequence SRC and return the result.  */
1348
1349 gimple_seq
1350 gimple_seq_copy (gimple_seq src)
1351 {
1352   gimple_stmt_iterator gsi;
1353   gimple_seq new_seq = NULL;
1354   gimple stmt;
1355
1356   for (gsi = gsi_start (src); !gsi_end_p (gsi); gsi_next (&gsi))
1357     {
1358       stmt = gimple_copy (gsi_stmt (gsi));
1359       gimple_seq_add_stmt (&new_seq, stmt);
1360     }
1361
1362   return new_seq;
1363 }
1364
1365
1366
1367 /* Return true if calls C1 and C2 are known to go to the same function.  */
1368
1369 bool
1370 gimple_call_same_target_p (const_gimple c1, const_gimple c2)
1371 {
1372   if (gimple_call_internal_p (c1))
1373     return (gimple_call_internal_p (c2)
1374             && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2));
1375   else
1376     return (gimple_call_fn (c1) == gimple_call_fn (c2)
1377             || (gimple_call_fndecl (c1)
1378                 && gimple_call_fndecl (c1) == gimple_call_fndecl (c2)));
1379 }
1380
1381 /* Detect flags from a GIMPLE_CALL.  This is just like
1382    call_expr_flags, but for gimple tuples.  */
1383
1384 int
1385 gimple_call_flags (const_gimple stmt)
1386 {
1387   int flags;
1388   tree decl = gimple_call_fndecl (stmt);
1389
1390   if (decl)
1391     flags = flags_from_decl_or_type (decl);
1392   else if (gimple_call_internal_p (stmt))
1393     flags = internal_fn_flags (gimple_call_internal_fn (stmt));
1394   else
1395     flags = flags_from_decl_or_type (gimple_call_fntype (stmt));
1396
1397   if (stmt->subcode & GF_CALL_NOTHROW)
1398     flags |= ECF_NOTHROW;
1399
1400   return flags;
1401 }
1402
1403 /* Return the "fn spec" string for call STMT.  */
1404
1405 static const_tree
1406 gimple_call_fnspec (const gcall *stmt)
1407 {
1408   tree type, attr;
1409
1410   if (gimple_call_internal_p (stmt))
1411     return internal_fn_fnspec (gimple_call_internal_fn (stmt));
1412
1413   type = gimple_call_fntype (stmt);
1414   if (!type)
1415     return NULL_TREE;
1416
1417   attr = lookup_attribute ("fn spec", TYPE_ATTRIBUTES (type));
1418   if (!attr)
1419     return NULL_TREE;
1420
1421   return TREE_VALUE (TREE_VALUE (attr));
1422 }
1423
1424 /* Detects argument flags for argument number ARG on call STMT.  */
1425
1426 int
1427 gimple_call_arg_flags (const gcall *stmt, unsigned arg)
1428 {
1429   const_tree attr = gimple_call_fnspec (stmt);
1430
1431   if (!attr || 1 + arg >= (unsigned) TREE_STRING_LENGTH (attr))
1432     return 0;
1433
1434   switch (TREE_STRING_POINTER (attr)[1 + arg])
1435     {
1436     case 'x':
1437     case 'X':
1438       return EAF_UNUSED;
1439
1440     case 'R':
1441       return EAF_DIRECT | EAF_NOCLOBBER | EAF_NOESCAPE;
1442
1443     case 'r':
1444       return EAF_NOCLOBBER | EAF_NOESCAPE;
1445
1446     case 'W':
1447       return EAF_DIRECT | EAF_NOESCAPE;
1448
1449     case 'w':
1450       return EAF_NOESCAPE;
1451
1452     case '.':
1453     default:
1454       return 0;
1455     }
1456 }
1457
1458 /* Detects return flags for the call STMT.  */
1459
1460 int
1461 gimple_call_return_flags (const gcall *stmt)
1462 {
1463   const_tree attr;
1464
1465   if (gimple_call_flags (stmt) & ECF_MALLOC)
1466     return ERF_NOALIAS;
1467
1468   attr = gimple_call_fnspec (stmt);
1469   if (!attr || TREE_STRING_LENGTH (attr) < 1)
1470     return 0;
1471
1472   switch (TREE_STRING_POINTER (attr)[0])
1473     {
1474     case '1':
1475     case '2':
1476     case '3':
1477     case '4':
1478       return ERF_RETURNS_ARG | (TREE_STRING_POINTER (attr)[0] - '1');
1479
1480     case 'm':
1481       return ERF_NOALIAS;
1482
1483     case '.':
1484     default:
1485       return 0;
1486     }
1487 }
1488
1489
1490 /* Return true if GS is a copy assignment.  */
1491
1492 bool
1493 gimple_assign_copy_p (gimple gs)
1494 {
1495   return (gimple_assign_single_p (gs)
1496           && is_gimple_val (gimple_op (gs, 1)));
1497 }
1498
1499
1500 /* Return true if GS is a SSA_NAME copy assignment.  */
1501
1502 bool
1503 gimple_assign_ssa_name_copy_p (gimple gs)
1504 {
1505   return (gimple_assign_single_p (gs)
1506           && TREE_CODE (gimple_assign_lhs (gs)) == SSA_NAME
1507           && TREE_CODE (gimple_assign_rhs1 (gs)) == SSA_NAME);
1508 }
1509
1510
1511 /* Return true if GS is an assignment with a unary RHS, but the
1512    operator has no effect on the assigned value.  The logic is adapted
1513    from STRIP_NOPS.  This predicate is intended to be used in tuplifying
1514    instances in which STRIP_NOPS was previously applied to the RHS of
1515    an assignment.
1516
1517    NOTE: In the use cases that led to the creation of this function
1518    and of gimple_assign_single_p, it is typical to test for either
1519    condition and to proceed in the same manner.  In each case, the
1520    assigned value is represented by the single RHS operand of the
1521    assignment.  I suspect there may be cases where gimple_assign_copy_p,
1522    gimple_assign_single_p, or equivalent logic is used where a similar
1523    treatment of unary NOPs is appropriate.  */
1524
1525 bool
1526 gimple_assign_unary_nop_p (gimple gs)
1527 {
1528   return (is_gimple_assign (gs)
1529           && (CONVERT_EXPR_CODE_P (gimple_assign_rhs_code (gs))
1530               || gimple_assign_rhs_code (gs) == NON_LVALUE_EXPR)
1531           && gimple_assign_rhs1 (gs) != error_mark_node
1532           && (TYPE_MODE (TREE_TYPE (gimple_assign_lhs (gs)))
1533               == TYPE_MODE (TREE_TYPE (gimple_assign_rhs1 (gs)))));
1534 }
1535
1536 /* Set BB to be the basic block holding G.  */
1537
1538 void
1539 gimple_set_bb (gimple stmt, basic_block bb)
1540 {
1541   stmt->bb = bb;
1542
1543   if (gimple_code (stmt) != GIMPLE_LABEL)
1544     return;
1545
1546   /* If the statement is a label, add the label to block-to-labels map
1547      so that we can speed up edge creation for GIMPLE_GOTOs.  */
1548   if (cfun->cfg)
1549     {
1550       tree t;
1551       int uid;
1552
1553       t = gimple_label_label (as_a <glabel *> (stmt));
1554       uid = LABEL_DECL_UID (t);
1555       if (uid == -1)
1556         {
1557           unsigned old_len =
1558             vec_safe_length (label_to_block_map_for_fn (cfun));
1559           LABEL_DECL_UID (t) = uid = cfun->cfg->last_label_uid++;
1560           if (old_len <= (unsigned) uid)
1561             {
1562               unsigned new_len = 3 * uid / 2 + 1;
1563
1564               vec_safe_grow_cleared (label_to_block_map_for_fn (cfun),
1565                                      new_len);
1566             }
1567         }
1568
1569       (*label_to_block_map_for_fn (cfun))[uid] = bb;
1570     }
1571 }
1572
1573
1574 /* Modify the RHS of the assignment pointed-to by GSI using the
1575    operands in the expression tree EXPR.
1576
1577    NOTE: The statement pointed-to by GSI may be reallocated if it
1578    did not have enough operand slots.
1579
1580    This function is useful to convert an existing tree expression into
1581    the flat representation used for the RHS of a GIMPLE assignment.
1582    It will reallocate memory as needed to expand or shrink the number
1583    of operand slots needed to represent EXPR.
1584
1585    NOTE: If you find yourself building a tree and then calling this
1586    function, you are most certainly doing it the slow way.  It is much
1587    better to build a new assignment or to use the function
1588    gimple_assign_set_rhs_with_ops, which does not require an
1589    expression tree to be built.  */
1590
1591 void
1592 gimple_assign_set_rhs_from_tree (gimple_stmt_iterator *gsi, tree expr)
1593 {
1594   enum tree_code subcode;
1595   tree op1, op2, op3;
1596
1597   extract_ops_from_tree_1 (expr, &subcode, &op1, &op2, &op3);
1598   gimple_assign_set_rhs_with_ops (gsi, subcode, op1, op2, op3);
1599 }
1600
1601
1602 /* Set the RHS of assignment statement pointed-to by GSI to CODE with
1603    operands OP1, OP2 and OP3.
1604
1605    NOTE: The statement pointed-to by GSI may be reallocated if it
1606    did not have enough operand slots.  */
1607
1608 void
1609 gimple_assign_set_rhs_with_ops (gimple_stmt_iterator *gsi, enum tree_code code,
1610                                 tree op1, tree op2, tree op3)
1611 {
1612   unsigned new_rhs_ops = get_gimple_rhs_num_ops (code);
1613   gimple stmt = gsi_stmt (*gsi);
1614
1615   /* If the new CODE needs more operands, allocate a new statement.  */
1616   if (gimple_num_ops (stmt) < new_rhs_ops + 1)
1617     {
1618       tree lhs = gimple_assign_lhs (stmt);
1619       gimple new_stmt = gimple_alloc (gimple_code (stmt), new_rhs_ops + 1);
1620       memcpy (new_stmt, stmt, gimple_size (gimple_code (stmt)));
1621       gimple_init_singleton (new_stmt);
1622       gsi_replace (gsi, new_stmt, true);
1623       stmt = new_stmt;
1624
1625       /* The LHS needs to be reset as this also changes the SSA name
1626          on the LHS.  */
1627       gimple_assign_set_lhs (stmt, lhs);
1628     }
1629
1630   gimple_set_num_ops (stmt, new_rhs_ops + 1);
1631   gimple_set_subcode (stmt, code);
1632   gimple_assign_set_rhs1 (stmt, op1);
1633   if (new_rhs_ops > 1)
1634     gimple_assign_set_rhs2 (stmt, op2);
1635   if (new_rhs_ops > 2)
1636     gimple_assign_set_rhs3 (stmt, op3);
1637 }
1638
1639
1640 /* Return the LHS of a statement that performs an assignment,
1641    either a GIMPLE_ASSIGN or a GIMPLE_CALL.  Returns NULL_TREE
1642    for a call to a function that returns no value, or for a
1643    statement other than an assignment or a call.  */
1644
1645 tree
1646 gimple_get_lhs (const_gimple stmt)
1647 {
1648   enum gimple_code code = gimple_code (stmt);
1649
1650   if (code == GIMPLE_ASSIGN)
1651     return gimple_assign_lhs (stmt);
1652   else if (code == GIMPLE_CALL)
1653     return gimple_call_lhs (stmt);
1654   else
1655     return NULL_TREE;
1656 }
1657
1658
1659 /* Set the LHS of a statement that performs an assignment,
1660    either a GIMPLE_ASSIGN or a GIMPLE_CALL.  */
1661
1662 void
1663 gimple_set_lhs (gimple stmt, tree lhs)
1664 {
1665   enum gimple_code code = gimple_code (stmt);
1666
1667   if (code == GIMPLE_ASSIGN)
1668     gimple_assign_set_lhs (stmt, lhs);
1669   else if (code == GIMPLE_CALL)
1670     gimple_call_set_lhs (stmt, lhs);
1671   else
1672     gcc_unreachable ();
1673 }
1674
1675
1676 /* Return a deep copy of statement STMT.  All the operands from STMT
1677    are reallocated and copied using unshare_expr.  The DEF, USE, VDEF
1678    and VUSE operand arrays are set to empty in the new copy.  The new
1679    copy isn't part of any sequence.  */
1680
1681 gimple
1682 gimple_copy (gimple stmt)
1683 {
1684   enum gimple_code code = gimple_code (stmt);
1685   unsigned num_ops = gimple_num_ops (stmt);
1686   gimple copy = gimple_alloc (code, num_ops);
1687   unsigned i;
1688
1689   /* Shallow copy all the fields from STMT.  */
1690   memcpy (copy, stmt, gimple_size (code));
1691   gimple_init_singleton (copy);
1692
1693   /* If STMT has sub-statements, deep-copy them as well.  */
1694   if (gimple_has_substatements (stmt))
1695     {
1696       gimple_seq new_seq;
1697       tree t;
1698
1699       switch (gimple_code (stmt))
1700         {
1701         case GIMPLE_BIND:
1702           {
1703             gbind *bind_stmt = as_a <gbind *> (stmt);
1704             gbind *bind_copy = as_a <gbind *> (copy);
1705             new_seq = gimple_seq_copy (gimple_bind_body (bind_stmt));
1706             gimple_bind_set_body (bind_copy, new_seq);
1707             gimple_bind_set_vars (bind_copy,
1708                                   unshare_expr (gimple_bind_vars (bind_stmt)));
1709             gimple_bind_set_block (bind_copy, gimple_bind_block (bind_stmt));
1710           }
1711           break;
1712
1713         case GIMPLE_CATCH:
1714           {
1715             gcatch *catch_stmt = as_a <gcatch *> (stmt);
1716             gcatch *catch_copy = as_a <gcatch *> (copy);
1717             new_seq = gimple_seq_copy (gimple_catch_handler (catch_stmt));
1718             gimple_catch_set_handler (catch_copy, new_seq);
1719             t = unshare_expr (gimple_catch_types (catch_stmt));
1720             gimple_catch_set_types (catch_copy, t);
1721           }
1722           break;
1723
1724         case GIMPLE_EH_FILTER:
1725           {
1726             geh_filter *eh_filter_stmt = as_a <geh_filter *> (stmt);
1727             geh_filter *eh_filter_copy = as_a <geh_filter *> (copy);
1728             new_seq
1729               = gimple_seq_copy (gimple_eh_filter_failure (eh_filter_stmt));
1730             gimple_eh_filter_set_failure (eh_filter_copy, new_seq);
1731             t = unshare_expr (gimple_eh_filter_types (eh_filter_stmt));
1732             gimple_eh_filter_set_types (eh_filter_copy, t);
1733           }
1734           break;
1735
1736         case GIMPLE_EH_ELSE:
1737           {
1738             geh_else *eh_else_stmt = as_a <geh_else *> (stmt);
1739             geh_else *eh_else_copy = as_a <geh_else *> (copy);
1740             new_seq = gimple_seq_copy (gimple_eh_else_n_body (eh_else_stmt));
1741             gimple_eh_else_set_n_body (eh_else_copy, new_seq);
1742             new_seq = gimple_seq_copy (gimple_eh_else_e_body (eh_else_stmt));
1743             gimple_eh_else_set_e_body (eh_else_copy, new_seq);
1744           }
1745           break;
1746
1747         case GIMPLE_TRY:
1748           {
1749             gtry *try_stmt = as_a <gtry *> (stmt);
1750             gtry *try_copy = as_a <gtry *> (copy);
1751             new_seq = gimple_seq_copy (gimple_try_eval (try_stmt));
1752             gimple_try_set_eval (try_copy, new_seq);
1753             new_seq = gimple_seq_copy (gimple_try_cleanup (try_stmt));
1754             gimple_try_set_cleanup (try_copy, new_seq);
1755           }
1756           break;
1757
1758         case GIMPLE_OMP_FOR:
1759           new_seq = gimple_seq_copy (gimple_omp_for_pre_body (stmt));
1760           gimple_omp_for_set_pre_body (copy, new_seq);
1761           t = unshare_expr (gimple_omp_for_clauses (stmt));
1762           gimple_omp_for_set_clauses (copy, t);
1763           {
1764             gomp_for *omp_for_copy = as_a <gomp_for *> (copy);
1765             omp_for_copy->iter = ggc_vec_alloc<gimple_omp_for_iter>
1766               ( gimple_omp_for_collapse (stmt));
1767           }
1768           for (i = 0; i < gimple_omp_for_collapse (stmt); i++)
1769             {
1770               gimple_omp_for_set_cond (copy, i,
1771                                        gimple_omp_for_cond (stmt, i));
1772               gimple_omp_for_set_index (copy, i,
1773                                         gimple_omp_for_index (stmt, i));
1774               t = unshare_expr (gimple_omp_for_initial (stmt, i));
1775               gimple_omp_for_set_initial (copy, i, t);
1776               t = unshare_expr (gimple_omp_for_final (stmt, i));
1777               gimple_omp_for_set_final (copy, i, t);
1778               t = unshare_expr (gimple_omp_for_incr (stmt, i));
1779               gimple_omp_for_set_incr (copy, i, t);
1780             }
1781           goto copy_omp_body;
1782
1783         case GIMPLE_OMP_PARALLEL:
1784           {
1785             gomp_parallel *omp_par_stmt = as_a <gomp_parallel *> (stmt);
1786             gomp_parallel *omp_par_copy = as_a <gomp_parallel *> (copy);
1787             t = unshare_expr (gimple_omp_parallel_clauses (omp_par_stmt));
1788             gimple_omp_parallel_set_clauses (omp_par_copy, t);
1789             t = unshare_expr (gimple_omp_parallel_child_fn (omp_par_stmt));
1790             gimple_omp_parallel_set_child_fn (omp_par_copy, t);
1791             t = unshare_expr (gimple_omp_parallel_data_arg (omp_par_stmt));
1792             gimple_omp_parallel_set_data_arg (omp_par_copy, t);
1793           }
1794           goto copy_omp_body;
1795
1796         case GIMPLE_OMP_TASK:
1797           t = unshare_expr (gimple_omp_task_clauses (stmt));
1798           gimple_omp_task_set_clauses (copy, t);
1799           t = unshare_expr (gimple_omp_task_child_fn (stmt));
1800           gimple_omp_task_set_child_fn (copy, t);
1801           t = unshare_expr (gimple_omp_task_data_arg (stmt));
1802           gimple_omp_task_set_data_arg (copy, t);
1803           t = unshare_expr (gimple_omp_task_copy_fn (stmt));
1804           gimple_omp_task_set_copy_fn (copy, t);
1805           t = unshare_expr (gimple_omp_task_arg_size (stmt));
1806           gimple_omp_task_set_arg_size (copy, t);
1807           t = unshare_expr (gimple_omp_task_arg_align (stmt));
1808           gimple_omp_task_set_arg_align (copy, t);
1809           goto copy_omp_body;
1810
1811         case GIMPLE_OMP_CRITICAL:
1812           t = unshare_expr (gimple_omp_critical_name (
1813                               as_a <gomp_critical *> (stmt)));
1814           gimple_omp_critical_set_name (as_a <gomp_critical *> (copy), t);
1815           goto copy_omp_body;
1816
1817         case GIMPLE_OMP_SECTIONS:
1818           t = unshare_expr (gimple_omp_sections_clauses (stmt));
1819           gimple_omp_sections_set_clauses (copy, t);
1820           t = unshare_expr (gimple_omp_sections_control (stmt));
1821           gimple_omp_sections_set_control (copy, t);
1822           /* FALLTHRU  */
1823
1824         case GIMPLE_OMP_SINGLE:
1825         case GIMPLE_OMP_TARGET:
1826         case GIMPLE_OMP_TEAMS:
1827         case GIMPLE_OMP_SECTION:
1828         case GIMPLE_OMP_MASTER:
1829         case GIMPLE_OMP_TASKGROUP:
1830         case GIMPLE_OMP_ORDERED:
1831         copy_omp_body:
1832           new_seq = gimple_seq_copy (gimple_omp_body (stmt));
1833           gimple_omp_set_body (copy, new_seq);
1834           break;
1835
1836         case GIMPLE_TRANSACTION:
1837           new_seq = gimple_seq_copy (gimple_transaction_body (
1838                                        as_a <gtransaction *> (stmt)));
1839           gimple_transaction_set_body (as_a <gtransaction *> (copy),
1840                                        new_seq);
1841           break;
1842
1843         case GIMPLE_WITH_CLEANUP_EXPR:
1844           new_seq = gimple_seq_copy (gimple_wce_cleanup (stmt));
1845           gimple_wce_set_cleanup (copy, new_seq);
1846           break;
1847
1848         default:
1849           gcc_unreachable ();
1850         }
1851     }
1852
1853   /* Make copy of operands.  */
1854   for (i = 0; i < num_ops; i++)
1855     gimple_set_op (copy, i, unshare_expr (gimple_op (stmt, i)));
1856
1857   if (gimple_has_mem_ops (stmt))
1858     {
1859       gimple_set_vdef (copy, gimple_vdef (stmt));
1860       gimple_set_vuse (copy, gimple_vuse (stmt));
1861     }
1862
1863   /* Clear out SSA operand vectors on COPY.  */
1864   if (gimple_has_ops (stmt))
1865     {
1866       gimple_set_use_ops (copy, NULL);
1867
1868       /* SSA operands need to be updated.  */
1869       gimple_set_modified (copy, true);
1870     }
1871
1872   return copy;
1873 }
1874
1875
1876 /* Return true if statement S has side-effects.  We consider a
1877    statement to have side effects if:
1878
1879    - It is a GIMPLE_CALL not marked with ECF_PURE or ECF_CONST.
1880    - Any of its operands are marked TREE_THIS_VOLATILE or TREE_SIDE_EFFECTS.  */
1881
1882 bool
1883 gimple_has_side_effects (const_gimple s)
1884 {
1885   if (is_gimple_debug (s))
1886     return false;
1887
1888   /* We don't have to scan the arguments to check for
1889      volatile arguments, though, at present, we still
1890      do a scan to check for TREE_SIDE_EFFECTS.  */
1891   if (gimple_has_volatile_ops (s))
1892     return true;
1893
1894   if (gimple_code (s) == GIMPLE_ASM
1895       && gimple_asm_volatile_p (as_a <const gasm *> (s)))
1896     return true;
1897
1898   if (is_gimple_call (s))
1899     {
1900       int flags = gimple_call_flags (s);
1901
1902       /* An infinite loop is considered a side effect.  */
1903       if (!(flags & (ECF_CONST | ECF_PURE))
1904           || (flags & ECF_LOOPING_CONST_OR_PURE))
1905         return true;
1906
1907       return false;
1908     }
1909
1910   return false;
1911 }
1912
1913 /* Helper for gimple_could_trap_p and gimple_assign_rhs_could_trap_p.
1914    Return true if S can trap.  When INCLUDE_MEM is true, check whether
1915    the memory operations could trap.  When INCLUDE_STORES is true and
1916    S is a GIMPLE_ASSIGN, the LHS of the assignment is also checked.  */
1917
1918 bool
1919 gimple_could_trap_p_1 (gimple s, bool include_mem, bool include_stores)
1920 {
1921   tree t, div = NULL_TREE;
1922   enum tree_code op;
1923
1924   if (include_mem)
1925     {
1926       unsigned i, start = (is_gimple_assign (s) && !include_stores) ? 1 : 0;
1927
1928       for (i = start; i < gimple_num_ops (s); i++)
1929         if (tree_could_trap_p (gimple_op (s, i)))
1930           return true;
1931     }
1932
1933   switch (gimple_code (s))
1934     {
1935     case GIMPLE_ASM:
1936       return gimple_asm_volatile_p (as_a <gasm *> (s));
1937
1938     case GIMPLE_CALL:
1939       t = gimple_call_fndecl (s);
1940       /* Assume that calls to weak functions may trap.  */
1941       if (!t || !DECL_P (t) || DECL_WEAK (t))
1942         return true;
1943       return false;
1944
1945     case GIMPLE_ASSIGN:
1946       t = gimple_expr_type (s);
1947       op = gimple_assign_rhs_code (s);
1948       if (get_gimple_rhs_class (op) == GIMPLE_BINARY_RHS)
1949         div = gimple_assign_rhs2 (s);
1950       return (operation_could_trap_p (op, FLOAT_TYPE_P (t),
1951                                       (INTEGRAL_TYPE_P (t)
1952                                        && TYPE_OVERFLOW_TRAPS (t)),
1953                                       div));
1954
1955     default:
1956       break;
1957     }
1958
1959   return false;
1960 }
1961
1962 /* Return true if statement S can trap.  */
1963
1964 bool
1965 gimple_could_trap_p (gimple s)
1966 {
1967   return gimple_could_trap_p_1 (s, true, true);
1968 }
1969
1970 /* Return true if RHS of a GIMPLE_ASSIGN S can trap.  */
1971
1972 bool
1973 gimple_assign_rhs_could_trap_p (gimple s)
1974 {
1975   gcc_assert (is_gimple_assign (s));
1976   return gimple_could_trap_p_1 (s, true, false);
1977 }
1978
1979
1980 /* Print debugging information for gimple stmts generated.  */
1981
1982 void
1983 dump_gimple_statistics (void)
1984 {
1985   int i, total_tuples = 0, total_bytes = 0;
1986
1987   if (! GATHER_STATISTICS)
1988     {
1989       fprintf (stderr, "No gimple statistics\n");
1990       return;
1991     }
1992
1993   fprintf (stderr, "\nGIMPLE statements\n");
1994   fprintf (stderr, "Kind                   Stmts      Bytes\n");
1995   fprintf (stderr, "---------------------------------------\n");
1996   for (i = 0; i < (int) gimple_alloc_kind_all; ++i)
1997     {
1998       fprintf (stderr, "%-20s %7d %10d\n", gimple_alloc_kind_names[i],
1999           gimple_alloc_counts[i], gimple_alloc_sizes[i]);
2000       total_tuples += gimple_alloc_counts[i];
2001       total_bytes += gimple_alloc_sizes[i];
2002     }
2003   fprintf (stderr, "---------------------------------------\n");
2004   fprintf (stderr, "%-20s %7d %10d\n", "Total", total_tuples, total_bytes);
2005   fprintf (stderr, "---------------------------------------\n");
2006 }
2007
2008
2009 /* Return the number of operands needed on the RHS of a GIMPLE
2010    assignment for an expression with tree code CODE.  */
2011
2012 unsigned
2013 get_gimple_rhs_num_ops (enum tree_code code)
2014 {
2015   enum gimple_rhs_class rhs_class = get_gimple_rhs_class (code);
2016
2017   if (rhs_class == GIMPLE_UNARY_RHS || rhs_class == GIMPLE_SINGLE_RHS)
2018     return 1;
2019   else if (rhs_class == GIMPLE_BINARY_RHS)
2020     return 2;
2021   else if (rhs_class == GIMPLE_TERNARY_RHS)
2022     return 3;
2023   else
2024     gcc_unreachable ();
2025 }
2026
2027 #define DEFTREECODE(SYM, STRING, TYPE, NARGS)                               \
2028   (unsigned char)                                                           \
2029   ((TYPE) == tcc_unary ? GIMPLE_UNARY_RHS                                   \
2030    : ((TYPE) == tcc_binary                                                  \
2031       || (TYPE) == tcc_comparison) ? GIMPLE_BINARY_RHS                      \
2032    : ((TYPE) == tcc_constant                                                \
2033       || (TYPE) == tcc_declaration                                          \
2034       || (TYPE) == tcc_reference) ? GIMPLE_SINGLE_RHS                       \
2035    : ((SYM) == TRUTH_AND_EXPR                                               \
2036       || (SYM) == TRUTH_OR_EXPR                                             \
2037       || (SYM) == TRUTH_XOR_EXPR) ? GIMPLE_BINARY_RHS                       \
2038    : (SYM) == TRUTH_NOT_EXPR ? GIMPLE_UNARY_RHS                             \
2039    : ((SYM) == COND_EXPR                                                    \
2040       || (SYM) == WIDEN_MULT_PLUS_EXPR                                      \
2041       || (SYM) == WIDEN_MULT_MINUS_EXPR                                     \
2042       || (SYM) == DOT_PROD_EXPR                                             \
2043       || (SYM) == SAD_EXPR                                                  \
2044       || (SYM) == REALIGN_LOAD_EXPR                                         \
2045       || (SYM) == VEC_COND_EXPR                                             \
2046       || (SYM) == VEC_PERM_EXPR                                             \
2047       || (SYM) == FMA_EXPR) ? GIMPLE_TERNARY_RHS                            \
2048    : ((SYM) == CONSTRUCTOR                                                  \
2049       || (SYM) == OBJ_TYPE_REF                                              \
2050       || (SYM) == ASSERT_EXPR                                               \
2051       || (SYM) == ADDR_EXPR                                                 \
2052       || (SYM) == WITH_SIZE_EXPR                                            \
2053       || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS                             \
2054    : GIMPLE_INVALID_RHS),
2055 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2056
2057 const unsigned char gimple_rhs_class_table[] = {
2058 #include "all-tree.def"
2059 };
2060
2061 #undef DEFTREECODE
2062 #undef END_OF_BASE_TREE_CODES
2063
2064 /* Canonicalize a tree T for use in a COND_EXPR as conditional.  Returns
2065    a canonicalized tree that is valid for a COND_EXPR or NULL_TREE, if
2066    we failed to create one.  */
2067
2068 tree
2069 canonicalize_cond_expr_cond (tree t)
2070 {
2071   /* Strip conversions around boolean operations.  */
2072   if (CONVERT_EXPR_P (t)
2073       && (truth_value_p (TREE_CODE (TREE_OPERAND (t, 0)))
2074           || TREE_CODE (TREE_TYPE (TREE_OPERAND (t, 0)))
2075              == BOOLEAN_TYPE))
2076     t = TREE_OPERAND (t, 0);
2077
2078   /* For !x use x == 0.  */
2079   if (TREE_CODE (t) == TRUTH_NOT_EXPR)
2080     {
2081       tree top0 = TREE_OPERAND (t, 0);
2082       t = build2 (EQ_EXPR, TREE_TYPE (t),
2083                   top0, build_int_cst (TREE_TYPE (top0), 0));
2084     }
2085   /* For cmp ? 1 : 0 use cmp.  */
2086   else if (TREE_CODE (t) == COND_EXPR
2087            && COMPARISON_CLASS_P (TREE_OPERAND (t, 0))
2088            && integer_onep (TREE_OPERAND (t, 1))
2089            && integer_zerop (TREE_OPERAND (t, 2)))
2090     {
2091       tree top0 = TREE_OPERAND (t, 0);
2092       t = build2 (TREE_CODE (top0), TREE_TYPE (t),
2093                   TREE_OPERAND (top0, 0), TREE_OPERAND (top0, 1));
2094     }
2095   /* For x ^ y use x != y.  */
2096   else if (TREE_CODE (t) == BIT_XOR_EXPR)
2097     t = build2 (NE_EXPR, TREE_TYPE (t),
2098                 TREE_OPERAND (t, 0), TREE_OPERAND (t, 1));
2099   
2100   if (is_gimple_condexpr (t))
2101     return t;
2102
2103   return NULL_TREE;
2104 }
2105
2106 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2107    the positions marked by the set ARGS_TO_SKIP.  */
2108
2109 gcall *
2110 gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2111 {
2112   int i;
2113   int nargs = gimple_call_num_args (stmt);
2114   auto_vec<tree> vargs (nargs);
2115   gcall *new_stmt;
2116
2117   for (i = 0; i < nargs; i++)
2118     if (!bitmap_bit_p (args_to_skip, i))
2119       vargs.quick_push (gimple_call_arg (stmt, i));
2120
2121   if (gimple_call_internal_p (stmt))
2122     new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
2123                                                vargs);
2124   else
2125     new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
2126
2127   if (gimple_call_lhs (stmt))
2128     gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2129
2130   gimple_set_vuse (new_stmt, gimple_vuse (stmt));
2131   gimple_set_vdef (new_stmt, gimple_vdef (stmt));
2132
2133   if (gimple_has_location (stmt))
2134     gimple_set_location (new_stmt, gimple_location (stmt));
2135   gimple_call_copy_flags (new_stmt, stmt);
2136   gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2137
2138   gimple_set_modified (new_stmt, true);
2139
2140   return new_stmt;
2141 }
2142
2143
2144
2145 /* Return true if the field decls F1 and F2 are at the same offset.
2146
2147    This is intended to be used on GIMPLE types only.  */
2148
2149 bool
2150 gimple_compare_field_offset (tree f1, tree f2)
2151 {
2152   if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2153     {
2154       tree offset1 = DECL_FIELD_OFFSET (f1);
2155       tree offset2 = DECL_FIELD_OFFSET (f2);
2156       return ((offset1 == offset2
2157                /* Once gimplification is done, self-referential offsets are
2158                   instantiated as operand #2 of the COMPONENT_REF built for
2159                   each access and reset.  Therefore, they are not relevant
2160                   anymore and fields are interchangeable provided that they
2161                   represent the same access.  */
2162                || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2163                    && TREE_CODE (offset2) == PLACEHOLDER_EXPR
2164                    && (DECL_SIZE (f1) == DECL_SIZE (f2)
2165                        || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2166                            && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2167                        || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
2168                    && DECL_ALIGN (f1) == DECL_ALIGN (f2))
2169                || operand_equal_p (offset1, offset2, 0))
2170               && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2171                                      DECL_FIELD_BIT_OFFSET (f2)));
2172     }
2173
2174   /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2175      should be, so handle differing ones specially by decomposing
2176      the offset into a byte and bit offset manually.  */
2177   if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2178       && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2179     {
2180       unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2181       unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2182       bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2183       byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2184                       + bit_offset1 / BITS_PER_UNIT);
2185       bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2186       byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2187                       + bit_offset2 / BITS_PER_UNIT);
2188       if (byte_offset1 != byte_offset2)
2189         return false;
2190       return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2191     }
2192
2193   return false;
2194 }
2195
2196
2197 /* Return a type the same as TYPE except unsigned or
2198    signed according to UNSIGNEDP.  */
2199
2200 static tree
2201 gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2202 {
2203   tree type1;
2204   int i;
2205
2206   type1 = TYPE_MAIN_VARIANT (type);
2207   if (type1 == signed_char_type_node
2208       || type1 == char_type_node
2209       || type1 == unsigned_char_type_node)
2210     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2211   if (type1 == integer_type_node || type1 == unsigned_type_node)
2212     return unsignedp ? unsigned_type_node : integer_type_node;
2213   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2214     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2215   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2216     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2217   if (type1 == long_long_integer_type_node
2218       || type1 == long_long_unsigned_type_node)
2219     return unsignedp
2220            ? long_long_unsigned_type_node
2221            : long_long_integer_type_node;
2222
2223   for (i = 0; i < NUM_INT_N_ENTS; i ++)
2224     if (int_n_enabled_p[i]
2225         && (type1 == int_n_trees[i].unsigned_type
2226             || type1 == int_n_trees[i].signed_type))
2227         return unsignedp
2228           ? int_n_trees[i].unsigned_type
2229           : int_n_trees[i].signed_type;
2230
2231 #if HOST_BITS_PER_WIDE_INT >= 64
2232   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2233     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2234 #endif
2235   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2236     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2237   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2238     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2239   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2240     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2241   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2242     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2243
2244 #define GIMPLE_FIXED_TYPES(NAME)            \
2245   if (type1 == short_ ## NAME ## _type_node \
2246       || type1 == unsigned_short_ ## NAME ## _type_node) \
2247     return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2248                      : short_ ## NAME ## _type_node; \
2249   if (type1 == NAME ## _type_node \
2250       || type1 == unsigned_ ## NAME ## _type_node) \
2251     return unsignedp ? unsigned_ ## NAME ## _type_node \
2252                      : NAME ## _type_node; \
2253   if (type1 == long_ ## NAME ## _type_node \
2254       || type1 == unsigned_long_ ## NAME ## _type_node) \
2255     return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2256                      : long_ ## NAME ## _type_node; \
2257   if (type1 == long_long_ ## NAME ## _type_node \
2258       || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2259     return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2260                      : long_long_ ## NAME ## _type_node;
2261
2262 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2263   if (type1 == NAME ## _type_node \
2264       || type1 == u ## NAME ## _type_node) \
2265     return unsignedp ? u ## NAME ## _type_node \
2266                      : NAME ## _type_node;
2267
2268 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2269   if (type1 == sat_ ## short_ ## NAME ## _type_node \
2270       || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2271     return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2272                      : sat_ ## short_ ## NAME ## _type_node; \
2273   if (type1 == sat_ ## NAME ## _type_node \
2274       || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2275     return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2276                      : sat_ ## NAME ## _type_node; \
2277   if (type1 == sat_ ## long_ ## NAME ## _type_node \
2278       || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2279     return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2280                      : sat_ ## long_ ## NAME ## _type_node; \
2281   if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2282       || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2283     return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2284                      : sat_ ## long_long_ ## NAME ## _type_node;
2285
2286 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME)       \
2287   if (type1 == sat_ ## NAME ## _type_node \
2288       || type1 == sat_ ## u ## NAME ## _type_node) \
2289     return unsignedp ? sat_ ## u ## NAME ## _type_node \
2290                      : sat_ ## NAME ## _type_node;
2291
2292   GIMPLE_FIXED_TYPES (fract);
2293   GIMPLE_FIXED_TYPES_SAT (fract);
2294   GIMPLE_FIXED_TYPES (accum);
2295   GIMPLE_FIXED_TYPES_SAT (accum);
2296
2297   GIMPLE_FIXED_MODE_TYPES (qq);
2298   GIMPLE_FIXED_MODE_TYPES (hq);
2299   GIMPLE_FIXED_MODE_TYPES (sq);
2300   GIMPLE_FIXED_MODE_TYPES (dq);
2301   GIMPLE_FIXED_MODE_TYPES (tq);
2302   GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2303   GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2304   GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2305   GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2306   GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2307   GIMPLE_FIXED_MODE_TYPES (ha);
2308   GIMPLE_FIXED_MODE_TYPES (sa);
2309   GIMPLE_FIXED_MODE_TYPES (da);
2310   GIMPLE_FIXED_MODE_TYPES (ta);
2311   GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2312   GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2313   GIMPLE_FIXED_MODE_TYPES_SAT (da);
2314   GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2315
2316   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2317      the precision; they have precision set to match their range, but
2318      may use a wider mode to match an ABI.  If we change modes, we may
2319      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
2320      the precision as well, so as to yield correct results for
2321      bit-field types.  C++ does not have these separate bit-field
2322      types, and producing a signed or unsigned variant of an
2323      ENUMERAL_TYPE may cause other problems as well.  */
2324   if (!INTEGRAL_TYPE_P (type)
2325       || TYPE_UNSIGNED (type) == unsignedp)
2326     return type;
2327
2328 #define TYPE_OK(node)                                                       \
2329   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
2330    && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2331   if (TYPE_OK (signed_char_type_node))
2332     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2333   if (TYPE_OK (integer_type_node))
2334     return unsignedp ? unsigned_type_node : integer_type_node;
2335   if (TYPE_OK (short_integer_type_node))
2336     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2337   if (TYPE_OK (long_integer_type_node))
2338     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2339   if (TYPE_OK (long_long_integer_type_node))
2340     return (unsignedp
2341             ? long_long_unsigned_type_node
2342             : long_long_integer_type_node);
2343
2344   for (i = 0; i < NUM_INT_N_ENTS; i ++)
2345     if (int_n_enabled_p[i]
2346         && TYPE_MODE (type) == int_n_data[i].m
2347         && TYPE_PRECISION (type) == int_n_data[i].bitsize)
2348         return unsignedp
2349           ? int_n_trees[i].unsigned_type
2350           : int_n_trees[i].signed_type;
2351
2352 #if HOST_BITS_PER_WIDE_INT >= 64
2353   if (TYPE_OK (intTI_type_node))
2354     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2355 #endif
2356   if (TYPE_OK (intDI_type_node))
2357     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2358   if (TYPE_OK (intSI_type_node))
2359     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2360   if (TYPE_OK (intHI_type_node))
2361     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2362   if (TYPE_OK (intQI_type_node))
2363     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2364
2365 #undef GIMPLE_FIXED_TYPES
2366 #undef GIMPLE_FIXED_MODE_TYPES
2367 #undef GIMPLE_FIXED_TYPES_SAT
2368 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2369 #undef TYPE_OK
2370
2371   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2372 }
2373
2374
2375 /* Return an unsigned type the same as TYPE in other respects.  */
2376
2377 tree
2378 gimple_unsigned_type (tree type)
2379 {
2380   return gimple_signed_or_unsigned_type (true, type);
2381 }
2382
2383
2384 /* Return a signed type the same as TYPE in other respects.  */
2385
2386 tree
2387 gimple_signed_type (tree type)
2388 {
2389   return gimple_signed_or_unsigned_type (false, type);
2390 }
2391
2392
2393 /* Return the typed-based alias set for T, which may be an expression
2394    or a type.  Return -1 if we don't do anything special.  */
2395
2396 alias_set_type
2397 gimple_get_alias_set (tree t)
2398 {
2399   tree u;
2400
2401   /* Permit type-punning when accessing a union, provided the access
2402      is directly through the union.  For example, this code does not
2403      permit taking the address of a union member and then storing
2404      through it.  Even the type-punning allowed here is a GCC
2405      extension, albeit a common and useful one; the C standard says
2406      that such accesses have implementation-defined behavior.  */
2407   for (u = t;
2408        TREE_CODE (u) == COMPONENT_REF || TREE_CODE (u) == ARRAY_REF;
2409        u = TREE_OPERAND (u, 0))
2410     if (TREE_CODE (u) == COMPONENT_REF
2411         && TREE_CODE (TREE_TYPE (TREE_OPERAND (u, 0))) == UNION_TYPE)
2412       return 0;
2413
2414   /* That's all the expressions we handle specially.  */
2415   if (!TYPE_P (t))
2416     return -1;
2417
2418   /* For convenience, follow the C standard when dealing with
2419      character types.  Any object may be accessed via an lvalue that
2420      has character type.  */
2421   if (t == char_type_node
2422       || t == signed_char_type_node
2423       || t == unsigned_char_type_node)
2424     return 0;
2425
2426   /* Allow aliasing between signed and unsigned variants of the same
2427      type.  We treat the signed variant as canonical.  */
2428   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2429     {
2430       tree t1 = gimple_signed_type (t);
2431
2432       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2433       if (t1 != t)
2434         return get_alias_set (t1);
2435     }
2436
2437   return -1;
2438 }
2439
2440
2441 /* Helper for gimple_ior_addresses_taken_1.  */
2442
2443 static bool
2444 gimple_ior_addresses_taken_1 (gimple, tree addr, tree, void *data)
2445 {
2446   bitmap addresses_taken = (bitmap)data;
2447   addr = get_base_address (addr);
2448   if (addr
2449       && DECL_P (addr))
2450     {
2451       bitmap_set_bit (addresses_taken, DECL_UID (addr));
2452       return true;
2453     }
2454   return false;
2455 }
2456
2457 /* Set the bit for the uid of all decls that have their address taken
2458    in STMT in the ADDRESSES_TAKEN bitmap.  Returns true if there
2459    were any in this stmt.  */
2460
2461 bool
2462 gimple_ior_addresses_taken (bitmap addresses_taken, gimple stmt)
2463 {
2464   return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2465                                         gimple_ior_addresses_taken_1);
2466 }
2467
2468
2469 /* Return true if TYPE1 and TYPE2 are compatible enough for builtin
2470    processing.  */
2471
2472 static bool
2473 validate_type (tree type1, tree type2)
2474 {
2475   if (INTEGRAL_TYPE_P (type1)
2476       && INTEGRAL_TYPE_P (type2))
2477     ;
2478   else if (POINTER_TYPE_P (type1)
2479            && POINTER_TYPE_P (type2))
2480     ;
2481   else if (TREE_CODE (type1)
2482            != TREE_CODE (type2))
2483     return false;
2484   return true;
2485 }
2486
2487 /* Return true when STMTs arguments and return value match those of FNDECL,
2488    a decl of a builtin function.  */
2489
2490 bool
2491 gimple_builtin_call_types_compatible_p (const_gimple stmt, tree fndecl)
2492 {
2493   gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2494
2495   tree ret = gimple_call_lhs (stmt);
2496   if (ret
2497       && !validate_type (TREE_TYPE (ret), TREE_TYPE (TREE_TYPE (fndecl))))
2498     return false;
2499
2500   tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2501   unsigned nargs = gimple_call_num_args (stmt);
2502   for (unsigned i = 0; i < nargs; ++i)
2503     {
2504       /* Variadic args follow.  */
2505       if (!targs)
2506         return true;
2507       tree arg = gimple_call_arg (stmt, i);
2508       if (!validate_type (TREE_TYPE (arg), TREE_VALUE (targs)))
2509         return false;
2510       targs = TREE_CHAIN (targs);
2511     }
2512   if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2513     return false;
2514   return true;
2515 }
2516
2517 /* Return true when STMT is builtins call.  */
2518
2519 bool
2520 gimple_call_builtin_p (const_gimple stmt)
2521 {
2522   tree fndecl;
2523   if (is_gimple_call (stmt)
2524       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2525       && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
2526     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2527   return false;
2528 }
2529
2530 /* Return true when STMT is builtins call to CLASS.  */
2531
2532 bool
2533 gimple_call_builtin_p (const_gimple stmt, enum built_in_class klass)
2534 {
2535   tree fndecl;
2536   if (is_gimple_call (stmt)
2537       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2538       && DECL_BUILT_IN_CLASS (fndecl) == klass)
2539     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2540   return false;
2541 }
2542
2543 /* Return true when STMT is builtins call to CODE of CLASS.  */
2544
2545 bool
2546 gimple_call_builtin_p (const_gimple stmt, enum built_in_function code)
2547 {
2548   tree fndecl;
2549   if (is_gimple_call (stmt)
2550       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2551       && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL 
2552       && DECL_FUNCTION_CODE (fndecl) == code)
2553     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2554   return false;
2555 }
2556
2557 /* Return true if STMT clobbers memory.  STMT is required to be a
2558    GIMPLE_ASM.  */
2559
2560 bool
2561 gimple_asm_clobbers_memory_p (const gasm *stmt)
2562 {
2563   unsigned i;
2564
2565   for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
2566     {
2567       tree op = gimple_asm_clobber_op (stmt, i);
2568       if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
2569         return true;
2570     }
2571
2572   return false;
2573 }
2574
2575 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE.  */
2576
2577 void
2578 dump_decl_set (FILE *file, bitmap set)
2579 {
2580   if (set)
2581     {
2582       bitmap_iterator bi;
2583       unsigned i;
2584
2585       fprintf (file, "{ ");
2586
2587       EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
2588         {
2589           fprintf (file, "D.%u", i);
2590           fprintf (file, " ");
2591         }
2592
2593       fprintf (file, "}");
2594     }
2595   else
2596     fprintf (file, "NIL");
2597 }
2598
2599 /* Return true when CALL is a call stmt that definitely doesn't
2600    free any memory or makes it unavailable otherwise.  */
2601 bool
2602 nonfreeing_call_p (gimple call)
2603 {
2604   if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
2605       && gimple_call_flags (call) & ECF_LEAF)
2606     switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
2607       {
2608         /* Just in case these become ECF_LEAF in the future.  */
2609         case BUILT_IN_FREE:
2610         case BUILT_IN_TM_FREE:
2611         case BUILT_IN_REALLOC:
2612         case BUILT_IN_STACK_RESTORE:
2613           return false;
2614         default:
2615           return true;
2616       }
2617   else if (gimple_call_internal_p (call))
2618     switch (gimple_call_internal_fn (call))
2619       {
2620       case IFN_ABNORMAL_DISPATCHER:
2621         return true;
2622       default:
2623         if (gimple_call_flags (call) & ECF_LEAF)
2624           return true;
2625         return false;
2626       }
2627
2628   tree fndecl = gimple_call_fndecl (call);
2629   if (!fndecl)
2630     return false;
2631   struct cgraph_node *n = cgraph_node::get (fndecl);
2632   if (!n)
2633     return false;
2634   enum availability availability;
2635   n = n->function_symbol (&availability);
2636   if (!n || availability <= AVAIL_INTERPOSABLE)
2637     return false;
2638   return n->nonfreeing_fn;
2639 }
2640
2641 /* Callback for walk_stmt_load_store_ops.
2642  
2643    Return TRUE if OP will dereference the tree stored in DATA, FALSE
2644    otherwise.
2645
2646    This routine only makes a superficial check for a dereference.  Thus
2647    it must only be used if it is safe to return a false negative.  */
2648 static bool
2649 check_loadstore (gimple, tree op, tree, void *data)
2650 {
2651   if ((TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
2652       && operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0))
2653     return true;
2654   return false;
2655 }
2656
2657 /* If OP can be inferred to be non-NULL after STMT executes, return true.
2658
2659    DEREFERENCE is TRUE if we can use a pointer dereference to infer a
2660    non-NULL range, FALSE otherwise.
2661
2662    ATTRIBUTE is TRUE if we can use attributes to infer a non-NULL range
2663    for function arguments and return values.  FALSE otherwise.  */
2664
2665 bool
2666 infer_nonnull_range (gimple stmt, tree op, bool dereference, bool attribute)
2667 {
2668   /* We can only assume that a pointer dereference will yield
2669      non-NULL if -fdelete-null-pointer-checks is enabled.  */
2670   if (!flag_delete_null_pointer_checks
2671       || !POINTER_TYPE_P (TREE_TYPE (op))
2672       || gimple_code (stmt) == GIMPLE_ASM)
2673     return false;
2674
2675   if (dereference
2676       && walk_stmt_load_store_ops (stmt, (void *)op,
2677                                    check_loadstore, check_loadstore))
2678     return true;
2679
2680   if (attribute
2681       && is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
2682     {
2683       tree fntype = gimple_call_fntype (stmt);
2684       tree attrs = TYPE_ATTRIBUTES (fntype);
2685       for (; attrs; attrs = TREE_CHAIN (attrs))
2686         {
2687           attrs = lookup_attribute ("nonnull", attrs);
2688
2689           /* If "nonnull" wasn't specified, we know nothing about
2690              the argument.  */
2691           if (attrs == NULL_TREE)
2692             return false;
2693
2694           /* If "nonnull" applies to all the arguments, then ARG
2695              is non-null if it's in the argument list.  */
2696           if (TREE_VALUE (attrs) == NULL_TREE)
2697             {
2698               for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
2699                 {
2700                   if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
2701                       && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
2702                     return true;
2703                 }
2704               return false;
2705             }
2706
2707           /* Now see if op appears in the nonnull list.  */
2708           for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
2709             {
2710               int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
2711               tree arg = gimple_call_arg (stmt, idx);
2712               if (operand_equal_p (op, arg, 0))
2713                 return true;
2714             }
2715         }
2716     }
2717
2718   /* If this function is marked as returning non-null, then we can
2719      infer OP is non-null if it is used in the return statement.  */
2720   if (attribute)
2721     if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
2722       if (gimple_return_retval (return_stmt)
2723           && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
2724           && lookup_attribute ("returns_nonnull",
2725                                TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
2726         return true;
2727
2728   return false;
2729 }
2730
2731 /* Compare two case labels.  Because the front end should already have
2732    made sure that case ranges do not overlap, it is enough to only compare
2733    the CASE_LOW values of each case label.  */
2734
2735 static int
2736 compare_case_labels (const void *p1, const void *p2)
2737 {
2738   const_tree const case1 = *(const_tree const*)p1;
2739   const_tree const case2 = *(const_tree const*)p2;
2740
2741   /* The 'default' case label always goes first.  */
2742   if (!CASE_LOW (case1))
2743     return -1;
2744   else if (!CASE_LOW (case2))
2745     return 1;
2746   else
2747     return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
2748 }
2749
2750 /* Sort the case labels in LABEL_VEC in place in ascending order.  */
2751
2752 void
2753 sort_case_labels (vec<tree> label_vec)
2754 {
2755   label_vec.qsort (compare_case_labels);
2756 }
2757 \f
2758 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
2759
2760    LABELS is a vector that contains all case labels to look at.
2761
2762    INDEX_TYPE is the type of the switch index expression.  Case labels
2763    in LABELS are discarded if their values are not in the value range
2764    covered by INDEX_TYPE.  The remaining case label values are folded
2765    to INDEX_TYPE.
2766
2767    If a default case exists in LABELS, it is removed from LABELS and
2768    returned in DEFAULT_CASEP.  If no default case exists, but the
2769    case labels already cover the whole range of INDEX_TYPE, a default
2770    case is returned pointing to one of the existing case labels.
2771    Otherwise DEFAULT_CASEP is set to NULL_TREE.
2772
2773    DEFAULT_CASEP may be NULL, in which case the above comment doesn't
2774    apply and no action is taken regardless of whether a default case is
2775    found or not.  */
2776
2777 void
2778 preprocess_case_label_vec_for_gimple (vec<tree> labels,
2779                                       tree index_type,
2780                                       tree *default_casep)
2781 {
2782   tree min_value, max_value;
2783   tree default_case = NULL_TREE;
2784   size_t i, len;
2785
2786   i = 0;
2787   min_value = TYPE_MIN_VALUE (index_type);
2788   max_value = TYPE_MAX_VALUE (index_type);
2789   while (i < labels.length ())
2790     {
2791       tree elt = labels[i];
2792       tree low = CASE_LOW (elt);
2793       tree high = CASE_HIGH (elt);
2794       bool remove_element = FALSE;
2795
2796       if (low)
2797         {
2798           gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
2799           gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
2800
2801           /* This is a non-default case label, i.e. it has a value.
2802
2803              See if the case label is reachable within the range of
2804              the index type.  Remove out-of-range case values.  Turn
2805              case ranges into a canonical form (high > low strictly)
2806              and convert the case label values to the index type.
2807
2808              NB: The type of gimple_switch_index() may be the promoted
2809              type, but the case labels retain the original type.  */
2810
2811           if (high)
2812             {
2813               /* This is a case range.  Discard empty ranges.
2814                  If the bounds or the range are equal, turn this
2815                  into a simple (one-value) case.  */
2816               int cmp = tree_int_cst_compare (high, low);
2817               if (cmp < 0)
2818                 remove_element = TRUE;
2819               else if (cmp == 0)
2820                 high = NULL_TREE;
2821             }
2822
2823           if (! high)
2824             {
2825               /* If the simple case value is unreachable, ignore it.  */
2826               if ((TREE_CODE (min_value) == INTEGER_CST
2827                    && tree_int_cst_compare (low, min_value) < 0)
2828                   || (TREE_CODE (max_value) == INTEGER_CST
2829                       && tree_int_cst_compare (low, max_value) > 0))
2830                 remove_element = TRUE;
2831               else
2832                 low = fold_convert (index_type, low);
2833             }
2834           else
2835             {
2836               /* If the entire case range is unreachable, ignore it.  */
2837               if ((TREE_CODE (min_value) == INTEGER_CST
2838                    && tree_int_cst_compare (high, min_value) < 0)
2839                   || (TREE_CODE (max_value) == INTEGER_CST
2840                       && tree_int_cst_compare (low, max_value) > 0))
2841                 remove_element = TRUE;
2842               else
2843                 {
2844                   /* If the lower bound is less than the index type's
2845                      minimum value, truncate the range bounds.  */
2846                   if (TREE_CODE (min_value) == INTEGER_CST
2847                       && tree_int_cst_compare (low, min_value) < 0)
2848                     low = min_value;
2849                   low = fold_convert (index_type, low);
2850
2851                   /* If the upper bound is greater than the index type's
2852                      maximum value, truncate the range bounds.  */
2853                   if (TREE_CODE (max_value) == INTEGER_CST
2854                       && tree_int_cst_compare (high, max_value) > 0)
2855                     high = max_value;
2856                   high = fold_convert (index_type, high);
2857
2858                   /* We may have folded a case range to a one-value case.  */
2859                   if (tree_int_cst_equal (low, high))
2860                     high = NULL_TREE;
2861                 }
2862             }
2863
2864           CASE_LOW (elt) = low;
2865           CASE_HIGH (elt) = high;
2866         }
2867       else
2868         {
2869           gcc_assert (!default_case);
2870           default_case = elt;
2871           /* The default case must be passed separately to the
2872              gimple_build_switch routine.  But if DEFAULT_CASEP
2873              is NULL, we do not remove the default case (it would
2874              be completely lost).  */
2875           if (default_casep)
2876             remove_element = TRUE;
2877         }
2878
2879       if (remove_element)
2880         labels.ordered_remove (i);
2881       else
2882         i++;
2883     }
2884   len = i;
2885
2886   if (!labels.is_empty ())
2887     sort_case_labels (labels);
2888
2889   if (default_casep && !default_case)
2890     {
2891       /* If the switch has no default label, add one, so that we jump
2892          around the switch body.  If the labels already cover the whole
2893          range of the switch index_type, add the default label pointing
2894          to one of the existing labels.  */
2895       if (len
2896           && TYPE_MIN_VALUE (index_type)
2897           && TYPE_MAX_VALUE (index_type)
2898           && tree_int_cst_equal (CASE_LOW (labels[0]),
2899                                  TYPE_MIN_VALUE (index_type)))
2900         {
2901           tree low, high = CASE_HIGH (labels[len - 1]);
2902           if (!high)
2903             high = CASE_LOW (labels[len - 1]);
2904           if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
2905             {
2906               for (i = 1; i < len; i++)
2907                 {
2908                   high = CASE_LOW (labels[i]);
2909                   low = CASE_HIGH (labels[i - 1]);
2910                   if (!low)
2911                     low = CASE_LOW (labels[i - 1]);
2912                   if (wi::add (low, 1) != high)
2913                     break;
2914                 }
2915               if (i == len)
2916                 {
2917                   tree label = CASE_LABEL (labels[0]);
2918                   default_case = build_case_label (NULL_TREE, NULL_TREE,
2919                                                    label);
2920                 }
2921             }
2922         }
2923     }
2924
2925   if (default_casep)
2926     *default_casep = default_case;
2927 }
2928
2929 /* Set the location of all statements in SEQ to LOC.  */
2930
2931 void
2932 gimple_seq_set_location (gimple_seq seq, location_t loc)
2933 {
2934   for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
2935     gimple_set_location (gsi_stmt (i), loc);
2936 }
2937
2938 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements.  */
2939
2940 void
2941 gimple_seq_discard (gimple_seq seq)
2942 {
2943   gimple_stmt_iterator gsi;
2944
2945   for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
2946     {
2947       gimple stmt = gsi_stmt (gsi);
2948       gsi_remove (&gsi, true);
2949       release_defs (stmt);
2950       ggc_free (stmt);
2951     }
2952 }