GCC Wikia
Advertisement

このページを編集する際は,編集に関する方針に従ってください.[]

概要[]

引数[]

実装[]

7023 /* Fold a binary expression of code CODE and type TYPE with operands
7024    OP0 and OP1.  Return the folded expression if folding is
7025    successful.  Otherwise, return NULL_TREE.  */
7026 
7027 tree
7028 fold_binary (enum tree_code code, tree type, tree op0, tree op1)
7029 {
7030   tree t1 = NULL_TREE;
7031   tree tem;
7032   tree arg0 = NULL_TREE, arg1 = NULL_TREE;
7033   enum tree_code_class kind = TREE_CODE_CLASS (code);
7034 
7035   /* WINS will be nonzero when the switch is done
7036      if all operands are constant.  */
7037   int wins = 1;
7038 
7039   gcc_assert (IS_EXPR_CODE_CLASS (kind)
7040               && TREE_CODE_LENGTH (code) == 2);
7041 
7042   arg0 = op0;
7043   arg1 = op1;
7044 
7045   if (arg0)
7046     {
7047       tree subop;
7048 
7049       /* Strip any conversions that don't change the mode.  This is
7050          safe for every expression, except for a comparison expression
7051          because its signedness is derived from its operands.  So, in
7052          the latter case, only strip conversions that don't change the
7053          signedness.
7054 
7055          Note that this is done as an internal manipulation within the
7056          constant folder, in order to find the simplest representation
7057          of the arguments so that their form can be studied.  In any
7058          cases, the appropriate type conversions should be put back in
7059          the tree that will get out of the constant folder.  */
7060       if (kind == tcc_comparison)
7061         STRIP_SIGN_NOPS (arg0);
7062       else
7063         STRIP_NOPS (arg0);
7064 
7065       if (TREE_CODE (arg0) == COMPLEX_CST)
7066         subop = TREE_REALPART (arg0);
7067       else
7068         subop = arg0;
7069 
7070       if (TREE_CODE (subop) != INTEGER_CST
7071           && TREE_CODE (subop) != REAL_CST)
7072         /* Note that TREE_CONSTANT isn't enough:
7073            static var addresses are constant but we can't
7074            do arithmetic on them.  */
7075         wins = 0;
7076     }
7077 
7078   if (arg1)
7079     {
7080       tree subop;
7081 
7082       /* Strip any conversions that don't change the mode.  This is
7083          safe for every expression, except for a comparison expression
7084          because its signedness is derived from its operands.  So, in
7085          the latter case, only strip conversions that don't change the
7086          signedness.
7087 
7088          Note that this is done as an internal manipulation within the
7089          constant folder, in order to find the simplest representation
7090          of the arguments so that their form can be studied.  In any
7091          cases, the appropriate type conversions should be put back in
7092          the tree that will get out of the constant folder.  */
7093       if (kind == tcc_comparison)
7094         STRIP_SIGN_NOPS (arg1);
7095       else
7096         STRIP_NOPS (arg1);
7097 
7098       if (TREE_CODE (arg1) == COMPLEX_CST)
7099         subop = TREE_REALPART (arg1);
7100       else
7101         subop = arg1;
7102 
7103       if (TREE_CODE (subop) != INTEGER_CST
7104           && TREE_CODE (subop) != REAL_CST)
7105         /* Note that TREE_CONSTANT isn't enough:
7106            static var addresses are constant but we can't
7107            do arithmetic on them.  */
7108         wins = 0;
7109     }
7110 
7111   /* If this is a commutative operation, and ARG0 is a constant, move it
7112      to ARG1 to reduce the number of tests below.  */

可換な命令(arg0とarg1を交換して計算しても結果が変わらない命令)であり、arg0が固定値であればarg0とarg1を交換して畳み込んでみる。

7113   if (commutative_tree_code (code)
7114       && tree_swap_operands_p (arg0, arg1, true))
7115     return fold_build2 (code, type, op1, op0);
7116 
7117   /* Now WINS is set as described above,
7118      ARG0 is the first operand of EXPR,
7119      and ARG1 is the second operand (if it has more than one operand).
7120 
7121      First check for cases where an arithmetic operation is applied to a
7122      compound, conditional, or comparison operation.  Push the arithmetic
7123      operation inside the compound or conditional to see if any folding
7124      can then be done.  Convert comparison to conditional for this purpose.
7125      The also optimizes non-constant cases that used to be done in
7126      expand_expr.
7127 
7128      Before we do that, see if this is a BIT_AND_EXPR or a BIT_IOR_EXPR,
7129      one of the operands is a comparison and the other is a comparison, a
7130      BIT_AND_EXPR with the constant 1, or a truth value.  In that case, the
7131      code below would make the expression more complex.  Change it to a
7132      TRUTH_{AND,OR}_EXPR.  Likewise, convert a similar NE_EXPR to
7133      TRUTH_XOR_EXPR and an EQ_EXPR to the inversion of a TRUTH_XOR_EXPR.  */
7134 
7135   if ((code == BIT_AND_EXPR || code == BIT_IOR_EXPR
7136        || code == EQ_EXPR || code == NE_EXPR)
7137       && ((truth_value_p (TREE_CODE (arg0))
7138            && (truth_value_p (TREE_CODE (arg1))
7139                || (TREE_CODE (arg1) == BIT_AND_EXPR
7140                    && integer_onep (TREE_OPERAND (arg1, 1)))))
7141           || (truth_value_p (TREE_CODE (arg1))
7142               && (truth_value_p (TREE_CODE (arg0))
7143                   || (TREE_CODE (arg0) == BIT_AND_EXPR
7144                       && integer_onep (TREE_OPERAND (arg0, 1)))))))
7145     {
7146       tem = fold_build2 (code == BIT_AND_EXPR ? TRUTH_AND_EXPR
7147                          : code == BIT_IOR_EXPR ? TRUTH_OR_EXPR
7148                          : TRUTH_XOR_EXPR,
7149                          boolean_type_node,
7150                          fold_convert (boolean_type_node, arg0),
7151                          fold_convert (boolean_type_node, arg1));
7152 
7153       if (code == EQ_EXPR)
7154         tem = invert_truthvalue (tem);
7155 
7156       return fold_convert (type, tem);
7157     }
7158 

tcc_binary, tcc_comparison[]

7159   if (TREE_CODE_CLASS (code) == tcc_binary
7160       || TREE_CODE_CLASS (code) == tcc_comparison)
7161     {
7162       if (TREE_CODE (arg0) == COMPOUND_EXPR)
7163         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg0, 0),
7164                        fold_build2 (code, type,
7165                                     TREE_OPERAND (arg0, 1), op1));
7166       if (TREE_CODE (arg1) == COMPOUND_EXPR
7167           && reorder_operands_p (arg0, TREE_OPERAND (arg1, 0)))
7168         return build2 (COMPOUND_EXPR, type, TREE_OPERAND (arg1, 0),
7169                        fold_build2 (code, type,
7170                                     op0, TREE_OPERAND (arg1, 1)));
7171 
7172       if (TREE_CODE (arg0) == COND_EXPR || COMPARISON_CLASS_P (arg0))
7173         {
7174           tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
7175                                                      arg0, arg1, 
7176                                                      /*cond_first_p=*/1);
7177           if (tem != NULL_TREE)
7178             return tem;
7179         }
7180 
7181       if (TREE_CODE (arg1) == COND_EXPR || COMPARISON_CLASS_P (arg1))
7182         {
7183           tem = fold_binary_op_with_conditional_arg (code, type, op0, op1,
7184                                                      arg1, arg0, 
7185                                                      /*cond_first_p=*/0);
7186           if (tem != NULL_TREE)
7187             return tem;
7188         }
7189     }
7190 
7191   switch (code)
7192     {

PLUS_EXPR[]

7193     case PLUS_EXPR:
7194       /* A + (-B) -> A - B */
7195       if (TREE_CODE (arg1) == NEGATE_EXPR)
7196         return fold_build2 (MINUS_EXPR, type,
7197                             fold_convert (type, arg0),
7198                             fold_convert (type, TREE_OPERAND (arg1, 0)));
7199       /* (-A) + B -> B - A */
7200       if (TREE_CODE (arg0) == NEGATE_EXPR
7201           && reorder_operands_p (TREE_OPERAND (arg0, 0), arg1))
7202         return fold_build2 (MINUS_EXPR, type,
7203                             fold_convert (type, arg1),
7204                             fold_convert (type, TREE_OPERAND (arg0, 0)));
7205       /* Convert ~A + 1 to -A.  */
7206       if (INTEGRAL_TYPE_P (type)
7207           && TREE_CODE (arg0) == BIT_NOT_EXPR
7208           && integer_onep (arg1))
7209         return fold_build1 (NEGATE_EXPR, type, TREE_OPERAND (arg0, 0));
7210 

INTEGER[]

7211       if (! FLOAT_TYPE_P (type))
7212         {
7213           if (integer_zerop (arg1))
7214             return non_lvalue (fold_convert (type, arg0));
7215 
7216           /* If we are adding two BIT_AND_EXPR's, both of which are and'ing
7217              with a constant, and the two constants have no bits in common,
7218              we should treat this as a BIT_IOR_EXPR since this may produce more
7219              simplifications.  */
7220           if (TREE_CODE (arg0) == BIT_AND_EXPR
7221               && TREE_CODE (arg1) == BIT_AND_EXPR
7222               && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
7223               && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
7224               && integer_zerop (const_binop (BIT_AND_EXPR,
7225                                              TREE_OPERAND (arg0, 1),
7226                                              TREE_OPERAND (arg1, 1), 0)))
7227             {
7228               code = BIT_IOR_EXPR;
7229               goto bit_ior;
7230             }
7231 
7232           /* Reassociate (plus (plus (mult) (foo)) (mult)) as
7233              (plus (plus (mult) (mult)) (foo)) so that we can
7234              take advantage of the factoring cases below.  */
7235           if (((TREE_CODE (arg0) == PLUS_EXPR
7236                 || TREE_CODE (arg0) == MINUS_EXPR)
7237                && TREE_CODE (arg1) == MULT_EXPR)
7238               || ((TREE_CODE (arg1) == PLUS_EXPR
7239                    || TREE_CODE (arg1) == MINUS_EXPR)
7240                   && TREE_CODE (arg0) == MULT_EXPR))
7241             {
7242               tree parg0, parg1, parg, marg;
7243               enum tree_code pcode;
7244 
7245               if (TREE_CODE (arg1) == MULT_EXPR)
7246                 parg = arg0, marg = arg1;
7247               else
7248                 parg = arg1, marg = arg0;
7249               pcode = TREE_CODE (parg);
7250               parg0 = TREE_OPERAND (parg, 0);
7251               parg1 = TREE_OPERAND (parg, 1);
7252               STRIP_NOPS (parg0);
7253               STRIP_NOPS (parg1);
7254 
7255               if (TREE_CODE (parg0) == MULT_EXPR
7256                   && TREE_CODE (parg1) != MULT_EXPR)
7257                 return fold_build2 (pcode, type,
7258                                     fold_build2 (PLUS_EXPR, type,
7259                                                  fold_convert (type, parg0),
7260                                                  fold_convert (type, marg)),
7261                                     fold_convert (type, parg1));
7262               if (TREE_CODE (parg0) != MULT_EXPR
7263                   && TREE_CODE (parg1) == MULT_EXPR)
7264                 return fold_build2 (PLUS_EXPR, type,
7265                                     fold_convert (type, parg0),
7266                                     fold_build2 (pcode, type,
7267                                                  fold_convert (type, marg),
7268                                                  fold_convert (type,
7269                                                                parg1)));
7270             }
7271 
7272           if (TREE_CODE (arg0) == MULT_EXPR && TREE_CODE (arg1) == MULT_EXPR)
7273             {
7274               tree arg00, arg01, arg10, arg11;
7275               tree alt0 = NULL_TREE, alt1 = NULL_TREE, same;
7276 
7277               /* (A * C) + (B * C) -> (A+B) * C.
7278                  We are most concerned about the case where C is a constant,
7279                  but other combinations show up during loop reduction.  Since
7280                  it is not difficult, try all four possibilities.  */
7281 
7282               arg00 = TREE_OPERAND (arg0, 0);
7283               arg01 = TREE_OPERAND (arg0, 1);
7284               arg10 = TREE_OPERAND (arg1, 0);
7285               arg11 = TREE_OPERAND (arg1, 1);
7286               same = NULL_TREE;
7287 
7288               if (operand_equal_p (arg01, arg11, 0))
7289                 same = arg01, alt0 = arg00, alt1 = arg10;
7290               else if (operand_equal_p (arg00, arg10, 0))
7291                 same = arg00, alt0 = arg01, alt1 = arg11;
7292               else if (operand_equal_p (arg00, arg11, 0))
7293                 same = arg00, alt0 = arg01, alt1 = arg10;
7294               else if (operand_equal_p (arg01, arg10, 0))
7295                 same = arg01, alt0 = arg00, alt1 = arg11;
7296 
7297               /* No identical multiplicands; see if we can find a common
7298                  power-of-two factor in non-power-of-two multiplies.  This
7299                  can help in multi-dimensional array access.  */
7300               else if (TREE_CODE (arg01) == INTEGER_CST
7301                        && TREE_CODE (arg11) == INTEGER_CST
7302                        && TREE_INT_CST_HIGH (arg01) == 0
7303                        && TREE_INT_CST_HIGH (arg11) == 0)
7304                 {
7305                   HOST_WIDE_INT int01, int11, tmp;
7306                   int01 = TREE_INT_CST_LOW (arg01);
7307                   int11 = TREE_INT_CST_LOW (arg11);
7308 
7309                   /* Move min of absolute values to int11.  */
7310                   if ((int01 >= 0 ? int01 : -int01)
7311                       < (int11 >= 0 ? int11 : -int11))
7312                     {
7313                       tmp = int01, int01 = int11, int11 = tmp;
7314                       alt0 = arg00, arg00 = arg10, arg10 = alt0;
7315                       alt0 = arg01, arg01 = arg11, arg11 = alt0;
7316                     }
7317 
7318                   if (exact_log2 (int11) > 0 && int01 % int11 == 0)
7319                     {
7320                       alt0 = fold_build2 (MULT_EXPR, type, arg00,
7321                                           build_int_cst (NULL_TREE,
7322                                                          int01 / int11));
7323                       alt1 = arg10;
7324                       same = arg11;
7325                     }
7326                 }
7327 
7328               if (same)
7329                 return fold_build2 (MULT_EXPR, type,
7330                                     fold_build2 (PLUS_EXPR, type,
7331                                                  fold_convert (type, alt0),
7332                                                  fold_convert (type, alt1)),
7333                                     fold_convert (type, same));
7334             }
7335 
7336           /* Try replacing &a[i1] + c * i2 with &a[i1 + i2], if c is step
7337              of the array.  Loop optimizer sometimes produce this type of
7338              expressions.  */
7339           if (TREE_CODE (arg0) == ADDR_EXPR)
7340             {
7341               tem = try_move_mult_to_index (PLUS_EXPR, arg0, arg1);
7342               if (tem)
7343                 return fold_convert (type, tem);
7344             }
7345           else if (TREE_CODE (arg1) == ADDR_EXPR)
7346             {
7347               tem = try_move_mult_to_index (PLUS_EXPR, arg1, arg0);
7348               if (tem)
7349                 return fold_convert (type, tem);
7350             }
7351         }

REAL[]

7352       else
7353         {
7354           /* See if ARG1 is zero and X + ARG1 reduces to X.  */
7355           if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 0))
7356             return non_lvalue (fold_convert (type, arg0));
7357 
7358           /* Likewise if the operands are reversed.  */
7359           if (fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
7360             return non_lvalue (fold_convert (type, arg1));
7361 
7362           /* Convert X + -C into X - C.  */
7363           if (TREE_CODE (arg1) == REAL_CST
7364               && REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1)))
7365             {
7366               tem = fold_negate_const (arg1, type);
7367               if (!TREE_OVERFLOW (arg1) || !flag_trapping_math)
7368                 return fold_build2 (MINUS_EXPR, type,
7369                                     fold_convert (type, arg0),
7370                                     fold_convert (type, tem));
7371             }
7372 
7373           if (flag_unsafe_math_optimizations
7374               && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
7375               && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
7376               && (tem = distribute_real_division (code, type, arg0, arg1)))
7377             return tem;
7378 
7379           /* Convert x+x into x*2.0.  */
7380           if (operand_equal_p (arg0, arg1, 0)
7381               && SCALAR_FLOAT_TYPE_P (type))
7382             return fold_build2 (MULT_EXPR, type, arg0,
7383                                 build_real (type, dconst2));
7384 
7385           /* Convert x*c+x into x*(c+1).  */
7386           if (flag_unsafe_math_optimizations
7387               && TREE_CODE (arg0) == MULT_EXPR
7388               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
7389               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg0, 1))
7390               && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
7391             {
7392               REAL_VALUE_TYPE c;
7393 
7394               c = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
7395               real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7396               return fold_build2 (MULT_EXPR, type, arg1,
7397                                   build_real (type, c));
7398             }
7399 
7400           /* Convert x+x*c into x*(c+1).  */
7401           if (flag_unsafe_math_optimizations
7402               && TREE_CODE (arg1) == MULT_EXPR
7403               && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST
7404               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg1, 1))
7405               && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
7406             {
7407               REAL_VALUE_TYPE c;
7408 
7409               c = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
7410               real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7411               return fold_build2 (MULT_EXPR, type, arg0,
7412                                   build_real (type, c));
7413             }
7414 
7415           /* Convert x*c1+x*c2 into x*(c1+c2).  */
7416           if (flag_unsafe_math_optimizations
7417               && TREE_CODE (arg0) == MULT_EXPR
7418               && TREE_CODE (arg1) == MULT_EXPR
7419               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
7420               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg0, 1))
7421               && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST
7422               && ! TREE_CONSTANT_OVERFLOW (TREE_OPERAND (arg1, 1))
7423               && operand_equal_p (TREE_OPERAND (arg0, 0),
7424                                   TREE_OPERAND (arg1, 0), 0))
7425             {
7426               REAL_VALUE_TYPE c1, c2;
7427 
7428               c1 = TREE_REAL_CST (TREE_OPERAND (arg0, 1));
7429               c2 = TREE_REAL_CST (TREE_OPERAND (arg1, 1));
7430               real_arithmetic (&c1, PLUS_EXPR, &c1, &c2);
7431               return fold_build2 (MULT_EXPR, type,
7432                                   TREE_OPERAND (arg0, 0),
7433                                   build_real (type, c1));
7434             }
7435           /* Convert a + (b*c + d*e) into (a + b*c) + d*e.  */
7436           if (flag_unsafe_math_optimizations
7437               && TREE_CODE (arg1) == PLUS_EXPR
7438               && TREE_CODE (arg0) != MULT_EXPR)
7439             {
7440               tree tree10 = TREE_OPERAND (arg1, 0);
7441               tree tree11 = TREE_OPERAND (arg1, 1);
7442               if (TREE_CODE (tree11) == MULT_EXPR
7443                   && TREE_CODE (tree10) == MULT_EXPR)
7444                 {
7445                   tree tree0;
7446                   tree0 = fold_build2 (PLUS_EXPR, type, arg0, tree10);
7447                   return fold_build2 (PLUS_EXPR, type, tree0, tree11);
7448                 }
7449             }
7450           /* Convert (b*c + d*e) + a into b*c + (d*e +a).  */
7451           if (flag_unsafe_math_optimizations
7452               && TREE_CODE (arg0) == PLUS_EXPR
7453               && TREE_CODE (arg1) != MULT_EXPR)
7454             {
7455               tree tree00 = TREE_OPERAND (arg0, 0);
7456               tree tree01 = TREE_OPERAND (arg0, 1);
7457               if (TREE_CODE (tree01) == MULT_EXPR
7458                   && TREE_CODE (tree00) == MULT_EXPR)
7459                 {
7460                   tree tree0;
7461                   tree0 = fold_build2 (PLUS_EXPR, type, tree01, arg1);
7462                   return fold_build2 (PLUS_EXPR, type, tree00, tree0);
7463                 }
7464             }
7465         }
7466 

