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) == ADDR_EXPR                                                 \
2412       || (SYM) == WITH_SIZE_EXPR                                            \
2413       || (SYM) == SSA_NAME) ? GIMPLE_SINGLE_RHS                             \
2414    : GIMPLE_INVALID_RHS),
2415 #define END_OF_BASE_TREE_CODES (unsigned char) GIMPLE_INVALID_RHS,
2416
2417 const unsigned char gimple_rhs_class_table[] = {
2418 #include "all-tree.def"
2419 };
2420
2421 #undef DEFTREECODE
2422 #undef END_OF_BASE_TREE_CODES
2423
2424 /* Build a GIMPLE_CALL identical to STMT but skipping the arguments in
2425    the positions marked by the set ARGS_TO_SKIP.  */
2426
2427 gcall *
2428 gimple_call_copy_skip_args (gcall *stmt, bitmap args_to_skip)
2429 {
2430   int i;
2431   int nargs = gimple_call_num_args (stmt);
2432   auto_vec<tree> vargs (nargs);
2433   gcall *new_stmt;
2434
2435   for (i = 0; i < nargs; i++)
2436     if (!bitmap_bit_p (args_to_skip, i))
2437       vargs.quick_push (gimple_call_arg (stmt, i));
2438
2439   if (gimple_call_internal_p (stmt))
2440     new_stmt = gimple_build_call_internal_vec (gimple_call_internal_fn (stmt),
2441                                                vargs);
2442   else
2443     new_stmt = gimple_build_call_vec (gimple_call_fn (stmt), vargs);
2444
2445   if (gimple_call_lhs (stmt))
2446     gimple_call_set_lhs (new_stmt, gimple_call_lhs (stmt));
2447
2448   gimple_set_vuse (new_stmt, gimple_vuse (stmt));
2449   gimple_set_vdef (new_stmt, gimple_vdef (stmt));
2450
2451   if (gimple_has_location (stmt))
2452     gimple_set_location (new_stmt, gimple_location (stmt));
2453   gimple_call_copy_flags (new_stmt, stmt);
2454   gimple_call_set_chain (new_stmt, gimple_call_chain (stmt));
2455
2456   gimple_set_modified (new_stmt, true);
2457
2458   return new_stmt;
2459 }
2460
2461
2462
2463 /* Return true if the field decls F1 and F2 are at the same offset.
2464
2465    This is intended to be used on GIMPLE types only.  */
2466
2467 bool
2468 gimple_compare_field_offset (tree f1, tree f2)
2469 {
2470   if (DECL_OFFSET_ALIGN (f1) == DECL_OFFSET_ALIGN (f2))
2471     {
2472       tree offset1 = DECL_FIELD_OFFSET (f1);
2473       tree offset2 = DECL_FIELD_OFFSET (f2);
2474       return ((offset1 == offset2
2475                /* Once gimplification is done, self-referential offsets are
2476                   instantiated as operand #2 of the COMPONENT_REF built for
2477                   each access and reset.  Therefore, they are not relevant
2478                   anymore and fields are interchangeable provided that they
2479                   represent the same access.  */
2480                || (TREE_CODE (offset1) == PLACEHOLDER_EXPR
2481                    && TREE_CODE (offset2) == PLACEHOLDER_EXPR
2482                    && (DECL_SIZE (f1) == DECL_SIZE (f2)
2483                        || (TREE_CODE (DECL_SIZE (f1)) == PLACEHOLDER_EXPR
2484                            && TREE_CODE (DECL_SIZE (f2)) == PLACEHOLDER_EXPR)
2485                        || operand_equal_p (DECL_SIZE (f1), DECL_SIZE (f2), 0))
2486                    && DECL_ALIGN (f1) == DECL_ALIGN (f2))
2487                || operand_equal_p (offset1, offset2, 0))
2488               && tree_int_cst_equal (DECL_FIELD_BIT_OFFSET (f1),
2489                                      DECL_FIELD_BIT_OFFSET (f2)));
2490     }
2491
2492   /* Fortran and C do not always agree on what DECL_OFFSET_ALIGN
2493      should be, so handle differing ones specially by decomposing
2494      the offset into a byte and bit offset manually.  */
2495   if (tree_fits_shwi_p (DECL_FIELD_OFFSET (f1))
2496       && tree_fits_shwi_p (DECL_FIELD_OFFSET (f2)))
2497     {
2498       unsigned HOST_WIDE_INT byte_offset1, byte_offset2;
2499       unsigned HOST_WIDE_INT bit_offset1, bit_offset2;
2500       bit_offset1 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f1));
2501       byte_offset1 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f1))
2502                       + bit_offset1 / BITS_PER_UNIT);
2503       bit_offset2 = TREE_INT_CST_LOW (DECL_FIELD_BIT_OFFSET (f2));
2504       byte_offset2 = (TREE_INT_CST_LOW (DECL_FIELD_OFFSET (f2))
2505                       + bit_offset2 / BITS_PER_UNIT);
2506       if (byte_offset1 != byte_offset2)
2507         return false;
2508       return bit_offset1 % BITS_PER_UNIT == bit_offset2 % BITS_PER_UNIT;
2509     }
2510
2511   return false;
2512 }
2513
2514
2515 /* Return a type the same as TYPE except unsigned or
2516    signed according to UNSIGNEDP.  */
2517
2518 static tree
2519 gimple_signed_or_unsigned_type (bool unsignedp, tree type)
2520 {
2521   tree type1;
2522   int i;
2523
2524   type1 = TYPE_MAIN_VARIANT (type);
2525   if (type1 == signed_char_type_node
2526       || type1 == char_type_node
2527       || type1 == unsigned_char_type_node)
2528     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2529   if (type1 == integer_type_node || type1 == unsigned_type_node)
2530     return unsignedp ? unsigned_type_node : integer_type_node;
2531   if (type1 == short_integer_type_node || type1 == short_unsigned_type_node)
2532     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2533   if (type1 == long_integer_type_node || type1 == long_unsigned_type_node)
2534     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2535   if (type1 == long_long_integer_type_node
2536       || type1 == long_long_unsigned_type_node)
2537     return unsignedp
2538            ? long_long_unsigned_type_node
2539            : long_long_integer_type_node;
2540
2541   for (i = 0; i < NUM_INT_N_ENTS; i ++)
2542     if (int_n_enabled_p[i]
2543         && (type1 == int_n_trees[i].unsigned_type
2544             || type1 == int_n_trees[i].signed_type))
2545         return unsignedp
2546           ? int_n_trees[i].unsigned_type
2547           : int_n_trees[i].signed_type;
2548
2549 #if HOST_BITS_PER_WIDE_INT >= 64
2550   if (type1 == intTI_type_node || type1 == unsigned_intTI_type_node)
2551     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2552 #endif
2553   if (type1 == intDI_type_node || type1 == unsigned_intDI_type_node)
2554     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2555   if (type1 == intSI_type_node || type1 == unsigned_intSI_type_node)
2556     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2557   if (type1 == intHI_type_node || type1 == unsigned_intHI_type_node)
2558     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2559   if (type1 == intQI_type_node || type1 == unsigned_intQI_type_node)
2560     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2561
2562 #define GIMPLE_FIXED_TYPES(NAME)            \
2563   if (type1 == short_ ## NAME ## _type_node \
2564       || type1 == unsigned_short_ ## NAME ## _type_node) \
2565     return unsignedp ? unsigned_short_ ## NAME ## _type_node \
2566                      : short_ ## NAME ## _type_node; \
2567   if (type1 == NAME ## _type_node \
2568       || type1 == unsigned_ ## NAME ## _type_node) \
2569     return unsignedp ? unsigned_ ## NAME ## _type_node \
2570                      : NAME ## _type_node; \
2571   if (type1 == long_ ## NAME ## _type_node \
2572       || type1 == unsigned_long_ ## NAME ## _type_node) \
2573     return unsignedp ? unsigned_long_ ## NAME ## _type_node \
2574                      : long_ ## NAME ## _type_node; \
2575   if (type1 == long_long_ ## NAME ## _type_node \
2576       || type1 == unsigned_long_long_ ## NAME ## _type_node) \
2577     return unsignedp ? unsigned_long_long_ ## NAME ## _type_node \
2578                      : long_long_ ## NAME ## _type_node;
2579
2580 #define GIMPLE_FIXED_MODE_TYPES(NAME) \
2581   if (type1 == NAME ## _type_node \
2582       || type1 == u ## NAME ## _type_node) \
2583     return unsignedp ? u ## NAME ## _type_node \
2584                      : NAME ## _type_node;
2585
2586 #define GIMPLE_FIXED_TYPES_SAT(NAME) \
2587   if (type1 == sat_ ## short_ ## NAME ## _type_node \
2588       || type1 == sat_ ## unsigned_short_ ## NAME ## _type_node) \
2589     return unsignedp ? sat_ ## unsigned_short_ ## NAME ## _type_node \
2590                      : sat_ ## short_ ## NAME ## _type_node; \
2591   if (type1 == sat_ ## NAME ## _type_node \
2592       || type1 == sat_ ## unsigned_ ## NAME ## _type_node) \
2593     return unsignedp ? sat_ ## unsigned_ ## NAME ## _type_node \
2594                      : sat_ ## NAME ## _type_node; \
2595   if (type1 == sat_ ## long_ ## NAME ## _type_node \
2596       || type1 == sat_ ## unsigned_long_ ## NAME ## _type_node) \
2597     return unsignedp ? sat_ ## unsigned_long_ ## NAME ## _type_node \
2598                      : sat_ ## long_ ## NAME ## _type_node; \
2599   if (type1 == sat_ ## long_long_ ## NAME ## _type_node \
2600       || type1 == sat_ ## unsigned_long_long_ ## NAME ## _type_node) \
2601     return unsignedp ? sat_ ## unsigned_long_long_ ## NAME ## _type_node \
2602                      : sat_ ## long_long_ ## NAME ## _type_node;
2603
2604 #define GIMPLE_FIXED_MODE_TYPES_SAT(NAME)       \
2605   if (type1 == sat_ ## NAME ## _type_node \
2606       || type1 == sat_ ## u ## NAME ## _type_node) \
2607     return unsignedp ? sat_ ## u ## NAME ## _type_node \
2608                      : sat_ ## NAME ## _type_node;
2609
2610   GIMPLE_FIXED_TYPES (fract);
2611   GIMPLE_FIXED_TYPES_SAT (fract);
2612   GIMPLE_FIXED_TYPES (accum);
2613   GIMPLE_FIXED_TYPES_SAT (accum);
2614
2615   GIMPLE_FIXED_MODE_TYPES (qq);
2616   GIMPLE_FIXED_MODE_TYPES (hq);
2617   GIMPLE_FIXED_MODE_TYPES (sq);
2618   GIMPLE_FIXED_MODE_TYPES (dq);
2619   GIMPLE_FIXED_MODE_TYPES (tq);
2620   GIMPLE_FIXED_MODE_TYPES_SAT (qq);
2621   GIMPLE_FIXED_MODE_TYPES_SAT (hq);
2622   GIMPLE_FIXED_MODE_TYPES_SAT (sq);
2623   GIMPLE_FIXED_MODE_TYPES_SAT (dq);
2624   GIMPLE_FIXED_MODE_TYPES_SAT (tq);
2625   GIMPLE_FIXED_MODE_TYPES (ha);
2626   GIMPLE_FIXED_MODE_TYPES (sa);
2627   GIMPLE_FIXED_MODE_TYPES (da);
2628   GIMPLE_FIXED_MODE_TYPES (ta);
2629   GIMPLE_FIXED_MODE_TYPES_SAT (ha);
2630   GIMPLE_FIXED_MODE_TYPES_SAT (sa);
2631   GIMPLE_FIXED_MODE_TYPES_SAT (da);
2632   GIMPLE_FIXED_MODE_TYPES_SAT (ta);
2633
2634   /* For ENUMERAL_TYPEs in C++, must check the mode of the types, not
2635      the precision; they have precision set to match their range, but
2636      may use a wider mode to match an ABI.  If we change modes, we may
2637      wind up with bad conversions.  For INTEGER_TYPEs in C, must check
2638      the precision as well, so as to yield correct results for
2639      bit-field types.  C++ does not have these separate bit-field
2640      types, and producing a signed or unsigned variant of an
2641      ENUMERAL_TYPE may cause other problems as well.  */
2642   if (!INTEGRAL_TYPE_P (type)
2643       || TYPE_UNSIGNED (type) == unsignedp)
2644     return type;
2645
2646 #define TYPE_OK(node)                                                       \
2647   (TYPE_MODE (type) == TYPE_MODE (node)                                     \
2648    && TYPE_PRECISION (type) == TYPE_PRECISION (node))
2649   if (TYPE_OK (signed_char_type_node))
2650     return unsignedp ? unsigned_char_type_node : signed_char_type_node;
2651   if (TYPE_OK (integer_type_node))
2652     return unsignedp ? unsigned_type_node : integer_type_node;
2653   if (TYPE_OK (short_integer_type_node))
2654     return unsignedp ? short_unsigned_type_node : short_integer_type_node;
2655   if (TYPE_OK (long_integer_type_node))
2656     return unsignedp ? long_unsigned_type_node : long_integer_type_node;
2657   if (TYPE_OK (long_long_integer_type_node))
2658     return (unsignedp
2659             ? long_long_unsigned_type_node
2660             : long_long_integer_type_node);
2661
2662   for (i = 0; i < NUM_INT_N_ENTS; i ++)
2663     if (int_n_enabled_p[i]
2664         && TYPE_MODE (type) == int_n_data[i].m
2665         && TYPE_PRECISION (type) == int_n_data[i].bitsize)
2666         return unsignedp
2667           ? int_n_trees[i].unsigned_type
2668           : int_n_trees[i].signed_type;
2669
2670 #if HOST_BITS_PER_WIDE_INT >= 64
2671   if (TYPE_OK (intTI_type_node))
2672     return unsignedp ? unsigned_intTI_type_node : intTI_type_node;
2673 #endif
2674   if (TYPE_OK (intDI_type_node))
2675     return unsignedp ? unsigned_intDI_type_node : intDI_type_node;
2676   if (TYPE_OK (intSI_type_node))
2677     return unsignedp ? unsigned_intSI_type_node : intSI_type_node;
2678   if (TYPE_OK (intHI_type_node))
2679     return unsignedp ? unsigned_intHI_type_node : intHI_type_node;
2680   if (TYPE_OK (intQI_type_node))
2681     return unsignedp ? unsigned_intQI_type_node : intQI_type_node;
2682
2683 #undef GIMPLE_FIXED_TYPES
2684 #undef GIMPLE_FIXED_MODE_TYPES
2685 #undef GIMPLE_FIXED_TYPES_SAT
2686 #undef GIMPLE_FIXED_MODE_TYPES_SAT
2687 #undef TYPE_OK
2688
2689   return build_nonstandard_integer_type (TYPE_PRECISION (type), unsignedp);
2690 }
2691
2692
2693 /* Return an unsigned type the same as TYPE in other respects.  */
2694
2695 tree
2696 gimple_unsigned_type (tree type)
2697 {
2698   return gimple_signed_or_unsigned_type (true, type);
2699 }
2700
2701
2702 /* Return a signed type the same as TYPE in other respects.  */
2703
2704 tree
2705 gimple_signed_type (tree type)
2706 {
2707   return gimple_signed_or_unsigned_type (false, type);
2708 }
2709
2710
2711 /* Return the typed-based alias set for T, which may be an expression
2712    or a type.  Return -1 if we don't do anything special.  */
2713
2714 alias_set_type
2715 gimple_get_alias_set (tree t)
2716 {
2717   /* That's all the expressions we handle specially.  */
2718   if (!TYPE_P (t))
2719     return -1;
2720
2721   /* For convenience, follow the C standard when dealing with
2722      character types.  Any object may be accessed via an lvalue that
2723      has character type.  */
2724   if (t == char_type_node
2725       || t == signed_char_type_node
2726       || t == unsigned_char_type_node)
2727     return 0;
2728
2729   /* Allow aliasing between signed and unsigned variants of the same
2730      type.  We treat the signed variant as canonical.  */
2731   if (TREE_CODE (t) == INTEGER_TYPE && TYPE_UNSIGNED (t))
2732     {
2733       tree t1 = gimple_signed_type (t);
2734
2735       /* t1 == t can happen for boolean nodes which are always unsigned.  */
2736       if (t1 != t)
2737         return get_alias_set (t1);
2738     }
2739
2740   /* Allow aliasing between enumeral types and the underlying
2741      integer type.  This is required for C since those are
2742      compatible types.  */
2743   else if (TREE_CODE (t) == ENUMERAL_TYPE)
2744     {
2745       tree t1 = lang_hooks.types.type_for_size (tree_to_uhwi (TYPE_SIZE (t)),
2746                                                 false /* short-cut above */);
2747       return get_alias_set (t1);
2748     }
2749
2750   return -1;
2751 }
2752
2753
2754 /* Helper for gimple_ior_addresses_taken_1.  */
2755
2756 static bool
2757 gimple_ior_addresses_taken_1 (gimple *, tree addr, tree, void *data)
2758 {
2759   bitmap addresses_taken = (bitmap)data;
2760   addr = get_base_address (addr);
2761   if (addr
2762       && DECL_P (addr))
2763     {
2764       bitmap_set_bit (addresses_taken, DECL_UID (addr));
2765       return true;
2766     }
2767   return false;
2768 }
2769
2770 /* Set the bit for the uid of all decls that have their address taken
2771    in STMT in the ADDRESSES_TAKEN bitmap.  Returns true if there
2772    were any in this stmt.  */
2773
2774 bool
2775 gimple_ior_addresses_taken (bitmap addresses_taken, gimple *stmt)
2776 {
2777   return walk_stmt_load_store_addr_ops (stmt, addresses_taken, NULL, NULL,
2778                                         gimple_ior_addresses_taken_1);
2779 }
2780
2781
2782 /* Return true when STMTs arguments and return value match those of FNDECL,
2783    a decl of a builtin function.  */
2784
2785 bool
2786 gimple_builtin_call_types_compatible_p (const gimple *stmt, tree fndecl)
2787 {
2788   gcc_checking_assert (DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN);
2789
2790   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
2791     if (tree decl = builtin_decl_explicit (DECL_FUNCTION_CODE (fndecl)))
2792       fndecl = decl;
2793
2794   tree ret = gimple_call_lhs (stmt);
2795   if (ret
2796       && !useless_type_conversion_p (TREE_TYPE (ret),
2797                                      TREE_TYPE (TREE_TYPE (fndecl))))
2798     return false;
2799
2800   tree targs = TYPE_ARG_TYPES (TREE_TYPE (fndecl));
2801   unsigned nargs = gimple_call_num_args (stmt);
2802   for (unsigned i = 0; i < nargs; ++i)
2803     {
2804       /* Variadic args follow.  */
2805       if (!targs)
2806         return true;
2807       tree arg = gimple_call_arg (stmt, i);
2808       tree type = TREE_VALUE (targs);
2809       if (!useless_type_conversion_p (type, TREE_TYPE (arg))
2810           /* char/short integral arguments are promoted to int
2811              by several frontends if targetm.calls.promote_prototypes
2812              is true.  Allow such promotion too.  */
2813           && !(INTEGRAL_TYPE_P (type)
2814                && TYPE_PRECISION (type) < TYPE_PRECISION (integer_type_node)
2815                && targetm.calls.promote_prototypes (TREE_TYPE (fndecl))
2816                && useless_type_conversion_p (integer_type_node,
2817                                              TREE_TYPE (arg))))
2818         return false;
2819       targs = TREE_CHAIN (targs);
2820     }
2821   if (targs && !VOID_TYPE_P (TREE_VALUE (targs)))
2822     return false;
2823   return true;
2824 }
2825
2826 /* Return true when STMT is operator a replaceable delete call.  */
2827
2828 bool
2829 gimple_call_operator_delete_p (const gcall *stmt)
2830 {
2831   tree fndecl;
2832
2833   if ((fndecl = gimple_call_fndecl (stmt)) != NULL_TREE)
2834     return DECL_IS_OPERATOR_DELETE_P (fndecl);
2835   return false;
2836 }
2837
2838 /* Return true when STMT is builtins call.  */
2839
2840 bool
2841 gimple_call_builtin_p (const gimple *stmt)
2842 {
2843   tree fndecl;
2844   if (is_gimple_call (stmt)
2845       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2846       && DECL_BUILT_IN_CLASS (fndecl) != NOT_BUILT_IN)
2847     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2848   return false;
2849 }
2850
2851 /* Return true when STMT is builtins call to CLASS.  */
2852
2853 bool
2854 gimple_call_builtin_p (const gimple *stmt, enum built_in_class klass)
2855 {
2856   tree fndecl;
2857   if (is_gimple_call (stmt)
2858       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2859       && DECL_BUILT_IN_CLASS (fndecl) == klass)
2860     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2861   return false;
2862 }
2863
2864 /* Return true when STMT is builtins call to CODE of CLASS.  */
2865
2866 bool
2867 gimple_call_builtin_p (const gimple *stmt, enum built_in_function code)
2868 {
2869   tree fndecl;
2870   if (is_gimple_call (stmt)
2871       && (fndecl = gimple_call_fndecl (stmt)) != NULL_TREE
2872       && fndecl_built_in_p (fndecl, code))
2873     return gimple_builtin_call_types_compatible_p (stmt, fndecl);
2874   return false;
2875 }
2876
2877 /* If CALL is a call to a combined_fn (i.e. an internal function or
2878    a normal built-in function), return its code, otherwise return
2879    CFN_LAST.  */
2880
2881 combined_fn
2882 gimple_call_combined_fn (const gimple *stmt)
2883 {
2884   if (const gcall *call = dyn_cast <const gcall *> (stmt))
2885     {
2886       if (gimple_call_internal_p (call))
2887         return as_combined_fn (gimple_call_internal_fn (call));
2888
2889       tree fndecl = gimple_call_fndecl (stmt);
2890       if (fndecl
2891           && fndecl_built_in_p (fndecl, BUILT_IN_NORMAL)
2892           && gimple_builtin_call_types_compatible_p (stmt, fndecl))
2893         return as_combined_fn (DECL_FUNCTION_CODE (fndecl));
2894     }
2895   return CFN_LAST;
2896 }
2897
2898 /* Return true if STMT clobbers memory.  STMT is required to be a
2899    GIMPLE_ASM.  */
2900
2901 bool
2902 gimple_asm_clobbers_memory_p (const gasm *stmt)
2903 {
2904   unsigned i;
2905
2906   for (i = 0; i < gimple_asm_nclobbers (stmt); i++)
2907     {
2908       tree op = gimple_asm_clobber_op (stmt, i);
2909       if (strcmp (TREE_STRING_POINTER (TREE_VALUE (op)), "memory") == 0)
2910         return true;
2911     }
2912
2913   /* Non-empty basic ASM implicitly clobbers memory.  */
2914   if (gimple_asm_input_p (stmt) && strlen (gimple_asm_string (stmt)) != 0)
2915     return true;
2916
2917   return false;
2918 }
2919
2920 /* Dump bitmap SET (assumed to contain VAR_DECLs) to FILE.  */
2921
2922 void
2923 dump_decl_set (FILE *file, bitmap set)
2924 {
2925   if (set)
2926     {
2927       bitmap_iterator bi;
2928       unsigned i;
2929
2930       fprintf (file, "{ ");
2931
2932       EXECUTE_IF_SET_IN_BITMAP (set, 0, i, bi)
2933         {
2934           fprintf (file, "D.%u", i);
2935           fprintf (file, " ");
2936         }
2937
2938       fprintf (file, "}");
2939     }
2940   else
2941     fprintf (file, "NIL");
2942 }
2943
2944 /* Return true when CALL is a call stmt that definitely doesn't
2945    free any memory or makes it unavailable otherwise.  */
2946 bool
2947 nonfreeing_call_p (gimple *call)
2948 {
2949   if (gimple_call_builtin_p (call, BUILT_IN_NORMAL)
2950       && gimple_call_flags (call) & ECF_LEAF)
2951     switch (DECL_FUNCTION_CODE (gimple_call_fndecl (call)))
2952       {
2953         /* Just in case these become ECF_LEAF in the future.  */
2954         case BUILT_IN_FREE:
2955         case BUILT_IN_TM_FREE:
2956         case BUILT_IN_REALLOC:
2957         case BUILT_IN_STACK_RESTORE:
2958           return false;
2959         default:
2960           return true;
2961       }
2962   else if (gimple_call_internal_p (call))
2963     switch (gimple_call_internal_fn (call))
2964       {
2965       case IFN_ABNORMAL_DISPATCHER:
2966         return true;
2967       case IFN_ASAN_MARK:
2968         return tree_to_uhwi (gimple_call_arg (call, 0)) == ASAN_MARK_UNPOISON;
2969       default:
2970         if (gimple_call_flags (call) & ECF_LEAF)
2971           return true;
2972         return false;
2973       }
2974
2975   tree fndecl = gimple_call_fndecl (call);
2976   if (!fndecl)
2977     return false;
2978   struct cgraph_node *n = cgraph_node::get (fndecl);
2979   if (!n)
2980     return false;
2981   enum availability availability;
2982   n = n->function_symbol (&availability);
2983   if (!n || availability <= AVAIL_INTERPOSABLE)
2984     return false;
2985   return n->nonfreeing_fn;
2986 }
2987
2988 /* Return true when CALL is a call stmt that definitely need not
2989    be considered to be a memory barrier.  */
2990 bool
2991 nonbarrier_call_p (gimple *call)
2992 {
2993   if (gimple_call_flags (call) & (ECF_PURE | ECF_CONST))
2994     return true;
2995   /* Should extend this to have a nonbarrier_fn flag, just as above in
2996      the nonfreeing case.  */
2997   return false;
2998 }
2999
3000 /* Callback for walk_stmt_load_store_ops.
3001
3002    Return TRUE if OP will dereference the tree stored in DATA, FALSE
3003    otherwise.
3004
3005    This routine only makes a superficial check for a dereference.  Thus
3006    it must only be used if it is safe to return a false negative.  */
3007 static bool
3008 check_loadstore (gimple *, tree op, tree, void *data)
3009 {
3010   if (TREE_CODE (op) == MEM_REF || TREE_CODE (op) == TARGET_MEM_REF)
3011     {
3012       /* Some address spaces may legitimately dereference zero.  */
3013       addr_space_t as = TYPE_ADDR_SPACE (TREE_TYPE (op));
3014       if (targetm.addr_space.zero_address_valid (as))
3015         return false;
3016
3017       return operand_equal_p (TREE_OPERAND (op, 0), (tree)data, 0);
3018     }
3019   return false;
3020 }
3021
3022
3023 /* Return true if OP can be inferred to be non-NULL after STMT executes,
3024    either by using a pointer dereference or attributes.  */
3025 bool
3026 infer_nonnull_range (gimple *stmt, tree op)
3027 {
3028   return (infer_nonnull_range_by_dereference (stmt, op)
3029           || infer_nonnull_range_by_attribute (stmt, op));
3030 }
3031
3032 /* Return true if OP can be inferred to be non-NULL after STMT
3033    executes by using a pointer dereference.  */
3034 bool
3035 infer_nonnull_range_by_dereference (gimple *stmt, tree op)
3036 {
3037   /* We can only assume that a pointer dereference will yield
3038      non-NULL if -fdelete-null-pointer-checks is enabled.  */
3039   if (!flag_delete_null_pointer_checks
3040       || !POINTER_TYPE_P (TREE_TYPE (op))
3041       || gimple_code (stmt) == GIMPLE_ASM
3042       || gimple_clobber_p (stmt))
3043     return false;
3044
3045   if (walk_stmt_load_store_ops (stmt, (void *)op,
3046                                 check_loadstore, check_loadstore))
3047     return true;
3048
3049   return false;
3050 }
3051
3052 /* Return true if OP can be inferred to be a non-NULL after STMT
3053    executes by using attributes.  */
3054 bool
3055 infer_nonnull_range_by_attribute (gimple *stmt, tree op)
3056 {
3057   /* We can only assume that a pointer dereference will yield
3058      non-NULL if -fdelete-null-pointer-checks is enabled.  */
3059   if (!flag_delete_null_pointer_checks
3060       || !POINTER_TYPE_P (TREE_TYPE (op))
3061       || gimple_code (stmt) == GIMPLE_ASM)
3062     return false;
3063
3064   if (is_gimple_call (stmt) && !gimple_call_internal_p (stmt))
3065     {
3066       tree fntype = gimple_call_fntype (stmt);
3067       tree attrs = TYPE_ATTRIBUTES (fntype);
3068       for (; attrs; attrs = TREE_CHAIN (attrs))
3069         {
3070           attrs = lookup_attribute ("nonnull", attrs);
3071
3072           /* If "nonnull" wasn't specified, we know nothing about
3073              the argument.  */
3074           if (attrs == NULL_TREE)
3075             return false;
3076
3077           /* If "nonnull" applies to all the arguments, then ARG
3078              is non-null if it's in the argument list.  */
3079           if (TREE_VALUE (attrs) == NULL_TREE)
3080             {
3081               for (unsigned int i = 0; i < gimple_call_num_args (stmt); i++)
3082                 {
3083                   if (POINTER_TYPE_P (TREE_TYPE (gimple_call_arg (stmt, i)))
3084                       && operand_equal_p (op, gimple_call_arg (stmt, i), 0))
3085                     return true;
3086                 }
3087               return false;
3088             }
3089
3090           /* Now see if op appears in the nonnull list.  */
3091           for (tree t = TREE_VALUE (attrs); t; t = TREE_CHAIN (t))
3092             {
3093               unsigned int idx = TREE_INT_CST_LOW (TREE_VALUE (t)) - 1;
3094               if (idx < gimple_call_num_args (stmt))
3095                 {
3096                   tree arg = gimple_call_arg (stmt, idx);
3097                   if (operand_equal_p (op, arg, 0))
3098                     return true;
3099                 }
3100             }
3101         }
3102     }
3103
3104   /* If this function is marked as returning non-null, then we can
3105      infer OP is non-null if it is used in the return statement.  */
3106   if (greturn *return_stmt = dyn_cast <greturn *> (stmt))
3107     if (gimple_return_retval (return_stmt)
3108         && operand_equal_p (gimple_return_retval (return_stmt), op, 0)
3109         && lookup_attribute ("returns_nonnull",
3110                              TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl))))
3111       return true;
3112
3113   return false;
3114 }
3115
3116 /* Compare two case labels.  Because the front end should already have
3117    made sure that case ranges do not overlap, it is enough to only compare
3118    the CASE_LOW values of each case label.  */
3119
3120 static int
3121 compare_case_labels (const void *p1, const void *p2)
3122 {
3123   const_tree const case1 = *(const_tree const*)p1;
3124   const_tree const case2 = *(const_tree const*)p2;
3125
3126   /* The 'default' case label always goes first.  */
3127   if (!CASE_LOW (case1))
3128     return -1;
3129   else if (!CASE_LOW (case2))
3130     return 1;
3131   else
3132     return tree_int_cst_compare (CASE_LOW (case1), CASE_LOW (case2));
3133 }
3134
3135 /* Sort the case labels in LABEL_VEC in place in ascending order.  */
3136
3137 void
3138 sort_case_labels (vec<tree> &label_vec)
3139 {
3140   label_vec.qsort (compare_case_labels);
3141 }
3142 \f
3143 /* Prepare a vector of case labels to be used in a GIMPLE_SWITCH statement.
3144
3145    LABELS is a vector that contains all case labels to look at.
3146
3147    INDEX_TYPE is the type of the switch index expression.  Case labels
3148    in LABELS are discarded if their values are not in the value range
3149    covered by INDEX_TYPE.  The remaining case label values are folded
3150    to INDEX_TYPE.
3151
3152    If a default case exists in LABELS, it is removed from LABELS and
3153    returned in DEFAULT_CASEP.  If no default case exists, but the
3154    case labels already cover the whole range of INDEX_TYPE, a default
3155    case is returned pointing to one of the existing case labels.
3156    Otherwise DEFAULT_CASEP is set to NULL_TREE.
3157
3158    DEFAULT_CASEP may be NULL, in which case the above comment doesn't
3159    apply and no action is taken regardless of whether a default case is
3160    found or not.  */
3161
3162 void
3163 preprocess_case_label_vec_for_gimple (vec<tree> &labels,
3164                                       tree index_type,
3165                                       tree *default_casep)
3166 {
3167   tree min_value, max_value;
3168   tree default_case = NULL_TREE;
3169   size_t i, len;
3170
3171   i = 0;
3172   min_value = TYPE_MIN_VALUE (index_type);
3173   max_value = TYPE_MAX_VALUE (index_type);
3174   while (i < labels.length ())
3175     {
3176       tree elt = labels[i];
3177       tree low = CASE_LOW (elt);
3178       tree high = CASE_HIGH (elt);
3179       bool remove_element = FALSE;
3180
3181       if (low)
3182         {
3183           gcc_checking_assert (TREE_CODE (low) == INTEGER_CST);
3184           gcc_checking_assert (!high || TREE_CODE (high) == INTEGER_CST);
3185
3186           /* This is a non-default case label, i.e. it has a value.
3187
3188              See if the case label is reachable within the range of
3189              the index type.  Remove out-of-range case values.  Turn
3190              case ranges into a canonical form (high > low strictly)
3191              and convert the case label values to the index type.
3192
3193              NB: The type of gimple_switch_index() may be the promoted
3194              type, but the case labels retain the original type.  */
3195
3196           if (high)
3197             {
3198               /* This is a case range.  Discard empty ranges.
3199                  If the bounds or the range are equal, turn this
3200                  into a simple (one-value) case.  */
3201               int cmp = tree_int_cst_compare (high, low);
3202               if (cmp < 0)
3203                 remove_element = TRUE;
3204               else if (cmp == 0)
3205                 high = NULL_TREE;
3206             }
3207
3208           if (! high)
3209             {
3210               /* If the simple case value is unreachable, ignore it.  */
3211               if ((TREE_CODE (min_value) == INTEGER_CST
3212                    && tree_int_cst_compare (low, min_value) < 0)
3213                   || (TREE_CODE (max_value) == INTEGER_CST
3214                       && tree_int_cst_compare (low, max_value) > 0))
3215                 remove_element = TRUE;
3216               else
3217                 low = fold_convert (index_type, low);
3218             }
3219           else
3220             {
3221               /* If the entire case range is unreachable, ignore it.  */
3222               if ((TREE_CODE (min_value) == INTEGER_CST
3223                    && tree_int_cst_compare (high, min_value) < 0)
3224                   || (TREE_CODE (max_value) == INTEGER_CST
3225                       && tree_int_cst_compare (low, max_value) > 0))
3226                 remove_element = TRUE;
3227               else
3228                 {
3229                   /* If the lower bound is less than the index type's
3230                      minimum value, truncate the range bounds.  */
3231                   if (TREE_CODE (min_value) == INTEGER_CST
3232                       && tree_int_cst_compare (low, min_value) < 0)
3233                     low = min_value;
3234                   low = fold_convert (index_type, low);
3235
3236                   /* If the upper bound is greater than the index type's
3237                      maximum value, truncate the range bounds.  */
3238                   if (TREE_CODE (max_value) == INTEGER_CST
3239                       && tree_int_cst_compare (high, max_value) > 0)
3240                     high = max_value;
3241                   high = fold_convert (index_type, high);
3242
3243                   /* We may have folded a case range to a one-value case.  */
3244                   if (tree_int_cst_equal (low, high))
3245                     high = NULL_TREE;
3246                 }
3247             }
3248
3249           CASE_LOW (elt) = low;
3250           CASE_HIGH (elt) = high;
3251         }
3252       else
3253         {
3254           gcc_assert (!default_case);
3255           default_case = elt;
3256           /* The default case must be passed separately to the
3257              gimple_build_switch routine.  But if DEFAULT_CASEP
3258              is NULL, we do not remove the default case (it would
3259              be completely lost).  */
3260           if (default_casep)
3261             remove_element = TRUE;
3262         }
3263
3264       if (remove_element)
3265         labels.ordered_remove (i);
3266       else
3267         i++;
3268     }
3269   len = i;
3270
3271   if (!labels.is_empty ())
3272     sort_case_labels (labels);
3273
3274   if (default_casep && !default_case)
3275     {
3276       /* If the switch has no default label, add one, so that we jump
3277          around the switch body.  If the labels already cover the whole
3278          range of the switch index_type, add the default label pointing
3279          to one of the existing labels.  */
3280       if (len
3281           && TYPE_MIN_VALUE (index_type)
3282           && TYPE_MAX_VALUE (index_type)
3283           && tree_int_cst_equal (CASE_LOW (labels[0]),
3284                                  TYPE_MIN_VALUE (index_type)))
3285         {
3286           tree low, high = CASE_HIGH (labels[len - 1]);
3287           if (!high)
3288             high = CASE_LOW (labels[len - 1]);
3289           if (tree_int_cst_equal (high, TYPE_MAX_VALUE (index_type)))
3290             {
3291               tree widest_label = labels[0];
3292               for (i = 1; i < len; i++)
3293                 {
3294                   high = CASE_LOW (labels[i]);
3295                   low = CASE_HIGH (labels[i - 1]);
3296                   if (!low)
3297                     low = CASE_LOW (labels[i - 1]);
3298
3299                   if (CASE_HIGH (labels[i]) != NULL_TREE
3300                       && (CASE_HIGH (widest_label) == NULL_TREE
3301                           || (wi::gtu_p
3302                               (wi::to_wide (CASE_HIGH (labels[i]))
3303                                - wi::to_wide (CASE_LOW (labels[i])),
3304                                wi::to_wide (CASE_HIGH (widest_label))
3305                                - wi::to_wide (CASE_LOW (widest_label))))))
3306                     widest_label = labels[i];
3307
3308                   if (wi::to_wide (low) + 1 != wi::to_wide (high))
3309                     break;
3310                 }
3311               if (i == len)
3312                 {
3313                   /* Designate the label with the widest range to be the
3314                      default label.  */
3315                   tree label = CASE_LABEL (widest_label);
3316                   default_case = build_case_label (NULL_TREE, NULL_TREE,
3317                                                    label);
3318                 }
3319             }
3320         }
3321     }
3322
3323   if (default_casep)
3324     *default_casep = default_case;
3325 }
3326
3327 /* Set the location of all statements in SEQ to LOC.  */
3328
3329 void
3330 gimple_seq_set_location (gimple_seq seq, location_t loc)
3331 {
3332   for (gimple_stmt_iterator i = gsi_start (seq); !gsi_end_p (i); gsi_next (&i))
3333     gimple_set_location (gsi_stmt (i), loc);
3334 }
3335
3336 /* Release SSA_NAMEs in SEQ as well as the GIMPLE statements.  */
3337
3338 void
3339 gimple_seq_discard (gimple_seq seq)
3340 {
3341   gimple_stmt_iterator gsi;
3342
3343   for (gsi = gsi_start (seq); !gsi_end_p (gsi); )
3344     {
3345       gimple *stmt = gsi_stmt (gsi);
3346       gsi_remove (&gsi, true);
3347       release_defs (stmt);
3348       ggc_free (stmt);
3349     }
3350 }
3351
3352 /* See if STMT now calls function that takes no parameters and if so, drop
3353    call arguments.  This is used when devirtualization machinery redirects
3354    to __builtin_unreachable or __cxa_pure_virtual.  */
3355
3356 void
3357 maybe_remove_unused_call_args (struct function *fn, gimple *stmt)
3358 {
3359   tree decl = gimple_call_fndecl (stmt);
3360   if (TYPE_ARG_TYPES (TREE_TYPE (decl))
3361       && TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (decl))) == void_type_node
3362       && gimple_call_num_args (stmt))
3363     {
3364       gimple_set_num_ops (stmt, 3);
3365       update_stmt_fn (fn, stmt);
3366     }
3367 }
3368
3369 /* Return false if STMT will likely expand to real function call.  */
3370
3371 bool
3372 gimple_inexpensive_call_p (gcall *stmt)
3373 {
3374   if (gimple_call_internal_p (stmt))
3375     return true;
3376   tree decl = gimple_call_fndecl (stmt);
3377   if (decl && is_inexpensive_builtin (decl))
3378     return true;
3379   return false;
3380 }
3381
3382 /* Return a non-artificial location for STMT.  If STMT does not have
3383    location information, get the location from EXPR.  */
3384
3385 location_t
3386 gimple_or_expr_nonartificial_location (gimple *stmt, tree expr)
3387 {
3388   location_t loc = gimple_nonartificial_location (stmt);
3389   if (loc == UNKNOWN_LOCATION && EXPR_HAS_LOCATION (expr))
3390     loc = tree_nonartificial_location (expr);
3391   return expansion_point_location_if_in_system_header (loc);
3392 }
3393
3394
3395 #if CHECKING_P
3396
3397 namespace selftest {
3398
3399 /* Selftests for core gimple structures.  */
3400
3401 /* Verify that STMT is pretty-printed as EXPECTED.
3402    Helper function for selftests.  */
3403
3404 static void
3405 verify_gimple_pp (const char *expected, gimple *stmt)
3406 {
3407   pretty_printer pp;
3408   pp_gimple_stmt_1 (&pp, stmt, 0 /* spc */, TDF_NONE /* flags */);
3409   ASSERT_STREQ (expected, pp_formatted_text (&pp));
3410 }
3411
3412 /* Build a GIMPLE_ASSIGN equivalent to
3413      tmp = 5;
3414    and verify various properties of it.  */
3415
3416 static void
3417 test_assign_single ()
3418 {
3419   tree type = integer_type_node;
3420   tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3421                          get_identifier ("tmp"),
3422                          type);
3423   tree rhs = build_int_cst (type, 5);
3424   gassign *stmt = gimple_build_assign (lhs, rhs);
3425   verify_gimple_pp ("tmp = 5;", stmt);
3426
3427   ASSERT_TRUE (is_gimple_assign (stmt));
3428   ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3429   ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3430   ASSERT_EQ (rhs, gimple_assign_rhs1 (stmt));
3431   ASSERT_EQ (NULL, gimple_assign_rhs2 (stmt));
3432   ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3433   ASSERT_TRUE (gimple_assign_single_p (stmt));
3434   ASSERT_EQ (INTEGER_CST, gimple_assign_rhs_code (stmt));
3435 }
3436
3437 /* Build a GIMPLE_ASSIGN equivalent to
3438      tmp = a * b;
3439    and verify various properties of it.  */
3440
3441 static void
3442 test_assign_binop ()
3443 {
3444   tree type = integer_type_node;
3445   tree lhs = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3446                          get_identifier ("tmp"),
3447                          type);
3448   tree a = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3449                        get_identifier ("a"),
3450                        type);
3451   tree b = build_decl (UNKNOWN_LOCATION, VAR_DECL,
3452                        get_identifier ("b"),
3453                        type);
3454   gassign *stmt = gimple_build_assign (lhs, MULT_EXPR, a, b);
3455   verify_gimple_pp ("tmp = a * b;", stmt);
3456
3457   ASSERT_TRUE (is_gimple_assign (stmt));
3458   ASSERT_EQ (lhs, gimple_assign_lhs (stmt));
3459   ASSERT_EQ (lhs, gimple_get_lhs (stmt));
3460   ASSERT_EQ (a, gimple_assign_rhs1 (stmt));
3461   ASSERT_EQ (b, gimple_assign_rhs2 (stmt));
3462   ASSERT_EQ (NULL, gimple_assign_rhs3 (stmt));
3463   ASSERT_FALSE (gimple_assign_single_p (stmt));
3464   ASSERT_EQ (MULT_EXPR, gimple_assign_rhs_code (stmt));
3465 }
3466
3467 /* Build a GIMPLE_NOP and verify various properties of it.  */
3468
3469 static void
3470 test_nop_stmt ()
3471 {
3472   gimple *stmt = gimple_build_nop ();
3473   verify_gimple_pp ("GIMPLE_NOP", stmt);
3474   ASSERT_EQ (GIMPLE_NOP, gimple_code (stmt));
3475   ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3476   ASSERT_FALSE (gimple_assign_single_p (stmt));
3477 }
3478
3479 /* Build a GIMPLE_RETURN equivalent to
3480      return 7;
3481    and verify various properties of it.  */
3482
3483 static void
3484 test_return_stmt ()
3485 {
3486   tree type = integer_type_node;
3487   tree val = build_int_cst (type, 7);
3488   greturn *stmt = gimple_build_return (val);
3489   verify_gimple_pp ("return 7;", stmt);
3490
3491   ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3492   ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3493   ASSERT_EQ (val, gimple_return_retval (stmt));
3494   ASSERT_FALSE (gimple_assign_single_p (stmt));
3495 }
3496
3497 /* Build a GIMPLE_RETURN equivalent to
3498      return;
3499    and verify various properties of it.  */
3500
3501 static void
3502 test_return_without_value ()
3503 {
3504   greturn *stmt = gimple_build_return (NULL);
3505   verify_gimple_pp ("return;", stmt);
3506
3507   ASSERT_EQ (GIMPLE_RETURN, gimple_code (stmt));
3508   ASSERT_EQ (NULL, gimple_get_lhs (stmt));
3509   ASSERT_EQ (NULL, gimple_return_retval (stmt));
3510   ASSERT_FALSE (gimple_assign_single_p (stmt));
3511 }
3512
3513 /* Run all of the selftests within this file.  */
3514
3515 void
3516 gimple_cc_tests ()
3517 {
3518   test_assign_single ();
3519   test_assign_binop ();
3520   test_nop_stmt ();
3521   test_return_stmt ();
3522   test_return_without_value ();
3523 }
3524
3525 } // namespace selftest
3526
3527
3528 #endif /* CHECKING_P */