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

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