7467      bit_rotate:
7468       /* (A << C1) + (A >> C2) if A is unsigned and C1+C2 is the size of A
7469          is a rotate of A by C1 bits.  */
7470       /* (A << B) + (A >> (Z - B)) if A is unsigned and Z is the size of A
7471          is a rotate of A by B bits.  */
7472       {
7473         enum tree_code code0, code1;
7474         code0 = TREE_CODE (arg0);
7475         code1 = TREE_CODE (arg1);
7476         if (((code0 == RSHIFT_EXPR && code1 == LSHIFT_EXPR)
7477              || (code1 == RSHIFT_EXPR && code0 == LSHIFT_EXPR))
7478             && operand_equal_p (TREE_OPERAND (arg0, 0),
7479                                 TREE_OPERAND (arg1, 0), 0)
7480             && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
7481           {
7482             tree tree01, tree11;
7483             enum tree_code code01, code11;
7484 
7485             tree01 = TREE_OPERAND (arg0, 1);
7486             tree11 = TREE_OPERAND (arg1, 1);
7487             STRIP_NOPS (tree01);
7488             STRIP_NOPS (tree11);
7489             code01 = TREE_CODE (tree01);
7490             code11 = TREE_CODE (tree11);
7491             if (code01 == INTEGER_CST
7492                 && code11 == INTEGER_CST
7493                 && TREE_INT_CST_HIGH (tree01) == 0
7494                 && TREE_INT_CST_HIGH (tree11) == 0
7495                 && ((TREE_INT_CST_LOW (tree01) + TREE_INT_CST_LOW (tree11))
7496                     == TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)))))
7497               return build2 (LROTATE_EXPR, type, TREE_OPERAND (arg0, 0),
7498                              code0 == LSHIFT_EXPR ? tree01 : tree11);
7499             else if (code11 == MINUS_EXPR)
7500               {
7501                 tree tree110, tree111;
7502                 tree110 = TREE_OPERAND (tree11, 0);
7503                 tree111 = TREE_OPERAND (tree11, 1);
7504                 STRIP_NOPS (tree110);
7505                 STRIP_NOPS (tree111);
7506                 if (TREE_CODE (tree110) == INTEGER_CST
7507                     && 0 == compare_tree_int (tree110,
7508                                               TYPE_PRECISION
7509                                               (TREE_TYPE (TREE_OPERAND
7510                                                           (arg0, 0))))
7511                     && operand_equal_p (tree01, tree111, 0))
7512                   return build2 ((code0 == LSHIFT_EXPR
7513                                   ? LROTATE_EXPR
7514                                   : RROTATE_EXPR),
7515                                  type, TREE_OPERAND (arg0, 0), tree01);
7516               }
7517             else if (code01 == MINUS_EXPR)
7518               {
7519                 tree tree010, tree011;
7520                 tree010 = TREE_OPERAND (tree01, 0);
7521                 tree011 = TREE_OPERAND (tree01, 1);
7522                 STRIP_NOPS (tree010);
7523                 STRIP_NOPS (tree011);
7524                 if (TREE_CODE (tree010) == INTEGER_CST
7525                     && 0 == compare_tree_int (tree010,
7526                                               TYPE_PRECISION
7527                                               (TREE_TYPE (TREE_OPERAND
7528                                                           (arg0, 0))))
7529                     && operand_equal_p (tree11, tree011, 0))
7530                   return build2 ((code0 != LSHIFT_EXPR
7531                                   ? LROTATE_EXPR
7532                                   : RROTATE_EXPR),
7533                                  type, TREE_OPERAND (arg0, 0), tree11);
7534               }
7535           }
7536       }
7537 

7538     associate:
7539       /* In most languages, can't associate operations on floats through
7540          parentheses.  Rather than remember where the parentheses were, we
7541          don't associate floats at all, unless the user has specified
7542          -funsafe-math-optimizations.  */
7543 
7544       if (! wins
7545           && (! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
7546         {
7547           tree var0, con0, lit0, minus_lit0;
7548           tree var1, con1, lit1, minus_lit1;
7549 
7550           /* Split both trees into variables, constants, and literals.  Then
7551              associate each group together, the constants with literals,
7552              then the result with variables.  This increases the chances of
7553              literals being recombined later and of generating relocatable
7554              expressions for the sum of a constant and literal.  */
7555           var0 = split_tree (arg0, code, &con0, &lit0, &minus_lit0, 0);
7556           var1 = split_tree (arg1, code, &con1, &lit1, &minus_lit1,
7557                              code == MINUS_EXPR);
7558 
7559           /* Only do something if we found more than two objects.  Otherwise,
7560              nothing has changed and we risk infinite recursion.  */
7561           if (2 < ((var0 != 0) + (var1 != 0)
7562                    + (con0 != 0) + (con1 != 0)
7563                    + (lit0 != 0) + (lit1 != 0)
7564                    + (minus_lit0 != 0) + (minus_lit1 != 0)))
7565             {
7566               /* Recombine MINUS_EXPR operands by using PLUS_EXPR.  */
7567               if (code == MINUS_EXPR)
7568                 code = PLUS_EXPR;
7569 
7570               var0 = associate_trees (var0, var1, code, type);
7571               con0 = associate_trees (con0, con1, code, type);
7572               lit0 = associate_trees (lit0, lit1, code, type);
7573               minus_lit0 = associate_trees (minus_lit0, minus_lit1, code, type);
7574 
7575               /* Preserve the MINUS_EXPR if the negative part of the literal is
7576                  greater than the positive part.  Otherwise, the multiplicative
7577                  folding code (i.e extract_muldiv) may be fooled in case
7578                  unsigned constants are subtracted, like in the following
7579                  example: ((X*2 + 4) - 8U)/2.  */
7580               if (minus_lit0 && lit0)
7581                 {
7582                   if (TREE_CODE (lit0) == INTEGER_CST
7583                       && TREE_CODE (minus_lit0) == INTEGER_CST
7584                       && tree_int_cst_lt (lit0, minus_lit0))
7585                     {
7586                       minus_lit0 = associate_trees (minus_lit0, lit0,
7587                                                     MINUS_EXPR, type);
7588                       lit0 = 0;
7589                     }
7590                   else
7591                     {
7592                       lit0 = associate_trees (lit0, minus_lit0,
7593                                               MINUS_EXPR, type);
7594                       minus_lit0 = 0;
7595                     }
7596                 }
7597               if (minus_lit0)
7598                 {
7599                   if (con0 == 0)
7600                     return fold_convert (type,
7601                                          associate_trees (var0, minus_lit0,
7602                                                           MINUS_EXPR, type));
7603                   else
7604                     {
7605                       con0 = associate_trees (con0, minus_lit0,
7606                                               MINUS_EXPR, type);
7607                       return fold_convert (type,
7608                                            associate_trees (var0, con0,
7609                                                             PLUS_EXPR, type));
7610                     }
7611                 }
7612 
7613               con0 = associate_trees (con0, lit0, code, type);
7614               return fold_convert (type, associate_trees (var0, con0,
7615                                                           code, type));
7616             }
7617         }
7618 

7619     binary:
7620       if (wins)
7621         t1 = const_binop (code, arg0, arg1, 0);
7622       if (t1 != NULL_TREE)
7623         {
7624           /* The return value should always have
7625              the same type as the original expression.  */
7626           if (TREE_TYPE (t1) != type)
7627             t1 = fold_convert (type, t1);
7628 
7629           return t1;
7630         }
7631       return NULL_TREE;
7632 

MINUS_EXPR[]

7633     case MINUS_EXPR:
7634       /* A - (-B) -> A + B */
7635       if (TREE_CODE (arg1) == NEGATE_EXPR)
7636         return fold_build2 (PLUS_EXPR, type, arg0, TREE_OPERAND (arg1, 0));
7637       /* (-A) - B -> (-B) - A  where B is easily negated and we can swap.  */
7638       if (TREE_CODE (arg0) == NEGATE_EXPR
7639           && (FLOAT_TYPE_P (type)
7640               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv))
7641           && negate_expr_p (arg1)
7642           && reorder_operands_p (arg0, arg1))
7643         return fold_build2 (MINUS_EXPR, type, negate_expr (arg1),
7644                             TREE_OPERAND (arg0, 0));
7645       /* Convert -A - 1 to ~A.  */
7646       if (INTEGRAL_TYPE_P (type)
7647           && TREE_CODE (arg0) == NEGATE_EXPR
7648           && integer_onep (arg1))
7649         return fold_build1 (BIT_NOT_EXPR, type, TREE_OPERAND (arg0, 0));
7650 
7651       /* Convert -1 - A to ~A.  */
7652       if (INTEGRAL_TYPE_P (type)
7653           && integer_all_onesp (arg0))
7654         return fold_build1 (BIT_NOT_EXPR, type, arg1);
7655 
7656       if (! FLOAT_TYPE_P (type))
7657         {
7658           if (! wins && integer_zerop (arg0))
7659             return negate_expr (fold_convert (type, arg1));
7660           if (integer_zerop (arg1))
7661             return non_lvalue (fold_convert (type, arg0));
7662 
7663           /* Fold A - (A & B) into ~B & A.  */
7664           if (!TREE_SIDE_EFFECTS (arg0)
7665               && TREE_CODE (arg1) == BIT_AND_EXPR)
7666             {
7667               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 1), 0))
7668                 return fold_build2 (BIT_AND_EXPR, type,
7669                                     fold_build1 (BIT_NOT_EXPR, type,
7670                                                  TREE_OPERAND (arg1, 0)),
7671                                     arg0);
7672               if (operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
7673                 return fold_build2 (BIT_AND_EXPR, type,
7674                                     fold_build1 (BIT_NOT_EXPR, type,
7675                                                  TREE_OPERAND (arg1, 1)),
7676                                     arg0);
7677             }
7678 
7679           /* Fold (A & ~B) - (A & B) into (A ^ B) - B, where B is
7680              any power of 2 minus 1.  */
7681           if (TREE_CODE (arg0) == BIT_AND_EXPR
7682               && TREE_CODE (arg1) == BIT_AND_EXPR
7683               && operand_equal_p (TREE_OPERAND (arg0, 0),
7684                                   TREE_OPERAND (arg1, 0), 0))
7685             {
7686               tree mask0 = TREE_OPERAND (arg0, 1);
7687               tree mask1 = TREE_OPERAND (arg1, 1);
7688               tree tem = fold_build1 (BIT_NOT_EXPR, type, mask0);
7689 
7690               if (operand_equal_p (tem, mask1, 0))
7691                 {
7692                   tem = fold_build2 (BIT_XOR_EXPR, type,
7693                                      TREE_OPERAND (arg0, 0), mask1);
7694                   return fold_build2 (MINUS_EXPR, type, tem, mask1);
7695                 }
7696             }
7697         }
7698 
7699       /* See if ARG1 is zero and X - ARG1 reduces to X.  */
7700       else if (fold_real_zero_addition_p (TREE_TYPE (arg0), arg1, 1))
7701         return non_lvalue (fold_convert (type, arg0));
7702 
7703       /* (ARG0 - ARG1) is the same as (-ARG1 + ARG0).  So check whether
7704          ARG0 is zero and X + ARG0 reduces to X, since that would mean
7705          (-ARG1 + ARG0) reduces to -ARG1.  */
7706       else if (!wins && fold_real_zero_addition_p (TREE_TYPE (arg1), arg0, 0))
7707         return negate_expr (fold_convert (type, arg1));
7708 
7709       /* Fold &x - &x.  This can happen from &x.foo - &x.
7710          This is unsafe for certain floats even in non-IEEE formats.
7711          In IEEE, it is unsafe because it does wrong for NaNs.
7712          Also note that operand_equal_p is always false if an operand
7713          is volatile.  */
7714 
7715       if ((! FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations)
7716           && operand_equal_p (arg0, arg1, 0))
7717         return fold_convert (type, integer_zero_node);
7718 
7719       /* A - B -> A + (-B) if B is easily negatable.  */
7720       if (!wins && negate_expr_p (arg1)
7721           && ((FLOAT_TYPE_P (type)
7722                /* Avoid this transformation if B is a positive REAL_CST.  */
7723                && (TREE_CODE (arg1) != REAL_CST
7724                    ||  REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg1))))
7725               || (INTEGRAL_TYPE_P (type) && flag_wrapv && !flag_trapv)))
7726         return fold_build2 (PLUS_EXPR, type,
7727                             fold_convert (type, arg0),
7728                             fold_convert (type, negate_expr (arg1)));
7729 
7730       /* Try folding difference of addresses.  */
7731       {
7732         HOST_WIDE_INT diff;
7733 
7734         if ((TREE_CODE (arg0) == ADDR_EXPR
7735              || TREE_CODE (arg1) == ADDR_EXPR)
7736             && ptr_difference_const (arg0, arg1, &diff))
7737           return build_int_cst_type (type, diff);
7738       }
7739 
7740       /* Fold &a[i] - &a[j] to i-j.  */
7741       if (TREE_CODE (arg0) == ADDR_EXPR
7742           && TREE_CODE (TREE_OPERAND (arg0, 0)) == ARRAY_REF
7743           && TREE_CODE (arg1) == ADDR_EXPR
7744           && TREE_CODE (TREE_OPERAND (arg1, 0)) == ARRAY_REF)
7745         {
7746           tree aref0 = TREE_OPERAND (arg0, 0);
7747           tree aref1 = TREE_OPERAND (arg1, 0);
7748           if (operand_equal_p (TREE_OPERAND (aref0, 0),
7749                                TREE_OPERAND (aref1, 0), 0))
7750             {
7751               tree op0 = fold_convert (type, TREE_OPERAND (aref0, 1));
7752               tree op1 = fold_convert (type, TREE_OPERAND (aref1, 1));
7753               tree esz = array_ref_element_size (aref0);
7754               tree diff = build2 (MINUS_EXPR, type, op0, op1);
7755               return fold_build2 (MULT_EXPR, type, diff,
7756                                   fold_convert (type, esz));
7757                                   
7758             }
7759         }
7760 
7761       /* Try replacing &a[i1] - c * i2 with &a[i1 - i2], if c is step
7762          of the array.  Loop optimizer sometimes produce this type of
7763          expressions.  */
7764       if (TREE_CODE (arg0) == ADDR_EXPR)
7765         {
7766           tem = try_move_mult_to_index (MINUS_EXPR, arg0, arg1);
7767           if (tem)
7768             return fold_convert (type, tem);
7769         }
7770 
7771       if (flag_unsafe_math_optimizations
7772           && (TREE_CODE (arg0) == RDIV_EXPR || TREE_CODE (arg0) == MULT_EXPR)
7773           && (TREE_CODE (arg1) == RDIV_EXPR || TREE_CODE (arg1) == MULT_EXPR)
7774           && (tem = distribute_real_division (code, type, arg0, arg1)))
7775         return tem;
7776 
7777       if (TREE_CODE (arg0) == MULT_EXPR
7778           && TREE_CODE (arg1) == MULT_EXPR
7779           && (!FLOAT_TYPE_P (type) || flag_unsafe_math_optimizations))
7780         {
7781           /* (A * C) - (B * C) -> (A-B) * C.  */
7782           if (operand_equal_p (TREE_OPERAND (arg0, 1),
7783                                TREE_OPERAND (arg1, 1), 0))
7784             return fold_build2 (MULT_EXPR, type,
7785                                 fold_build2 (MINUS_EXPR, type,
7786                                              TREE_OPERAND (arg0, 0),
7787                                              TREE_OPERAND (arg1, 0)),
7788                                 TREE_OPERAND (arg0, 1));
7789           /* (A * C1) - (A * C2) -> A * (C1-C2).  */
7790           if (operand_equal_p (TREE_OPERAND (arg0, 0),
7791                                TREE_OPERAND (arg1, 0), 0))
7792             return fold_build2 (MULT_EXPR, type,
7793                                 TREE_OPERAND (arg0, 0),
7794                                 fold_build2 (MINUS_EXPR, type,
7795                                              TREE_OPERAND (arg0, 1),
7796                                              TREE_OPERAND (arg1, 1)));
7797         }
7798 
7799       goto associate;
7800 

