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 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 3, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along 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 79bool 80useless_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 304void 305gimple_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 325gimple_seq 326gimple_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. */ 334bool 335gimple_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 343const char * 344gimple_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 375tree 376copy_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 if (DECL_USER_ALIGN (var)) 391 { 392 DECL_ALIGN (copy) = DECL_ALIGN (var); 393 DECL_USER_ALIGN (copy) = 1; 394 } 395 396 return copy; 397} 398 399/* Given SSA_NAMEs NAME1 and NAME2, return true if they are candidates for 400 coalescing together, false otherwise. 401 402 This must stay consistent with var_map_base_init in tree-ssa-live.c. */ 403 404bool 405gimple_can_coalesce_p (tree name1, tree name2) 406{ 407 /* First check the SSA_NAME's associated DECL. We only want to 408 coalesce if they have the same DECL or both have no associated DECL. */ 409 tree var1 = SSA_NAME_VAR (name1); 410 tree var2 = SSA_NAME_VAR (name2); 411 var1 = (var1 && (!VAR_P (var1) || !DECL_IGNORED_P (var1))) ? var1 : NULL_TREE; 412 var2 = (var2 && (!VAR_P (var2) || !DECL_IGNORED_P (var2))) ? var2 : NULL_TREE; 413 if (var1 != var2) 414 return false; 415 416 /* Now check the types. If the types are the same, then we should 417 try to coalesce V1 and V2. */ 418 tree t1 = TREE_TYPE (name1); 419 tree t2 = TREE_TYPE (name2); 420 if (t1 == t2) 421 return true; 422 423 /* If the types are not the same, check for a canonical type match. This 424 (for example) allows coalescing when the types are fundamentally the 425 same, but just have different names. 426 427 Note pointer types with different address spaces may have the same 428 canonical type. Those are rejected for coalescing by the 429 types_compatible_p check. */ 430 if (TYPE_CANONICAL (t1) 431 && TYPE_CANONICAL (t1) == TYPE_CANONICAL (t2) 432 && types_compatible_p (t1, t2)) 433 return true; 434 435 return false; 436} 437 438/* Strip off a legitimate source ending from the input string NAME of 439 length LEN. Rather than having to know the names used by all of 440 our front ends, we strip off an ending of a period followed by 441 up to five characters. (Java uses ".class".) */ 442 443static inline void 444remove_suffix (char *name, int len) 445{ 446 int i; 447 448 for (i = 2; i < 8 && len > i; i++) 449 { 450 if (name[len - i] == '.') 451 { 452 name[len - i] = '\0'; 453 break; 454 } 455 } 456} 457 458/* Create a new temporary name with PREFIX. Return an identifier. */ 459 460static GTY(()) unsigned int tmp_var_id_num; 461 462tree 463create_tmp_var_name (const char *prefix) 464{ 465 char *tmp_name; 466 467 if (prefix) 468 { 469 char *preftmp = ASTRDUP (prefix); 470 471 remove_suffix (preftmp, strlen (preftmp)); 472 clean_symbol_name (preftmp); 473 474 prefix = preftmp; 475 } 476 477 ASM_FORMAT_PRIVATE_NAME (tmp_name, prefix ? prefix : "T", tmp_var_id_num++); 478 return get_identifier (tmp_name); 479} 480 481/* Create a new temporary variable declaration of type TYPE. 482 Do NOT push it into the current binding. */ 483 484tree 485create_tmp_var_raw (tree type, const char *prefix) 486{ 487 tree tmp_var; 488 489 tmp_var = build_decl (input_location, 490 VAR_DECL, prefix ? create_tmp_var_name (prefix) : NULL, 491 type); 492 493 /* The variable was declared by the compiler. */ 494 DECL_ARTIFICIAL (tmp_var) = 1; 495 /* And we don't want debug info for it. */ 496 DECL_IGNORED_P (tmp_var) = 1; 497 498 /* Make the variable writable. */ 499 TREE_READONLY (tmp_var) = 0; 500 501 DECL_EXTERNAL (tmp_var) = 0; 502 TREE_STATIC (tmp_var) = 0; 503 TREE_USED (tmp_var) = 1; 504 505 return tmp_var; 506} 507 508/* Create a new temporary variable declaration of type TYPE. DO push the 509 variable into the current binding. Further, assume that this is called 510 only from gimplification or optimization, at which point the creation of 511 certain types are bugs. */ 512 513tree 514create_tmp_var (tree type, const char *prefix) 515{ 516 tree tmp_var; 517 518 /* We don't allow types that are addressable (meaning we can't make copies), 519 or incomplete. We also used to reject every variable size objects here, 520 but now support those for which a constant upper bound can be obtained. 521 The processing for variable sizes is performed in gimple_add_tmp_var, 522 point at which it really matters and possibly reached via paths not going 523 through this function, e.g. after direct calls to create_tmp_var_raw. */ 524 gcc_assert (!TREE_ADDRESSABLE (type) && COMPLETE_TYPE_P (type)); 525 526 tmp_var = create_tmp_var_raw (type, prefix); 527 gimple_add_tmp_var (tmp_var); 528 return tmp_var; 529} 530 531/* Create a new temporary variable declaration of type TYPE by calling 532 create_tmp_var and if TYPE is a vector or a complex number, mark the new 533 temporary as gimple register. */ 534 535tree 536create_tmp_reg (tree type, const char *prefix) 537{ 538 tree tmp; 539 540 tmp = create_tmp_var (type, prefix); 541 if (TREE_CODE (type) == COMPLEX_TYPE 542 || TREE_CODE (type) == VECTOR_TYPE) 543 DECL_GIMPLE_REG_P (tmp) = 1; 544 545 return tmp; 546} 547 548/* Create a new temporary variable declaration of type TYPE by calling 549 create_tmp_var and if TYPE is a vector or a complex number, mark the new 550 temporary as gimple register. */ 551 552tree 553create_tmp_reg_fn (struct function *fn, tree type, const char *prefix) 554{ 555 tree tmp; 556 557 tmp = create_tmp_var_raw (type, prefix); 558 gimple_add_tmp_var_fn (fn, tmp); 559 if (TREE_CODE (type) == COMPLEX_TYPE 560 || TREE_CODE (type) == VECTOR_TYPE) 561 DECL_GIMPLE_REG_P (tmp) = 1; 562 563 return tmp; 564} 565 566 567/* ----- Expression related ----- */ 568 569/* Extract the operands and code for expression EXPR into *SUBCODE_P, 570 *OP1_P, *OP2_P and *OP3_P respectively. */ 571 572void 573extract_ops_from_tree (tree expr, enum tree_code *subcode_p, tree *op1_p, 574 tree *op2_p, tree *op3_p) 575{ 576 enum gimple_rhs_class grhs_class; 577 578 *subcode_p = TREE_CODE (expr); 579 grhs_class = get_gimple_rhs_class (*subcode_p); 580 581 if (grhs_class == GIMPLE_TERNARY_RHS) 582 { 583 *op1_p = TREE_OPERAND (expr, 0); 584 *op2_p = TREE_OPERAND (expr, 1); 585 *op3_p = TREE_OPERAND (expr, 2); 586 } 587 else if (grhs_class == GIMPLE_BINARY_RHS) 588 { 589 *op1_p = TREE_OPERAND (expr, 0); 590 *op2_p = TREE_OPERAND (expr, 1); 591 *op3_p = NULL_TREE; 592 } 593 else if (grhs_class == GIMPLE_UNARY_RHS) 594 { 595 *op1_p = TREE_OPERAND (expr, 0); 596 *op2_p = NULL_TREE; 597 *op3_p = NULL_TREE; 598 } 599 else if (grhs_class == GIMPLE_SINGLE_RHS) 600 { 601 *op1_p = expr; 602 *op2_p = NULL_TREE; 603 *op3_p = NULL_TREE; 604 } 605 else 606 gcc_unreachable (); 607} 608 609/* Extract operands for a GIMPLE_COND statement out of COND_EXPR tree COND. */ 610 611void 612gimple_cond_get_ops_from_tree (tree cond, enum tree_code *code_p, 613 tree *lhs_p, tree *rhs_p) 614{ 615 gcc_assert (TREE_CODE_CLASS (TREE_CODE (cond)) == tcc_comparison 616 || TREE_CODE (cond) == TRUTH_NOT_EXPR 617 || is_gimple_min_invariant (cond) 618 || SSA_VAR_P (cond)); 619 620 extract_ops_from_tree (cond, code_p, lhs_p, rhs_p); 621 622 /* Canonicalize conditionals of the form 'if (!VAL)'. */ 623 if (*code_p == TRUTH_NOT_EXPR) 624 { 625 *code_p = EQ_EXPR; 626 gcc_assert (*lhs_p && *rhs_p == NULL_TREE); 627 *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p)); 628 } 629 /* Canonicalize conditionals of the form 'if (VAL)' */ 630 else if (TREE_CODE_CLASS (*code_p) != tcc_comparison) 631 { 632 *code_p = NE_EXPR; 633 gcc_assert (*lhs_p && *rhs_p == NULL_TREE); 634 *rhs_p = build_zero_cst (TREE_TYPE (*lhs_p)); 635 } 636} 637 638/* Return true if T is a valid LHS for a GIMPLE assignment expression. */ 639 640bool 641is_gimple_lvalue (tree t) 642{ 643 return (is_gimple_addressable (t) 644 || TREE_CODE (t) == WITH_SIZE_EXPR 645 /* These are complex lvalues, but don't have addresses, so they 646 go here. */ 647 || TREE_CODE (t) == BIT_FIELD_REF); 648} 649 650/* Return true if T is a GIMPLE condition. */ 651 652bool 653is_gimple_condexpr (tree t) 654{ 655 return (is_gimple_val (t) || (COMPARISON_CLASS_P (t) 656 && !tree_could_throw_p (t) 657 && is_gimple_val (TREE_OPERAND (t, 0)) 658 && is_gimple_val (TREE_OPERAND (t, 1)))); 659} 660 661/* Return true if T is a gimple address. */ 662 663bool 664is_gimple_address (const_tree t) 665{ 666 tree op; 667 668 if (TREE_CODE (t) != ADDR_EXPR) 669 return false; 670 671 op = TREE_OPERAND (t, 0); 672 while (handled_component_p (op)) 673 { 674 if ((TREE_CODE (op) == ARRAY_REF 675 || TREE_CODE (op) == ARRAY_RANGE_REF) 676 && !is_gimple_val (TREE_OPERAND (op, 1))) 677 return false; 678 679 op = TREE_OPERAND (op, 0); 680 } 681 682 if (CONSTANT_CLASS_P (op) || TREE_CODE (op) == MEM_REF) 683 return true; 684 685 switch (TREE_CODE (op)) 686 { 687 case PARM_DECL: 688 case RESULT_DECL: 689 case LABEL_DECL: 690 case FUNCTION_DECL: 691 case VAR_DECL: 692 case CONST_DECL: 693 return true; 694 695 default: 696 return false; 697 } 698} 699 700/* Return true if T is a gimple invariant address. */ 701 702bool 703is_gimple_invariant_address (const_tree t) 704{ 705 const_tree op; 706 707 if (TREE_CODE (t) != ADDR_EXPR) 708 return false; 709 710 op = strip_invariant_refs (TREE_OPERAND (t, 0)); 711 if (!op) 712 return false; 713 714 if (TREE_CODE (op) == MEM_REF) 715 { 716 const_tree op0 = TREE_OPERAND (op, 0); 717 return (TREE_CODE (op0) == ADDR_EXPR 718 && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0)) 719 || decl_address_invariant_p (TREE_OPERAND (op0, 0)))); 720 } 721 722 return CONSTANT_CLASS_P (op) || decl_address_invariant_p (op); 723} 724 725/* Return true if T is a gimple invariant address at IPA level 726 (so addresses of variables on stack are not allowed). */ 727 728bool 729is_gimple_ip_invariant_address (const_tree t) 730{ 731 const_tree op; 732 733 if (TREE_CODE (t) != ADDR_EXPR) 734 return false; 735 736 op = strip_invariant_refs (TREE_OPERAND (t, 0)); 737 if (!op) 738 return false; 739 740 if (TREE_CODE (op) == MEM_REF) 741 { 742 const_tree op0 = TREE_OPERAND (op, 0); 743 return (TREE_CODE (op0) == ADDR_EXPR 744 && (CONSTANT_CLASS_P (TREE_OPERAND (op0, 0)) 745 || decl_address_ip_invariant_p (TREE_OPERAND (op0, 0)))); 746 } 747 748 return CONSTANT_CLASS_P (op) || decl_address_ip_invariant_p (op); 749} 750 751/* Return true if T is a GIMPLE minimal invariant. It's a restricted 752 form of function invariant. */ 753 754bool 755is_gimple_min_invariant (const_tree t) 756{ 757 if (TREE_CODE (t) == ADDR_EXPR) 758 return is_gimple_invariant_address (t); 759 760 return is_gimple_constant (t); 761} 762 763/* Return true if T is a GIMPLE interprocedural invariant. It's a restricted 764 form of gimple minimal invariant. */ 765 766bool 767is_gimple_ip_invariant (const_tree t) 768{ 769 if (TREE_CODE (t) == ADDR_EXPR) 770 return is_gimple_ip_invariant_address (t); 771 772 return is_gimple_constant (t); 773} 774 775/* Return true if T is a non-aggregate register variable. */ 776 777bool 778is_gimple_reg (tree t) 779{ 780 if (virtual_operand_p (t)) 781 return false; 782 783 if (TREE_CODE (t) == SSA_NAME) 784 return true; 785 786 if (!is_gimple_variable (t)) 787 return false; 788 789 if (!is_gimple_reg_type (TREE_TYPE (t))) 790 return false; 791 792 /* A volatile decl is not acceptable because we can't reuse it as 793 needed. We need to copy it into a temp first. */ 794 if (TREE_THIS_VOLATILE (t)) 795 return false; 796 797 /* We define "registers" as things that can be renamed as needed, 798 which with our infrastructure does not apply to memory. */ 799 if (needs_to_live_in_memory (t)) 800 return false; 801 802 /* Hard register variables are an interesting case. For those that 803 are call-clobbered, we don't know where all the calls are, since 804 we don't (want to) take into account which operations will turn 805 into libcalls at the rtl level. For those that are call-saved, 806 we don't currently model the fact that calls may in fact change 807 global hard registers, nor do we examine ASM_CLOBBERS at the tree 808 level, and so miss variable changes that might imply. All around, 809 it seems safest to not do too much optimization with these at the 810 tree level at all. We'll have to rely on the rtl optimizers to 811 clean this up, as there we've got all the appropriate bits exposed. */ 812 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t)) 813 return false; 814 815 /* Complex and vector values must have been put into SSA-like form. 816 That is, no assignments to the individual components. */ 817 if (TREE_CODE (TREE_TYPE (t)) == COMPLEX_TYPE 818 || TREE_CODE (TREE_TYPE (t)) == VECTOR_TYPE) 819 return DECL_GIMPLE_REG_P (t); 820 821 return true; 822} 823 824 825/* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant. */ 826 827bool 828is_gimple_val (tree t) 829{ 830 /* Make loads from volatiles and memory vars explicit. */ 831 if (is_gimple_variable (t) 832 && is_gimple_reg_type (TREE_TYPE (t)) 833 && !is_gimple_reg (t)) 834 return false; 835 836 return (is_gimple_variable (t) || is_gimple_min_invariant (t)); 837} 838 839/* Similarly, but accept hard registers as inputs to asm statements. */ 840 841bool 842is_gimple_asm_val (tree t) 843{ 844 if (TREE_CODE (t) == VAR_DECL && DECL_HARD_REGISTER (t)) 845 return true; 846 847 return is_gimple_val (t); 848} 849 850/* Return true if T is a GIMPLE minimal lvalue. */ 851 852bool 853is_gimple_min_lval (tree t) 854{ 855 if (!(t = CONST_CAST_TREE (strip_invariant_refs (t)))) 856 return false; 857 return (is_gimple_id (t) || TREE_CODE (t) == MEM_REF); 858} 859 860/* Return true if T is a valid function operand of a CALL_EXPR. */ 861 862bool 863is_gimple_call_addr (tree t) 864{ 865 return (TREE_CODE (t) == OBJ_TYPE_REF || is_gimple_val (t)); 866} 867 868/* Return true if T is a valid address operand of a MEM_REF. */ 869 870bool 871is_gimple_mem_ref_addr (tree t) 872{ 873 return (is_gimple_reg (t) 874 || TREE_CODE (t) == INTEGER_CST 875 || (TREE_CODE (t) == ADDR_EXPR 876 && (CONSTANT_CLASS_P (TREE_OPERAND (t, 0)) 877 || decl_address_invariant_p (TREE_OPERAND (t, 0))))); 878} 879 880/* Mark X addressable. Unlike the langhook we expect X to be in gimple 881 form and we don't do any syntax checking. */ 882 883void 884mark_addressable (tree x) 885{ 886 while (handled_component_p (x)) 887 x = TREE_OPERAND (x, 0); 888 if (TREE_CODE (x) == MEM_REF 889 && TREE_CODE (TREE_OPERAND (x, 0)) == ADDR_EXPR) 890 x = TREE_OPERAND (TREE_OPERAND (x, 0), 0); 891 if (TREE_CODE (x) != VAR_DECL 892 && TREE_CODE (x) != PARM_DECL 893 && TREE_CODE (x) != RESULT_DECL) 894 return; 895 TREE_ADDRESSABLE (x) = 1; 896 897 /* Also mark the artificial SSA_NAME that points to the partition of X. */ 898 if (TREE_CODE (x) == VAR_DECL 899 && !DECL_EXTERNAL (x) 900 && !TREE_STATIC (x) 901 && cfun->gimple_df != NULL 902 && cfun->gimple_df->decls_to_pointers != NULL) 903 { 904 tree *namep = cfun->gimple_df->decls_to_pointers->get (x); 905 if (namep) 906 TREE_ADDRESSABLE (*namep) = 1; 907 } 908} 909 910/* Returns true iff T is a valid RHS for an assignment to a renamed 911 user -- or front-end generated artificial -- variable. */ 912 913bool 914is_gimple_reg_rhs (tree t) 915{ 916 return get_gimple_rhs_class (TREE_CODE (t)) != GIMPLE_INVALID_RHS; 917} 918 919#include "gt-gimple-expr.h" 920