gcc/gimple.cc

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