MULT_EXPR[]

7801     case MULT_EXPR:
7802       /* (-A) * (-B) -> A * B  */
7803       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
7804         return fold_build2 (MULT_EXPR, type,
7805                             TREE_OPERAND (arg0, 0),
7806                             negate_expr (arg1));
7807       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
7808         return fold_build2 (MULT_EXPR, type,
7809                             negate_expr (arg0),
7810                             TREE_OPERAND (arg1, 0));
7811 

INTEGER[]

7812       if (! FLOAT_TYPE_P (type))
7813         {
7814           if (integer_zerop (arg1))
7815             return omit_one_operand (type, arg1, arg0);
7816           if (integer_onep (arg1))
7817             return non_lvalue (fold_convert (type, arg0));
7818           /* Transform x * -1 into -x.  */
7819           if (integer_all_onesp (arg1))
7820             return fold_convert (type, negate_expr (arg0));
7821 
7822           /* (a * (1 << b)) is (a << b)  */
7823           if (TREE_CODE (arg1) == LSHIFT_EXPR
7824               && integer_onep (TREE_OPERAND (arg1, 0)))
7825             return fold_build2 (LSHIFT_EXPR, type, arg0,
7826                                 TREE_OPERAND (arg1, 1));
7827           if (TREE_CODE (arg0) == LSHIFT_EXPR
7828               && integer_onep (TREE_OPERAND (arg0, 0)))
7829             return fold_build2 (LSHIFT_EXPR, type, arg1,
7830                                 TREE_OPERAND (arg0, 1));
7831 
7832           if (TREE_CODE (arg1) == INTEGER_CST
7833               && 0 != (tem = extract_muldiv (op0,
7834                                              fold_convert (type, arg1),
7835                                              code, NULL_TREE)))
7836             return fold_convert (type, tem);
7837 
7838         }

REAL[]

7839       else
7840         {
7841           /* Maybe fold x * 0 to 0.  The expressions aren't the same
7842              when x is NaN, since x * 0 is also NaN.  Nor are they the
7843              same in modes with signed zeros, since multiplying a
7844              negative value by 0 gives -0, not +0.  */
7845           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
7846               && !HONOR_SIGNED_ZEROS (TYPE_MODE (TREE_TYPE (arg0)))
7847               && real_zerop (arg1))
7848             return omit_one_operand (type, arg1, arg0);
7849           /* In IEEE floating point, x*1 is not equivalent to x for snans.  */
7850           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7851               && real_onep (arg1))
7852             return non_lvalue (fold_convert (type, arg0));
7853 
7854           /* Transform x * -1.0 into -x.  */
7855           if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
7856               && real_minus_onep (arg1))
7857             return fold_convert (type, negate_expr (arg0));
7858 
7859           /* Convert (C1/X)*C2 into (C1*C2)/X.  */
7860           if (flag_unsafe_math_optimizations
7861               && TREE_CODE (arg0) == RDIV_EXPR
7862               && TREE_CODE (arg1) == REAL_CST
7863               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST)
7864             {
7865               tree tem = const_binop (MULT_EXPR, TREE_OPERAND (arg0, 0),
7866                                       arg1, 0);
7867               if (tem)
7868                 return fold_build2 (RDIV_EXPR, type, tem,
7869                                     TREE_OPERAND (arg0, 1));
7870             }
7871 
7872           /* Strip sign operations from X in X*X, i.e. -Y*-Y -> Y*Y.  */
7873           if (operand_equal_p (arg0, arg1, 0))
7874             {
7875               tree tem = fold_strip_sign_ops (arg0);
7876               if (tem != NULL_TREE)
7877                 {
7878                   tem = fold_convert (type, tem);
7879                   return fold_build2 (MULT_EXPR, type, tem, tem);
7880                 }
7881             }
7882 
7883           if (flag_unsafe_math_optimizations)
7884             {
7885               enum built_in_function fcode0 = builtin_mathfn_code (arg0);
7886               enum built_in_function fcode1 = builtin_mathfn_code (arg1);
7887 
7888               /* Optimizations of root(...)*root(...).  */
7889               if (fcode0 == fcode1 && BUILTIN_ROOT_P (fcode0))
7890                 {
7891                   tree rootfn, arg, arglist;
7892                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7893                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7894 
7895                   /* Optimize sqrt(x)*sqrt(x) as x.  */
7896                   if (BUILTIN_SQRT_P (fcode0)
7897                       && operand_equal_p (arg00, arg10, 0)
7898                       && ! HONOR_SNANS (TYPE_MODE (type)))
7899                     return arg00;
7900 
7901                   /* Optimize root(x)*root(y) as root(x*y).  */
7902                   rootfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7903                   arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
7904                   arglist = build_tree_list (NULL_TREE, arg);
7905                   return build_function_call_expr (rootfn, arglist);
7906                 }
7907 
7908               /* Optimize expN(x)*expN(y) as expN(x+y).  */
7909               if (fcode0 == fcode1 && BUILTIN_EXPONENT_P (fcode0))
7910                 {
7911                   tree expfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7912                   tree arg = fold_build2 (PLUS_EXPR, type,
7913                                           TREE_VALUE (TREE_OPERAND (arg0, 1)),
7914                                           TREE_VALUE (TREE_OPERAND (arg1, 1)));
7915                   tree arglist = build_tree_list (NULL_TREE, arg);
7916                   return build_function_call_expr (expfn, arglist);
7917                 }
7918 
7919               /* Optimizations of pow(...)*pow(...).  */
7920               if ((fcode0 == BUILT_IN_POW && fcode1 == BUILT_IN_POW)
7921                   || (fcode0 == BUILT_IN_POWF && fcode1 == BUILT_IN_POWF)
7922                   || (fcode0 == BUILT_IN_POWL && fcode1 == BUILT_IN_POWL))
7923                 {
7924                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
7925                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
7926                                                                      1)));
7927                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7928                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
7929                                                                      1)));
7930 
7931                   /* Optimize pow(x,y)*pow(z,y) as pow(x*z,y).  */
7932                   if (operand_equal_p (arg01, arg11, 0))
7933                     {
7934                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7935                       tree arg = fold_build2 (MULT_EXPR, type, arg00, arg10);
7936                       tree arglist = tree_cons (NULL_TREE, arg,
7937                                                 build_tree_list (NULL_TREE,
7938                                                                  arg01));
7939                       return build_function_call_expr (powfn, arglist);
7940                     }
7941 
7942                   /* Optimize pow(x,y)*pow(x,z) as pow(x,y+z).  */
7943                   if (operand_equal_p (arg00, arg10, 0))
7944                     {
7945                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
7946                       tree arg = fold_build2 (PLUS_EXPR, type, arg01, arg11);
7947                       tree arglist = tree_cons (NULL_TREE, arg00,
7948                                                 build_tree_list (NULL_TREE,
7949                                                                  arg));
7950                       return build_function_call_expr (powfn, arglist);
7951                     }
7952                 }
7953 
7954               /* Optimize tan(x)*cos(x) as sin(x).  */
7955               if (((fcode0 == BUILT_IN_TAN && fcode1 == BUILT_IN_COS)
7956                    || (fcode0 == BUILT_IN_TANF && fcode1 == BUILT_IN_COSF)
7957                    || (fcode0 == BUILT_IN_TANL && fcode1 == BUILT_IN_COSL)
7958                    || (fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_TAN)
7959                    || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_TANF)
7960                    || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_TANL))
7961                   && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
7962                                       TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
7963                 {
7964                   tree sinfn = mathfn_built_in (type, BUILT_IN_SIN);
7965 
7966                   if (sinfn != NULL_TREE)
7967                     return build_function_call_expr (sinfn,
7968                                                      TREE_OPERAND (arg0, 1));
7969                 }
7970 
7971               /* Optimize x*pow(x,c) as pow(x,c+1).  */
7972               if (fcode1 == BUILT_IN_POW
7973                   || fcode1 == BUILT_IN_POWF
7974                   || fcode1 == BUILT_IN_POWL)
7975                 {
7976                   tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
7977                   tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1,
7978                                                                      1)));
7979                   if (TREE_CODE (arg11) == REAL_CST
7980                       && ! TREE_CONSTANT_OVERFLOW (arg11)
7981                       && operand_equal_p (arg0, arg10, 0))
7982                     {
7983                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
7984                       REAL_VALUE_TYPE c;
7985                       tree arg, arglist;
7986 
7987                       c = TREE_REAL_CST (arg11);
7988                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
7989                       arg = build_real (type, c);
7990                       arglist = build_tree_list (NULL_TREE, arg);
7991                       arglist = tree_cons (NULL_TREE, arg0, arglist);
7992                       return build_function_call_expr (powfn, arglist);
7993                     }
7994                 }
7995 
7996               /* Optimize pow(x,c)*x as pow(x,c+1).  */
7997               if (fcode0 == BUILT_IN_POW
7998                   || fcode0 == BUILT_IN_POWF
7999                   || fcode0 == BUILT_IN_POWL)
8000                 {
8001                   tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
8002                   tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0,
8003                                                                      1)));
8004                   if (TREE_CODE (arg01) == REAL_CST
8005                       && ! TREE_CONSTANT_OVERFLOW (arg01)
8006                       && operand_equal_p (arg1, arg00, 0))
8007                     {
8008                       tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
8009                       REAL_VALUE_TYPE c;
8010                       tree arg, arglist;
8011 
8012                       c = TREE_REAL_CST (arg01);
8013                       real_arithmetic (&c, PLUS_EXPR, &c, &dconst1);
8014                       arg = build_real (type, c);
8015                       arglist = build_tree_list (NULL_TREE, arg);
8016                       arglist = tree_cons (NULL_TREE, arg1, arglist);
8017                       return build_function_call_expr (powfn, arglist);
8018                     }
8019                 }
8020 
8021               /* Optimize x*x as pow(x,2.0), which is expanded as x*x.  */
8022               if (! optimize_size
8023                   && operand_equal_p (arg0, arg1, 0))
8024                 {
8025                   tree powfn = mathfn_built_in (type, BUILT_IN_POW);
8026 
8027                   if (powfn)
8028                     {
8029                       tree arg = build_real (type, dconst2);
8030                       tree arglist = build_tree_list (NULL_TREE, arg);
8031                       arglist = tree_cons (NULL_TREE, arg0, arglist);
8032                       return build_function_call_expr (powfn, arglist);
8033                     }
8034                 }
8035             }
8036         }
8037       goto associate;
8038 

BIT_IOR_EXPR[]

8039     case BIT_IOR_EXPR:

8040     bit_ior:
8041       if (integer_all_onesp (arg1))
8042         return omit_one_operand (type, arg1, arg0);
8043       if (integer_zerop (arg1))
8044         return non_lvalue (fold_convert (type, arg0));
8045       if (operand_equal_p (arg0, arg1, 0))
8046         return non_lvalue (fold_convert (type, arg0));
8047 
8048       /* ~X | X is -1.  */
8049       if (TREE_CODE (arg0) == BIT_NOT_EXPR
8050           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
8051         {
8052           t1 = build_int_cst (type, -1);
8053           t1 = force_fit_type (t1, 0, false, false);
8054           return omit_one_operand (type, t1, arg1);
8055         }
8056 
8057       /* X | ~X is -1.  */
8058       if (TREE_CODE (arg1) == BIT_NOT_EXPR
8059           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8060         {
8061           t1 = build_int_cst (type, -1);
8062           t1 = force_fit_type (t1, 0, false, false);
8063           return omit_one_operand (type, t1, arg0);
8064         }
8065 
8066       t1 = distribute_bit_expr (code, type, arg0, arg1);
8067       if (t1 != NULL_TREE)
8068         return t1;
8069 
8070       /* Convert (or (not arg0) (not arg1)) to (not (and (arg0) (arg1))).
8071 
8072          This results in more efficient code for machines without a NAND
8073          instruction.  Combine will canonicalize to the first form
8074          which will allow use of NAND instructions provided by the
8075          backend if they exist.  */
8076       if (TREE_CODE (arg0) == BIT_NOT_EXPR
8077           && TREE_CODE (arg1) == BIT_NOT_EXPR)
8078         {
8079           return fold_build1 (BIT_NOT_EXPR, type,
8080                               build2 (BIT_AND_EXPR, type,
8081                                       TREE_OPERAND (arg0, 0),
8082                                       TREE_OPERAND (arg1, 0)));
8083         }
8084 
8085       /* See if this can be simplified into a rotate first.  If that
8086          is unsuccessful continue in the association code.  */
8087       goto bit_rotate;
8088 

BIT_XOR_EXPR[]

8089     case BIT_XOR_EXPR:
8090       if (integer_zerop (arg1))
8091         return non_lvalue (fold_convert (type, arg0));
8092       if (integer_all_onesp (arg1))
8093         return fold_build1 (BIT_NOT_EXPR, type, arg0);
8094       if (operand_equal_p (arg0, arg1, 0))
8095         return omit_one_operand (type, integer_zero_node, arg0);
8096 
8097       /* ~X ^ X is -1.  */
8098       if (TREE_CODE (arg0) == BIT_NOT_EXPR
8099           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
8100         {
8101           t1 = build_int_cst (type, -1);
8102           t1 = force_fit_type (t1, 0, false, false);
8103           return omit_one_operand (type, t1, arg1);
8104         }
8105 
8106       /* X ^ ~X is -1.  */
8107       if (TREE_CODE (arg1) == BIT_NOT_EXPR
8108           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8109         {
8110           t1 = build_int_cst (type, -1);
8111           t1 = force_fit_type (t1, 0, false, false);
8112           return omit_one_operand (type, t1, arg0);
8113         }
8114 
8115       /* If we are XORing two BIT_AND_EXPR's, both of which are and'ing
8116          with a constant, and the two constants have no bits in common,
8117          we should treat this as a BIT_IOR_EXPR since this may produce more
8118          simplifications.  */
8119       if (TREE_CODE (arg0) == BIT_AND_EXPR
8120           && TREE_CODE (arg1) == BIT_AND_EXPR
8121           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8122           && TREE_CODE (TREE_OPERAND (arg1, 1)) == INTEGER_CST
8123           && integer_zerop (const_binop (BIT_AND_EXPR,
8124                                          TREE_OPERAND (arg0, 1),
8125                                          TREE_OPERAND (arg1, 1), 0)))
8126         {
8127           code = BIT_IOR_EXPR;
8128           goto bit_ior;
8129         }
8130 
8131       /* (X | Y) ^ X -> Y & ~ X*/
8132       if (TREE_CODE (arg0) == BIT_IOR_EXPR
8133           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
8134         {
8135           tree t2 = TREE_OPERAND (arg0, 1);
8136           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
8137                             arg1);
8138           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
8139                             fold_convert (type, t1));
8140           return t1;
8141         }
8142 
8143       /* (Y | X) ^ X -> Y & ~ X*/
8144       if (TREE_CODE (arg0) == BIT_IOR_EXPR
8145           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
8146         {
8147           tree t2 = TREE_OPERAND (arg0, 0);
8148           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1),
8149                             arg1);
8150           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
8151                             fold_convert (type, t1));
8152           return t1;
8153         }
8154 
8155       /* X ^ (X | Y) -> Y & ~ X*/
8156       if (TREE_CODE (arg1) == BIT_IOR_EXPR
8157           && operand_equal_p (TREE_OPERAND (arg1, 0), arg0, 0))
8158         {
8159           tree t2 = TREE_OPERAND (arg1, 1);
8160           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
8161                             arg0);
8162           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
8163                             fold_convert (type, t1));
8164           return t1;
8165         }
8166 
8167       /* X ^ (Y | X) -> Y & ~ X*/
8168       if (TREE_CODE (arg1) == BIT_IOR_EXPR
8169           && operand_equal_p (TREE_OPERAND (arg1, 1), arg0, 0))
8170         {
8171           tree t2 = TREE_OPERAND (arg1, 0);
8172           t1 = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg0),
8173                             arg0);
8174           t1 = fold_build2 (BIT_AND_EXPR, type, fold_convert (type, t2),
8175                             fold_convert (type, t1));
8176           return t1;
8177         }
8178         
8179       /* Convert ~X ^ ~Y to X ^ Y.  */
8180       if (TREE_CODE (arg0) == BIT_NOT_EXPR
8181           && TREE_CODE (arg1) == BIT_NOT_EXPR)
8182         return fold_build2 (code, type,
8183                             fold_convert (type, TREE_OPERAND (arg0, 0)),
8184                             fold_convert (type, TREE_OPERAND (arg1, 0)));
8185 
8186       /* See if this can be simplified into a rotate first.  If that
8187          is unsuccessful continue in the association code.  */
8188       goto bit_rotate;
8189 

