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_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 user
 239    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 and
 245      the LHS is a user variable, then we need to introduce a temporary.
 246      ie temp = RHS; LHS = temp.
 247
 248      This way the optimizers can determine that the user variable is
 249      only modified if evaluation of the RHS does not throw.  */
 250   if (is_gimple_reg_type (TREE_TYPE (t))
 251       && TREE_SIDE_EFFECTS (t)
 252       && (TREE_CODE (t) == CALL_EXPR
 253           || (flag_non_call_exceptions && tree_could_trap_p (t))))
 254     return is_gimple_val (t);
 255   else
 256     /* Don't force a temp of a non-renamable type; the copy could be
 257        arbitrarily expensive.  Instead we will generate a V_MAY_DEF for
 258        the assignment.  */
 259     return is_gimple_tmp_rhs (t);
 260 }
 261
 262 /* Returns true iff T is a valid RHS for an assignment to an un-renamed
 263    LHS, or for a call argument.  */
 264
 265 bool
 266 is_gimple_mem_rhs (tree t)
 267 {
 268   /* If we're dealing with a renamable type, either source or dest
 269      must be a renamed variable.  */
 270   if (is_gimple_reg_type (TREE_TYPE (t)))
 271     return is_gimple_val (t);
 272   else
 273     return is_gimple_tmp_rhs (t);
 274 }
 275
 276 /* Returns the appropriate RHS predicate for this LHS.  */
 277
 278 gimple_predicate
 279 rhs_predicate_for (tree lhs)
 280 {
 281   if (is_gimple_tmp_var (lhs))
 282     return is_gimple_tmp_rhs;
 283   else if (is_gimple_reg (lhs))
 284     return is_gimple_reg_rhs;
 285   else
 286     return is_gimple_mem_rhs;
 287 }
 288
 289 /* Returns true if T is a valid CONSTRUCTOR component in GIMPLE, either
 290    a val or another CONSTRUCTOR.  */
 291
 292 bool
 293 is_gimple_constructor_elt (tree t)
 294 {
 295   return (is_gimple_val (t)
 296           || TREE_CODE (t) == CONSTRUCTOR);
 297 }
 298
 299 /*  Return true if T is a valid LHS for a GIMPLE assignment expression.  */
 300
 301 bool
 302 is_gimple_lvalue (tree t)
 303 {
 304   return (is_gimple_addressable (t)
 305           || TREE_CODE (t) == WITH_SIZE_EXPR
 306           /* These are complex lvalues, but don't have addresses, so they
 307              go here.  */
 308           || TREE_CODE (t) == BIT_FIELD_REF);
 309 }
 310
 311 /*  Return true if T is a GIMPLE condition.  */
 312
 313 bool
 314 is_gimple_condexpr (tree t)
 315 {
 316   return (is_gimple_val (t)
 317           || TREE_CODE_CLASS (TREE_CODE (t)) == '<');
 318 }
 319
 320 /*  Return true if T is something whose address can be taken.  */
 321
 322 bool
 323 is_gimple_addressable (tree t)
 324 {
 325   return (is_gimple_id (t) || handled_component_p (t)
 326           || TREE_CODE (t) == REALPART_EXPR
 327           || TREE_CODE (t) == IMAGPART_EXPR
 328           || TREE_CODE (t) == INDIRECT_REF);
 329 }
 330
 331 /* Return true if T is function invariant.  Or rather a restricted
 332    form of function invariant.  */
 333
 334 bool
 335 is_gimple_min_invariant (tree t)
 336 {
 337   switch (TREE_CODE (t))
 338     {
 339     case ADDR_EXPR:
 340       return TREE_INVARIANT (t);
 341
 342     case INTEGER_CST:
 343     case REAL_CST:
 344     case STRING_CST:
 345     case COMPLEX_CST:
 346     case VECTOR_CST:
 347       return !TREE_OVERFLOW (t);
 348
 349     default:
 350       return false;
 351     }
 352 }
 353
 354 /* Return true if T looks like a valid GIMPLE statement.  */
 355
 356 bool
 357 is_gimple_stmt (tree t)
 358 {
 359   enum tree_code code = TREE_CODE (t);
 360
 361   if (IS_EMPTY_STMT (t))
 362     return 1;
 363
 364   switch (code)
 365     {
 366     case BIND_EXPR:
 367     case COND_EXPR:
 368       /* These are only valid if they're void.  */
 369       return TREE_TYPE (t) == NULL || VOID_TYPE_P (TREE_TYPE (t));
 370
 371     case SWITCH_EXPR:
 372     case GOTO_EXPR:
 373     case RETURN_EXPR:
 374     case LABEL_EXPR:
 375     case CASE_LABEL_EXPR:
 376     case TRY_CATCH_EXPR:
 377     case TRY_FINALLY_EXPR:
 378     case EH_FILTER_EXPR:
 379     case CATCH_EXPR:
 380     case ASM_EXPR:
 381     case RESX_EXPR:
 382     case PHI_NODE:
 383     case STATEMENT_LIST:
 384       /* These are always void.  */
 385       return true;
 386
 387     case CALL_EXPR:
 388     case MODIFY_EXPR:
 389       /* These are valid regardless of their type.  */
 390       return true;
 391
 392     default:
 393       return false;
 394     }
 395 }
 396
 397 /* Return true if T is a variable.  */
 398
 399 bool
 400 is_gimple_variable (tree t)
 401 {
 402   return (TREE_CODE (t) == VAR_DECL
 403           || TREE_CODE (t) == PARM_DECL
 404           || TREE_CODE (t) == RESULT_DECL
 405           || TREE_CODE (t) == SSA_NAME);
 406 }
 407
 408 /*  Return true if T is a GIMPLE identifier (something with an address).  */
 409
 410 static inline bool
 411 is_gimple_id (tree t)
 412 {
 413   return (is_gimple_variable (t)
 414           || TREE_CODE (t) == FUNCTION_DECL
 415           || TREE_CODE (t) == LABEL_DECL
 416           || TREE_CODE (t) == CONST_DECL
 417           /* Allow string constants, since they are addressable.  */
 418           || TREE_CODE (t) == STRING_CST);
 419 }
 420
 421 /* Return true if TYPE is a suitable type for a scalar register variable.  */
 422
 423 bool
 424 is_gimple_reg_type (tree type)
 425 {
 426   return (!AGGREGATE_TYPE_P (type)
 427           && TREE_CODE (type) != COMPLEX_TYPE);
 428 }
 429
 430
 431 /* Return true if T is a scalar register variable.  */
 432
 433 bool
 434 is_gimple_reg (tree t)
 435 {
 436   if (TREE_CODE (t) == SSA_NAME)
 437     t = SSA_NAME_VAR (t);
 438
 439   return (is_gimple_variable (t)
 440           && is_gimple_reg_type (TREE_TYPE (t))
 441           /* A volatile decl is not acceptable because we can't reuse it as
 442              needed.  We need to copy it into a temp first.  */
 443           && ! TREE_THIS_VOLATILE (t)
 444           && ! TREE_ADDRESSABLE (t)
 445           && ! needs_to_live_in_memory (t));
 446 }
 447
 448 /* Returns true if T is a GIMPLE temporary variable, false otherwise.  */
 449
 450 bool
 451 is_gimple_tmp_var (tree t)
 452 {
 453   /* FIXME this could trigger for other local artificials, too.  */
 454   return (TREE_CODE (t) == VAR_DECL && DECL_ARTIFICIAL (t)
 455           && !TREE_STATIC (t) && !DECL_EXTERNAL (t));
 456 }
 457
 458 /* Returns true if T is a GIMPLE temporary register variable.  */
 459
 460 bool
 461 is_gimple_tmp_reg (tree t)
 462 {
 463   /* The intent of this is to get hold of a value that won't change.
 464      An SSA_NAME qualifies no matter if its of a user variable or not.  */
 465   if (TREE_CODE (t) == SSA_NAME)
 466     return true;
 467
 468   /* We don't know the lifetime characteristics of user variables.  */
 469   if (TREE_CODE (t) != VAR_DECL || !DECL_ARTIFICIAL (t))
 470     return false;
 471
 472   /* Finally, it must be capable of being placed in a register.  */
 473   return is_gimple_reg (t);
 474 }
 475
 476 /* Return true if T is a GIMPLE variable whose address is not needed.  */
 477
 478 bool
 479 is_gimple_non_addressable (tree t)
 480 {
 481   if (TREE_CODE (t) == SSA_NAME)
 482     t = SSA_NAME_VAR (t);
 483
 484   return (is_gimple_variable (t)
 485           && ! TREE_ADDRESSABLE (t)
 486           && ! needs_to_live_in_memory (t));
 487 }
 488
 489 /* Return true if T is a GIMPLE rvalue, i.e. an identifier or a constant.  */
 490
 491 bool
 492 is_gimple_val (tree t)
 493 {
 494   /* Make loads from volatiles and memory vars explicit.  */
 495   if (is_gimple_variable (t)
 496       && is_gimple_reg_type (TREE_TYPE (t))
 497       && !is_gimple_reg (t))
 498     return false;
 499
 500   /* FIXME make these decls.  That can happen only when we expose the
 501      entire landing-pad construct at the tree level.  */
 502   if (TREE_CODE (t) == EXC_PTR_EXPR || TREE_CODE (t) == FILTER_EXPR)
 503     return 1;
 504
 505   return (is_gimple_variable (t) || is_gimple_min_invariant (t));
 506 }
 507
 508
 509 /* Return true if T is a GIMPLE minimal lvalue.  */
 510
 511 bool
 512 is_gimple_min_lval (tree t)
 513 {
 514   return (is_gimple_id (t)
 515           || TREE_CODE (t) == INDIRECT_REF);
 516 }
 517
 518 /* Return true if T is a typecast operation.  */
 519
 520 bool
 521 is_gimple_cast (tree t)
 522 {
 523   return (TREE_CODE (t) == NOP_EXPR
 524           || TREE_CODE (t) == CONVERT_EXPR
 525           || TREE_CODE (t) == FIX_TRUNC_EXPR
 526           || TREE_CODE (t) == FIX_CEIL_EXPR
 527           || TREE_CODE (t) == FIX_FLOOR_EXPR
 528           || TREE_CODE (t) == FIX_ROUND_EXPR);
 529 }
 530
 531 /* Return true if T is a valid op0 of a CALL_EXPR.  */
 532
 533 bool
 534 is_gimple_call_addr (tree t)
 535 {
 536   return (TREE_CODE (t) == OBJ_TYPE_REF
 537           || is_gimple_val (t));
 538 }
 539
 540 /* If T makes a function call, return the corresponding CALL_EXPR operand.
 541    Otherwise, return NULL_TREE.  */
 542
 543 tree
 544 get_call_expr_in (tree t)
 545 {
 546   if (TREE_CODE (t) == MODIFY_EXPR)
 547     t = TREE_OPERAND (t, 1);
 548   if (TREE_CODE (t) == WITH_SIZE_EXPR)
 549     t = TREE_OPERAND (t, 0);
 550   if (TREE_CODE (t) == CALL_EXPR)
 551     return t;
 552   return NULL_TREE;
 553 }
 554
 555 /* Given a memory reference expression, return the base address.  Note that,
 556    in contrast with get_base_var, this will not recurse inside INDIRECT_REF
 557    expressions.  Therefore, given the reference PTR->FIELD, this function
 558    will return *PTR.  Whereas get_base_var would've returned PTR.  */
 559
 560 tree
 561 get_base_address (tree t)
 562 {
 563   while (TREE_CODE (t) == REALPART_EXPR || TREE_CODE (t) == IMAGPART_EXPR
 564          || handled_component_p (t))
 565     t = TREE_OPERAND (t, 0);
 566
 567   if (SSA_VAR_P (t)
 568       || TREE_CODE (t) == STRING_CST
 569       || TREE_CODE (t) == CONSTRUCTOR
 570       || TREE_CODE (t) == INDIRECT_REF)
 571     return t;
 572   else
 573     return NULL_TREE;
 574 }
 575
 576 void
 577 recalculate_side_effects (tree t)
 578 {
 579   enum tree_code code = TREE_CODE (t);
 580   int fro = first_rtl_op (code);
 581   int i;
 582
 583   switch (TREE_CODE_CLASS (code))
 584     {
 585     case 'e':
 586       switch (code)
 587         {
 588         case INIT_EXPR:
 589         case MODIFY_EXPR:
 590         case VA_ARG_EXPR:
 591         case PREDECREMENT_EXPR:
 592         case PREINCREMENT_EXPR:
 593         case POSTDECREMENT_EXPR:
 594         case POSTINCREMENT_EXPR:
 595           /* All of these have side-effects, no matter what their
 596              operands are.  */
 597           return;
 598
 599         default:
 600           break;
 601         }
 602       /* Fall through.  */
 603
 604     case '<':  /* a comparison expression */
 605     case '1':  /* a unary arithmetic expression */
 606     case '2':  /* a binary arithmetic expression */
 607     case 'r':  /* a reference */
 608       TREE_SIDE_EFFECTS (t) = TREE_THIS_VOLATILE (t);
 609       for (i = 0; i < fro; ++i)
 610         {
 611           tree op = TREE_OPERAND (t, i);
 612           if (op && TREE_SIDE_EFFECTS (op))
 613             TREE_SIDE_EFFECTS (t) = 1;
 614         }
 615       break;
 616    }
 617 }