gcc/gimple.cc

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