BIT_AND_EXPR[]

8190     case BIT_AND_EXPR:
8191       if (integer_all_onesp (arg1))
8192         return non_lvalue (fold_convert (type, arg0));
8193       if (integer_zerop (arg1))
8194         return omit_one_operand (type, arg1, arg0);
8195       if (operand_equal_p (arg0, arg1, 0))
8196         return non_lvalue (fold_convert (type, arg0));
8197 
8198       /* ~X & X is always zero.  */
8199       if (TREE_CODE (arg0) == BIT_NOT_EXPR
8200           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
8201         return omit_one_operand (type, integer_zero_node, arg1);
8202 
8203       /* X & ~X is always zero.  */
8204       if (TREE_CODE (arg1) == BIT_NOT_EXPR
8205           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8206         return omit_one_operand (type, integer_zero_node, arg0);
8207 
8208       t1 = distribute_bit_expr (code, type, arg0, arg1);
8209       if (t1 != NULL_TREE)
8210         return t1;
8211       /* Simplify ((int)c & 0377) into (int)c, if c is unsigned char.  */
8212       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) == NOP_EXPR
8213           && TYPE_UNSIGNED (TREE_TYPE (TREE_OPERAND (arg0, 0))))
8214         {
8215           unsigned int prec
8216             = TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (arg0, 0)));
8217 
8218           if (prec < BITS_PER_WORD && prec < HOST_BITS_PER_WIDE_INT
8219               && (~TREE_INT_CST_LOW (arg1)
8220                   & (((HOST_WIDE_INT) 1 << prec) - 1)) == 0)
8221             return fold_convert (type, TREE_OPERAND (arg0, 0));
8222         }
8223 
8224       /* Convert (and (not arg0) (not arg1)) to (not (or (arg0) (arg1))).
8225 
8226          This results in more efficient code for machines without a NOR
8227          instruction.  Combine will canonicalize to the first form
8228          which will allow use of NOR instructions provided by the
8229          backend if they exist.  */
8230       if (TREE_CODE (arg0) == BIT_NOT_EXPR
8231           && TREE_CODE (arg1) == BIT_NOT_EXPR)
8232         {
8233           return fold_build1 (BIT_NOT_EXPR, type,
8234                               build2 (BIT_IOR_EXPR, type,
8235                                       TREE_OPERAND (arg0, 0),
8236                                       TREE_OPERAND (arg1, 0)));
8237         }
8238 
8239       goto associate;
8240 

RDIV_EXPR[]

8241     case RDIV_EXPR:
8242       /* Don't touch a floating-point divide by zero unless the mode
8243          of the constant can represent infinity.  */
8244       if (TREE_CODE (arg1) == REAL_CST
8245           && !MODE_HAS_INFINITIES (TYPE_MODE (TREE_TYPE (arg1)))
8246           && real_zerop (arg1))
8247         return NULL_TREE;
8248 
8249       /* (-A) / (-B) -> A / B  */
8250       if (TREE_CODE (arg0) == NEGATE_EXPR && negate_expr_p (arg1))
8251         return fold_build2 (RDIV_EXPR, type,
8252                             TREE_OPERAND (arg0, 0),
8253                             negate_expr (arg1));
8254       if (TREE_CODE (arg1) == NEGATE_EXPR && negate_expr_p (arg0))
8255         return fold_build2 (RDIV_EXPR, type,
8256                             negate_expr (arg0),
8257                             TREE_OPERAND (arg1, 0));
8258 
8259       /* In IEEE floating point, x/1 is not equivalent to x for snans.  */
8260       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
8261           && real_onep (arg1))
8262         return non_lvalue (fold_convert (type, arg0));
8263 
8264       /* In IEEE floating point, x/-1 is not equivalent to -x for snans.  */
8265       if (!HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0)))
8266           && real_minus_onep (arg1))
8267         return non_lvalue (fold_convert (type, negate_expr (arg0)));
8268 
8269       /* If ARG1 is a constant, we can convert this to a multiply by the
8270          reciprocal.  This does not have the same rounding properties,
8271          so only do this if -funsafe-math-optimizations.  We can actually
8272          always safely do it if ARG1 is a power of two, but it's hard to
8273          tell if it is or not in a portable manner.  */
8274       if (TREE_CODE (arg1) == REAL_CST)
8275         {
8276           if (flag_unsafe_math_optimizations
8277               && 0 != (tem = const_binop (code, build_real (type, dconst1),
8278                                           arg1, 0)))
8279             return fold_build2 (MULT_EXPR, type, arg0, tem);
8280           /* Find the reciprocal if optimizing and the result is exact.  */
8281           if (optimize)
8282             {
8283               REAL_VALUE_TYPE r;
8284               r = TREE_REAL_CST (arg1);
8285               if (exact_real_inverse (TYPE_MODE(TREE_TYPE(arg0)), &r))
8286                 {
8287                   tem = build_real (type, r);
8288                   return fold_build2 (MULT_EXPR, type,
8289                                       fold_convert (type, arg0), tem);
8290                 }
8291             }
8292         }
8293       /* Convert A/B/C to A/(B*C).  */
8294       if (flag_unsafe_math_optimizations
8295           && TREE_CODE (arg0) == RDIV_EXPR)
8296         return fold_build2 (RDIV_EXPR, type, TREE_OPERAND (arg0, 0),
8297                             fold_build2 (MULT_EXPR, type,
8298                                          TREE_OPERAND (arg0, 1), arg1));
8299 
8300       /* Convert A/(B/C) to (A/B)*C.  */
8301       if (flag_unsafe_math_optimizations
8302           && TREE_CODE (arg1) == RDIV_EXPR)
8303         return fold_build2 (MULT_EXPR, type,
8304                             fold_build2 (RDIV_EXPR, type, arg0,
8305                                          TREE_OPERAND (arg1, 0)),
8306                             TREE_OPERAND (arg1, 1));
8307 
8308       /* Convert C1/(X*C2) into (C1/C2)/X.  */
8309       if (flag_unsafe_math_optimizations
8310           && TREE_CODE (arg1) == MULT_EXPR
8311           && TREE_CODE (arg0) == REAL_CST
8312           && TREE_CODE (TREE_OPERAND (arg1, 1)) == REAL_CST)
8313         {
8314           tree tem = const_binop (RDIV_EXPR, arg0,
8315                                   TREE_OPERAND (arg1, 1), 0);
8316           if (tem)
8317             return fold_build2 (RDIV_EXPR, type, tem,
8318                                 TREE_OPERAND (arg1, 0));
8319         }
8320 
8321       if (flag_unsafe_math_optimizations)
8322         {
8323           enum built_in_function fcode = builtin_mathfn_code (arg1);
8324           /* Optimize x/expN(y) into x*expN(-y).  */
8325           if (BUILTIN_EXPONENT_P (fcode))
8326             {
8327               tree expfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
8328               tree arg = negate_expr (TREE_VALUE (TREE_OPERAND (arg1, 1)));
8329               tree arglist = build_tree_list (NULL_TREE,
8330                                               fold_convert (type, arg));
8331               arg1 = build_function_call_expr (expfn, arglist);
8332               return fold_build2 (MULT_EXPR, type, arg0, arg1);
8333             }
8334 
8335           /* Optimize x/pow(y,z) into x*pow(y,-z).  */
8336           if (fcode == BUILT_IN_POW
8337               || fcode == BUILT_IN_POWF
8338               || fcode == BUILT_IN_POWL)
8339             {
8340               tree powfn = TREE_OPERAND (TREE_OPERAND (arg1, 0), 0);
8341               tree arg10 = TREE_VALUE (TREE_OPERAND (arg1, 1));
8342               tree arg11 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg1, 1)));
8343               tree neg11 = fold_convert (type, negate_expr (arg11));
8344               tree arglist = tree_cons(NULL_TREE, arg10,
8345                                        build_tree_list (NULL_TREE, neg11));
8346               arg1 = build_function_call_expr (powfn, arglist);
8347               return fold_build2 (MULT_EXPR, type, arg0, arg1);
8348             }
8349         }
8350 
8351       if (flag_unsafe_math_optimizations)
8352         {
8353           enum built_in_function fcode0 = builtin_mathfn_code (arg0);
8354           enum built_in_function fcode1 = builtin_mathfn_code (arg1);
8355 
8356           /* Optimize sin(x)/cos(x) as tan(x).  */
8357           if (((fcode0 == BUILT_IN_SIN && fcode1 == BUILT_IN_COS)
8358                || (fcode0 == BUILT_IN_SINF && fcode1 == BUILT_IN_COSF)
8359                || (fcode0 == BUILT_IN_SINL && fcode1 == BUILT_IN_COSL))
8360               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
8361                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
8362             {
8363               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
8364 
8365               if (tanfn != NULL_TREE)
8366                 return build_function_call_expr (tanfn,
8367                                                  TREE_OPERAND (arg0, 1));
8368             }
8369 
8370           /* Optimize cos(x)/sin(x) as 1.0/tan(x).  */
8371           if (((fcode0 == BUILT_IN_COS && fcode1 == BUILT_IN_SIN)
8372                || (fcode0 == BUILT_IN_COSF && fcode1 == BUILT_IN_SINF)
8373                || (fcode0 == BUILT_IN_COSL && fcode1 == BUILT_IN_SINL))
8374               && operand_equal_p (TREE_VALUE (TREE_OPERAND (arg0, 1)),
8375                                   TREE_VALUE (TREE_OPERAND (arg1, 1)), 0))
8376             {
8377               tree tanfn = mathfn_built_in (type, BUILT_IN_TAN);
8378 
8379               if (tanfn != NULL_TREE)
8380                 {
8381                   tree tmp = TREE_OPERAND (arg0, 1);
8382                   tmp = build_function_call_expr (tanfn, tmp);
8383                   return fold_build2 (RDIV_EXPR, type,
8384                                       build_real (type, dconst1), tmp);
8385                 }
8386             }
8387 
8388           /* Optimize pow(x,c)/x as pow(x,c-1).  */
8389           if (fcode0 == BUILT_IN_POW
8390               || fcode0 == BUILT_IN_POWF
8391               || fcode0 == BUILT_IN_POWL)
8392             {
8393               tree arg00 = TREE_VALUE (TREE_OPERAND (arg0, 1));
8394               tree arg01 = TREE_VALUE (TREE_CHAIN (TREE_OPERAND (arg0, 1)));
8395               if (TREE_CODE (arg01) == REAL_CST
8396                   && ! TREE_CONSTANT_OVERFLOW (arg01)
8397                   && operand_equal_p (arg1, arg00, 0))
8398                 {
8399                   tree powfn = TREE_OPERAND (TREE_OPERAND (arg0, 0), 0);
8400                   REAL_VALUE_TYPE c;
8401                   tree arg, arglist;
8402 
8403                   c = TREE_REAL_CST (arg01);
8404                   real_arithmetic (&c, MINUS_EXPR, &c, &dconst1);
8405                   arg = build_real (type, c);
8406                   arglist = build_tree_list (NULL_TREE, arg);
8407                   arglist = tree_cons (NULL_TREE, arg1, arglist);
8408                   return build_function_call_expr (powfn, arglist);
8409                 }
8410             }
8411         }
8412       goto binary;
8413 

*_DIV_EXPR[]

8414     case TRUNC_DIV_EXPR:
8415     case ROUND_DIV_EXPR:
8416     case FLOOR_DIV_EXPR:
8417     case CEIL_DIV_EXPR:
8418     case EXACT_DIV_EXPR:
8419       if (integer_onep (arg1))
8420         return non_lvalue (fold_convert (type, arg0));
8421       if (integer_zerop (arg1))
8422         return NULL_TREE;
8423       /* X / -1 is -X.  */
8424       if (!TYPE_UNSIGNED (type)
8425           && TREE_CODE (arg1) == INTEGER_CST
8426           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
8427           && TREE_INT_CST_HIGH (arg1) == -1)
8428         return fold_convert (type, negate_expr (arg0));
8429 
8430       /* If arg0 is a multiple of arg1, then rewrite to the fastest div
8431          operation, EXACT_DIV_EXPR.
8432 
8433          Note that only CEIL_DIV_EXPR and FLOOR_DIV_EXPR are rewritten now.
8434          At one time others generated faster code, it's not clear if they do
8435          after the last round to changes to the DIV code in expmed.c.  */
8436       if ((code == CEIL_DIV_EXPR || code == FLOOR_DIV_EXPR)
8437           && multiple_of_p (type, arg0, arg1))
8438         return fold_build2 (EXACT_DIV_EXPR, type, arg0, arg1);
8439 
8440       if (TREE_CODE (arg1) == INTEGER_CST
8441           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE)))
8442         return fold_convert (type, tem);
8443 
8444       goto binary;
8445 

*_MOD_EXPR[]

