gcc/gimple.cc

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