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 = const_unop (*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 = const_binop (*res_code, type, res_ops[0], res_ops[1]);
 154       else
 155         {
 156           tree decl = builtin_decl_implicit (*res_code);
 157           if (decl)
 158             {
 159               tem = fold_builtin_n (UNKNOWN_LOCATION, decl, res_ops, 2, false);
 160               if (tem)
 161                 {
 162                   /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 163                   STRIP_NOPS (tem);
 164                   tem = fold_convert (type, tem);
 165                 }
 166             }
 167         }
 168       if (tem != NULL_TREE
 169           && CONSTANT_CLASS_P (tem))
 170         {
 171           res_ops[0] = tem;
 172           res_ops[1] = NULL_TREE;
 173           res_ops[2] = NULL_TREE;
 174           *res_code = TREE_CODE (res_ops[0]);
 175           return true;
 176         }
 177     }
 178
 179   /* Canonicalize operand order.  */
 180   bool canonicalized = false;
 181   if (res_code->is_tree_code ()
 182       && (TREE_CODE_CLASS ((enum tree_code) *res_code) == tcc_comparison
 183           || commutative_tree_code (*res_code))
 184       && tree_swap_operands_p (res_ops[0], res_ops[1], false))
 185     {
 186       tree tem = res_ops[0];
 187       res_ops[0] = res_ops[1];
 188       res_ops[1] = tem;
 189       if (TREE_CODE_CLASS ((enum tree_code) *res_code) == tcc_comparison)
 190         *res_code = swap_tree_comparison (*res_code);
 191       canonicalized = true;
 192     }
 193
 194   code_helper res_code2;
 195   tree res_ops2[3] = {};
 196   if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
 197                        *res_code, type, res_ops[0], res_ops[1]))
 198     {
 199       *res_code = res_code2;
 200       res_ops[0] = res_ops2[0];
 201       res_ops[1] = res_ops2[1];
 202       res_ops[2] = res_ops2[2];
 203       return true;
 204     }
 205
 206   return canonicalized;
 207 }
 208
 209 /* Helper that matches and simplifies the toplevel result from
 210    a gimple_simplify run (where we don't want to build
 211    a stmt in case it's used in in-place folding).  Replaces
 212    *RES_CODE and *RES_OPS with a simplified and/or canonicalized
 213    result and returns whether any change was made.  */
 214
 215 static bool
 216 gimple_resimplify3 (gimple_seq *seq,
 217                     code_helper *res_code, tree type, tree *res_ops,
 218                     tree (*valueize)(tree))
 219 {
 220   if (constant_for_folding (res_ops[0]) && constant_for_folding (res_ops[1])
 221       && constant_for_folding (res_ops[2]))
 222     {
 223       tree tem = NULL_TREE;
 224       if (res_code->is_tree_code ())
 225         tem = fold_ternary/*_to_constant*/ (*res_code, type, res_ops[0],
 226                                             res_ops[1], res_ops[2]);
 227       else
 228         {
 229           tree decl = builtin_decl_implicit (*res_code);
 230           if (decl)
 231             {
 232               tem = fold_builtin_n (UNKNOWN_LOCATION, decl, res_ops, 3, false);
 233               if (tem)
 234                 {
 235                   /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 236                   STRIP_NOPS (tem);
 237                   tem = fold_convert (type, tem);
 238                 }
 239             }
 240         }
 241       if (tem != NULL_TREE
 242           && CONSTANT_CLASS_P (tem))
 243         {
 244           res_ops[0] = tem;
 245           res_ops[1] = NULL_TREE;
 246           res_ops[2] = NULL_TREE;
 247           *res_code = TREE_CODE (res_ops[0]);
 248           return true;
 249         }
 250     }
 251
 252   /* Canonicalize operand order.  */
 253   bool canonicalized = false;
 254   if (res_code->is_tree_code ()
 255       && commutative_ternary_tree_code (*res_code)
 256       && tree_swap_operands_p (res_ops[0], res_ops[1], false))
 257     {
 258       tree tem = res_ops[0];
 259       res_ops[0] = res_ops[1];
 260       res_ops[1] = tem;
 261       canonicalized = true;
 262     }
 263
 264   code_helper res_code2;
 265   tree res_ops2[3] = {};
 266   if (gimple_simplify (&res_code2, res_ops2, seq, valueize,
 267                        *res_code, type,
 268                        res_ops[0], res_ops[1], res_ops[2]))
 269     {
 270       *res_code = res_code2;
 271       res_ops[0] = res_ops2[0];
 272       res_ops[1] = res_ops2[1];
 273       res_ops[2] = res_ops2[2];
 274       return true;
 275     }
 276
 277   return canonicalized;
 278 }
 279
 280
 281 /* If in GIMPLE expressions with CODE go as single-rhs build
 282    a GENERIC tree for that expression into *OP0.  */
 283
 284 void
 285 maybe_build_generic_op (enum tree_code code, tree type,
 286                         tree *op0, tree op1, tree op2)
 287 {
 288   switch (code)
 289     {
 290     case REALPART_EXPR:
 291     case IMAGPART_EXPR:
 292     case VIEW_CONVERT_EXPR:
 293       *op0 = build1 (code, type, *op0);
 294       break;
 295     case BIT_FIELD_REF:
 296       *op0 = build3 (code, type, *op0, op1, op2);
 297       break;
 298     default:;
 299     }
 300 }
 301
 302 /* Push the exploded expression described by RCODE, TYPE and OPS
 303    as a statement to SEQ if necessary and return a gimple value
 304    denoting the value of the expression.  If RES is not NULL
 305    then the result will be always RES and even gimple values are
 306    pushed to SEQ.  */
 307
 308 tree
 309 maybe_push_res_to_seq (code_helper rcode, tree type, tree *ops,
 310                        gimple_seq *seq, tree res)
 311 {
 312   if (rcode.is_tree_code ())
 313     {
 314       if (!res
 315           && (TREE_CODE_LENGTH ((tree_code) rcode) == 0
 316               || ((tree_code) rcode) == ADDR_EXPR)
 317           && is_gimple_val (ops[0]))
 318         return ops[0];
 319       if (!seq)
 320         return NULL_TREE;
 321       /* Play safe and do not allow abnormals to be mentioned in
 322          newly created statements.  */
 323       if ((TREE_CODE (ops[0]) == SSA_NAME
 324            && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[0]))
 325           || (ops[1]
 326               && TREE_CODE (ops[1]) == SSA_NAME
 327               && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[1]))
 328           || (ops[2]
 329               && TREE_CODE (ops[2]) == SSA_NAME
 330               && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[2])))
 331         return NULL_TREE;
 332       if (!res)
 333         res = make_ssa_name (type);
 334       maybe_build_generic_op (rcode, type, &ops[0], ops[1], ops[2]);
 335       gimple new_stmt = gimple_build_assign (res, rcode,
 336                                              ops[0], ops[1], ops[2]);
 337       gimple_seq_add_stmt_without_update (seq, new_stmt);
 338       return res;
 339     }
 340   else
 341     {
 342       if (!seq)
 343         return NULL_TREE;
 344       tree decl = builtin_decl_implicit (rcode);
 345       if (!decl)
 346         return NULL_TREE;
 347       unsigned nargs = type_num_arguments (TREE_TYPE (decl));
 348       gcc_assert (nargs <= 3);
 349       /* Play safe and do not allow abnormals to be mentioned in
 350          newly created statements.  */
 351       if ((TREE_CODE (ops[0]) == SSA_NAME
 352            && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[0]))
 353           || (nargs >= 2
 354               && TREE_CODE (ops[1]) == SSA_NAME
 355               && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[1]))
 356           || (nargs == 3
 357               && TREE_CODE (ops[2]) == SSA_NAME
 358               && SSA_NAME_OCCURS_IN_ABNORMAL_PHI (ops[2])))
 359         return NULL_TREE;
 360       if (!res)
 361         res = make_ssa_name (type);
 362       gimple new_stmt = gimple_build_call (decl, nargs, ops[0], ops[1], ops[2]);
 363       gimple_call_set_lhs (new_stmt, res);
 364       gimple_seq_add_stmt_without_update (seq, new_stmt);
 365       return res;
 366     }
 367 }
 368
 369
 370 /* Public API overloads follow for operation being tree_code or
 371    built_in_function and for one to three operands or arguments.
 372    They return NULL_TREE if nothing could be simplified or
 373    the resulting simplified value with parts pushed to SEQ.
 374    If SEQ is NULL then if the simplification needs to create
 375    new stmts it will fail.  If VALUEIZE is non-NULL then all
 376    SSA names will be valueized using that hook prior to
 377    applying simplifications.  */
 378
 379 /* Unary ops.  */
 380
 381 tree
 382 gimple_simplify (enum tree_code code, tree type,
 383                  tree op0,
 384                  gimple_seq *seq, tree (*valueize)(tree))
 385 {
 386   if (constant_for_folding (op0))
 387     {
 388       tree res = const_unop (code, type, op0);
 389       if (res != NULL_TREE
 390           && CONSTANT_CLASS_P (res))
 391         return res;
 392     }
 393
 394   code_helper rcode;
 395   tree ops[3] = {};
 396   if (!gimple_simplify (&rcode, ops, seq, valueize,
 397                         code, type, op0))
 398     return NULL_TREE;
 399   return maybe_push_res_to_seq (rcode, type, ops, seq);
 400 }
 401
 402 /* Binary ops.  */
 403
 404 tree
 405 gimple_simplify (enum tree_code code, tree type,
 406                  tree op0, tree op1,
 407                  gimple_seq *seq, tree (*valueize)(tree))
 408 {
 409   if (constant_for_folding (op0) && constant_for_folding (op1))
 410     {
 411       tree res = const_binop (code, type, op0, op1);
 412       if (res != NULL_TREE
 413           && CONSTANT_CLASS_P (res))
 414         return res;
 415     }
 416
 417   /* Canonicalize operand order both for matching and fallback stmt
 418      generation.  */
 419   if ((commutative_tree_code (code)
 420        || TREE_CODE_CLASS (code) == tcc_comparison)
 421       && tree_swap_operands_p (op0, op1, false))
 422     {
 423       tree tem = op0;
 424       op0 = op1;
 425       op1 = tem;
 426       if (TREE_CODE_CLASS (code) == tcc_comparison)
 427         code = swap_tree_comparison (code);
 428     }
 429
 430   code_helper rcode;
 431   tree ops[3] = {};
 432   if (!gimple_simplify (&rcode, ops, seq, valueize,
 433                         code, type, op0, op1))
 434     return NULL_TREE;
 435   return maybe_push_res_to_seq (rcode, type, ops, seq);
 436 }
 437
 438 /* Ternary ops.  */
 439
 440 tree
 441 gimple_simplify (enum tree_code code, tree type,
 442                  tree op0, tree op1, tree op2,
 443                  gimple_seq *seq, tree (*valueize)(tree))
 444 {
 445   if (constant_for_folding (op0) && constant_for_folding (op1)
 446       && constant_for_folding (op2))
 447     {
 448       tree res = fold_ternary/*_to_constant */ (code, type, op0, op1, op2);
 449       if (res != NULL_TREE
 450           && CONSTANT_CLASS_P (res))
 451         return res;
 452     }
 453
 454   /* Canonicalize operand order both for matching and fallback stmt
 455      generation.  */
 456   if (commutative_ternary_tree_code (code)
 457       && tree_swap_operands_p (op0, op1, false))
 458     {
 459       tree tem = op0;
 460       op0 = op1;
 461       op1 = tem;
 462     }
 463
 464   code_helper rcode;
 465   tree ops[3] = {};
 466   if (!gimple_simplify (&rcode, ops, seq, valueize,
 467                         code, type, op0, op1, op2))
 468     return NULL_TREE;
 469   return maybe_push_res_to_seq (rcode, type, ops, seq);
 470 }
 471
 472 /* Builtin function with one argument.  */
 473
 474 tree
 475 gimple_simplify (enum built_in_function fn, tree type,
 476                  tree arg0,
 477                  gimple_seq *seq, tree (*valueize)(tree))
 478 {
 479   if (constant_for_folding (arg0))
 480     {
 481       tree decl = builtin_decl_implicit (fn);
 482       if (decl)
 483         {
 484           tree res = fold_builtin_n (UNKNOWN_LOCATION, decl, &arg0, 1, false);
 485           if (res)
 486             {
 487               /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 488               STRIP_NOPS (res);
 489               res = fold_convert (type, res);
 490               if (CONSTANT_CLASS_P (res))
 491                 return res;
 492             }
 493         }
 494     }
 495
 496   code_helper rcode;
 497   tree ops[3] = {};
 498   if (!gimple_simplify (&rcode, ops, seq, valueize,
 499                         fn, type, arg0))
 500     return NULL_TREE;
 501   return maybe_push_res_to_seq (rcode, type, ops, seq);
 502 }
 503
 504 /* Builtin function with two arguments.  */
 505
 506 tree
 507 gimple_simplify (enum built_in_function fn, tree type,
 508                  tree arg0, tree arg1,
 509                  gimple_seq *seq, tree (*valueize)(tree))
 510 {
 511   if (constant_for_folding (arg0)
 512       && constant_for_folding (arg1))
 513     {
 514       tree decl = builtin_decl_implicit (fn);
 515       if (decl)
 516         {
 517           tree args[2];
 518           args[0] = arg0;
 519           args[1] = arg1;
 520           tree res = fold_builtin_n (UNKNOWN_LOCATION, decl, args, 2, false);
 521           if (res)
 522             {
 523               /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 524               STRIP_NOPS (res);
 525               res = fold_convert (type, res);
 526               if (CONSTANT_CLASS_P (res))
 527                 return res;
 528             }
 529         }
 530     }
 531
 532   code_helper rcode;
 533   tree ops[3] = {};
 534   if (!gimple_simplify (&rcode, ops, seq, valueize,
 535                         fn, type, arg0, arg1))
 536     return NULL_TREE;
 537   return maybe_push_res_to_seq (rcode, type, ops, seq);
 538 }
 539
 540 /* Builtin function with three arguments.  */
 541
 542 tree
 543 gimple_simplify (enum built_in_function fn, tree type,
 544                  tree arg0, tree arg1, tree arg2,
 545                  gimple_seq *seq, tree (*valueize)(tree))
 546 {
 547   if (constant_for_folding (arg0)
 548       && constant_for_folding (arg1)
 549       && constant_for_folding (arg2))
 550     {
 551       tree decl = builtin_decl_implicit (fn);
 552       if (decl)
 553         {
 554           tree args[3];
 555           args[0] = arg0;
 556           args[1] = arg1;
 557           args[2] = arg2;
 558           tree res = fold_builtin_n (UNKNOWN_LOCATION, decl, args, 3, false);
 559           if (res)
 560             {
 561               /* fold_builtin_n wraps the result inside a NOP_EXPR.  */
 562               STRIP_NOPS (res);
 563               res = fold_convert (type, res);
 564               if (CONSTANT_CLASS_P (res))
 565                 return res;
 566             }
 567         }
 568     }
 569
 570   code_helper rcode;
 571   tree ops[3] = {};
 572   if (!gimple_simplify (&rcode, ops, seq, valueize,
 573                         fn, type, arg0, arg1, arg2))
 574     return NULL_TREE;
 575   return maybe_push_res_to_seq (rcode, type, ops, seq);
 576 }
 577
 578
 579 /* The main STMT based simplification entry.  It is used by the fold_stmt
 580    and the fold_stmt_to_constant APIs.  */
 581
 582 bool
 583 gimple_simplify (gimple stmt,
 584                  code_helper *rcode, tree *ops,
 585                  gimple_seq *seq, tree (*valueize)(tree))
 586 {
 587   switch (gimple_code (stmt))
 588     {
 589     case GIMPLE_ASSIGN:
 590       {
 591         enum tree_code code = gimple_assign_rhs_code (stmt);
 592         tree type = TREE_TYPE (gimple_assign_lhs (stmt));
 593         switch (gimple_assign_rhs_class (stmt))
 594           {
 595           case GIMPLE_SINGLE_RHS:
 596             if (code == REALPART_EXPR
 597                 || code == IMAGPART_EXPR
 598                 || code == VIEW_CONVERT_EXPR)
 599               {
 600                 tree op0 = TREE_OPERAND (gimple_assign_rhs1 (stmt), 0);
 601                 if (valueize && TREE_CODE (op0) == SSA_NAME)
 602                   {
 603                     tree tem = valueize (op0);
 604                     if (tem)
 605                       op0 = tem;
 606                   }
 607                 *rcode = code;
 608                 ops[0] = op0;
 609                 return gimple_resimplify1 (seq, rcode, type, ops, valueize);
 610               }
 611             else if (code == BIT_FIELD_REF)
 612               {
 613                 tree rhs1 = gimple_assign_rhs1 (stmt);
 614                 tree op0 = TREE_OPERAND (rhs1, 0);
 615                 if (valueize && TREE_CODE (op0) == SSA_NAME)
 616                   {
 617                     tree tem = valueize (op0);
 618                     if (tem)
 619                       op0 = tem;
 620                   }
 621                 *rcode = code;
 622                 ops[0] = op0;
 623                 ops[1] = TREE_OPERAND (rhs1, 1);
 624                 ops[2] = TREE_OPERAND (rhs1, 2);
 625                 return gimple_resimplify3 (seq, rcode, type, ops, valueize);
 626               }
 627             else if (code == SSA_NAME
 628                      && valueize)
 629               {
 630                 tree op0 = gimple_assign_rhs1 (stmt);
 631                 tree valueized = valueize (op0);
 632                 if (!valueized || op0 == valueized)
 633                   return false;
 634                 ops[0] = valueized;
 635                 *rcode = TREE_CODE (op0);
 636                 return true;
 637               }
 638             break;
 639           case GIMPLE_UNARY_RHS:
 640             {
 641               tree rhs1 = gimple_assign_rhs1 (stmt);
 642               if (valueize && TREE_CODE (rhs1) == SSA_NAME)
 643                 {
 644                   tree tem = valueize (rhs1);
 645                   if (tem)
 646                     rhs1 = tem;
 647                 }
 648               *rcode = code;
 649               ops[0] = rhs1;
 650               return gimple_resimplify1 (seq, rcode, type, ops, valueize);
 651             }
 652           case GIMPLE_BINARY_RHS:
 653             {
 654               tree rhs1 = gimple_assign_rhs1 (stmt);
 655               if (valueize && TREE_CODE (rhs1) == SSA_NAME)
 656                 {
 657                   tree tem = valueize (rhs1);
 658                   if (tem)
 659                     rhs1 = tem;
 660                 }
 661               tree rhs2 = gimple_assign_rhs2 (stmt);
 662               if (valueize && TREE_CODE (rhs2) == SSA_NAME)
 663                 {
 664                   tree tem = valueize (rhs2);
 665                   if (tem)
 666                     rhs2 = tem;
 667                 }
 668               *rcode = code;
 669               ops[0] = rhs1;
 670               ops[1] = rhs2;
 671               return gimple_resimplify2 (seq, rcode, type, ops, valueize);
 672             }
 673           case GIMPLE_TERNARY_RHS:
 674             {
 675               tree rhs1 = gimple_assign_rhs1 (stmt);
 676               if (valueize && TREE_CODE (rhs1) == SSA_NAME)
 677                 {
 678                   tree tem = valueize (rhs1);
 679                   if (tem)
 680                     rhs1 = tem;
 681                 }
 682               tree rhs2 = gimple_assign_rhs2 (stmt);
 683               if (valueize && TREE_CODE (rhs2) == SSA_NAME)
 684                 {
 685                   tree tem = valueize (rhs2);
 686                   if (tem)
 687                     rhs2 = tem;
 688                 }
 689               tree rhs3 = gimple_assign_rhs3 (stmt);
 690               if (valueize && TREE_CODE (rhs3) == SSA_NAME)
 691                 {
 692                   tree tem = valueize (rhs3);
 693                   if (tem)
 694                     rhs3 = tem;
 695                 }
 696               *rcode = code;
 697               ops[0] = rhs1;
 698               ops[1] = rhs2;
 699               ops[2] = rhs3;
 700               return gimple_resimplify3 (seq, rcode, type, ops, valueize);
 701             }
 702           default:
 703             gcc_unreachable ();
 704           }
 705         break;
 706       }
 707
 708     case GIMPLE_CALL:
 709       /* ???  This way we can't simplify calls with side-effects.  */
 710       if (gimple_call_lhs (stmt) != NULL_TREE)
 711         {
 712           tree fn = gimple_call_fn (stmt);
 713           /* ???  Internal function support missing.  */
 714           if (!fn)
 715             return false;
 716           if (valueize && TREE_CODE (fn) == SSA_NAME)
 717             {
 718               tree tem = valueize (fn);
 719               if (tem)
 720                 fn = tem;
 721             }
 722           if (!fn
 723               || TREE_CODE (fn) != ADDR_EXPR
 724               || TREE_CODE (TREE_OPERAND (fn, 0)) != FUNCTION_DECL
 725               || DECL_BUILT_IN_CLASS (TREE_OPERAND (fn, 0)) != BUILT_IN_NORMAL
 726               || !builtin_decl_implicit (DECL_FUNCTION_CODE (TREE_OPERAND (fn, 0)))
 727               || !gimple_builtin_call_types_compatible_p (stmt,
 728                                                           TREE_OPERAND (fn, 0)))
 729             return false;
 730
 731           tree decl = TREE_OPERAND (fn, 0);
 732           tree type = TREE_TYPE (gimple_call_lhs (stmt));
 733           switch (gimple_call_num_args (stmt))
 734             {
 735             case 1:
 736               {
 737                 tree arg1 = gimple_call_arg (stmt, 0);
 738                 if (valueize && TREE_CODE (arg1) == SSA_NAME)
 739                   {
 740                     tree tem = valueize (arg1);
 741                     if (tem)
 742                       arg1 = tem;
 743                   }
 744                 *rcode = DECL_FUNCTION_CODE (decl);
 745                 ops[0] = arg1;
 746                 return gimple_resimplify1 (seq, rcode, type, ops, valueize);
 747               }
 748             case 2:
 749               {
 750                 tree arg1 = gimple_call_arg (stmt, 0);
 751                 if (valueize && TREE_CODE (arg1) == SSA_NAME)
 752                   {
 753                     tree tem = valueize (arg1);
 754                     if (tem)
 755                       arg1 = tem;
 756                   }
 757                 tree arg2 = gimple_call_arg (stmt, 1);
 758                 if (valueize && TREE_CODE (arg2) == SSA_NAME)
 759                   {
 760                     tree tem = valueize (arg2);
 761                     if (tem)
 762                       arg2 = tem;
 763                   }
 764                 *rcode = DECL_FUNCTION_CODE (decl);
 765                 ops[0] = arg1;
 766                 ops[1] = arg2;
 767                 return gimple_resimplify2 (seq, rcode, type, ops, valueize);
 768               }
 769             case 3:
 770               {
 771                 tree arg1 = gimple_call_arg (stmt, 0);
 772                 if (valueize && TREE_CODE (arg1) == SSA_NAME)
 773                   {
 774                     tree tem = valueize (arg1);
 775                     if (tem)
 776                       arg1 = tem;
 777                   }
 778                 tree arg2 = gimple_call_arg (stmt, 1);
 779                 if (valueize && TREE_CODE (arg2) == SSA_NAME)
 780                   {
 781                     tree tem = valueize (arg2);
 782                     if (tem)
 783                       arg2 = tem;
 784                   }
 785                 tree arg3 = gimple_call_arg (stmt, 2);
 786                 if (valueize && TREE_CODE (arg3) == SSA_NAME)
 787                   {
 788                     tree tem = valueize (arg3);
 789                     if (tem)
 790                       arg3 = tem;
 791                   }
 792                 *rcode = DECL_FUNCTION_CODE (decl);
 793                 ops[0] = arg1;
 794                 ops[1] = arg2;
 795                 ops[2] = arg3;
 796                 return gimple_resimplify3 (seq, rcode, type, ops, valueize);
 797               }
 798             default:
 799               return false;
 800             }
 801         }
 802       break;
 803
 804     case GIMPLE_COND:
 805       {
 806         tree lhs = gimple_cond_lhs (stmt);
 807         if (valueize && TREE_CODE (lhs) == SSA_NAME)
 808           {
 809             tree tem = valueize (lhs);
 810             if (tem)
 811               lhs = tem;
 812           }
 813         tree rhs = gimple_cond_rhs (stmt);
 814         if (valueize && TREE_CODE (rhs) == SSA_NAME)
 815           {
 816             tree tem = valueize (rhs);
 817             if (tem)
 818               rhs = tem;
 819           }
 820         *rcode = gimple_cond_code (stmt);
 821         ops[0] = lhs;
 822         ops[1] = rhs;
 823         return gimple_resimplify2 (seq, rcode, boolean_type_node, ops, valueize);
 824       }
 825
 826     default:
 827       break;
 828     }
 829
 830   return false;
 831 }
 832
 833
 834 /* Helper for the autogenerated code, valueize OP.  */
 835
 836 inline tree
 837 do_valueize (tree (*valueize)(tree), tree op)
 838 {
 839   if (valueize && TREE_CODE (op) == SSA_NAME)
 840     return valueize (op);
 841   return op;
 842 }
 843