8446     case CEIL_MOD_EXPR:
8447     case FLOOR_MOD_EXPR:
8448     case ROUND_MOD_EXPR:
8449     case TRUNC_MOD_EXPR:
8450       /* X % 1 is always zero, but be sure to preserve any side
8451          effects in X.  */
8452       if (integer_onep (arg1))
8453         return omit_one_operand (type, integer_zero_node, arg0);
8454 
8455       /* X % 0, return X % 0 unchanged so that we can get the
8456          proper warnings and errors.  */
8457       if (integer_zerop (arg1))
8458         return NULL_TREE;
8459 
8460       /* 0 % X is always zero, but be sure to preserve any side
8461          effects in X.  Place this after checking for X == 0.  */
8462       if (integer_zerop (arg0))
8463         return omit_one_operand (type, integer_zero_node, arg1);
8464 
8465       /* X % -1 is zero.  */
8466       if (!TYPE_UNSIGNED (type)
8467           && TREE_CODE (arg1) == INTEGER_CST
8468           && TREE_INT_CST_LOW (arg1) == (unsigned HOST_WIDE_INT) -1
8469           && TREE_INT_CST_HIGH (arg1) == -1)
8470         return omit_one_operand (type, integer_zero_node, arg0);
8471 
8472       /* Optimize TRUNC_MOD_EXPR by a power of two into a BIT_AND_EXPR,
8473          i.e. "X % C" into "X & C2", if X and C are positive.  */
8474       if ((code == TRUNC_MOD_EXPR || code == FLOOR_MOD_EXPR)
8475           && (TYPE_UNSIGNED (type) || tree_expr_nonnegative_p (arg0))
8476           && integer_pow2p (arg1) && tree_int_cst_sgn (arg1) >= 0)
8477         {
8478           unsigned HOST_WIDE_INT high, low;
8479           tree mask;
8480           int l;
8481 
8482           l = tree_log2 (arg1);
8483           if (l >= HOST_BITS_PER_WIDE_INT)
8484             {
8485               high = ((unsigned HOST_WIDE_INT) 1
8486                       << (l - HOST_BITS_PER_WIDE_INT)) - 1;
8487               low = -1;
8488             }
8489           else
8490             {
8491               high = 0;
8492               low = ((unsigned HOST_WIDE_INT) 1 << l) - 1;
8493             }
8494 
8495           mask = build_int_cst_wide (type, low, high);
8496           return fold_build2 (BIT_AND_EXPR, type,
8497                               fold_convert (type, arg0), mask);
8498         }
8499 
8500       /* X % -C is the same as X % C.  */
8501       if (code == TRUNC_MOD_EXPR
8502           && !TYPE_UNSIGNED (type)
8503           && TREE_CODE (arg1) == INTEGER_CST
8504           && !TREE_CONSTANT_OVERFLOW (arg1)
8505           && TREE_INT_CST_HIGH (arg1) < 0
8506           && !flag_trapv
8507           /* Avoid this transformation if C is INT_MIN, i.e. C == -C.  */
8508           && !sign_bit_p (arg1, arg1))
8509         return fold_build2 (code, type, fold_convert (type, arg0),
8510                             fold_convert (type, negate_expr (arg1)));
8511 
8512       /* X % -Y is the same as X % Y.  */
8513       if (code == TRUNC_MOD_EXPR
8514           && !TYPE_UNSIGNED (type)
8515           && TREE_CODE (arg1) == NEGATE_EXPR
8516           && !flag_trapv)
8517         return fold_build2 (code, type, fold_convert (type, arg0),
8518                             fold_convert (type, TREE_OPERAND (arg1, 0)));
8519 
8520       if (TREE_CODE (arg1) == INTEGER_CST
8521           && 0 != (tem = extract_muldiv (op0, arg1, code, NULL_TREE)))
8522         return fold_convert (type, tem);
8523 
8524       goto binary;
8525 

ROTATE_EXPR[]

8526     case LROTATE_EXPR:
8527     case RROTATE_EXPR:
8528       if (integer_all_onesp (arg0))
8529         return omit_one_operand (type, arg0, arg1);
8530       goto shift;
8531 

SHIFT_EXPR[]

8532     case RSHIFT_EXPR:
8533       /* Optimize -1 >> x for arithmetic right shifts.  */
8534       if (integer_all_onesp (arg0) && !TYPE_UNSIGNED (type))
8535         return omit_one_operand (type, arg0, arg1);
8536       /* ... fall through ...  */
8537 
8538     case LSHIFT_EXPR:

8539     shift:
8540       if (integer_zerop (arg1))
8541         return non_lvalue (fold_convert (type, arg0));
8542       if (integer_zerop (arg0))
8543         return omit_one_operand (type, arg0, arg1);
8544 
8545       /* Since negative shift count is not well-defined,
8546          don't try to compute it in the compiler.  */
8547       if (TREE_CODE (arg1) == INTEGER_CST && tree_int_cst_sgn (arg1) < 0)
8548         return NULL_TREE;
8549 
8550       /* Turn (a OP c1) OP c2 into a OP (c1+c2).  */
8551       if (TREE_CODE (arg0) == code && host_integerp (arg1, false)
8552           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
8553           && host_integerp (TREE_OPERAND (arg0, 1), false)
8554           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
8555         {
8556           HOST_WIDE_INT low = (TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1))
8557                                + TREE_INT_CST_LOW (arg1));
8558 
8559           /* Deal with a OP (c1 + c2) being undefined but (a OP c1) OP c2
8560              being well defined.  */
8561           if (low >= TYPE_PRECISION (type))
8562             {
8563               if (code == LROTATE_EXPR || code == RROTATE_EXPR)
8564                 low = low % TYPE_PRECISION (type);
8565               else if (TYPE_UNSIGNED (type) || code == LSHIFT_EXPR)
8566                 return build_int_cst (type, 0);
8567               else
8568                 low = TYPE_PRECISION (type) - 1;
8569             }
8570 
8571           return fold_build2 (code, type, TREE_OPERAND (arg0, 0),
8572                               build_int_cst (type, low));
8573         }
8574 
8575       /* Transform (x >> c) << c into x & (-1<<c), or transform (x << c) >> c
8576          into x & ((unsigned)-1 >> c) for unsigned types.  */
8577       if (((code == LSHIFT_EXPR && TREE_CODE (arg0) == RSHIFT_EXPR)
8578            || (TYPE_UNSIGNED (type)
8579                && code == RSHIFT_EXPR && TREE_CODE (arg0) == LSHIFT_EXPR))
8580           && host_integerp (arg1, false)
8581           && TREE_INT_CST_LOW (arg1) < TYPE_PRECISION (type)
8582           && host_integerp (TREE_OPERAND (arg0, 1), false)
8583           && TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)) < TYPE_PRECISION (type))
8584         {
8585           HOST_WIDE_INT low0 = TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1));
8586           HOST_WIDE_INT low1 = TREE_INT_CST_LOW (arg1);
8587           tree lshift;
8588           tree arg00;
8589 
8590           if (low0 == low1)
8591             {
8592               arg00 = fold_convert (type, TREE_OPERAND (arg0, 0));
8593 
8594               lshift = build_int_cst (type, -1);
8595               lshift = int_const_binop (code, lshift, arg1, 0);
8596 
8597               return fold_build2 (BIT_AND_EXPR, type, arg00, lshift);
8598             }
8599         }
8600 
8601       /* Rewrite an LROTATE_EXPR by a constant into an
8602          RROTATE_EXPR by a new constant.  */
8603       if (code == LROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST)
8604         {
8605           tree tem = build_int_cst (NULL_TREE,
8606                                     GET_MODE_BITSIZE (TYPE_MODE (type)));
8607           tem = fold_convert (TREE_TYPE (arg1), tem);
8608           tem = const_binop (MINUS_EXPR, tem, arg1, 0);
8609           return fold_build2 (RROTATE_EXPR, type, arg0, tem);
8610         }
8611 
8612       /* If we have a rotate of a bit operation with the rotate count and
8613          the second operand of the bit operation both constant,
8614          permute the two operations.  */
8615       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
8616           && (TREE_CODE (arg0) == BIT_AND_EXPR
8617               || TREE_CODE (arg0) == BIT_IOR_EXPR
8618               || TREE_CODE (arg0) == BIT_XOR_EXPR)
8619           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
8620         return fold_build2 (TREE_CODE (arg0), type,
8621                             fold_build2 (code, type,
8622                                          TREE_OPERAND (arg0, 0), arg1),
8623                             fold_build2 (code, type,
8624                                          TREE_OPERAND (arg0, 1), arg1));
8625 
8626       /* Two consecutive rotates adding up to the width of the mode can
8627          be ignored.  */
8628       if (code == RROTATE_EXPR && TREE_CODE (arg1) == INTEGER_CST
8629           && TREE_CODE (arg0) == RROTATE_EXPR
8630           && TREE_CODE (TREE_OPERAND (arg0, 1)) ==
INTEGER_CST
8631           && TREE_INT_CST_HIGH (arg1) == 0
8632           && TREE_INT_CST_HIGH (TREE_OPERAND (arg0, 1)) == 0
8633           && ((TREE_INT_CST_LOW (arg1)
8634                + TREE_INT_CST_LOW (TREE_OPERAND (arg0, 1)))
8635               == (unsigned int) GET_MODE_BITSIZE (TYPE_MODE (type))))
8636         return TREE_OPERAND (arg0, 0);
8637 
8638       goto binary;
8639 

MIN_EXPR[]

8640     case MIN_EXPR:
8641       if (operand_equal_p (arg0, arg1, 0))
8642         return omit_one_operand (type, arg0, arg1);
8643       if (INTEGRAL_TYPE_P (type)
8644           && operand_equal_p (arg1, TYPE_MIN_VALUE (type), OEP_ONLY_CONST))
8645         return omit_one_operand (type, arg1, arg0);
8646       goto associate;
8647

MAX_EXPR[]

8648     case MAX_EXPR:
8649       if (operand_equal_p (arg0, arg1, 0))
8650         return omit_one_operand (type, arg0, arg1);
8651       if (INTEGRAL_TYPE_P (type)
8652           && TYPE_MAX_VALUE (type)
8653           && operand_equal_p (arg1, TYPE_MAX_VALUE (type), OEP_ONLY_CONST))
8654         return omit_one_operand (type, arg1, arg0);
8655       goto associate;
8656 

TRUTH_ANDIF_EXPR[]

8657     case TRUTH_ANDIF_EXPR:
8658       /* Note that the operands of this must be ints
8659          and their values must be 0 or 1.
8660          ("true" is a fixed value perhaps depending on the language.)  */
8661       /* If first arg is constant zero, return it.  */
8662       if (integer_zerop (arg0))
8663         return fold_convert (type, arg0);

TRUTH_AND_EXPR[]

8664     case TRUTH_AND_EXPR:
8665       /* If either arg is constant true, drop it.  */
8666       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
8667         return non_lvalue (fold_convert (type, arg1));
8668       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1)
8669           /* Preserve sequence points.  */
8670           && (code != TRUTH_ANDIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
8671         return non_lvalue (fold_convert (type, arg0));
8672       /* If second arg is constant zero, result is zero, but first arg
8673          must be evaluated.  */
8674       if (integer_zerop (arg1))
8675         return omit_one_operand (type, arg1, arg0);
8676       /* Likewise for first arg, but note that only the TRUTH_AND_EXPR
8677          case will be handled here.  */
8678       if (integer_zerop (arg0))
8679         return omit_one_operand (type, arg0, arg1);
8680 
8681       /* !X && X is always false.  */
8682       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
8683           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
8684         return omit_one_operand (type, integer_zero_node, arg1);
8685       /* X && !X is always false.  */
8686       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
8687           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8688         return omit_one_operand (type, integer_zero_node, arg0);
8689 
8690       /* A < X && A + 1 > Y ==> A < X && A >= Y.  Normally A + 1 > Y
8691          means A >= Y && A != MAX, but in this case we know that
8692          A < X <= MAX.  */
8693 
8694       if (!TREE_SIDE_EFFECTS (arg0)
8695           && !TREE_SIDE_EFFECTS (arg1))
8696         {
8697           tem = fold_to_nonsharp_ineq_using_bound (arg0, arg1);
8698           if (tem && !operand_equal_p (tem, arg0, 0))
8699             return fold_build2 (code, type, tem, arg1);
8700 
8701           tem = fold_to_nonsharp_ineq_using_bound (arg1, arg0);
8702           if (tem && !operand_equal_p (tem, arg1, 0))
8703             return fold_build2 (code, type, arg0, tem);
8704         }
8705 

8706     truth_andor:
8707       /* We only do these simplifications if we are optimizing.  */
8708       if (!optimize)
8709         return NULL_TREE;
8710 
8711       /* Check for things like (A || B) && (A || C).  We can convert this
8712          to A || (B && C).  Note that either operator can be any of the four
8713          truth and/or operations and the transformation will still be
8714          valid.   Also note that we only care about order for the
8715          ANDIF and ORIF operators.  If B contains side effects, this
8716          might change the truth-value of A.  */
8717       if (TREE_CODE (arg0) == TREE_CODE (arg1)
8718           && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
8719               || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
8720               || TREE_CODE (arg0) == TRUTH_AND_EXPR
8721               || TREE_CODE (arg0) == TRUTH_OR_EXPR)
8722           && ! TREE_SIDE_EFFECTS (TREE_OPERAND (arg0, 1)))
8723         {
8724           tree a00 = TREE_OPERAND (arg0, 0);
8725           tree a01 = TREE_OPERAND (arg0, 1);
8726           tree a10 = TREE_OPERAND (arg1, 0);
8727           tree a11 = TREE_OPERAND (arg1, 1);
8728           int commutative = ((TREE_CODE (arg0) == TRUTH_OR_EXPR
8729                               || TREE_CODE (arg0) == TRUTH_AND_EXPR)
8730                              && (code == TRUTH_AND_EXPR
8731                                  || code == TRUTH_OR_EXPR));
8732 
8733           if (operand_equal_p (a00, a10, 0))
8734             return fold_build2 (TREE_CODE (arg0), type, a00,
8735                                 fold_build2 (code, type, a01, a11));
8736           else if (commutative && operand_equal_p (a00, a11, 0))
8737             return fold_build2 (TREE_CODE (arg0), type, a00,
8738                                 fold_build2 (code, type, a01, a10));
8739           else if (commutative && operand_equal_p (a01, a10, 0))
8740             return fold_build2 (TREE_CODE (arg0), type, a01,
8741                                 fold_build2 (code, type, a00, a11));
8742 
8743           /* This case if tricky because we must either have commutative
8744              operators or else A10 must not have side-effects.  */
8745 
8746           else if ((commutative || ! TREE_SIDE_EFFECTS (a10))
8747                    && operand_equal_p (a01, a11, 0))
8748             return fold_build2 (TREE_CODE (arg0), type,
8749                                 fold_build2 (code, type, a00, a10),
8750                                 a01);
8751         }
8752 
8753       /* See if we can build a range comparison.  */
8754       if (0 != (tem = fold_range_test (code, type, op0, op1)))
8755         return tem;
8756 
8757       /* Check for the possibility of merging component references.  If our
8758          lhs is another similar operation, try to merge its rhs with our
8759          rhs.  Then try to merge our lhs and rhs.  */
8760       if (TREE_CODE (arg0) == code
8761           && 0 != (tem = fold_truthop (code, type,
8762                                        TREE_OPERAND (arg0, 1), arg1)))
8763         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
8764 
8765       if ((tem = fold_truthop (code, type, arg0, arg1)) != 0)
8766         return tem;
8767 
8768       return NULL_TREE;
8769 

TRUTH_ORIF_EXPR[]

8770     case TRUTH_ORIF_EXPR:
8771       /* Note that the operands of this must be ints
8772          and their values must be 0 or true.
8773          ("true" is a fixed value perhaps depending on the language.)  */
8774       /* If first arg is constant true, return it.  */
8775       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
8776         return fold_convert (type, arg0);

TRUTH_OR_EXPR[]

8777     case TRUTH_OR_EXPR:
8778       /* If either arg is constant zero, drop it.  */
8779       if (TREE_CODE (arg0) == INTEGER_CST && integer_zerop (arg0))
8780         return non_lvalue (fold_convert (type, arg1));
8781       if (TREE_CODE (arg1) == INTEGER_CST && integer_zerop (arg1)
8782           /* Preserve sequence points.  */
8783           && (code != TRUTH_ORIF_EXPR || ! TREE_SIDE_EFFECTS (arg0)))
8784         return non_lvalue (fold_convert (type, arg0));
8785       /* If second arg is constant true, result is true, but we must
8786          evaluate first arg.  */
8787       if (TREE_CODE (arg1) == INTEGER_CST && ! integer_zerop (arg1))
8788         return omit_one_operand (type, arg1, arg0);
8789       /* Likewise for first arg, but note this only occurs here for
8790          TRUTH_OR_EXPR.  */
8791       if (TREE_CODE (arg0) == INTEGER_CST && ! integer_zerop (arg0))
8792         return omit_one_operand (type, arg0, arg1);
8793 
8794       /* !X || X is always true.  */
8795       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
8796           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
8797         return omit_one_operand (type, integer_one_node, arg1);
8798       /* X || !X is always true.  */
8799       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
8800           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8801         return omit_one_operand (type, integer_one_node, arg0);
8802 
8803       goto truth_andor;
8804 

TRUTH_XOR_EXPR[]

8805     case TRUTH_XOR_EXPR:
8806       /* If the second arg is constant zero, drop it.  */
8807       if (integer_zerop (arg1))
8808         return non_lvalue (fold_convert (type, arg0));
8809       /* If the second arg is constant true, this is a logical inversion.  */
8810       if (integer_onep (arg1))
8811         {
8812           /* Only call invert_truthvalue if operand is a truth value.  */
8813           if (TREE_CODE (TREE_TYPE (arg0)) != BOOLEAN_TYPE)
8814             tem = fold_build1 (TRUTH_NOT_EXPR, TREE_TYPE (arg0), arg0);
8815           else
8816             tem = invert_truthvalue (arg0);
8817           return non_lvalue (fold_convert (type, tem));
8818         }
8819       /* Identical arguments cancel to zero.  */
8820       if (operand_equal_p (arg0, arg1, 0))
8821         return omit_one_operand (type, integer_zero_node, arg0);
8822 
8823       /* !X ^ X is always true.  */
8824       if (TREE_CODE (arg0) == TRUTH_NOT_EXPR
8825           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0))
8826         return omit_one_operand (type, integer_one_node, arg1);
8827 
8828       /* X ^ !X is always true.  */
8829       if (TREE_CODE (arg1) == TRUTH_NOT_EXPR
8830           && operand_equal_p (arg0, TREE_OPERAND (arg1, 0), 0))
8831         return omit_one_operand (type, integer_one_node, arg0);
8832 
8833       return NULL_TREE;
8834 

