contrib/gcc-8.0/gcc/gimple-expr.c

   1 /* Gimple decl, type, and expression support functions.
   2
   3    Copyright (C) 2007-2018 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 "stringpool.h"
  29 #include "gimple-ssa.h"
  30 #include "fold-const.h"
  31 #include "tree-eh.h"
  32 #include "gimplify.h"
  33 #include "stor-layout.h"
  34 #include "demangle.h"
  35 #include "hash-set.h"
  36 #include "rtl.h"
  37 #include "tree-pass.h"
  38 #include "stringpool.h"
  39 #include "attribs.h"
  40
  41 /* ----- Type related -----  */
  42
  43 /* Return true if the conversion from INNER_TYPE to OUTER_TYPE is a
  44    useless type conversion, otherwise return false.
  45
  46    This function implicitly defines the middle-end type system.  With
  47    the notion of 'a < b' meaning that useless_type_conversion_p (a, b)
  48    holds and 'a > b' meaning that useless_type_conversion_p (b, a) holds,
  49    the following invariants shall be fulfilled:
  50
  51      1) useless_type_conversion_p is transitive.
  52         If a < b and b < c then a < c.
  53
  54      2) useless_type_conversion_p is not symmetric.
  55         From a < b does not follow a > b.
  56
  57      3) Types define the available set of operations applicable to values.
  58         A type conversion is useless if the operations for the target type
  59         is a subset of the operations for the source type.  For example
  60         casts to void* are useless, casts from void* are not (void* can't
  61         be dereferenced or offsetted, but copied, hence its set of operations
  62         is a strict subset of that of all other data pointer types).  Casts
  63         to const T* are useless (can't be written to), casts from const T*
  64         to T* are not.  */
  65
  66 bool
  67 useless_type_conversion_p (tree outer_type, tree inner_type)
  68 {
  69   /* Do the following before stripping toplevel qualifiers.  */
  70   if (POINTER_TYPE_P (inner_type)
  71       && POINTER_TYPE_P (outer_type))
  72     {
  73       /* Do not lose casts between pointers to different address spaces.  */
  74       if (TYPE_ADDR_SPACE (TREE_TYPE (outer_type))
  75           != TYPE_ADDR_SPACE (TREE_TYPE (inner_type)))
  76         return false;
  77       /* Do not lose casts to function pointer types.  */
  78       if ((TREE_CODE (TREE_TYPE (outer_type)) == FUNCTION_TYPE
  79            || TREE_CODE (TREE_TYPE (outer_type)) == METHOD_TYPE)
  80           && !(TREE_CODE (TREE_TYPE (inner_type)) == FUNCTION_TYPE
  81                || TREE_CODE (TREE_TYPE (inner_type)) == METHOD_TYPE))
  82         return false;
  83     }
  84
  85   /* From now on qualifiers on value types do not matter.  */
  86   inner_type = TYPE_MAIN_VARIANT (inner_type);
  87   outer_type = TYPE_MAIN_VARIANT (outer_type);
  88
  89   if (inner_type == outer_type)
  90     return true;
  91
  92   /* Changes in machine mode are never useless conversions because the RTL
  93      middle-end expects explicit conversions between modes.  */
  94   if (TYPE_MODE (inner_type) != TYPE_MODE (outer_type))
  95     return false;
  96
  97   /* If both the inner and outer types are integral types, then the
  98      conversion is not necessary if they have the same mode and
  99      signedness and precision, and both or neither are boolean.  */
 100   if (INTEGRAL_TYPE_P (inner_type)
 101       && INTEGRAL_TYPE_P (outer_type))
 102     {
 103       /* Preserve changes in signedness or precision.  */
 104       if (TYPE_UNSIGNED (inner_type) != TYPE_UNSIGNED (outer_type)
 105           || TYPE_PRECISION (inner_type) != TYPE_PRECISION (outer_type))
 106         return false;
 107
 108       /* Preserve conversions to/from BOOLEAN_TYPE if types are not
 109          of precision one.  */
 110       if (((TREE_CODE (inner_type) == BOOLEAN_TYPE)
 111            != (TREE_CODE (outer_type) == BOOLEAN_TYPE))
 112           && TYPE_PRECISION (outer_type) != 1)
 113         return false;
 114
 115       /* We don't need to preserve changes in the types minimum or
 116          maximum value in general as these do not generate code
 117          unless the types precisions are different.  */
 118       return true;
 119     }
 120
 121   /* Scalar floating point types with the same mode are compatible.  */
 122   else if (SCALAR_FLOAT_TYPE_P (inner_type)
 123            && SCALAR_FLOAT_TYPE_P (outer_type))
 124     return true;
 125
 126   /* Fixed point types with the same mode are compatible.  */
 127   else if (FIXED_POINT_TYPE_P (inner_type)
 128            && FIXED_POINT_TYPE_P (outer_type))
 129     return TYPE_SATURATING (inner_type) == TYPE_SATURATING (outer_type);
 130
 131   /* We need to take special care recursing to pointed-to types.  */
 132   else if (POINTER_TYPE_P (inner_type)
 133            && POINTER_TYPE_P (outer_type))
 134     {
 135       /* We do not care for const qualification of the pointed-to types
 136          as const qualification has no semantic value to the middle-end.  */
 137
 138       /* Otherwise pointers/references are equivalent.  */
 139       return true;
 140     }
 141
 142   /* Recurse for complex types.  */
 143   else if (TREE_CODE (inner_type) == COMPLEX_TYPE
 144            && TREE_CODE (outer_type) == COMPLEX_TYPE)
 145     return useless_type_conversion_p (TREE_TYPE (outer_type),
 146                                       TREE_TYPE (inner_type));
 147
 148   /* Recurse for vector types with the same number of subparts.  */
 149   else if (TREE_CODE (inner_type) == VECTOR_TYPE
 150            && TREE_CODE (outer_type) == VECTOR_TYPE
 151            && TYPE_PRECISION (inner_type) == TYPE_PRECISION (outer_type))
 152     return useless_type_conversion_p (TREE_TYPE (outer_type),
 153                                       TREE_TYPE (inner_type));
 154
 155   else if (TREE_CODE (inner_type) == ARRAY_TYPE
 156            && TREE_CODE (outer_type) == ARRAY_TYPE)
 157     {
 158       /* Preserve various attributes.  */
 159       if (TYPE_REVERSE_STORAGE_ORDER (inner_type)
 160           != TYPE_REVERSE_STORAGE_ORDER (outer_type))
 161         return false;
 162       if (TYPE_STRING_FLAG (inner_type) != TYPE_STRING_FLAG (outer_type))
 163         return false;
 164
 165       /* Conversions from array types with unknown extent to
 166          array types with known extent are not useless.  */
 167       if (!TYPE_DOMAIN (inner_type) && TYPE_DOMAIN (outer_type))
 168         return false;
 169
 170       /* Nor are conversions from array types with non-constant size to
 171          array types with constant size or to different size.  */
 172       if (TYPE_SIZE (outer_type)
 173           && TREE_CODE (TYPE_SIZE (outer_type)) == INTEGER_CST
 174           && (!TYPE_SIZE (inner_type)
 175               || TREE_CODE (TYPE_SIZE (inner_type)) != INTEGER_CST
 176               || !tree_int_cst_equal (TYPE_SIZE (outer_type),
 177                                       TYPE_SIZE (inner_type))))
 178         return false;
 179
 180       /* Check conversions between arrays with partially known extents.
 181          If the array min/max values are constant they have to match.
 182          Otherwise allow conversions to unknown and variable extents.
 183          In particular this declares conversions that may change the
 184          mode to BLKmode as useless.  */
 185       if (TYPE_DOMAIN (inner_type)
 186           && TYPE_DOMAIN (outer_type)
 187           && TYPE_DOMAIN (inner_type) != TYPE_DOMAIN (outer_type))
 188         {
 189           tree inner_min = TYPE_MIN_VALUE (TYPE_DOMAIN (inner_type));
 190           tree outer_min = TYPE_MIN_VALUE (TYPE_DOMAIN (outer_type));
 191           tree inner_max = TYPE_MAX_VALUE (TYPE_DOMAIN (inner_type));
 192           tree outer_max = TYPE_MAX_VALUE (TYPE_DOMAIN (outer_type));
 193
 194           /* After gimplification a variable min/max value carries no
 195              additional information compared to a NULL value.  All that
 196              matters has been lowered to be part of the IL.  */
 197           if (inner_min && TREE_CODE (inner_min) != INTEGER_CST)
 198             inner_min = NULL_TREE;
 199           if (outer_min && TREE_CODE (outer_min) != INTEGER_CST)
 200             outer_min = NULL_TREE;
 201           if (inner_max && TREE_CODE (inner_max) != INTEGER_CST)
 202             inner_max = NULL_TREE;
 203           if (outer_max && TREE_CODE (outer_max) != INTEGER_CST)
 204             outer_max = NULL_TREE;
 205
 206           /* Conversions NULL / variable <- cst are useless, but not
 207              the other way around.  */
 208           if (outer_min
 209               && (!inner_min
 210                   || !tree_int_cst_equal (inner_min, outer_min)))
 211             return false;
 212           if (outer_max
 213               && (!inner_max
 214                   || !tree_int_cst_equal (inner_max, outer_max)))
 215             return false;
 216         }
 217
 218       /* Recurse on the element check.  */
 219       return useless_type_conversion_p (TREE_TYPE (outer_type),
 220                                         TREE_TYPE (inner_type));
 221     }
 222
 223   else if ((TREE_CODE (inner_type) == FUNCTION_TYPE
 224             || TREE_CODE (inner_type) == METHOD_TYPE)
 225            && TREE_CODE (inner_type) == TREE_CODE (outer_type))
 226     {
 227       tree outer_parm, inner_parm;
 228
 229       /* If the return types are not compatible bail out.  */
 230       if (!useless_type_conversion_p (TREE_TYPE (outer_type),
 231                                       TREE_TYPE (inner_type)))
 232         return false;
 233
 234       /* Method types should belong to a compatible base class.  */
 235       if (TREE_CODE (inner_type) == METHOD_TYPE
 236           && !useless_type_conversion_p (TYPE_METHOD_BASETYPE (outer_type),
 237                                          TYPE_METHOD_BASETYPE (inner_type)))
 238         return false;
 239
 240       /* A conversion to an unprototyped argument list is ok.  */
 241       if (!prototype_p (outer_type))
 242         return true;
 243
 244       /* If the unqualified argument types are compatible the conversion
 245          is useless.  */
 246       if (TYPE_ARG_TYPES (outer_type) == TYPE_ARG_TYPES (inner_type))
 247         return true;
 248
 249       for (outer_parm = TYPE_ARG_TYPES (outer_type),
 250            inner_parm = TYPE_ARG_TYPES (inner_type);
 251            outer_parm && inner_parm;
 252            outer_parm = TREE_CHAIN (outer_parm),
 253            inner_parm = TREE_CHAIN (inner_parm))
 254         if (!useless_type_conversion_p
 255                (TYPE_MAIN_VARIANT (TREE_VALUE (outer_parm)),
 256                 TYPE_MAIN_VARIANT (TREE_VALUE (inner_parm))))
 257           return false;
 258
 259       /* If there is a mismatch in the number of arguments the functions
 260          are not compatible.  */
 261       if (outer_parm || inner_parm)
 262         return false;
 263
 264       /* Defer to the target if necessary.  */
 265       if (TYPE_ATTRIBUTES (inner_type) || TYPE_ATTRIBUTES (outer_type))
 266         return comp_type_attributes (outer_type, inner_type) != 0;
 267
 268       return true;
 269     }
 270
 271   /* For aggregates we rely on TYPE_CANONICAL exclusively and require
 272      explicit conversions for types involving to be structurally
 273      compared types.  */
 274   else if (AGGREGATE_TYPE_P (inner_type)
 275            && TREE_CODE (inner_type) == TREE_CODE (outer_type))
 276     return TYPE_CANONICAL (inner_type)
 277            && TYPE_CANONICAL (inner_type) == TYPE_CANONICAL (outer_type);
 278
 279   else if (TREE_CODE (inner_type) == OFFSET_TYPE
 280            && TREE_CODE (outer_type) == OFFSET_TYPE)
 281     return useless_type_conversion_p (TREE_TYPE (outer_type),
 282                                       TREE_TYPE (inner_type))
 283            && useless_type_conversion_p
 284                 (TYPE_OFFSET_BASETYPE (outer_type),
 285                  TYPE_OFFSET_BASETYPE (inner_type));
 286
 287   return false;
 288 }
 289
 290
 291 /* ----- Decl related -----  */
 292
 293 /* Set sequence SEQ to be the GIMPLE body for function FN.  */
 294
 295 void
 296 gimple_set_body (tree fndecl, gimple_seq seq)
 297 {
 298   struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
 299   if (fn == NULL)
 300     {
 301       /* If FNDECL still does not have a function structure associated
 302          with it, then it does not make sense for it to receive a
 303          GIMPLE body.  */
 304       gcc_assert (seq == NULL);
 305     }
 306   else
 307     fn->gimple_body = seq;
 308 }
 309
 310
 311 /* Return the body of GIMPLE statements for function FN.  After the
 312    CFG pass, the function body doesn't exist anymore because it has
 313    been split up into basic blocks.  In this case, it returns
 314    NULL.  */
 315
 316 gimple_seq
 317 gimple_body (tree fndecl)
 318 {
 319   struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
 320   return fn ? fn->gimple_body : NULL;
 321 }
 322
 323 /* Return true when FNDECL has Gimple body either in unlowered
 324    or CFG form.  */
 325 bool
 326 gimple_has_body_p (tree fndecl)
 327 {
 328   struct function *fn = DECL_STRUCT_FUNCTION (fndecl);
 329   return (gimple_body (fndecl) || (fn && fn->cfg && !(fn->curr_properties & PROP_rtl)));
 330 }
 331
 332 /* Return a printable name for symbol DECL.  */
 333
 334 const char *
 335 gimple_decl_printable_name (tree decl, int verbosity)
 336 {
 337   if (!DECL_NAME (decl))
 338     return NULL;
 339
 340   if (HAS_DECL_ASSEMBLER_NAME_P (decl) && DECL_ASSEMBLER_NAME_SET_P (decl))
 341     {
 342       int dmgl_opts = DMGL_NO_OPTS;
 343
 344       if (verbosity >= 2)
 345         {
 346           dmgl_opts = DMGL_VERBOSE
 347                       | DMGL_ANSI
 348                       | DMGL_GNU_V3
 349                       | DMGL_RET_POSTFIX;
 350           if (TREE_CODE (decl) == FUNCTION_DECL)
 351             dmgl_opts |= DMGL_PARAMS;
 352         }
 353
 354       const char *mangled_str
 355         = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME_RAW (decl));
 356       const char *str = cplus_demangle_v3 (mangled_str, dmgl_opts);
 357       return str ? str : mangled_str;
 358     }
 359
 360   return IDENTIFIER_POINTER (DECL_NAME (decl));
 361 }
 362
 363
 364 /* Create a new VAR_DECL and copy information from VAR to it.  */
 365
 366 tree
 367 copy_var_decl (tree var, tree name, tree type)
 368 {
 369   tree copy = build_decl (DECL_SOURCE_LOCATION (var), VAR_DECL, name, type);
 370
 371   TREE_ADDRESSABLE (copy) = TREE_ADDRESSABLE (var);
 372   TREE_THIS_VOLATILE (copy) = TREE_THIS_VOLATILE (var);
 373   DECL_GIMPLE_REG_P (copy) = DECL_GIMPLE_REG_P (var);
 374   DECL_ARTIFICIAL (copy) = DECL_ARTIFICIAL (var);
 375   DECL_IGNORED_P (copy) = DECL_IGNORED_P (var);
 376   DECL_CONTEXT (copy) = DECL_CONTEXT (var);
 377   TREE_NO_WARNING (copy) = TREE_NO_WARNING (var);
 378   TREE_USED (copy) = 1;
 379   DECL_SEEN_IN_BIND_EXPR_P (copy) = 1;
 380   DECL_ATTRIBUTES (copy) = DECL_ATTRIBUTES (var);
 381   if (DECL_USER_ALIGN (var))
 382     {
 383       SET_DECL_ALIGN (copy, DECL_ALIGN (var));
 384       DECL_USER_ALIGN (copy) = 1;
 385     }
 386
 387   return copy;
 388 }
 389
 390 /* Strip off a legitimate source ending from the input string NAME of
 391    length LEN.  Rather than having to know the names used by all of
 392    our front ends, we strip off an ending of a period followed by
 393    up to four characters.  (like ".cpp".)  */
 394
 395 static inline void
 396 remove_suffix (char *name, int len)
 397 {
 398   int i;
 399
 400   for (i = 2;  i < 7 && len > i;  i++)
 401     {
 402       if (name[len - i] == '.')
 403         {
 404           name[len - i] = '\0';
 405           break;
 406         }
 407     }
 408 }
 409
 410 /* Create a new temporary name with PREFIX.  Return an identifier.  */
 411
 412 static GTY(()) unsigned int tmp_var_id_num;
 413
 414 tree
 415 create_tmp_var_name (const char *prefix)
 416 {
 417   char *tmp_name;
 418
 419   if (prefix)
 420     {
 421       char *preftmp = ASTRDUP (prefix);
 422
 423       remove_suffix (preftmp, strlen (preftmp));
 424       clean_symbol_name (preftmp);
 425
 426       prefix = preftmp;
 427     }
 428
 429   ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++);
 430   return get_identifier (tmp_name);
 431 }
 432
 433 /* Create a new temporary variable declaration of type TYPE.
 434    Do NOT push it into the current binding.  */
 435
 436 tree
 437 create_tmp_var_raw (tree type, const char *prefix)
 438 {
 439   tree tmp_var;
 440
 441   tmp_var = build_decl (input_location,
 442                         VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL,
 443                         type);
 444
 445   /* The variable was declared by the compiler.  */
 446   DECL_ARTIFICIAL (tmp_var) = 1;
 447   /* And we don't want debug info for it.  */
 448   DECL_IGNORED_P (tmp_var) = 1;
 449   /* And we don't want even the fancy names of those printed in
 450      -fdump-final-insns= dumps.  */
 451   DECL_NAMELESS (tmp_var) = 1;
 452
 453   /* Make the variable writable.  */
 454   TREE_READONLY (tmp_var) = 0;
 455
 456   DECL_EXTERNAL (tmp_var) = 0;
 457   TREE_STATIC (tmp_var) = 0;
 458   TREE_USED (tmp_var) = 1;
 459
 460   return tmp_var;
 461 }
 462
 463 /* Create a new temporary variable declaration of type TYPE.  DO push the
 464    variable into the current binding.  Further, assume that this is called
 465    only from gimplification or optimization, at which point the creation of
 466    certain types are bugs.  */
 467
 468 tree
 469 create_tmp_var (tree type, const char *prefix)
 470 {
 471   tree tmp_var;
 472
 473   /* We don't allow types that are addressable (meaning we can't make copies),
 474      or incomplete.  We also used to reject every variable size objects here,
 475      but now support those for which a constant upper bound can be obtained.
 476      The processing for variable sizes is performed in gimple_add_tmp_var,
 477      point at which it really matters and possibly reached via paths not going
 478      through this function, e.g. after direct calls to create_tmp_var_raw.  */
 479   gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type));
 480
 481   tmp_var = create_tmp_var_raw (type, prefix);
 482   gimple_add_tmp_var (tmp_var);
 483   return tmp_var;
 484 }
 485
 486 /* Create a new temporary variable declaration of type TYPE by calling
 487    create_tmp_var and if TYPE is a vector or a complex number, mark the new
 488    temporary as gimple register.  */
 489
 490 tree
 491 create_tmp_reg (tree type, const char *prefix)
 492 {
 493   tree tmp;
 494
 495   tmp = create_tmp_var (type, prefix);
 496   if (TREE_CODE (type) == COMPLEX_TYPE
 497       || TREE_CODE (type) == VECTOR_TYPE)
 498     DECL_GIMPLE_REG_P (tmp) = 1;
 499
 500   return tmp;
 501 }
 502
 503 /* Create a new temporary variable declaration of type TYPE by calling
 504    create_tmp_var and if TYPE is a vector or a complex number, mark the new
 505    temporary as gimple register.  */
 506
 507 tree
 508 create_tmp_reg_fn (struct function *fn, tree type, const char *prefix)
 509 {
 510   tree tmp;
 511
 512   tmp = create_tmp_var_raw (type, prefix);
 513   gimple_add_tmp_var_fn (fn, tmp);
 514   if (TREE_CODE (type) == COMPLEX_TYPE
 515       || TREE_CODE (type) == VECTOR_TYPE)
 516     DECL_GIMPLE_REG_P (tmp) = 1;
 517
 518   return tmp;
 519 }
 520
 521
 522 /* ----- Expression related -----  */
 523
 524 /* Extract the operands and code for expression EXPR into *SUBCODE_P,
 525    *OP1_P, *OP2_P and *OP3_P respectively.  */
 526
 527 void
 528 extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p,
 529                        tree *op2_p, tree *op3_p)
 530 {
 531   enum gimple_rhs_class grhs_class;
 532
 533   *subcode_p = TREE_CODE (expr);
 534   grhs_class = get_gimple_rhs_class (*subcode_p);
 535
 536   if (grhs_class == GIMPLE_TERNARY_RHS)
 537     {
 538       *op1_p = TREE_OPERAND (expr, 0);
 539       *op2_p = TREE_OPERAND (expr, 1);
 540       *op3_p = TREE_OPERAND (expr, 2);
 541     }
 542   else if (grhs_class == GIMPLE_BINARY_RHS)
 543     {
 544       *op1_p = TREE_OPERAND (expr, 0);
 545       *op2_p = TREE_OPERAND (expr, 1);
 546       *op3_p = NULL_TREE;
 547     }
 548   else if (grhs_class == GIMPLE_UNARY_RHS)
 549     {
 550       *op1_p = TREE_OPERAND (expr, 0);
 551       *op2_p = NULL_TREE;
 552       *op3_p = NULL_TREE;
 553     }
 554   else if (grhs_class == GIMPLE_SINGLE_RHS)
 555     {
 556       *op1_p = expr;
 557       *op2_p = NULL_TREE;
 558       *op3_p = NULL_TREE;
 559     }
 560   else
 561     gcc_unreachable ();
 562 }
 563
 564 /* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND.  */
 565
 566 void
 567 gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p,
 568                                tree *lhs_p, tree *rhs_p)
 569 {
 570   gcc_assert (COMPARISON_CLASS_P (cond)
 571               || TREE_CODE (cond) == TRUTH_NOT_EXPR
 572               || is_gimple_min_invariant (cond)
 573               || SSA_VAR_P (cond));
 574
 575   extract_ops_from_tree (cond, code_p, lhs_p, rhs_p);
 576
 577   /* Canonicalize conditionals of the form 'if (!VAL)'.  */
 578   if (*code_p == TRUTH_NOT_EXPR)
 579     {
 580       *code_p = EQ_EXPR;
 581       gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
 582       *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p));
 583     }
 584   /* Canonicalize conditionals of the form 'if (VAL)'  */
 585   else if (TREE_CODE_CLASS (*code_p) != tcc_comparison)
 586     {
 587       *code_p = NE_EXPR;
 588       gcc_assert (*lhs_p && *rhs_p == NULL_TREE);
 589       *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p));
 590     }
 591 }
 592
 593 /*  Return true if T is a valid LHS for a GIMPLE assignment expression.  */
 594
 595 bool
 596 is_gimple_lvalue (tree t)
 597 {
 598   return (is_gimple_addressable (t)
 599           || TREE_CODE (t) == WITH_SIZE_EXPR
 600           /* These are complex lvalues, but don't have addresses, so they
 601              go here.  */
 602           || TREE_CODE (t) == BIT_FIELD_REF);
 603 }
 604
 605 /*  Return true if T is a GIMPLE condition.  */
 606
 607 bool
 608 is_gimple_condexpr (tree t)
 609 {
 610   return (is_gimple_val (t) || (COMPARISON_CLASS_P (t)
 611                                 && !tree_could_throw_p (t)
 612                                 && is_gimple_val (TREE_OPERAND (t, 0))
 613                                 && is_gimple_val (TREE_OPERAND (t, 1))));
 614 }
 615
 616 /* Return true if T is a gimple address.  */
 617
 618 bool
 619 is_gimple_address (const_tree t)
 620 {
 621   tree op;
 622
 623   if (TREE_CODE (t) != ADDR_EXPR)
 624     return false;
 625
 626   op = TREE_OPERAND (t, 0);
 627   while (handled_component_p (op))
 628     {
 629       if ((TREE_CODE (op) == ARRAY_REF
 630            || TREE_CODE (op) == ARRAY_RANGE_REF)
 631           && !is_gimple_val (TREE_OPERAND (op, 1)))
 632             return false;
 633
 634       op = TREE_OPERAND (op, 0);
 635     }
 636
 637   if (CONSTANT_CLASS_P (op)
 638       || TREE_CODE (op) == TARGET_MEM_REF
 639       || TREE_CODE (op) == MEM_REF)
 640     return true;
 641
 642   switch (TREE_CODE (op))
 643     {
 644     case PARM_DECL:
 645     case RESULT_DECL:
 646     case LABEL_DECL:
 647     case FUNCTION_DECL:
 648     case VAR_DECL:
 649     case CONST_DECL:
 650       return true;
 651
 652     default:
 653       return false;
 654     }
 655 }
 656
 657 /* Return true if T is a gimple invariant address.  */
 658
 659 bool
 660 is_gimple_invariant_address (const_tree t)
 661 {
 662   const_tree op;
 663
 664   if (TREE_CODE (t) != ADDR_EXPR)
 665     return false;
 666
 667   op = strip_invariant_refs (TREE_OPERAND (t, 0));
 668   if (!op)
 669     return false;
 670
 671   if (TREE_CODE (op) == MEM_REF)
 672     {
 673       const_tree op0 = TREE_OPERAND (op, 0);
 674       return (TREE_CODE (op0) == ADDR_EXPR
 675               && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
 676                   || decl_address_invariant_p (TREE_OPERAND (op0, 0))));
 677     }
 678
 679   return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op);
 680 }
 681
 682 /* Return true if T is a gimple invariant address at IPA level
 683    (so addresses of variables on stack are not allowed).  */
 684
 685 bool
 686 is_gimple_ip_invariant_address (const_tree t)
 687 {
 688   const_tree op;
 689
 690   if (TREE_CODE (t) != ADDR_EXPR)
 691     return false;
 692
 693   op = strip_invariant_refs (TREE_OPERAND (t, 0));
 694   if (!op)
 695     return false;
 696
 697   if (TREE_CODE (op) == MEM_REF)
 698     {
 699       const_tree op0 = TREE_OPERAND (op, 0);
 700       return (TREE_CODE (op0) == ADDR_EXPR
 701               && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0))
 702                   || decl_address_ip_invariant_p (TREE_OPERAND (op0, 0))));
 703     }
 704
 705   return CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op);
 706 }
 707
 708 /* Return true if T is a GIMPLE minimal invariant.  It's a restricted
 709    form of function invariant.  */
 710
 711 bool
 712 is_gimple_min_invariant (const_tree t)
 713 {
 714   if (TREE_CODE (t) == ADDR_EXPR)
 715     return is_gimple_invariant_address (t);
 716
 717   return is_gimple_constant (t);
 718 }
 719
 720 /* Return true if T is a GIMPLE interprocedural invariant.  It's a restricted
 721    form of gimple minimal invariant.  */
 722
 723 bool
 724 is_gimple_ip_invariant (const_tree t)
 725 {
 726   if (TREE_CODE (t) == ADDR_EXPR)
 727     return is_gimple_ip_invariant_address (t);
 728
 729   return is_gimple_constant (t);
 730 }
 731
 732 /* Return true if T is a non-aggregate register variable.  */
 733
 734 bool
 735 is_gimple_reg (tree t)
 736 {
 737   if (virtual_operand_p (t))
 738     return false;
 739
 740   if (TREE_CODE (t) == SSA_NAME)
 741     return true;
 742
 743   if (!is_gimple_variable (t))
 744     return false;
 745
 746   if (!is_gimple_reg_type (TREE_TYPE (t)))
 747     return false;
 748
 749   /* A volatile decl is not acceptable because we can't reuse it as
 750      needed.  We need to copy it into a temp first.  */
 751   if (TREE_THIS_VOLATILE (t))
 752     return false;
 753
 754   /* We define "registers" as things that can be renamed as needed,
 755      which with our infrastructure does not apply to memory.  */
 756   if (needs_to_live_in_memory (t))
 757     return false;
 758
 759   /* Hard register variables are an interesting case.  For those that
 760      are call-clobbered, we don't know where all the calls are, since
 761      we don't (want to) take into account which operations will turn
 762      into libcalls at the rtl level.  For those that are call-saved,
 763      we don't currently model the fact that calls may in fact change
 764      global hard registers, nor do we examine ASM_CLOBBERS at the tree
 765      level, and so miss variable changes that might imply.  All around,
 766      it seems safest to not do too much optimization with these at the
 767      tree level at all.  We'll have to rely on the rtl optimizers to
 768      clean this up, as there we've got all the appropriate bits exposed.  */
 769   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
 770     return false;
 771
 772   /* Complex and vector values must have been put into SSA-like form.
 773      That is, no assignments to the individual components.  */
 774   if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE
 775       || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE)
 776     return DECL_GIMPLE_REG_P (t);
 777
 778   return true;
 779 }
 780
 781
 782 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant.  */
 783
 784 bool
 785 is_gimple_val (tree t)
 786 {
 787   /* Make loads from volatiles and memory vars explicit.  */
 788   if (is_gimple_variable (t)
 789       && is_gimple_reg_type (TREE_TYPE (t))
 790       && !is_gimple_reg (t))
 791     return false;
 792
 793   return (is_gimple_variable (t) || is_gimple_min_invariant (t));
 794 }
 795
 796 /* Similarly, but accept hard registers as inputs to asm statements.  */
 797
 798 bool
 799 is_gimple_asm_val (tree t)
 800 {
 801   if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t))
 802     return true;
 803
 804   return is_gimple_val (t);
 805 }
 806
 807 /* Return true if T is a GIMPLE minimal lvalue.  */
 808
 809 bool
 810 is_gimple_min_lval (tree t)
 811 {
 812   if (!(t = CONST_CAST_TREE (strip_invariant_refs (t))))
 813     return false;
 814   return (is_gimple_id (t) || TREE_CODE (t) == MEM_REF);
 815 }
 816
 817 /* Return true if T is a valid function operand of a CALL_EXPR.  */
 818
 819 bool
 820 is_gimple_call_addr (tree t)
 821 {
 822   return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t));
 823 }
 824
 825 /* Return true if T is a valid address operand of a MEM_REF.  */
 826
 827 bool
 828 is_gimple_mem_ref_addr (tree t)
 829 {
 830   return (is_gimple_reg (t)
 831           || TREE_CODE (t) == INTEGER_CST
 832           || (TREE_CODE (t) == ADDR_EXPR
 833               && (CONSTANT_CLASS_P (TREE_OPERAND (t, 0))
 834                   || decl_address_invariant_p (TREE_OPERAND (t, 0)))));
 835 }
 836
 837 /* Hold trees marked addressable during expand.  */
 838
 839 static hash_set<tree> *mark_addressable_queue;
 840
 841 /* Mark X as addressable or queue it up if called during expand.  We
 842    don't want to apply it immediately during expand because decls are
 843    made addressable at that point due to RTL-only concerns, such as
 844    uses of memcpy for block moves, and TREE_ADDRESSABLE changes
 845    is_gimple_reg, which might make it seem like a variable that used
 846    to be a gimple_reg shouldn't have been an SSA name.  So we queue up
 847    this flag setting and only apply it when we're done with GIMPLE and
 848    only RTL issues matter.  */
 849
 850 static void
 851 mark_addressable_1 (tree x)
 852 {
 853   if (!currently_expanding_to_rtl)
 854     {
 855       TREE_ADDRESSABLE (x) = 1;
 856       return;
 857     }
 858
 859   if (!mark_addressable_queue)
 860     mark_addressable_queue = new hash_set<tree>();
 861   mark_addressable_queue->add (x);
 862 }
 863
 864 /* Adaptor for mark_addressable_1 for use in hash_set traversal.  */
 865
 866 bool
 867 mark_addressable_2 (tree const &x, void * ATTRIBUTE_UNUSED = NULL)
 868 {
 869   mark_addressable_1 (x);
 870   return false;
 871 }
 872
 873 /* Mark all queued trees as addressable, and empty the queue.  To be
 874    called right after clearing CURRENTLY_EXPANDING_TO_RTL.  */
 875
 876 void
 877 flush_mark_addressable_queue ()
 878 {
 879   gcc_assert (!currently_expanding_to_rtl);
 880   if (mark_addressable_queue)
 881     {
 882       mark_addressable_queue->traverse<void*, mark_addressable_2> (NULL);
 883       delete mark_addressable_queue;
 884       mark_addressable_queue = NULL;
 885     }
 886 }
 887
 888 /* Mark X addressable.  Unlike the langhook we expect X to be in gimple
 889    form and we don't do any syntax checking.  */
 890
 891 void
 892 mark_addressable (tree x)
 893 {
 894   while (handled_component_p (x))
 895     x = TREE_OPERAND (x, 0);
 896   if (TREE_CODE (x) == MEM_REF
 897       && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR)
 898     x = TREE_OPERAND (TREE_OPERAND (x, 0), 0);
 899   if (!VAR_P (x)
 900       && TREE_CODE (x) != PARM_DECL
 901       && TREE_CODE (x) != RESULT_DECL)
 902     return;
 903   mark_addressable_1 (x);
 904
 905   /* Also mark the artificial SSA_NAME that points to the partition of X.  */
 906   if (TREE_CODE (x) == VAR_DECL
 907       && !DECL_EXTERNAL (x)
 908       && !TREE_STATIC (x)
 909       && cfun->gimple_df != NULL
 910       && cfun->gimple_df->decls_to_pointers != NULL)
 911     {
 912       tree *namep = cfun->gimple_df->decls_to_pointers->get (x);
 913       if (namep)
 914         mark_addressable_1 (*namep);
 915     }
 916 }
 917
 918 /* Returns true iff T is a valid RHS for an assignment to a renamed
 919    user -- or front-end generated artificial -- variable.  */
 920
 921 bool
 922 is_gimple_reg_rhs (tree t)
 923 {
 924   return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS;
 925 }
 926
 927 #include "gt-gimple-expr.h"