gcc/tree-gimple.c

   1 /* Functions to analyze and validate GIMPLE trees.
   2    Copyright (C) 2002, 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Diego Novillo <dnovillo@redhat.com>
   4    Rewritten by Jason Merrill <jason@redhat.com>
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "ggc.h"
  27 #include "tm.h"
  28 #include "tree.h"
  29 #include "tree-gimple.h"
  30 #include "tree-flow.h"
  31 #include "output.h"
  32 #include "rtl.h"
  33 #include "expr.h"
  34 #include "bitmap.h"
  35
  36 /* GCC GIMPLE structure
  37
  38    Inspired by the SIMPLE C grammar at
  39
  40         http://www-acaps.cs.mcgill.ca/info/McCAT/McCAT.html
  41
  42    function     : FUNCTION_DECL
  43                         DECL_SAVED_TREE -> compound-stmt
  44
  45    compound-stmt: STATEMENT_LIST
  46                         members -> stmt
  47
  48    stmt         : block
  49                 | if-stmt
  50                 | switch-stmt
  51                 | goto-stmt
  52                 | return-stmt
  53                 | resx-stmt
  54                 | label-stmt
  55                 | try-stmt
  56                 | modify-stmt
  57                 | call-stmt
  58
  59    block        : BIND_EXPR
  60                         BIND_EXPR_VARS -> chain of DECLs
  61                         BIND_EXPR_BLOCK -> BLOCK
  62                         BIND_EXPR_BODY -> compound-stmt
  63
  64    if-stmt      : COND_EXPR
  65                         op0 -> condition
  66                         op1 -> compound-stmt
  67                         op2 -> compound-stmt
  68
  69    switch-stmt  : SWITCH_EXPR
  70                         op0 -> val
  71                         op1 -> NULL
  72                         op2 -> TREE_VEC of CASE_LABEL_EXPRs
  73                             The CASE_LABEL_EXPRs are sorted by CASE_LOW,
  74                             and default is last.
  75
  76    goto-stmt    : GOTO_EXPR
  77                         op0 -> LABEL_DECL | val
  78
  79    return-stmt  : RETURN_EXPR
  80                         op0 -> return-value
  81
  82    return-value : NULL
  83                 | RESULT_DECL
  84                 | MODIFY_EXPR
  85                         op0 -> RESULT_DECL
  86                         op1 -> lhs
  87
  88    resx-stmt    : RESX_EXPR
  89
  90    label-stmt   : LABEL_EXPR
  91                         op0 -> LABEL_DECL
  92
  93    try-stmt     : TRY_CATCH_EXPR
  94                         op0 -> compound-stmt
  95                         op1 -> handler
  96                 | TRY_FINALLY_EXPR
  97                         op0 -> compound-stmt
  98                         op1 -> compound-stmt
  99
 100    handler      : catch-seq
 101                 | EH_FILTER_EXPR
 102                 | compound-stmt
 103
 104    catch-seq    : STATEMENT_LIST
 105                         members -> CATCH_EXPR
 106
 107    modify-stmt  : MODIFY_EXPR
 108                         op0 -> lhs
 109                         op1 -> rhs
 110
 111    call-stmt    : CALL_EXPR
 112                         op0 -> val | OBJ_TYPE_REF
 113                         op1 -> call-arg-list
 114
 115    call-arg-list: TREE_LIST
 116                         members -> lhs
 117
 118    addr-expr-arg: ID
 119                 | compref
 120
 121    addressable  : addr-expr-arg
 122                 | indirectref
 123
 124    with-size-arg: addressable
 125                 | call-stmt
 126
 127    indirectref  : INDIRECT_REF
 128                         op0 -> val
 129
 130    lhs          : addressable
 131                 | bitfieldref
 132                 | WITH_SIZE_EXPR
 133                         op0 -> with-size-arg
 134                         op1 -> val
 135
 136    min-lval     : ID
 137                 | indirectref
 138
 139    bitfieldref  : BIT_FIELD_REF
 140                         op0 -> inner-compref
 141                         op1 -> CONST
 142                         op2 -> var
 143
 144    compref      : inner-compref
 145                 | REALPART_EXPR
 146                         op0 -> inner-compref
 147                 | IMAGPART_EXPR
 148                         op0 -> inner-compref
 149
 150    inner-compref: min-lval
 151                 | COMPONENT_REF
 152                         op0 -> inner-compref
 153                         op1 -> FIELD_DECL
 154                         op2 -> val
 155                 | ARRAY_REF
 156                         op0 -> inner-compref
 157                         op1 -> val
 158                         op2 -> val
 159                         op3 -> val
 160                 | ARRAY_RANGE_REF
 161                         op0 -> inner-compref
 162                         op1 -> val
 163                         op2 -> val
 164                         op3 -> val
 165                 | VIEW_CONVERT_EXPR
 166                         op0 -> inner-compref
 167
 168    condition    : val
 169                 | RELOP
 170                         op0 -> val
 171                         op1 -> val
 172
 173    val          : ID
 174                 | CONST
 175
 176    rhs          : lhs
 177                 | CONST
 178                 | call-stmt
 179                 | ADDR_EXPR
 180                         op0 -> addr-expr-arg
 181                 | UNOP
 182                         op0 -> val
 183                 | BINOP
 184                         op0 -> val
 185                         op1 -> val
 186                 | RELOP
 187                         op0 -> val
 188                         op1 -> val
 189 */
 190
 191 static inline bool is_gimple_id (tree);
 192
 193 /* Validation of GIMPLE expressions.  */
 194
 195 /* Return true if T is a GIMPLE RHS for an assignment to a temporary.  */
 196
 197 bool
 198 is_gimple_formal_tmp_rhs (tree t)
 199 {
 200   enum tree_code code = TREE_CODE (t);
 201
 202   switch (TREE_CODE_CLASS (code))
 203     {
 204     case '1':
 205     case '2':
 206     case '<':
 207       return true;
 208
 209     default:
 210       break;
 211     }
 212
 213   switch (code)
 214     {
 215     case TRUTH_NOT_EXPR:
 216     case TRUTH_AND_EXPR:
 217     case TRUTH_OR_EXPR:
 218     case TRUTH_XOR_EXPR:
 219     case ADDR_EXPR:
 220     case CALL_EXPR:
 221     case CONSTRUCTOR:
 222     case COMPLEX_EXPR:
 223     case INTEGER_CST:
 224     case REAL_CST:
 225     case STRING_CST:
 226     case COMPLEX_CST:
 227     case VECTOR_CST:
 228     case OBJ_TYPE_REF:
 229       return true;
 230
 231     default:
 232       break;
 233     }
 234
 235   return is_gimple_lvalue (t) || is_gimple_val (t);
 236 }
 237
 238 /* Returns true iff T is a valid RHS for an assignment to a renamed
 239    user -- or front-end generated artificial -- variable.  */
 240
 241 bool
 242 is_gimple_reg_rhs (tree t)
 243 {
 244   /* If the RHS of the MODIFY_EXPR may throw or make a nonlocal goto
 245      and the LHS is a user variable, then we need to introduce a formal
 246      temporary.  This way the optimizers can determine that the user
 247      variable is only modified if evaluation of the RHS does not throw.
 248
 249      Don't force a temp of a non-renamable type; the copy could be
 250      arbitrarily expensive.  Instead we will generate a V_MAY_DEF for
 251      the assignment.  */
 252
 253   if (is_gimple_reg_type (TREE_TYPE (t))
 254       && ((TREE_CODE (t) == CALL_EXPR && TREE_SIDE_EFFECTS (t))
 255           || tree_could_throw_p (t)))
 256     return false;
 257
 258   return is_gimple_formal_tmp_rhs (t);
 259 }
 260
 261 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
 262    LHS, or for a call argument.  */
 263
 264 bool
 265 is_gimple_mem_rhs (tree t)
 266 {
 267   /* If we're dealing with a renamable type, either source or dest
 268      must be a renamed variable.  */
 269   if (is_gimple_reg_type (TREE_TYPE (t)))
 270     return is_gimple_val (t);
 271   else
 272     return is_gimple_formal_tmp_rhs (t);
 273 }
 274
 275 /* Returns the appropriate RHS predicate for this LHS.  */
 276
 277 gimple_predicate
 278 rhs_predicate_for (tree lhs)
 279 {
 280   if (is_gimple_formal_tmp_var (lhs))
 281     return is_gimple_formal_tmp_rhs;
 282   else if (is_gimple_reg (lhs))
 283     return is_gimple_reg_rhs;
 284   else
 285     return is_gimple_mem_rhs;
 286 }
 287
 288 /* Returns true if T is a valid CONSTRUCTOR component in GIMPLE, either
 289    a val or another CONSTRUCTOR.  */
 290
 291 bool
 292 is_gimple_constructor_elt (tree t)
 293 {
 294   return (is_gimple_val (t)
 295           || TREE_CODE (t) == CONSTRUCTOR);
 296 }
 297
 298 /*  Return true if T is a valid LHS for a GIMPLE assignment expression.  */
 299
 300 bool
 301 is_gimple_lvalue (tree t)
 302 {
 303   return (is_gimple_addressable (t)
 304           || TREE_CODE (t) == WITH_SIZE_EXPR
 305           /* These are complex lvalues, but don't have addresses, so they
 306              go here.  */
 307           || TREE_CODE (t) == BIT_FIELD_REF);
 308 }
 309
 310 /*  Return true if T is a GIMPLE condition.  */
 311
 312 bool
 313 is_gimple_condexpr (tree t)
 314 {
 315   return (is_gimple_val (t)
 316           || TREE_CODE_CLASS (TREE_CODE (t)) == '<');
 317 }
 318
 319 /*  Return true if T is something whose address can be taken.  */
 320
 321 bool
 322 is_gimple_addressable (tree t)
 323 {
 324   return (is_gimple_id (t) || handled_component_p (t)
 325           || TREE_CODE (t) == REALPART_EXPR
 326           || TREE_CODE (t) == IMAGPART_EXPR
 327           || TREE_CODE (t) == INDIRECT_REF);
 328 }
 329
 330 /* Return true if T is function invariant.  Or rather a restricted
 331    form of function invariant.  */
 332
 333 bool
 334 is_gimple_min_invariant (tree t)
 335 {
 336   switch (TREE_CODE (t))
 337     {
 338     case ADDR_EXPR:
 339       return TREE_INVARIANT (t);
 340
 341     case INTEGER_CST:
 342     case REAL_CST:
 343     case STRING_CST:
 344     case COMPLEX_CST:
 345     case VECTOR_CST:
 346       return !TREE_OVERFLOW (t);
 347
 348     default:
 349       return false;
 350     }
 351 }
 352
 353 /* Return true if T looks like a valid GIMPLE statement.  */
 354
 355 bool
 356 is_gimple_stmt (tree t)
 357 {
 358   enum tree_code code = TREE_CODE (t);
 359
 360   if (IS_EMPTY_STMT (t))
 361     return 1;
 362
 363   switch (code)
 364     {
 365     case BIND_EXPR:
 366     case COND_EXPR:
 367       /* These are only valid if they're void.  */
 368       return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
 369
 370     case SWITCH_EXPR:
 371     case GOTO_EXPR:
 372     case RETURN_EXPR:
 373     case LABEL_EXPR:
 374     case CASE_LABEL_EXPR:
 375     case TRY_CATCH_EXPR:
 376     case TRY_FINALLY_EXPR:
 377     case EH_FILTER_EXPR:
 378     case CATCH_EXPR:
 379     case ASM_EXPR:
 380     case RESX_EXPR:
 381     case PHI_NODE:
 382     case STATEMENT_LIST:
 383       /* These are always void.  */
 384       return true;
 385
 386     case CALL_EXPR:
 387     case MODIFY_EXPR:
 388       /* These are valid regardless of their type.  */
 389       return true;
 390
 391     default:
 392       return false;
 393     }
 394 }
 395
 396 /* Return true if T is a variable.  */
 397
 398 bool
 399 is_gimple_variable (tree t)
 400 {
 401   return (TREE_CODE (t) == VAR_DECL
 402           || TREE_CODE (t) == PARM_DECL
 403           || TREE_CODE (t) == RESULT_DECL
 404           || TREE_CODE (t) == SSA_NAME);
 405 }
 406
 407 /*  Return true if T is a GIMPLE identifier (something with an address).  */
 408
 409 static inline bool
 410 is_gimple_id (tree t)
 411 {
 412   return (is_gimple_variable (t)
 413           || TREE_CODE (t) == FUNCTION_DECL
 414           || TREE_CODE (t) == LABEL_DECL
 415           || TREE_CODE (t) == CONST_DECL
 416           /* Allow string constants, since they are addressable.  */
 417           || TREE_CODE (t) == STRING_CST);
 418 }
 419
 420 /* Return true if TYPE is a suitable type for a scalar register variable.  */
 421
 422 bool
 423 is_gimple_reg_type (tree type)
 424 {
 425   return (!AGGREGATE_TYPE_P (type)
 426           && TREE_CODE (type) != COMPLEX_TYPE);
 427 }
 428
 429
 430 /* Return true if T is a scalar register variable.  */
 431
 432 bool
 433 is_gimple_reg (tree t)
 434 {
 435   if (TREE_CODE (t) == SSA_NAME)
 436     t = SSA_NAME_VAR (t);
 437
 438   return (is_gimple_variable (t)
 439           && is_gimple_reg_type (TREE_TYPE (t))
 440           /* A volatile decl is not acceptable because we can't reuse it as
 441              needed.  We need to copy it into a temp first.  */
 442           && ! TREE_THIS_VOLATILE (t)
 443           && ! needs_to_live_in_memory (t));
 444 }
 445
 446 /* Returns true if T is a GIMPLE formal temporary variable.  */
 447
 448 bool
 449 is_gimple_formal_tmp_var (tree t)
 450 {
 451   if (TREE_CODE (t) == SSA_NAME)
 452     return true;
 453
 454   return TREE_CODE (t) == VAR_DECL && DECL_GIMPLE_FORMAL_TEMP_P (t);
 455 }
 456
 457 /* Returns true if T is a GIMPLE formal temporary register variable.  */
 458
 459 bool
 460 is_gimple_formal_tmp_reg (tree t)
 461 {
 462   /* The intent of this is to get hold of a value that won't change.
 463      An SSA_NAME qualifies no matter if its of a user variable or not.  */
 464   if (TREE_CODE (t) == SSA_NAME)
 465     return true;
 466
 467   /* We don't know the lifetime characteristics of user variables.  */
 468   if (!is_gimple_formal_tmp_var (t))
 469     return false;
 470
 471   /* Finally, it must be capable of being placed in a register.  */
 472   return is_gimple_reg (t);
 473 }
 474
 475 /* Return true if T is a GIMPLE variable whose address is not needed.  */
 476
 477 bool
 478 is_gimple_non_addressable (tree t)
 479 {
 480   if (TREE_CODE (t) == SSA_NAME)
 481     t = SSA_NAME_VAR (t);
 482
 483   return (is_gimple_variable (t) && ! needs_to_live_in_memory (t));
 484 }
 485
 486 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant.  */
 487
 488 bool
 489 is_gimple_val (tree t)
 490 {
 491   /* Make loads from volatiles and memory vars explicit.  */
 492   if (is_gimple_variable (t)
 493       && is_gimple_reg_type (TREE_TYPE (t))
 494       && !is_gimple_reg (t))
 495     return false;
 496
 497   /* FIXME make these decls.  That can happen only when we expose the
 498      entire landing-pad construct at the tree level.  */
 499   if (TREE_CODE (t) == EXC_PTR_EXPR || TREE_CODE (t) == FILTER_EXPR)
 500     return 1;
 501
 502   return (is_gimple_variable (t) || is_gimple_min_invariant (t));
 503 }
 504
 505
 506 /* Return true if T is a GIMPLE minimal lvalue.  */
 507
 508 bool
 509 is_gimple_min_lval (tree t)
 510 {
 511   return (is_gimple_id (t)
 512           || TREE_CODE (t) == INDIRECT_REF);
 513 }
 514
 515 /* Return true if T is a typecast operation.  */
 516
 517 bool
 518 is_gimple_cast (tree t)
 519 {
 520   return (TREE_CODE (t) == NOP_EXPR
 521           || TREE_CODE (t) == CONVERT_EXPR
 522           || TREE_CODE (t) == FIX_TRUNC_EXPR
 523           || TREE_CODE (t) == FIX_CEIL_EXPR
 524           || TREE_CODE (t) == FIX_FLOOR_EXPR
 525           || TREE_CODE (t) == FIX_ROUND_EXPR);
 526 }
 527
 528 /* Return true if T is a valid op0 of a CALL_EXPR.  */
 529
 530 bool
 531 is_gimple_call_addr (tree t)
 532 {
 533   return (TREE_CODE (t) == OBJ_TYPE_REF
 534           || is_gimple_val (t));
 535 }
 536
 537 /* If T makes a function call, return the corresponding CALL_EXPR operand.
 538    Otherwise, return NULL_TREE.  */
 539
 540 tree
 541 get_call_expr_in (tree t)
 542 {
 543   if (TREE_CODE (t) == MODIFY_EXPR)
 544     t = TREE_OPERAND (t, 1);
 545   if (TREE_CODE (t) == WITH_SIZE_EXPR)
 546     t = TREE_OPERAND (t, 0);
 547   if (TREE_CODE (t) == CALL_EXPR)
 548     return t;
 549   return NULL_TREE;
 550 }
 551
 552 /* Given a memory reference expression, return the base address.  Note that,
 553    in contrast with get_base_var, this will not recurse inside INDIRECT_REF
 554    expressions.  Therefore, given the reference PTR->FIELD, this function
 555    will return *PTR.  Whereas get_base_var would've returned PTR.  */
 556
 557 tree
 558 get_base_address (tree t)
 559 {
 560   while (TREE_CODE (t) == REALPART_EXPR || TREE_CODE (t) == IMAGPART_EXPR
 561          || handled_component_p (t))
 562     t = TREE_OPERAND (t, 0);
 563
 564   if (SSA_VAR_P (t)
 565       || TREE_CODE (t) == STRING_CST
 566       || TREE_CODE (t) == CONSTRUCTOR
 567       || TREE_CODE (t) == INDIRECT_REF)
 568     return t;
 569   else
 570     return NULL_TREE;
 571 }
 572
 573 void
 574 recalculate_side_effects (tree t)
 575 {
 576   enum tree_code code = TREE_CODE (t);
 577   int fro = first_rtl_op (code);
 578   int i;
 579
 580   switch (TREE_CODE_CLASS (code))
 581     {
 582     case 'e':
 583       switch (code)
 584         {
 585         case INIT_EXPR:
 586         case MODIFY_EXPR:
 587         case VA_ARG_EXPR:
 588         case PREDECREMENT_EXPR:
 589         case PREINCREMENT_EXPR:
 590         case POSTDECREMENT_EXPR:
 591         case POSTINCREMENT_EXPR:
 592           /* All of these have side-effects, no matter what their
 593              operands are.  */
 594           return;
 595
 596         default:
 597           break;
 598         }
 599       /* Fall through.  */
 600
 601     case '<':  /* a comparison expression */
 602     case '1':  /* a unary arithmetic expression */
 603     case '2':  /* a binary arithmetic expression */
 604     case 'r':  /* a reference */
 605       TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
 606       for (i = 0; i < fro; ++i)
 607         {
 608           tree op = TREE_OPERAND (t, i);
 609           if (op && TREE_SIDE_EFFECTS (op))
 610             TREE_SIDE_EFFECTS (t) = 1;
 611         }
 612       break;
 613    }
 614 }