EQ_EXPR, NE_EXPR, LT_EXPR, GT_EXPR, GE_EXPR[]

8835     case EQ_EXPR:
8836     case NE_EXPR:
8837     case LT_EXPR:
8838     case GT_EXPR:
8839     case LE_EXPR:
8840     case GE_EXPR:       
8841       /* If one arg is a real or integer constant, put it last.  */
8842       if (tree_swap_operands_p (arg0, arg1, true))
8843         return fold_build2 (swap_tree_comparison (code), type, op1, op0);
8844         
8845       /* bool_var != 0 becomes bool_var. */
8846       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_zerop (arg1)
8847           && code == NE_EXPR)
8848         return non_lvalue (fold_convert (type, arg0));
8849         
8850       /* bool_var == 1 becomes bool_var. */
8851       if (TREE_CODE (TREE_TYPE (arg0)) == BOOLEAN_TYPE && integer_onep (arg1)
8852           && code == EQ_EXPR)
8853         return non_lvalue (fold_convert (type, arg0));
8854 
8855       /* If this is an equality comparison of the address of a non-weak
8856          object against zero, then we know the result.  */
8857       if ((code == EQ_EXPR || code == NE_EXPR)
8858           && TREE_CODE (arg0) == ADDR_EXPR
8859           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
8860           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
8861           && integer_zerop (arg1))
8862         return constant_boolean_node (code != EQ_EXPR, type);
8863 
8864       /* If this is an equality comparison of the address of two non-weak,
8865          unaliased symbols neither of which are extern (since we do not
8866          have access to attributes for externs), then we know the result.  */
8867       if ((code == EQ_EXPR || code == NE_EXPR)
8868           && TREE_CODE (arg0) == ADDR_EXPR
8869           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg0, 0))
8870           && ! DECL_WEAK (TREE_OPERAND (arg0, 0))
8871           && ! lookup_attribute ("alias",
8872                                  DECL_ATTRIBUTES (TREE_OPERAND (arg0, 0)))
8873           && ! DECL_EXTERNAL (TREE_OPERAND (arg0, 0))
8874           && TREE_CODE (arg1) == ADDR_EXPR
8875           && VAR_OR_FUNCTION_DECL_P (TREE_OPERAND (arg1, 0))
8876           && ! DECL_WEAK (TREE_OPERAND (arg1, 0))
8877           && ! lookup_attribute ("alias",
8878                                  DECL_ATTRIBUTES (TREE_OPERAND (arg1, 0)))
8879           && ! DECL_EXTERNAL (TREE_OPERAND (arg1, 0)))
8880         {
8881           /* We know that we're looking at the address of two
8882              non-weak, unaliased, static _DECL nodes.
8883 
8884              It is both wasteful and incorrect to call operand_equal_p
8885              to compare the two ADDR_EXPR nodes.  It is wasteful in that
8886              all we need to do is test pointer equality for the arguments
8887              to the two ADDR_EXPR nodes.  It is incorrect to use
8888              operand_equal_p as that function is NOT equivalent to a
8889              C equality test.  It can in fact return false for two
8890              objects which would test as equal using the C equality
8891              operator.  */
8892           bool equal = TREE_OPERAND (arg0, 0) == TREE_OPERAND (arg1, 0);
8893           return constant_boolean_node (equal
8894                                         ? code == EQ_EXPR : code != EQ_EXPR,
8895                                         type);
8896         }
8897 
8898       /* If this is a comparison of two exprs that look like an
8899          ARRAY_REF of the same object, then we can fold this to a
8900          comparison of the two offsets.  */
8901       if (TREE_CODE_CLASS (code) == tcc_comparison)
8902         {
8903           tree base0, offset0, base1, offset1;
8904 
8905           if (extract_array_ref (arg0, &base0, &offset0)
8906               && extract_array_ref (arg1, &base1, &offset1)
8907               && operand_equal_p (base0, base1, 0))
8908             {
8909               /* Handle no offsets on both sides specially.  */
8910               if (offset0 == NULL_TREE
8911                   && offset1 == NULL_TREE)
8912                 return fold_build2 (code, type, integer_zero_node,
8913                                     integer_zero_node);
8914 
8915               if (!offset0 || !offset1
8916                   || TREE_TYPE (offset0) == TREE_TYPE (offset1))
8917                 {
8918                   if (offset0 == NULL_TREE)
8919                     offset0 = build_int_cst (TREE_TYPE (offset1), 0);
8920                   if (offset1 == NULL_TREE)
8921                     offset1 = build_int_cst (TREE_TYPE (offset0), 0);
8922                   return fold_build2 (code, type, offset0, offset1);
8923                 }
8924             }
8925         }
8926 
8927       /* Transform comparisons of the form X +- C CMP X.  */
8928       if ((code != EQ_EXPR && code != NE_EXPR)
8929           && (TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
8930           && operand_equal_p (TREE_OPERAND (arg0, 0), arg1, 0)
8931           && ((TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
8932                && !HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg0))))
8933               || (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
8934                   && !TYPE_UNSIGNED (TREE_TYPE (arg1))
8935                   && !(flag_wrapv || flag_trapv))))
8936         {
8937           tree arg01 = TREE_OPERAND (arg0, 1);
8938           enum tree_code code0 = TREE_CODE (arg0);
8939           int is_positive;
8940 
8941           if (TREE_CODE (arg01) == REAL_CST)
8942             is_positive = REAL_VALUE_NEGATIVE (TREE_REAL_CST (arg01)) ? -1 : 1;
8943           else
8944             is_positive = tree_int_cst_sgn (arg01);
8945 
8946           /* (X - c) > X becomes false.  */
8947           if (code == GT_EXPR
8948               && ((code0 == MINUS_EXPR && is_positive >= 0)
8949                   || (code0 == PLUS_EXPR && is_positive <= 0)))
8950             return constant_boolean_node (0, type);
8951 
8952           /* Likewise (X + c) < X becomes false.  */
8953           if (code == LT_EXPR
8954               && ((code0 == PLUS_EXPR && is_positive >= 0)
8955                   || (code0 == MINUS_EXPR && is_positive <= 0)))
8956             return constant_boolean_node (0, type);
8957 
8958           /* Convert (X - c) <= X to true.  */
8959           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
8960               && code == LE_EXPR
8961               && ((code0 == MINUS_EXPR && is_positive >= 0)
8962                   || (code0 == PLUS_EXPR && is_positive <= 0)))
8963             return constant_boolean_node (1, type);
8964 
8965           /* Convert (X + c) >= X to true.  */
8966           if (!HONOR_NANS (TYPE_MODE (TREE_TYPE (arg1)))
8967               && code == GE_EXPR
8968               && ((code0 == PLUS_EXPR && is_positive >= 0)
8969                   || (code0 == MINUS_EXPR && is_positive <= 0)))
8970             return constant_boolean_node (1, type);
8971 
8972           if (TREE_CODE (arg01) == INTEGER_CST)
8973             {
8974               /* Convert X + c > X and X - c < X to true for integers.  */
8975               if (code == GT_EXPR
8976                   && ((code0 == PLUS_EXPR && is_positive > 0)
8977                       || (code0 == MINUS_EXPR && is_positive < 0)))
8978                 return constant_boolean_node (1, type);
8979 
8980               if (code == LT_EXPR
8981                   && ((code0 == MINUS_EXPR && is_positive > 0)
8982                       || (code0 == PLUS_EXPR && is_positive < 0)))
8983                 return constant_boolean_node (1, type);
8984 
8985               /* Convert X + c <= X and X - c >= X to false for integers.  */
8986               if (code == LE_EXPR
8987                   && ((code0 == PLUS_EXPR && is_positive > 0)
8988                       || (code0 == MINUS_EXPR && is_positive < 0)))
8989                 return constant_boolean_node (0, type);
8990 
8991               if (code == GE_EXPR
8992                   && ((code0 == MINUS_EXPR && is_positive > 0)
8993                       || (code0 == PLUS_EXPR && is_positive < 0)))
8994                 return constant_boolean_node (0, type);
8995             }
8996         }
8997 
8998       /* Transform comparisons of the form X +- C1 CMP C2 to X CMP C2 +- C1.  */
8999       if ((TREE_CODE (arg0) == PLUS_EXPR || TREE_CODE (arg0) == MINUS_EXPR)
9000           && (TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9001               && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9002               && !TYPE_UNSIGNED (TREE_TYPE (arg1))
9003               && !(flag_wrapv || flag_trapv))
9004           && (TREE_CODE (arg1) == INTEGER_CST
9005               && !TREE_OVERFLOW (arg1)))
9006         {
9007           tree const1 = TREE_OPERAND (arg0, 1);
9008           tree const2 = arg1;
9009           tree variable = TREE_OPERAND (arg0, 0);
9010           tree lhs;
9011           int lhs_add;
9012           lhs_add = TREE_CODE (arg0) != PLUS_EXPR;
9013           
9014           lhs = fold_build2 (lhs_add ? PLUS_EXPR : MINUS_EXPR,
9015                              TREE_TYPE (arg1), const2, const1);
9016           if (TREE_CODE (lhs) == TREE_CODE (arg1)
9017               && (TREE_CODE (lhs) != INTEGER_CST
9018                   || !TREE_OVERFLOW (lhs)))
9019             return fold_build2 (code, type, variable, lhs);
9020         }
9021 
9022       if (FLOAT_TYPE_P (TREE_TYPE (arg0)))
9023         {
9024           tree targ0 = strip_float_extensions (arg0);
9025           tree targ1 = strip_float_extensions (arg1);
9026           tree newtype = TREE_TYPE (targ0);
9027 
9028           if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
9029             newtype = TREE_TYPE (targ1);
9030 
9031           /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
9032           if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
9033             return fold_build2 (code, type, fold_convert (newtype, targ0),
9034                                 fold_convert (newtype, targ1));
9035 
9036           /* (-a) CMP (-b) -> b CMP a  */
9037           if (TREE_CODE (arg0) == NEGATE_EXPR
9038               && TREE_CODE (arg1) == NEGATE_EXPR)
9039             return fold_build2 (code, type, TREE_OPERAND (arg1, 0),
9040                                 TREE_OPERAND (arg0, 0));
9041 
9042           if (TREE_CODE (arg1) == REAL_CST)
9043           {
9044             REAL_VALUE_TYPE cst;
9045             cst = TREE_REAL_CST (arg1);
9046 
9047             /* (-a) CMP CST -> a swap(CMP) (-CST)  */
9048             if (TREE_CODE (arg0) == NEGATE_EXPR)
9049               return
9050                 fold_build2 (swap_tree_comparison (code), type,
9051                              TREE_OPERAND (arg0, 0),
9052                              build_real (TREE_TYPE (arg1),
9053                                          REAL_VALUE_NEGATE (cst)));
9054 
9055             /* IEEE doesn't distinguish +0 and -0 in comparisons.  */
9056             /* a CMP (-0) -> a CMP 0  */
9057             if (REAL_VALUE_MINUS_ZERO (cst))
9058               return fold_build2 (code, type, arg0,
9059                                   build_real (TREE_TYPE (arg1), dconst0));
9060 
9061             /* x != NaN is always true, other ops are always false.  */
9062             if (REAL_VALUE_ISNAN (cst)
9063                 && ! HONOR_SNANS (TYPE_MODE (TREE_TYPE (arg1))))
9064               {
9065                 tem = (code == NE_EXPR) ? integer_one_node : integer_zero_node;
9066                 return omit_one_operand (type, tem, arg0);
9067               }
9068 
9069             /* Fold comparisons against infinity.  */
9070             if (REAL_VALUE_ISINF (cst))
9071               {
9072                 tem = fold_inf_compare (code, type, arg0, arg1);
9073                 if (tem != NULL_TREE)
9074                   return tem;
9075               }
9076           }
9077 
9078           /* If this is a comparison of a real constant with a PLUS_EXPR
9079              or a MINUS_EXPR of a real constant, we can convert it into a
9080              comparison with a revised real constant as long as no overflow
9081              occurs when unsafe_math_optimizations are enabled.  */
9082           if (flag_unsafe_math_optimizations
9083               && TREE_CODE (arg1) == REAL_CST
9084               && (TREE_CODE (arg0) == PLUS_EXPR
9085                   || TREE_CODE (arg0) == MINUS_EXPR)
9086               && TREE_CODE (TREE_OPERAND (arg0, 1)) == REAL_CST
9087               && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
9088                                           ? MINUS_EXPR : PLUS_EXPR,
9089                                           arg1, TREE_OPERAND (arg0, 1), 0))
9090               && ! TREE_CONSTANT_OVERFLOW (tem))
9091             return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
9092 
9093           /* Likewise, we can simplify a comparison of a real constant with
9094              a MINUS_EXPR whose first operand is also a real constant, i.e.
9095              (c1 - x) < c2 becomes x > c1-c2.  */
9096           if (flag_unsafe_math_optimizations
9097               && TREE_CODE (arg1) == REAL_CST
9098               && TREE_CODE (arg0) == MINUS_EXPR
9099               && TREE_CODE (TREE_OPERAND (arg0, 0)) == REAL_CST
9100               && 0 != (tem = const_binop (MINUS_EXPR, TREE_OPERAND (arg0, 0),
9101                                           arg1, 0))
9102               && ! TREE_CONSTANT_OVERFLOW (tem))
9103             return fold_build2 (swap_tree_comparison (code), type,
9104                                 TREE_OPERAND (arg0, 1), tem);
9105 
9106           /* Fold comparisons against built-in math functions.  */
9107           if (TREE_CODE (arg1) == REAL_CST
9108               && flag_unsafe_math_optimizations
9109               && ! flag_errno_math)
9110             {
9111               enum built_in_function fcode = builtin_mathfn_code (arg0);
9112 
9113               if (fcode != END_BUILTINS)
9114                 {
9115                   tem = fold_mathfn_compare (fcode, code, type, arg0, arg1);
9116                   if (tem != NULL_TREE)
9117                     return tem;
9118                 }
9119             }
9120         }
9121 
9122       /* Convert foo++ == CONST into ++foo == CONST + INCR.  */
9123       if (TREE_CONSTANT (arg1)
9124           && (TREE_CODE (arg0) == POSTINCREMENT_EXPR
9125               || TREE_CODE (arg0) == POSTDECREMENT_EXPR)
9126           /* This optimization is invalid for ordered comparisons
9127              if CONST+INCR overflows or if foo+incr might overflow.
9128              This optimization is invalid for floating point due to rounding.
9129              For pointer types we assume overflow doesn't happen.  */
9130           && (POINTER_TYPE_P (TREE_TYPE (arg0))
9131               || (INTEGRAL_TYPE_P (TREE_TYPE (arg0))
9132                   && (code == EQ_EXPR || code == NE_EXPR))))
9133         {
9134           tree varop, newconst;
9135 
9136           if (TREE_CODE (arg0) == POSTINCREMENT_EXPR)
9137             {
9138               newconst = fold_build2 (PLUS_EXPR, TREE_TYPE (arg0),
9139                                       arg1, TREE_OPERAND (arg0, 1));
9140               varop = build2 (PREINCREMENT_EXPR, TREE_TYPE (arg0),
9141                               TREE_OPERAND (arg0, 0),
9142                               TREE_OPERAND (arg0, 1));
9143             }
9144           else
9145             {
9146               newconst = fold_build2 (MINUS_EXPR, TREE_TYPE (arg0),
9147                                       arg1, TREE_OPERAND (arg0, 1));
9148               varop = build2 (PREDECREMENT_EXPR, TREE_TYPE (arg0),
9149                               TREE_OPERAND (arg0, 0),
9150                               TREE_OPERAND (arg0, 1));
9151             }
9152 
9153 
9154           /* If VAROP is a reference to a bitfield, we must mask
9155              the constant by the width of the field.  */
9156           if (TREE_CODE (TREE_OPERAND (varop, 0)) == COMPONENT_REF
9157               && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (varop, 0), 1))
9158               && host_integerp (DECL_SIZE (TREE_OPERAND
9159                                            (TREE_OPERAND (varop, 0), 1)), 1))
9160             {
9161               tree fielddecl = TREE_OPERAND (TREE_OPERAND (varop, 0), 1);
9162               HOST_WIDE_INT size = tree_low_cst (DECL_SIZE (fielddecl), 1);
9163               tree folded_compare, shift;
9164 
9165               /* First check whether the comparison would come out
9166                  always the same.  If we don't do that we would
9167                  change the meaning with the masking.  */
9168               folded_compare = fold_build2 (code, type,
9169                                             TREE_OPERAND (varop, 0), arg1);
9170               if (integer_zerop (folded_compare)
9171                   || integer_onep (folded_compare))
9172                 return omit_one_operand (type, folded_compare, varop);
9173 
9174               shift = build_int_cst (NULL_TREE,
9175                                      TYPE_PRECISION (TREE_TYPE (varop)) - size);
9176               shift = fold_convert (TREE_TYPE (varop), shift);
9177               newconst = fold_build2 (LSHIFT_EXPR, TREE_TYPE (varop),
9178                                       newconst, shift);
9179               newconst = fold_build2 (RSHIFT_EXPR, TREE_TYPE (varop),
9180                                       newconst, shift);
9181             }
9182 
9183           return fold_build2 (code, type, varop, newconst);
9184         }
9185 
9186       /* Change X >= C to X > (C - 1) and X < C to X <= (C - 1) if C > 0.
9187          This transformation affects the cases which are handled in later
9188          optimizations involving comparisons with non-negative constants.  */
9189       if (TREE_CODE (arg1) == INTEGER_CST
9190           && TREE_CODE (arg0) != INTEGER_CST
9191           && tree_int_cst_sgn (arg1) > 0)
9192         {
9193           switch (code)
9194             {
9195             case GE_EXPR:
9196               arg1 = const_binop (MINUS_EXPR, arg1,
9197                                   build_int_cst (TREE_TYPE (arg1), 1), 0);
9198               return fold_build2 (GT_EXPR, type, arg0,
9199                                   fold_convert (TREE_TYPE (arg0), arg1));
9200 
9201             case LT_EXPR:
9202               arg1 = const_binop (MINUS_EXPR, arg1,
9203                                   build_int_cst (TREE_TYPE (arg1), 1), 0);
9204               return fold_build2 (LE_EXPR, type, arg0,
9205                                   fold_convert (TREE_TYPE (arg0), arg1));
9206 
9207             default:
9208               break;
9209             }
9210         }
9211 
9212       /* Comparisons with the highest or lowest possible integer of
9213          the specified size will have known values.  */
9214       {
9215         int width = GET_MODE_BITSIZE (TYPE_MODE (TREE_TYPE (arg1)));
9216 
9217         if (TREE_CODE (arg1) == INTEGER_CST
9218             && ! TREE_CONSTANT_OVERFLOW (arg1)
9219             && width <= 2 * HOST_BITS_PER_WIDE_INT
9220             && (INTEGRAL_TYPE_P (TREE_TYPE (arg1))
9221                 || POINTER_TYPE_P (TREE_TYPE (arg1))))
9222           {
9223             HOST_WIDE_INT signed_max_hi;
9224             unsigned HOST_WIDE_INT signed_max_lo;
9225             unsigned HOST_WIDE_INT max_hi, max_lo, min_hi, min_lo;
9226 
9227             if (width <= HOST_BITS_PER_WIDE_INT)
9228               {
9229                 signed_max_lo = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
9230                                 - 1;
9231                 signed_max_hi = 0;
9232                 max_hi = 0;
9233 
9234                 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
9235                   {
9236                     max_lo = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
9237                     min_lo = 0;
9238                     min_hi = 0;
9239                   }
9240                 else
9241                   {
9242                     max_lo = signed_max_lo;
9243                     min_lo = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
9244                     min_hi = -1;
9245                   }
9246               }
9247             else
9248               {
9249                 width -= HOST_BITS_PER_WIDE_INT;
9250                 signed_max_lo = -1;
9251                 signed_max_hi = ((unsigned HOST_WIDE_INT) 1 << (width - 1))
9252                                 - 1;
9253                 max_lo = -1;
9254                 min_lo = 0;
9255 
9256                 if (TYPE_UNSIGNED (TREE_TYPE (arg1)))
9257                   {
9258                     max_hi = ((unsigned HOST_WIDE_INT) 2 << (width - 1)) - 1;
9259                     min_hi = 0;
9260                   }
9261                 else
9262                   {
9263                     max_hi = signed_max_hi;
9264                     min_hi = ((unsigned HOST_WIDE_INT) -1 << (width - 1));
9265                   }
9266               }
9267 
9268             if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1) == max_hi
9269                 && TREE_INT_CST_LOW (arg1) == max_lo)
9270               switch (code)
9271                 {
9272                 case GT_EXPR:
9273                   return omit_one_operand (type, integer_zero_node, arg0);
9274 
9275                 case GE_EXPR:
9276                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
9277 
9278                 case LE_EXPR:
9279                   return omit_one_operand (type, integer_one_node, arg0);
9280 
9281                 case LT_EXPR:
9282                   return fold_build2 (NE_EXPR, type, arg0, arg1);
9283 
9284                 /* The GE_EXPR and LT_EXPR cases above are not normally
9285                    reached because of previous transformations.  */
9286 
9287                 default:
9288                   break;
9289                 }
9290             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
9291                      == max_hi
9292                      && TREE_INT_CST_LOW (arg1) == max_lo - 1)
9293               switch (code)
9294                 {
9295                 case GT_EXPR:
9296                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
9297                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
9298                 case LE_EXPR:
9299                   arg1 = const_binop (PLUS_EXPR, arg1, integer_one_node, 0);
9300                   return fold_build2 (NE_EXPR, type, arg0, arg1);
9301                 default:
9302                   break;
9303                 }
9304             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
9305                      == min_hi
9306                      && TREE_INT_CST_LOW (arg1) == min_lo)
9307               switch (code)
9308                 {
9309                 case LT_EXPR:
9310                   return omit_one_operand (type, integer_zero_node, arg0);
9311 
9312                 case LE_EXPR:
9313                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
9314 
9315                 case GE_EXPR:
9316                   return omit_one_operand (type, integer_one_node, arg0);
9317 
9318                 case GT_EXPR:
9319                   return fold_build2 (NE_EXPR, type, op0, op1);
9320 
9321                 default:
9322                   break;
9323                 }
9324             else if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (arg1)
9325                      == min_hi
9326                      && TREE_INT_CST_LOW (arg1) == min_lo + 1)
9327               switch (code)
9328                 {
9329                 case GE_EXPR:
9330                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
9331                   return fold_build2 (NE_EXPR, type, arg0, arg1);
9332                 case LT_EXPR:
9333                   arg1 = const_binop (MINUS_EXPR, arg1, integer_one_node, 0);
9334                   return fold_build2 (EQ_EXPR, type, arg0, arg1);
9335                 default:
9336                   break;
9337                 }
9338 
9339             else if (!in_gimple_form
9340                      && TREE_INT_CST_HIGH (arg1) == signed_max_hi
9341                      && TREE_INT_CST_LOW (arg1) == signed_max_lo
9342                      && TYPE_UNSIGNED (TREE_TYPE (arg1))
9343                      /* signed_type does not work on pointer types.  */
9344                      && INTEGRAL_TYPE_P (TREE_TYPE (arg1)))
9345               {
9346                 /* The following case also applies to X < signed_max+1
9347                    and X >= signed_max+1 because previous transformations.  */
9348                 if (code == LE_EXPR || code == GT_EXPR)
9349                   {
9350                     tree st0, st1;
9351                     st0 = lang_hooks.types.signed_type (TREE_TYPE (arg0));
9352                     st1 = lang_hooks.types.signed_type (TREE_TYPE (arg1));
9353                     return fold_build2 (code == LE_EXPR ? GE_EXPR: LT_EXPR,
9354                                         type, fold_convert (st0, arg0),
9355                                         build_int_cst (st1, 0));
9356                   }
9357               }
9358           }
9359       }
9360 
9361       /* If this is an EQ or NE comparison of a constant with a PLUS_EXPR or
9362          a MINUS_EXPR of a constant, we can convert it into a comparison with
9363          a revised constant as long as no overflow occurs.  */
9364       if ((code == EQ_EXPR || code == NE_EXPR)
9365           && TREE_CODE (arg1) == INTEGER_CST
9366           && (TREE_CODE (arg0) == PLUS_EXPR
9367               || TREE_CODE (arg0) == MINUS_EXPR)
9368           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9369           && 0 != (tem = const_binop (TREE_CODE (arg0) == PLUS_EXPR
9370                                       ? MINUS_EXPR : PLUS_EXPR,
9371                                       arg1, TREE_OPERAND (arg0, 1), 0))
9372           && ! TREE_CONSTANT_OVERFLOW (tem))
9373         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
9374 
9375       /* Similarly for a NEGATE_EXPR.  */
9376       else if ((code == EQ_EXPR || code == NE_EXPR)
9377                && TREE_CODE (arg0) == NEGATE_EXPR
9378                && TREE_CODE (arg1) == INTEGER_CST
9379                && 0 != (tem = negate_expr (arg1))
9380                && TREE_CODE (tem) == INTEGER_CST
9381                && ! TREE_CONSTANT_OVERFLOW (tem))
9382         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), tem);
9383 
9384       /* If we have X - Y == 0, we can convert that to X == Y and similarly
9385          for !=.  Don't do this for ordered comparisons due to overflow.  */
9386       else if ((code == NE_EXPR || code == EQ_EXPR)
9387                && integer_zerop (arg1) && TREE_CODE (arg0) == MINUS_EXPR)
9388         return fold_build2 (code, type,
9389                             TREE_OPERAND (arg0, 0), TREE_OPERAND (arg0, 1));
9390 
9391       else if (TREE_CODE (TREE_TYPE (arg0)) == INTEGER_TYPE
9392                && (TREE_CODE (arg0) == NOP_EXPR
9393                    || TREE_CODE (arg0) == CONVERT_EXPR))
9394         {
9395           /* If we are widening one operand of an integer comparison,
9396              see if the other operand is similarly being widened.  Perhaps we
9397              can do the comparison in the narrower type.  */
9398           tem = fold_widened_comparison (code, type, arg0, arg1);
9399           if (tem)
9400             return tem;
9401 
9402           /* Or if we are changing signedness.  */
9403           tem = fold_sign_changed_comparison (code, type, arg0, arg1);
9404           if (tem)
9405             return tem;
9406         }
9407 
9408       /* If this is comparing a constant with a MIN_EXPR or a MAX_EXPR of a
9409          constant, we can simplify it.  */
9410       else if (TREE_CODE (arg1) == INTEGER_CST
9411                && (TREE_CODE (arg0) == MIN_EXPR
9412                    || TREE_CODE (arg0) == MAX_EXPR)
9413                && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9414         {
9415           tem = optimize_minmax_comparison (code, type, op0, op1);
9416           if (tem)
9417             return tem;
9418 
9419           return NULL_TREE;
9420         }
9421 
9422       /* If we are comparing an ABS_EXPR with a constant, we can
9423          convert all the cases into explicit comparisons, but they may
9424          well not be faster than doing the ABS and one comparison.
9425          But ABS (X) <= C is a range comparison, which becomes a subtraction
9426          and a comparison, and is probably faster.  */
9427       else if (code == LE_EXPR && TREE_CODE (arg1) == INTEGER_CST
9428                && TREE_CODE (arg0) == ABS_EXPR
9429                && ! TREE_SIDE_EFFECTS (arg0)
9430                && (0 != (tem = negate_expr (arg1)))
9431                && TREE_CODE (tem) == INTEGER_CST
9432                && ! TREE_CONSTANT_OVERFLOW (tem))
9433         return fold_build2 (TRUTH_ANDIF_EXPR, type,
9434                             build2 (GE_EXPR, type,
9435                                     TREE_OPERAND (arg0, 0), tem),
9436                             build2 (LE_EXPR, type,
9437                                     TREE_OPERAND (arg0, 0), arg1));
9438 
9439       /* Convert ABS_EXPR<x> >= 0 to true.  */
9440       else if (code == GE_EXPR
9441                && tree_expr_nonnegative_p (arg0)
9442                && (integer_zerop (arg1)
9443                    || (! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0)))
9444                        && real_zerop (arg1))))
9445         return omit_one_operand (type, integer_one_node, arg0);
9446 
9447       /* Convert ABS_EXPR<x> < 0 to false.  */
9448       else if (code == LT_EXPR
9449                && tree_expr_nonnegative_p (arg0)
9450                && (integer_zerop (arg1) || real_zerop (arg1)))
9451         return omit_one_operand (type, integer_zero_node, arg0);
9452 
9453       /* Convert ABS_EXPR<x> == 0 or ABS_EXPR<x> != 0 to x == 0 or x != 0.  */
9454       else if ((code == EQ_EXPR || code == NE_EXPR)
9455                && TREE_CODE (arg0) == ABS_EXPR
9456                && (integer_zerop (arg1) || real_zerop (arg1)))
9457         return fold_build2 (code, type, TREE_OPERAND (arg0, 0), arg1);
9458 
9459       /* If this is an EQ or NE comparison with zero and ARG0 is
9460          (1 << foo) & bar, convert it to (bar >> foo) & 1.  Both require
9461          two operations, but the latter can be done in one less insn
9462          on machines that have only two-operand insns or on which a
9463          constant cannot be the first operand.  */
9464       if (integer_zerop (arg1) && (code == EQ_EXPR || code == NE_EXPR)
9465           && TREE_CODE (arg0) == BIT_AND_EXPR)
9466         {
9467           tree arg00 = TREE_OPERAND (arg0, 0);
9468           tree arg01 = TREE_OPERAND (arg0, 1);
9469           if (TREE_CODE (arg00) == LSHIFT_EXPR
9470               && integer_onep (TREE_OPERAND (arg00, 0)))
9471             return
9472               fold_build2 (code, type,
9473                            build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
9474                                    build2 (RSHIFT_EXPR, TREE_TYPE (arg00),
9475                                            arg01, TREE_OPERAND (arg00, 1)),
9476                                    fold_convert (TREE_TYPE (arg0),
9477                                                  integer_one_node)),
9478                            arg1);
9479           else if (TREE_CODE (TREE_OPERAND (arg0, 1)) == LSHIFT_EXPR
9480                    && integer_onep (TREE_OPERAND (TREE_OPERAND (arg0, 1), 0)))
9481             return
9482               fold_build2 (code, type,
9483                            build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
9484                                    build2 (RSHIFT_EXPR, TREE_TYPE (arg01),
9485                                            arg00, TREE_OPERAND (arg01, 1)),
9486                                    fold_convert (TREE_TYPE (arg0),
9487                                                  integer_one_node)),
9488                            arg1);
9489         }
9490 
9491       /* If this is an NE or EQ comparison of zero against the result of a
9492          signed MOD operation whose second operand is a power of 2, make
9493          the MOD operation unsigned since it is simpler and equivalent.  */
9494       if ((code == NE_EXPR || code == EQ_EXPR)
9495           && integer_zerop (arg1)
9496           && !TYPE_UNSIGNED (TREE_TYPE (arg0))
9497           && (TREE_CODE (arg0) == TRUNC_MOD_EXPR
9498               || TREE_CODE (arg0) == CEIL_MOD_EXPR
9499               || TREE_CODE (arg0) == FLOOR_MOD_EXPR
9500               || TREE_CODE (arg0) == ROUND_MOD_EXPR)
9501           && integer_pow2p (TREE_OPERAND (arg0, 1)))
9502         {
9503           tree newtype = lang_hooks.types.unsigned_type (TREE_TYPE (arg0));
9504           tree newmod = fold_build2 (TREE_CODE (arg0), newtype,
9505                                      fold_convert (newtype,
9506                                                    TREE_OPERAND (arg0, 0)),
9507                                      fold_convert (newtype,
9508                                                    TREE_OPERAND (arg0, 1)));
9509 
9510           return fold_build2 (code, type, newmod,
9511                               fold_convert (newtype, arg1));
9512         }
9513 
9514       /* If this is an NE comparison of zero with an AND of one, remove the
9515          comparison since the AND will give the correct value.  */
9516       if (code == NE_EXPR && integer_zerop (arg1)
9517           && TREE_CODE (arg0) == BIT_AND_EXPR
9518           && integer_onep (TREE_OPERAND (arg0, 1)))
9519         return fold_convert (type, arg0);
9520 
9521       /* If we have (A & C) == C where C is a power of 2, convert this into
9522          (A & C) != 0.  Similarly for NE_EXPR.  */
9523       if ((code == EQ_EXPR || code == NE_EXPR)
9524           && TREE_CODE (arg0) == BIT_AND_EXPR
9525           && integer_pow2p (TREE_OPERAND (arg0, 1))
9526           && operand_equal_p (TREE_OPERAND (arg0, 1), arg1, 0))
9527         return fold_build2 (code == EQ_EXPR ? NE_EXPR : EQ_EXPR, type,
9528                             arg0, fold_convert (TREE_TYPE (arg0),
9529                                                 integer_zero_node));
9530 
9531       /* If we have (A & C) != 0 or (A & C) == 0 and C is the sign
9532          bit, then fold the expression into A < 0 or A >= 0.  */
9533       tem = fold_single_bit_test_into_sign_test (code, arg0, arg1, type);
9534       if (tem)
9535         return tem;
9536 
9537       /* If we have (A & C) == D where D & ~C != 0, convert this into 0.
9538          Similarly for NE_EXPR.  */
9539       if ((code == EQ_EXPR || code == NE_EXPR)
9540           && TREE_CODE (arg0) == BIT_AND_EXPR
9541           && TREE_CODE (arg1) == INTEGER_CST
9542           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9543         {
9544           tree notc = fold_build1 (BIT_NOT_EXPR,
9545                                    TREE_TYPE (TREE_OPERAND (arg0, 1)),
9546                                    TREE_OPERAND (arg0, 1));
9547           tree dandnotc = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
9548                                        arg1, notc);
9549           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
9550           if (integer_nonzerop (dandnotc))
9551             return omit_one_operand (type, rslt, arg0);
9552         }
9553 
9554       /* If we have (A | C) == D where C & ~D != 0, convert this into 0.
9555          Similarly for NE_EXPR.  */
9556       if ((code == EQ_EXPR || code == NE_EXPR)
9557           && TREE_CODE (arg0) == BIT_IOR_EXPR
9558           && TREE_CODE (arg1) == INTEGER_CST
9559           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST)
9560         {
9561           tree notd = fold_build1 (BIT_NOT_EXPR, TREE_TYPE (arg1), arg1);
9562           tree candnotd = fold_build2 (BIT_AND_EXPR, TREE_TYPE (arg0),
9563                                        TREE_OPERAND (arg0, 1), notd);
9564           tree rslt = code == EQ_EXPR ? integer_zero_node : integer_one_node;
9565           if (integer_nonzerop (candnotd))
9566             return omit_one_operand (type, rslt, arg0);
9567         }
9568 
9569       /* If X is unsigned, convert X < (1 << Y) into X >> Y == 0
9570          and similarly for >= into !=.  */
9571       if ((code == LT_EXPR || code == GE_EXPR)
9572           && TYPE_UNSIGNED (TREE_TYPE (arg0))
9573           && TREE_CODE (arg1) == LSHIFT_EXPR
9574           && integer_onep (TREE_OPERAND (arg1, 0)))
9575         return build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
9576                        build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
9577                                TREE_OPERAND (arg1, 1)),
9578                        fold_convert (TREE_TYPE (arg0), integer_zero_node));
9579 
9580       else if ((code == LT_EXPR || code == GE_EXPR)
9581                && TYPE_UNSIGNED (TREE_TYPE (arg0))
9582                && (TREE_CODE (arg1) == NOP_EXPR
9583                    || TREE_CODE (arg1) == CONVERT_EXPR)
9584                && TREE_CODE (TREE_OPERAND (arg1, 0)) == LSHIFT_EXPR
9585                && integer_onep (TREE_OPERAND ([TREE_OPERAND]] (arg1, 0), 0)))
9586         return
9587           build2 (code == LT_EXPR ? EQ_EXPR : NE_EXPR, type,
9588                   fold_convert (TREE_TYPE (arg0),
9589                                 build2 (RSHIFT_EXPR, TREE_TYPE (arg0), arg0,
9590                                         TREE_OPERAND (TREE_OPERAND (arg1, 0),
9591                                                       1))),
9592                   fold_convert (TREE_TYPE (arg0), integer_zero_node));
9593 
9594       /* Simplify comparison of something with itself.  (For IEEE
9595          floating-point, we can only do some of these simplifications.)  */
9596       if (operand_equal_p (arg0, arg1, 0))
9597         {
9598           switch (code)
9599             {
9600             case EQ_EXPR:
9601               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9602                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9603                 return constant_boolean_node (1, type);
9604               break;
9605 
9606             case GE_EXPR:
9607             case LE_EXPR:
9608               if (! FLOAT_TYPE_P (TREE_TYPE (arg0))
9609                   || ! HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9610                 return constant_boolean_node (1, type);
9611               return fold_build2 (EQ_EXPR, type, arg0, arg1);
9612 
9613             case NE_EXPR:
9614               /* For NE, we can only do this simplification if integer
9615                  or we don't honor IEEE floating point NaNs.  */
9616               if (FLOAT_TYPE_P (TREE_TYPE (arg0))
9617                   && HONOR_NANS (TYPE_MODE (TREE_TYPE (arg0))))
9618                 break;
9619               /* ... fall through ...  */
9620             case GT_EXPR:
9621             case LT_EXPR:
9622               return constant_boolean_node (0, type);
9623             default:
9624               gcc_unreachable ();
9625             }
9626         }
9627 
9628       /* If we are comparing an expression that just has comparisons
9629          of two integer values, arithmetic expressions of those comparisons,
9630          and constants, we can simplify it.  There are only three cases
9631          to check: the two values can either be equal, the first can be
9632          greater, or the second can be greater.  Fold the expression for
9633          those three values.  Since each value must be 0 or 1, we have
9634          eight possibilities, each of which corresponds to the constant 0
9635          or 1 or one of the six possible comparisons.
9636 
9637          This handles common cases like (a > b) == 0 but also handles
9638          expressions like  ((x > y) - (y > x)) > 0, which supposedly
9639          occur in macroized code.  */
9640 
9641       if (TREE_CODE (arg1) == INTEGER_CST && TREE_CODE (arg0) != INTEGER_CST)
9642         {
9643           tree cval1 = 0, cval2 = 0;
9644           int save_p = 0;
9645 
9646           if (twoval_comparison_p (arg0, &cval1, &cval2, &save_p)
9647               /* Don't handle degenerate cases here; they should already
9648                  have been handled anyway.  */
9649               && cval1 != 0 && cval2 != 0
9650               && ! (TREE_CONSTANT (cval1) && TREE_CONSTANT (cval2))
9651               && TREE_TYPE (cval1) == TREE_TYPE (cval2)
9652               && INTEGRAL_TYPE_P (TREE_TYPE (cval1))
9653               && TYPE_MAX_VALUE (TREE_TYPE (cval1))
9654               && TYPE_MAX_VALUE (TREE_TYPE (cval2))
9655               && ! operand_equal_p (TYPE_MIN_VALUE (TREE_TYPE (cval1)),
9656                                     TYPE_MAX_VALUE (TREE_TYPE (cval2)), 0))
9657             {
9658               tree maxval = TYPE_MAX_VALUE (TREE_TYPE (cval1));
9659               tree minval = TYPE_MIN_VALUE (TREE_TYPE (cval1));
9660 
9661               /* We can't just pass T to eval_subst in case cval1 or cval2
9662                  was the same as ARG1.  */
9663 
9664               tree high_result
9665                 = fold_build2 (code, type,
9666                                eval_subst (arg0, cval1, maxval,
9667                                            cval2, minval),
9668                                arg1);
9669               tree equal_result
9670                 = fold_build2 (code, type,
9671                                eval_subst (arg0, cval1, maxval,
9672                                            cval2, maxval),
9673                                arg1);
9674               tree low_result
9675                 = fold_build2 (code, type,
9676                                eval_subst (arg0, cval1, minval,
9677                                            cval2, maxval),
9678                                arg1);
9679 
9680               /* All three of these results should be 0 or 1.  Confirm they
9681                  are.  Then use those values to select the proper code
9682                  to use.  */
9683 
9684               if ((integer_zerop (high_result)
9685                    || integer_onep (high_result))
9686                   && (integer_zerop (equal_result)
9687                       || integer_onep (equal_result))
9688                   && (integer_zerop (low_result)
9689                       || integer_onep (low_result)))
9690                 {
9691                   /* Make a 3-bit mask with the high-order bit being the
9692                      value for `>', the next for '=', and the low for '<'.  */
9693                   switch ((integer_onep (high_result) * 4)
9694                           + (integer_onep (equal_result) * 2)
9695                           + integer_onep (low_result))
9696                     {
9697                     case 0:
9698                       /* Always false.  */
9699                       return omit_one_operand (type, integer_zero_node, arg0);
9700                     case 1:
9701                       code = LT_EXPR;
9702                       break;
9703                     case 2:
9704                       code = EQ_EXPR;
9705                       break;
9706                     case 3:
9707                       code = LE_EXPR;
9708                       break;
9709                     case 4:
9710                       code = GT_EXPR;
9711                       break;
9712                     case 5:
9713                       code = NE_EXPR;
9714                       break;
9715                     case 6:
9716                       code = GE_EXPR;
9717                       break;
9718                     case 7:
9719                       /* Always true.  */
9720                       return omit_one_operand (type, integer_one_node, arg0);
9721                     }
9722 
9723                   if (save_p)
9724                     return save_expr (build2 (code, type, cval1, cval2));
9725                   else
9726                     return fold_build2 (code, type, cval1, cval2);
9727                 }
9728             }
9729         }
9730 
9731       /* If this is a comparison of a field, we may be able to simplify it.  */
9732       if (((TREE_CODE (arg0) == COMPONENT_REF
9733             && lang_hooks.can_use_bit_fields_p ())
9734            || TREE_CODE (arg0) == BIT_FIELD_REF)
9735           && (code == EQ_EXPR || code == NE_EXPR)
9736           /* Handle the constant case even without -O
9737              to make sure the warnings are given.  */
9738           && (optimize || TREE_CODE (arg1) == INTEGER_CST))
9739         {
9740           t1 = optimize_bit_field_compare (code, type, arg0, arg1);
9741           if (t1)
9742             return t1;
9743         }
9744 
9745       /* Fold a comparison of the address of COMPONENT_REFs with the same
9746          type and component to a comparison of the address of the base
9747          object.  In short, &x->a OP &y->a to x OP y and
9748          &x->a OP &y.a to x OP &y  */
9749       if (TREE_CODE (arg0) == ADDR_EXPR
9750           && TREE_CODE (TREE_OPERAND (arg0, 0)) == COMPONENT_REF
9751           && TREE_CODE (arg1) == ADDR_EXPR
9752           && TREE_CODE (TREE_OPERAND (arg1, 0)) == COMPONENT_REF)
9753         {
9754           tree cref0 = TREE_OPERAND (arg0, 0);
9755           tree cref1 = TREE_OPERAND (arg1, 0);
9756           if (TREE_OPERAND (cref0, 1) == TREE_OPERAND (cref1, 1))
9757             {
9758               tree op0 = TREE_OPERAND (cref0, 0);
9759               tree op1 = TREE_OPERAND (cref1, 0);
9760               return fold_build2 (code, type,
9761                                   build_fold_addr_expr (op0),
9762                                   build_fold_addr_expr (op1));
9763             }
9764         }
9765 
9766       /* Optimize comparisons of strlen vs zero to a compare of the
9767          first character of the string vs zero.  To wit,
9768                 strlen(ptr) == 0   =>  *ptr == 0
9769                 strlen(ptr) != 0   =>  *ptr != 0
9770          Other cases should reduce to one of these two (or a constant)
9771          due to the return value of strlen being unsigned.  */
9772       if ((code == EQ_EXPR || code == NE_EXPR)
9773           && integer_zerop (arg1)
9774           && TREE_CODE (arg0) == CALL_EXPR)
9775         {
9776           tree fndecl = get_callee_fndecl (arg0);
9777           tree arglist;
9778 
9779           if (fndecl
9780               && DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL
9781               && DECL_FUNCTION_CODE (fndecl) == BUILT_IN_STRLEN
9782               && (arglist = TREE_OPERAND (arg0, 1))
9783               && TREE_CODE (TREE_TYPE (TREE_VALUE (arglist))) == POINTER_TYPE
9784               && ! TREE_CHAIN (arglist))
9785             {
9786               tree iref = build_fold_indirect_ref (TREE_VALUE (arglist));
9787               return fold_build2 (code, type, iref,
9788                                   build_int_cst (TREE_TYPE (iref), 0));
9789             }
9790         }
9791 
9792       /* We can fold X/C1 op C2 where C1 and C2 are integer constants
9793          into a single range test.  */
9794       if ((TREE_CODE (arg0) == TRUNC_DIV_EXPR
9795            || TREE_CODE (arg0) == EXACT_DIV_EXPR)
9796           && TREE_CODE (arg1) == INTEGER_CST
9797           && TREE_CODE (TREE_OPERAND (arg0, 1)) == INTEGER_CST
9798           && !integer_zerop (TREE_OPERAND (arg0, 1))
9799           && !TREE_OVERFLOW (TREE_OPERAND (arg0, 1))
9800           && !TREE_OVERFLOW (arg1))
9801         {
9802           t1 = fold_div_compare (code, type, arg0, arg1);
9803           if (t1 != NULL_TREE)
9804             return t1;
9805         }
9806 
9807       if ((code == EQ_EXPR || code == NE_EXPR)
9808           && integer_zerop (arg1)
9809           && tree_expr_nonzero_p (arg0))
9810         {
9811           tree res = constant_boolean_node (code==NE_EXPR, type);
9812           return omit_one_operand (type, res, arg0);
9813         }
9814 
9815       t1 = fold_relational_const (code, type, arg0, arg1);
9816       return t1 == NULL_TREE ? NULL_TREE : t1;
9817 

UNORDERED_EXPR, ORDERED_EXPR, UNLT_EXPR, UNLE_EXPR, UNGT_EXPR, UNGE_EXPR, UNEQ_EXPR, LTGT_EXPR[]

9818     case UNORDERED_EXPR:
9819     case ORDERED_EXPR:
9820     case UNLT_EXPR:
9821     case UNLE_EXPR:
9822     case UNGT_EXPR:
9823     case UNGE_EXPR:
9824     case UNEQ_EXPR:
9825     case LTGT_EXPR:
9826       if (TREE_CODE (arg0) == REAL_CST && TREE_CODE (arg1) == REAL_CST)
9827         {
9828           t1 = fold_relational_const (code, type, arg0, arg1);
9829           if (t1 != NULL_TREE)
9830             return t1;
9831         }
9832 
9833       /* If the first operand is NaN, the result is constant.  */
9834       if (TREE_CODE (arg0) == REAL_CST
9835           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg0))
9836           && (code != LTGT_EXPR || ! flag_trapping_math))
9837         {
9838           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
9839                ? integer_zero_node
9840                : integer_one_node;
9841           return omit_one_operand (type, t1, arg1);
9842         }
9843 
9844       /* If the second operand is NaN, the result is constant.  */
9845       if (TREE_CODE (arg1) == REAL_CST
9846           && REAL_VALUE_ISNAN (TREE_REAL_CST (arg1))
9847           && (code != LTGT_EXPR || ! flag_trapping_math))
9848         {
9849           t1 = (code == ORDERED_EXPR || code == LTGT_EXPR)
9850                ? integer_zero_node
9851                : integer_one_node;
9852           return omit_one_operand (type, t1, arg0);
9853         }
9854 
9855       /* Simplify unordered comparison of something with itself.  */
9856       if ((code == UNLE_EXPR || code == UNGE_EXPR || code == UNEQ_EXPR)
9857           && operand_equal_p (arg0, arg1, 0))
9858         return constant_boolean_node (1, type);
9859 
9860       if (code == LTGT_EXPR
9861           && !flag_trapping_math
9862           && operand_equal_p (arg0, arg1, 0))
9863         return constant_boolean_node (0, type);
9864 
9865       /* Fold (double)float1 CMP (double)float2 into float1 CMP float2.  */
9866       {
9867         tree targ0 = strip_float_extensions (arg0);
9868         tree targ1 = strip_float_extensions (arg1);
9869         tree newtype = TREE_TYPE (targ0);
9870 
9871         if (TYPE_PRECISION (TREE_TYPE (targ1)) > TYPE_PRECISION (newtype))
9872           newtype = TREE_TYPE (targ1);
9873 
9874         if (TYPE_PRECISION (newtype) < TYPE_PRECISION (TREE_TYPE (arg0)))
9875           return fold_build2 (code, type, fold_convert (newtype, targ0),
9876                               fold_convert (newtype, targ1));
9877       }
9878 
9879       return NULL_TREE;
9880 

COMPOUND_EXPR[]

9881     case COMPOUND_EXPR:
9882       /* When pedantic, a compound expression can be neither an lvalue
9883          nor an integer constant expression.  */
9884       if (TREE_SIDE_EFFECTS (arg0) || TREE_CONSTANT (arg1))
9885         return NULL_TREE;
9886       /* Don't let (0, 0) be null pointer constant.  */
9887       tem = integer_zerop (arg1) ? build1 (NOP_EXPR, type, arg1)
9888                                  : fold_convert (type, arg1);
9889       return pedantic_non_lvalue (tem);
9890 

COMPLEX_EXPR[]

9891     case COMPLEX_EXPR:
9892       if (wins)
9893         return build_complex (type, arg0, arg1);
9894       return NULL_TREE;
9895

ASSERT_EXPR[]

9896     case ASSERT_EXPR:
9897       /* An ASSERT_EXPR should never be passed to fold_binary.  */
9898       gcc_unreachable ();
9899 
9900     default:
9901       return NULL_TREE;
9902     } /* switch (code) */
9903 }



リンク元

Advertisement