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