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" 928