gcc/gimple-match-head.c

   1 /* Preamble and helpers for the autogenerated gimple-match.c file.
   2    Copyright (C) 2014 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tree.h"
  24 #include "stringpool.h"
  25 #include "stor-layout.h"
  26 #include "flags.h"
  27 #include "tm.h"
  28 #include "hard-reg-set.h"
  29 #include "function.h"
  30 #include "predict.h"
  31 #include "vec.h"
  32 #include "hashtab.h"
  33 #include "hash-set.h"
  34 #include "machmode.h"
  35 #include "input.h"
  36 #include "basic-block.h"
  37 #include "tree-ssa-alias.h"
  38 #include "internal-fn.h"
  39 #include "gimple-expr.h"
  40 #include "is-a.h"
  41 #include "gimple.h"
  42 #include "gimple-ssa.h"
  43 #include "tree-ssanames.h"
  44 #include "gimple-fold.h"
  45 #include "gimple-iterator.h"
  46 #include "expr.h"
  47 #include "tree-dfa.h"
  48 #include "builtins.h"
  49 #include "tree-phinodes.h"
  50 #include "ssa-iterators.h"
  51 #include "dumpfile.h"
  52 #include "gimple-match.h"
  53
  54
  55 /* Forward declarations of the private auto-generated matchers.
  56    They expect valueized operands in canonical order and do not
  57    perform simplification of all-constant operands.  */
  58 static bool gimple_simplify (code_helper *, tree *,
  59                              gimple_seq *, tree (*)(tree),
  60                              code_helper, tree, tree);
  61 static bool gimple_simplify (code_helper *, tree *,
  62                              gimple_seq *, tree (*)(tree),
  63                              code_helper, tree, tree, tree);
  64 static bool gimple_simplify (code_helper *, tree *,
  65                              gimple_seq *, tree (*)(tree),
  66                              code_helper, tree, tree, tree, tree);
  67
  68
  69 /* Return whether T is a constant that we'll dispatch to fold to
  70    evaluate fully constant expressions.  */
  71
  72 static inline bool
  73 constant_for_folding (tree t)
  74 {
  75   return (CONSTANT_CLASS_P (t)
  76           /* The following is only interesting to string builtins.  */
  77           || (TREE_CODE (t) == ADDR_EXPR
  78               && TREE_CODE (TREE_OPERAND (t, 0)) == STRING_CST));
  79 }
  80
  81
  82 /* Helper that matches and simplifies the toplevel result from
  83    a gimple_simplify run (where we don't want to build
  84    a stmt in case it's used in in-place folding).  Replaces
  85    *RES_CODE and *RES_OPS with a simplified and/or canonicalized
  86    result and returns whether any change was made.  */
  87
  88 static bool
  89 gimple_resimplify1 (gimple_seq *seq,
  90                     code_helper *res_code, tree type, tree *res_ops,
  91                     tree (*valueize)(tree))
  92 {
  93   if (constant_for_folding (res_ops[0]))
  94     {
  95       tree tem = NULL_TREE;
  96       if (res_code->is_tree_code ())
  97         tem = fold_unary_to_constant (*res_code, type, res_ops[0]);
  98       else
  99         {
 100           tree decl = builtin_decl_implicit (*res_code);
 101           if (decl)
 102             {
 103               tem = fold_builtin_n (UNKNOWN_LOCATION, decl, res_ops, 1, false);
 104               if (tem)
 105                 {
 106                   /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 107                   STRIP_NOPS (tem);
 108                   tem = fold_convert (type, tem);
 109                 }
 110             }
 111         }
 112       if (tem != NULL_TREE
 113           && CONSTANT_CLASS_P (tem))
 114         {
 115           res_ops[0] = tem;
 116           res_ops[1] = NULL_TREE;
 117           res_ops[2] = NULL_TREE;
 118           *res_code = TREE_CODE (res_ops[0]);
 119           return true;
 120         }
 121     }
 122
 123   code_helper res_code2;
 124   tree res_ops2[3] = {};
 125   if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
 126                        *res_code, type, res_ops[0]))
 127     {
 128       *res_code = res_code2;
 129       res_ops[0] = res_ops2[0];
 130       res_ops[1] = res_ops2[1];
 131       res_ops[2] = res_ops2[2];
 132       return true;
 133     }
 134
 135   return false;
 136 }
 137
 138 /* Helper that matches and simplifies the toplevel result from
 139    a gimple_simplify run (where we don't want to build
 140    a stmt in case it's used in in-place folding).  Replaces
 141    *RES_CODE and *RES_OPS with a simplified and/or canonicalized
 142    result and returns whether any change was made.  */
 143
 144 static bool
 145 gimple_resimplify2 (gimple_seq *seq,
 146                     code_helper *res_code, tree type, tree *res_ops,
 147                     tree (*valueize)(tree))
 148 {
 149   if (constant_for_folding (res_ops[0]) && constant_for_folding (res_ops[1]))
 150     {
 151       tree tem = NULL_TREE;
 152       if (res_code->is_tree_code ())
 153         tem = fold_binary_to_constant (*res_code, type,
 154                                        res_ops[0], res_ops[1]);
 155       else
 156         {
 157           tree decl = builtin_decl_implicit (*res_code);
 158           if (decl)
 159             {
 160               tem = fold_builtin_n (UNKNOWN_LOCATION, decl, res_ops, 2, false);
 161               if (tem)
 162                 {
 163                   /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 164                   STRIP_NOPS (tem);
 165                   tem = fold_convert (type, tem);
 166                 }
 167             }
 168         }
 169       if (tem != NULL_TREE
 170           && CONSTANT_CLASS_P (tem))
 171         {
 172           res_ops[0] = tem;
 173           res_ops[1] = NULL_TREE;
 174           res_ops[2] = NULL_TREE;
 175           *res_code = TREE_CODE (res_ops[0]);
 176           return true;
 177         }
 178     }
 179
 180   /* Canonicalize operand order.  */
 181   bool canonicalized = false;
 182   if (res_code->is_tree_code ()
 183       && (TREE_CODE_CLASS ((enum tree_code) *res_code) == tcc_comparison
 184           || commutative_tree_code (*res_code))
 185       && tree_swap_operands_p (res_ops[0], res_ops[1], false))
 186     {
 187       tree tem = res_ops[0];
 188       res_ops[0] = res_ops[1];
 189       res_ops[1] = tem;
 190       if (TREE_CODE_CLASS ((enum tree_code) *res_code) == tcc_comparison)
 191         *res_code = swap_tree_comparison (*res_code);
 192       canonicalized = true;
 193     }
 194
 195   code_helper res_code2;
 196   tree res_ops2[3] = {};
 197   if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
 198                        *res_code, type, res_ops[0], res_ops[1]))
 199     {
 200       *res_code = res_code2;
 201       res_ops[0] = res_ops2[0];
 202       res_ops[1] = res_ops2[1];
 203       res_ops[2] = res_ops2[2];
 204       return true;
 205     }
 206
 207   return canonicalized;
 208 }
 209
 210 /* Helper that matches and simplifies the toplevel result from
 211    a gimple_simplify run (where we don't want to build
 212    a stmt in case it's used in in-place folding).  Replaces
 213    *RES_CODE and *RES_OPS with a simplified and/or canonicalized
 214    result and returns whether any change was made.  */
 215
 216 static bool
 217 gimple_resimplify3 (gimple_seq *seq,
 218                     code_helper *res_code, tree type, tree *res_ops,
 219                     tree (*valueize)(tree))
 220 {
 221   if (constant_for_folding (res_ops[0]) && constant_for_folding (res_ops[1])
 222       && constant_for_folding (res_ops[2]))
 223     {
 224       tree tem = NULL_TREE;
 225       if (res_code->is_tree_code ())
 226         tem = fold_ternary/*_to_constant*/ (*res_code, type, res_ops[0],
 227                                             res_ops[1], res_ops[2]);
 228       else
 229         {
 230           tree decl = builtin_decl_implicit (*res_code);
 231           if (decl)
 232             {
 233               tem = fold_builtin_n (UNKNOWN_LOCATION, decl, res_ops, 3, false);
 234               if (tem)
 235                 {
 236                   /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 237                   STRIP_NOPS (tem);
 238                   tem = fold_convert (type, tem);
 239                 }
 240             }
 241         }
 242       if (tem != NULL_TREE
 243           && CONSTANT_CLASS_P (tem))
 244         {
 245           res_ops[0] = tem;
 246           res_ops[1] = NULL_TREE;
 247           res_ops[2] = NULL_TREE;
 248           *res_code = TREE_CODE (res_ops[0]);
 249           return true;
 250         }
 251     }
 252
 253   /* Canonicalize operand order.  */
 254   bool canonicalized = false;
 255   if (res_code->is_tree_code ()
 256       && commutative_ternary_tree_code (*res_code)
 257       && tree_swap_operands_p (res_ops[0], res_ops[1], false))
 258     {
 259       tree tem = res_ops[0];
 260       res_ops[0] = res_ops[1];
 261       res_ops[1] = tem;
 262       canonicalized = true;
 263     }
 264
 265   code_helper res_code2;
 266   tree res_ops2[3] = {};
 267   if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
 268                        *res_code, type,
 269                        res_ops[0], res_ops[1], res_ops[2]))
 270     {
 271       *res_code = res_code2;
 272       res_ops[0] = res_ops2[0];
 273       res_ops[1] = res_ops2[1];
 274       res_ops[2] = res_ops2[2];
 275       return true;
 276     }
 277
 278   return canonicalized;
 279 }
 280
 281
 282 /* If in GIMPLE expressions with CODE go as single-rhs build
 283    a GENERIC tree for that expression into *OP0.  */
 284
 285 void
 286 maybe_build_generic_op (enum tree_code code, tree type,
 287                         tree *op0, tree op1, tree op2)
 288 {
 289   switch (code)
 290     {
 291     case REALPART_EXPR:
 292     case IMAGPART_EXPR:
 293     case VIEW_CONVERT_EXPR:
 294       *op0 = build1 (code, type, *op0);
 295       break;
 296     case BIT_FIELD_REF:
 297       *op0 = build3 (code, type, *op0, op1, op2);
 298       break;
 299     default:;
 300     }
 301 }
 302
 303 /* Push the exploded expression described by RCODE, TYPE and OPS
 304    as a statement to SEQ if necessary and return a gimple value
 305    denoting the value of the expression.  If RES is not NULL
 306    then the result will be always RES and even gimple values are
 307    pushed to SEQ.  */
 308
 309 tree
 310 maybe_push_res_to_seq (code_helper rcode, tree type, tree *ops,
 311                        gimple_seq *seq, tree res)
 312 {
 313   if (rcode.is_tree_code ())
 314     {
 315       if (!res
 316           && (TREE_CODE_LENGTH ((tree_code) rcode) == 0
 317               || ((tree_code) rcode) == ADDR_EXPR)
 318           && is_gimple_val (ops[0]))
 319         return ops[0];
 320       if (!seq)
 321         return NULL_TREE;
 322       /* Play safe and do not allow abnormals to be mentioned in
 323          newly created statements.  */
 324       if ((TREE_CODE (ops[0]) == SSA_NAME
 325            && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[0]))
 326           || (ops[1]
 327               && TREE_CODE (ops[1]) == SSA_NAME
 328               && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[1]))
 329           || (ops[2]
 330               && TREE_CODE (ops[2]) == SSA_NAME
 331               && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[2])))
 332         return NULL_TREE;
 333       if (!res)
 334         res = make_ssa_name (type, NULL);
 335       maybe_build_generic_op (rcode, type, &ops[0], ops[1], ops[2]);
 336       gimple new_stmt = gimple_build_assign_with_ops (rcode, res,
 337                                                       ops[0], ops[1], ops[2]);
 338       gimple_seq_add_stmt_without_update (seq, new_stmt);
 339       return res;
 340     }
 341   else
 342     {
 343       if (!seq)
 344         return NULL_TREE;
 345       tree decl = builtin_decl_implicit (rcode);
 346       if (!decl)
 347         return NULL_TREE;
 348       unsigned nargs = type_num_arguments (TREE_TYPE (decl));
 349       gcc_assert (nargs <= 3);
 350       /* Play safe and do not allow abnormals to be mentioned in
 351          newly created statements.  */
 352       if ((TREE_CODE (ops[0]) == SSA_NAME
 353            && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[0]))
 354           || (nargs >= 2
 355               && TREE_CODE (ops[1]) == SSA_NAME
 356               && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[1]))
 357           || (nargs == 3
 358               && TREE_CODE (ops[2]) == SSA_NAME
 359               && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[2])))
 360         return NULL_TREE;
 361       if (!res)
 362         res = make_ssa_name (type, NULL);
 363       gimple new_stmt = gimple_build_call (decl, nargs, ops[0], ops[1], ops[2]);
 364       gimple_call_set_lhs (new_stmt, res);
 365       gimple_seq_add_stmt_without_update (seq, new_stmt);
 366       return res;
 367     }
 368 }
 369
 370
 371 /* Public API overloads follow for operation being tree_code or
 372    built_in_function and for one to three operands or arguments.
 373    They return NULL_TREE if nothing could be simplified or
 374    the resulting simplified value with parts pushed to SEQ.
 375    If SEQ is NULL then if the simplification needs to create
 376    new stmts it will fail.  If VALUEIZE is non-NULL then all
 377    SSA names will be valueized using that hook prior to
 378    applying simplifications.  */
 379
 380 /* Unary ops.  */
 381
 382 tree
 383 gimple_simplify (enum tree_code code, tree type,
 384                  tree op0,
 385                  gimple_seq *seq, tree (*valueize)(tree))
 386 {
 387   if (constant_for_folding (op0))
 388     {
 389       tree res = fold_unary_to_constant (code, type, op0);
 390       if (res != NULL_TREE
 391           && CONSTANT_CLASS_P (res))
 392         return res;
 393     }
 394
 395   code_helper rcode;
 396   tree ops[3] = {};
 397   if (!gimple_simplify (&rcode, ops, seq, valueize,
 398                         code, type, op0))
 399     return NULL_TREE;
 400   return maybe_push_res_to_seq (rcode, type, ops, seq);
 401 }
 402
 403 /* Binary ops.  */
 404
 405 tree
 406 gimple_simplify (enum tree_code code, tree type,
 407                  tree op0, tree op1,
 408                  gimple_seq *seq, tree (*valueize)(tree))
 409 {
 410   if (constant_for_folding (op0) && constant_for_folding (op1))
 411     {
 412       tree res = fold_binary_to_constant (code, type, op0, op1);
 413       if (res != NULL_TREE
 414           && CONSTANT_CLASS_P (res))
 415         return res;
 416     }
 417
 418   /* Canonicalize operand order both for matching and fallback stmt
 419      generation.  */
 420   if ((commutative_tree_code (code)
 421        || TREE_CODE_CLASS (code) == tcc_comparison)
 422       && tree_swap_operands_p (op0, op1, false))
 423     {
 424       tree tem = op0;
 425       op0 = op1;
 426       op1 = tem;
 427       if (TREE_CODE_CLASS (code) == tcc_comparison)
 428         code = swap_tree_comparison (code);
 429     }
 430
 431   code_helper rcode;
 432   tree ops[3] = {};
 433   if (!gimple_simplify (&rcode, ops, seq, valueize,
 434                         code, type, op0, op1))
 435     return NULL_TREE;
 436   return maybe_push_res_to_seq (rcode, type, ops, seq);
 437 }
 438
 439 /* Ternary ops.  */
 440
 441 tree
 442 gimple_simplify (enum tree_code code, tree type,
 443                  tree op0, tree op1, tree op2,
 444                  gimple_seq *seq, tree (*valueize)(tree))
 445 {
 446   if (constant_for_folding (op0) && constant_for_folding (op1)
 447       && constant_for_folding (op2))
 448     {
 449       tree res = fold_ternary/*_to_constant */ (code, type, op0, op1, op2);
 450       if (res != NULL_TREE
 451           && CONSTANT_CLASS_P (res))
 452         return res;
 453     }
 454
 455   /* Canonicalize operand order both for matching and fallback stmt
 456      generation.  */
 457   if (commutative_ternary_tree_code (code)
 458       && tree_swap_operands_p (op0, op1, false))
 459     {
 460       tree tem = op0;
 461       op0 = op1;
 462       op1 = tem;
 463     }
 464
 465   code_helper rcode;
 466   tree ops[3] = {};
 467   if (!gimple_simplify (&rcode, ops, seq, valueize,
 468                         code, type, op0, op1, op2))
 469     return NULL_TREE;
 470   return maybe_push_res_to_seq (rcode, type, ops, seq);
 471 }
 472
 473 /* Builtin function with one argument.  */
 474
 475 tree
 476 gimple_simplify (enum built_in_function fn, tree type,
 477                  tree arg0,
 478                  gimple_seq *seq, tree (*valueize)(tree))
 479 {
 480   if (constant_for_folding (arg0))
 481     {
 482       tree decl = builtin_decl_implicit (fn);
 483       if (decl)
 484         {
 485           tree res = fold_builtin_n (UNKNOWN_LOCATION, decl, &arg0, 1, false);
 486           if (res)
 487             {
 488               /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 489               STRIP_NOPS (res);
 490               res = fold_convert (type, res);
 491               if (CONSTANT_CLASS_P (res))
 492                 return res;
 493             }
 494         }
 495     }
 496
 497   code_helper rcode;
 498   tree ops[3] = {};
 499   if (!gimple_simplify (&rcode, ops, seq, valueize,
 500                         fn, type, arg0))
 501     return NULL_TREE;
 502   return maybe_push_res_to_seq (rcode, type, ops, seq);
 503 }
 504
 505 /* Builtin function with two arguments.  */
 506
 507 tree
 508 gimple_simplify (enum built_in_function fn, tree type,
 509                  tree arg0, tree arg1,
 510                  gimple_seq *seq, tree (*valueize)(tree))
 511 {
 512   if (constant_for_folding (arg0)
 513       && constant_for_folding (arg1))
 514     {
 515       tree decl = builtin_decl_implicit (fn);
 516       if (decl)
 517         {
 518           tree args[2];
 519           args[0] = arg0;
 520           args[1] = arg1;
 521           tree res = fold_builtin_n (UNKNOWN_LOCATION, decl, args, 2, false);
 522           if (res)
 523             {
 524               /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 525               STRIP_NOPS (res);
 526               res = fold_convert (type, res);
 527               if (CONSTANT_CLASS_P (res))
 528                 return res;
 529             }
 530         }
 531     }
 532
 533   code_helper rcode;
 534   tree ops[3] = {};
 535   if (!gimple_simplify (&rcode, ops, seq, valueize,
 536                         fn, type, arg0, arg1))
 537     return NULL_TREE;
 538   return maybe_push_res_to_seq (rcode, type, ops, seq);
 539 }
 540
 541 /* Builtin function with three arguments.  */
 542
 543 tree
 544 gimple_simplify (enum built_in_function fn, tree type,
 545                  tree arg0, tree arg1, tree arg2,
 546                  gimple_seq *seq, tree (*valueize)(tree))
 547 {
 548   if (constant_for_folding (arg0)
 549       && constant_for_folding (arg1)
 550       && constant_for_folding (arg2))
 551     {
 552       tree decl = builtin_decl_implicit (fn);
 553       if (decl)
 554         {
 555           tree args[3];
 556           args[0] = arg0;
 557           args[1] = arg1;
 558           args[2] = arg2;
 559           tree res = fold_builtin_n (UNKNOWN_LOCATION, decl, args, 3, false);
 560           if (res)
 561             {
 562               /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 563               STRIP_NOPS (res);
 564               res = fold_convert (type, res);
 565               if (CONSTANT_CLASS_P (res))
 566                 return res;
 567             }
 568         }
 569     }
 570
 571   code_helper rcode;
 572   tree ops[3] = {};
 573   if (!gimple_simplify (&rcode, ops, seq, valueize,
 574                         fn, type, arg0, arg1, arg2))
 575     return NULL_TREE;
 576   return maybe_push_res_to_seq (rcode, type, ops, seq);
 577 }
 578
 579
 580 /* The main STMT based simplification entry.  It is used by the fold_stmt
 581    and the fold_stmt_to_constant APIs.  */
 582
 583 bool
 584 gimple_simplify (gimple stmt,
 585                  code_helper *rcode, tree *ops,
 586                  gimple_seq *seq, tree (*valueize)(tree))
 587 {
 588   switch (gimple_code (stmt))
 589     {
 590     case GIMPLE_ASSIGN:
 591       {
 592         enum tree_code code = gimple_assign_rhs_code (stmt);
 593         tree type = TREE_TYPE (gimple_assign_lhs (stmt));
 594         switch (gimple_assign_rhs_class (stmt))
 595           {
 596           case GIMPLE_SINGLE_RHS:
 597             if (code == REALPART_EXPR
 598                 || code == IMAGPART_EXPR
 599                 || code == VIEW_CONVERT_EXPR)
 600               {
 601                 tree op0 = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
 602                 if (valueize && TREE_CODE (op0) == SSA_NAME)
 603                   {
 604                     tree tem = valueize (op0);
 605                     if (tem)
 606                       op0 = tem;
 607                   }
 608                 *rcode = code;
 609                 ops[0] = op0;
 610                 return gimple_resimplify1 (seq, rcode, type, ops, valueize);
 611               }
 612             else if (code == BIT_FIELD_REF)
 613               {
 614                 tree rhs1 = gimple_assign_rhs1 (stmt);
 615                 tree op0 = TREE_OPERAND (rhs1, 0);
 616                 if (valueize && TREE_CODE (op0) == SSA_NAME)
 617                   {
 618                     tree tem = valueize (op0);
 619                     if (tem)
 620                       op0 = tem;
 621                   }
 622                 *rcode = code;
 623                 ops[0] = op0;
 624                 ops[1] = TREE_OPERAND (rhs1, 1);
 625                 ops[2] = TREE_OPERAND (rhs1, 2);
 626                 return gimple_resimplify3 (seq, rcode, type, ops, valueize);
 627               }
 628             else if (code == SSA_NAME
 629                      && valueize)
 630               {
 631                 tree op0 = gimple_assign_rhs1 (stmt);
 632                 tree valueized = valueize (op0);
 633                 if (!valueized || op0 == valueized)
 634                   return false;
 635                 ops[0] = valueized;
 636                 *rcode = TREE_CODE (op0);
 637                 return true;
 638               }
 639             break;
 640           case GIMPLE_UNARY_RHS:
 641             {
 642               tree rhs1 = gimple_assign_rhs1 (stmt);
 643               if (valueize && TREE_CODE (rhs1) == SSA_NAME)
 644                 {
 645                   tree tem = valueize (rhs1);
 646                   if (tem)
 647                     rhs1 = tem;
 648                 }
 649               *rcode = code;
 650               ops[0] = rhs1;
 651               return gimple_resimplify1 (seq, rcode, type, ops, valueize);
 652             }
 653           case GIMPLE_BINARY_RHS:
 654             {
 655               tree rhs1 = gimple_assign_rhs1 (stmt);
 656               if (valueize && TREE_CODE (rhs1) == SSA_NAME)
 657                 {
 658                   tree tem = valueize (rhs1);
 659                   if (tem)
 660                     rhs1 = tem;
 661                 }
 662               tree rhs2 = gimple_assign_rhs2 (stmt);
 663               if (valueize && TREE_CODE (rhs2) == SSA_NAME)
 664                 {
 665                   tree tem = valueize (rhs2);
 666                   if (tem)
 667                     rhs2 = tem;
 668                 }
 669               *rcode = code;
 670               ops[0] = rhs1;
 671               ops[1] = rhs2;
 672               return gimple_resimplify2 (seq, rcode, type, ops, valueize);
 673             }
 674           case GIMPLE_TERNARY_RHS:
 675             {
 676               tree rhs1 = gimple_assign_rhs1 (stmt);
 677               if (valueize && TREE_CODE (rhs1) == SSA_NAME)
 678                 {
 679                   tree tem = valueize (rhs1);
 680                   if (tem)
 681                     rhs1 = tem;
 682                 }
 683               tree rhs2 = gimple_assign_rhs2 (stmt);
 684               if (valueize && TREE_CODE (rhs2) == SSA_NAME)
 685                 {
 686                   tree tem = valueize (rhs2);
 687                   if (tem)
 688                     rhs2 = tem;
 689                 }
 690               tree rhs3 = gimple_assign_rhs3 (stmt);
 691               if (valueize && TREE_CODE (rhs3) == SSA_NAME)
 692                 {
 693                   tree tem = valueize (rhs3);
 694                   if (tem)
 695                     rhs3 = tem;
 696                 }
 697               *rcode = code;
 698               ops[0] = rhs1;
 699               ops[1] = rhs2;
 700               ops[2] = rhs3;
 701               return gimple_resimplify3 (seq, rcode, type, ops, valueize);
 702             }
 703           default:
 704             gcc_unreachable ();
 705           }
 706         break;
 707       }
 708
 709     case GIMPLE_CALL:
 710       /* ???  This way we can't simplify calls with side-effects.  */
 711       if (gimple_call_lhs (stmt) != NULL_TREE)
 712         {
 713           tree fn = gimple_call_fn (stmt);
 714           /* ???  Internal function support missing.  */
 715           if (!fn)
 716             return false;
 717           if (valueize && TREE_CODE (fn) == SSA_NAME)
 718             {
 719               tree tem = valueize (fn);
 720               if (tem)
 721                 fn = tem;
 722             }
 723           if (!fn
 724               || TREE_CODE (fn) != ADDR_EXPR
 725               || TREE_CODE (TREE_OPERAND (fn, 0)) != FUNCTION_DECL
 726               || DECL_BUILT_IN_CLASS (TREE_OPERAND (fn, 0)) != BUILT_IN_NORMAL
 727               || !builtin_decl_implicit (DECL_FUNCTION_CODE (TREE_OPERAND (fn, 0)))
 728               || !gimple_builtin_call_types_compatible_p (stmt,
 729                                                           TREE_OPERAND (fn, 0)))
 730             return false;
 731
 732           tree decl = TREE_OPERAND (fn, 0);
 733           tree type = TREE_TYPE (gimple_call_lhs (stmt));
 734           switch (gimple_call_num_args (stmt))
 735             {
 736             case 1:
 737               {
 738                 tree arg1 = gimple_call_arg (stmt, 0);
 739                 if (valueize && TREE_CODE (arg1) == SSA_NAME)
 740                   {
 741                     tree tem = valueize (arg1);
 742                     if (tem)
 743                       arg1 = tem;
 744                   }
 745                 *rcode = DECL_FUNCTION_CODE (decl);
 746                 ops[0] = arg1;
 747                 return gimple_resimplify1 (seq, rcode, type, ops, valueize);
 748               }
 749             case 2:
 750               {
 751                 tree arg1 = gimple_call_arg (stmt, 0);
 752                 if (valueize && TREE_CODE (arg1) == SSA_NAME)
 753                   {
 754                     tree tem = valueize (arg1);
 755                     if (tem)
 756                       arg1 = tem;
 757                   }
 758                 tree arg2 = gimple_call_arg (stmt, 1);
 759                 if (valueize && TREE_CODE (arg2) == SSA_NAME)
 760                   {
 761                     tree tem = valueize (arg2);
 762                     if (tem)
 763                       arg2 = tem;
 764                   }
 765                 *rcode = DECL_FUNCTION_CODE (decl);
 766                 ops[0] = arg1;
 767                 ops[1] = arg2;
 768                 return gimple_resimplify2 (seq, rcode, type, ops, valueize);
 769               }
 770             case 3:
 771               {
 772                 tree arg1 = gimple_call_arg (stmt, 0);
 773                 if (valueize && TREE_CODE (arg1) == SSA_NAME)
 774                   {
 775                     tree tem = valueize (arg1);
 776                     if (tem)
 777                       arg1 = tem;
 778                   }
 779                 tree arg2 = gimple_call_arg (stmt, 1);
 780                 if (valueize && TREE_CODE (arg2) == SSA_NAME)
 781                   {
 782                     tree tem = valueize (arg2);
 783                     if (tem)
 784                       arg2 = tem;
 785                   }
 786                 tree arg3 = gimple_call_arg (stmt, 2);
 787                 if (valueize && TREE_CODE (arg3) == SSA_NAME)
 788                   {
 789                     tree tem = valueize (arg3);
 790                     if (tem)
 791                       arg3 = tem;
 792                   }
 793                 *rcode = DECL_FUNCTION_CODE (decl);
 794                 ops[0] = arg1;
 795                 ops[1] = arg2;
 796                 ops[2] = arg3;
 797                 return gimple_resimplify3 (seq, rcode, type, ops, valueize);
 798               }
 799             default:
 800               return false;
 801             }
 802         }
 803       break;
 804
 805     case GIMPLE_COND:
 806       {
 807         tree lhs = gimple_cond_lhs (stmt);
 808         if (valueize && TREE_CODE (lhs) == SSA_NAME)
 809           {
 810             tree tem = valueize (lhs);
 811             if (tem)
 812               lhs = tem;
 813           }
 814         tree rhs = gimple_cond_rhs (stmt);
 815         if (valueize && TREE_CODE (rhs) == SSA_NAME)
 816           {
 817             tree tem = valueize (rhs);
 818             if (tem)
 819               rhs = tem;
 820           }
 821         *rcode = gimple_cond_code (stmt);
 822         ops[0] = lhs;
 823         ops[1] = rhs;
 824         return gimple_resimplify2 (seq, rcode, boolean_type_node, ops, valueize);
 825       }
 826
 827     default:
 828       break;
 829     }
 830
 831   return false;
 832 }
 833
 834
 835 /* Helper for the autogenerated code, valueize OP.  */
 836
 837 inline tree
 838 do_valueize (tree (*valueize)(tree), tree op)
 839 {
 840   if (valueize && TREE_CODE (op) == SSA_NAME)
 841     return valueize (op);
 842   return op;
 843 }
 844