Lines Matching refs:op
219 simplify_gen_unary (enum rtx_code code, enum machine_mode mode, rtx op,
225 if ((tem = simplify_unary_operation (code, mode, op, op_mode)) != 0)
228 return gen_rtx_fmt_e (code, mode, op);
378 rtx op, enum machine_mode op_mode)
382 if (GET_CODE (op) == CONST)
383 op = XEXP (op, 0);
385 trueop = avoid_constant_pool_reference (op);
391 return simplify_unary_operation_1 (code, mode, op);
397 simplify_unary_operation_1 (enum rtx_code code, enum machine_mode mode, rtx op)
406 if (GET_CODE (op) == NOT)
407 return XEXP (op, 0);
411 if (COMPARISON_P (op)
413 && ((reversed = reversed_comparison_code (op, NULL_RTX)) != UNKNOWN))
415 XEXP (op, 0), XEXP (op, 1));
418 if (GET_CODE (op) == PLUS
419 && XEXP (op, 1) == constm1_rtx)
420 return simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
423 if (GET_CODE (op) == NEG)
424 return plus_constant (XEXP (op, 0), -1);
427 if (GET_CODE (op) == XOR
428 && GET_CODE (XEXP (op, 1)) == CONST_INT
430 XEXP (op, 1), mode)) != 0)
431 return simplify_gen_binary (XOR, mode, XEXP (op, 0), temp);
434 if (GET_CODE (op) == PLUS
435 && GET_CODE (XEXP (op, 1)) == CONST_INT
436 && mode_signbit_p (mode, XEXP (op, 1))
438 XEXP (op, 1), mode)) != 0)
439 return simplify_gen_binary (XOR, mode, XEXP (op, 0), temp);
447 if (GET_CODE (op) == ASHIFT
448 && XEXP (op, 0) == const1_rtx)
451 return simplify_gen_binary (ROTATE, mode, temp, XEXP (op, 1));
459 && GET_CODE (op) == ASHIFTRT
460 && GET_CODE (XEXP (op, 1)) == CONST_INT
461 && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
463 XEXP (op, 0), const0_rtx);
466 if (GET_CODE (op) == SUBREG
467 && subreg_lowpart_p (op)
468 && (GET_MODE_SIZE (GET_MODE (op))
469 < GET_MODE_SIZE (GET_MODE (SUBREG_REG (op))))
470 && GET_CODE (SUBREG_REG (op)) == ASHIFT
471 && XEXP (SUBREG_REG (op), 0) == const1_rtx)
473 enum machine_mode inner_mode = GET_MODE (SUBREG_REG (op));
479 XEXP (SUBREG_REG (op), 1));
488 if (GET_CODE (op) == IOR || GET_CODE (op) == AND)
490 rtx in1 = XEXP (op, 0), in2 = XEXP (op, 1);
507 return gen_rtx_fmt_ee (GET_CODE (op) == IOR ? AND : IOR,
514 if (GET_CODE (op) == NEG)
515 return XEXP (op, 0);
518 if (GET_CODE (op) == PLUS
519 && XEXP (op, 1) == const1_rtx)
520 return simplify_gen_unary (NOT, mode, XEXP (op, 0), mode);
523 if (GET_CODE (op) == NOT)
524 return plus_constant (XEXP (op, 0), 1);
531 if (GET_CODE (op) == MINUS
534 return simplify_gen_binary (MINUS, mode, XEXP (op, 1), XEXP (op, 0));
536 if (GET_CODE (op) == PLUS
541 if (GET_CODE (XEXP (op, 1)) == CONST_INT
542 || GET_CODE (XEXP (op, 1)) == CONST_DOUBLE)
544 temp = simplify_unary_operation (NEG, mode, XEXP (op, 1), mode);
546 return simplify_gen_binary (MINUS, mode, temp, XEXP (op, 0));
550 temp = simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
551 return simplify_gen_binary (MINUS, mode, temp, XEXP (op, 1));
556 if (GET_CODE (op) == MULT
559 temp = simplify_gen_unary (NEG, mode, XEXP (op, 0), mode);
560 return simplify_gen_binary (MULT, mode, temp, XEXP (op, 1));
566 if (GET_CODE (op) == ASHIFT)
568 temp = simplify_unary_operation (NEG, mode, XEXP (op, 0), mode);
570 return simplify_gen_binary (ASHIFT, mode, temp, XEXP (op, 1));
575 if (GET_CODE (op) == ASHIFTRT
576 && GET_CODE (XEXP (op, 1)) == CONST_INT
577 && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
579 XEXP (op, 0), XEXP (op, 1));
583 if (GET_CODE (op) == LSHIFTRT
584 && GET_CODE (XEXP (op, 1)) == CONST_INT
585 && INTVAL (XEXP (op, 1)) == GET_MODE_BITSIZE (mode) - 1)
587 XEXP (op, 0), XEXP (op, 1));
590 if (GET_CODE (op) == XOR
591 && XEXP (op, 1) == const1_rtx
592 && nonzero_bits (XEXP (op, 0), mode) == 1)
593 return plus_constant (XEXP (op, 0), -1);
597 if (GET_CODE (op) == LT
598 && XEXP (op, 1) == const0_rtx)
600 enum machine_mode inner = GET_MODE (XEXP (op, 0));
604 temp = simplify_gen_binary (ASHIFTRT, inner, XEXP (op, 0),
614 temp = simplify_gen_binary (LSHIFTRT, inner, XEXP (op, 0),
633 if ((GET_CODE (op) == SIGN_EXTEND
634 || GET_CODE (op) == ZERO_EXTEND)
635 && GET_MODE (XEXP (op, 0)) == mode)
636 return XEXP (op, 0);
640 if ((GET_CODE (op) == ABS
641 || GET_CODE (op) == NEG)
642 && (GET_CODE (XEXP (op, 0)) == SIGN_EXTEND
643 || GET_CODE (XEXP (op, 0)) == ZERO_EXTEND)
644 && GET_MODE (XEXP (XEXP (op, 0), 0)) == mode)
645 return simplify_gen_unary (GET_CODE (op), mode,
646 XEXP (XEXP (op, 0), 0), mode);
650 if (GET_CODE (op) == SUBREG
651 && GET_CODE (SUBREG_REG (op)) == TRUNCATE
652 && subreg_lowpart_p (op))
653 return simplify_gen_unary (TRUNCATE, mode, XEXP (SUBREG_REG (op), 0),
654 GET_MODE (XEXP (SUBREG_REG (op), 0)));
664 GET_MODE_BITSIZE (GET_MODE (op)))
665 ? (num_sign_bit_copies (op, GET_MODE (op))
666 > (unsigned int) (GET_MODE_BITSIZE (GET_MODE (op))
668 : truncated_to_mode (mode, op))
669 && ! (GET_CODE (op) == LSHIFTRT
670 && GET_CODE (XEXP (op, 0)) == MULT))
671 return rtl_hooks.gen_lowpart_no_emit (mode, op);
678 && COMPARISON_P (op)
680 return rtl_hooks.gen_lowpart_no_emit (mode, op);
688 if (GET_CODE (op) == FLOAT_EXTEND
689 && GET_MODE (XEXP (op, 0)) == mode)
690 return XEXP (op, 0);
701 if ((GET_CODE (op) == FLOAT_TRUNCATE
703 || GET_CODE (op) == FLOAT_EXTEND)
704 return simplify_gen_unary (GET_MODE_SIZE (GET_MODE (XEXP (op,
709 XEXP (op, 0), mode);
712 if (GET_CODE (op) == FLOAT
714 || ((unsigned)significand_size (GET_MODE (op))
715 >= (GET_MODE_BITSIZE (GET_MODE (XEXP (op, 0)))
716 - num_sign_bit_copies (XEXP (op, 0),
717 GET_MODE (XEXP (op, 0)))))))
719 XEXP (op, 0),
720 GET_MODE (XEXP (op, 0)));
724 if ((GET_CODE (op) == ABS
725 || GET_CODE (op) == NEG)
726 && GET_CODE (XEXP (op, 0)) == FLOAT_EXTEND
727 && GET_MODE (XEXP (XEXP (op, 0), 0)) == mode)
728 return simplify_gen_unary (GET_CODE (op), mode,
729 XEXP (XEXP (op, 0), 0), mode);
733 if (GET_CODE (op) == SUBREG
734 && subreg_lowpart_p (op)
735 && GET_CODE (SUBREG_REG (op)) == FLOAT_TRUNCATE)
736 return SUBREG_REG (op);
748 if (GET_CODE (op) == FLOAT_EXTEND
749 || (GET_CODE (op) == FLOAT
750 && ((unsigned)significand_size (GET_MODE (op))
751 >= (GET_MODE_BITSIZE (GET_MODE (XEXP (op, 0)))
752 - num_sign_bit_copies (XEXP (op, 0),
753 GET_MODE (XEXP (op, 0)))))))
754 return simplify_gen_unary (GET_CODE (op), mode,
755 XEXP (op, 0),
756 GET_MODE (XEXP (op, 0)));
762 if (GET_CODE (op) == NEG)
763 return simplify_gen_unary (ABS, mode, XEXP (op, 0),
764 GET_MODE (XEXP (op, 0)));
768 if (GET_MODE (op) == VOIDmode)
772 if (GET_CODE (op) == FFS || GET_CODE (op) == ABS
773 || ((GET_MODE_BITSIZE (GET_MODE (op))
775 && ((nonzero_bits (op, GET_MODE (op))
777 << (GET_MODE_BITSIZE (GET_MODE (op)) - 1)))
779 return op;
782 if (num_sign_bit_copies (op, mode) == GET_MODE_BITSIZE (mode))
783 return gen_rtx_NEG (mode, op);
789 if (GET_CODE (op) == SIGN_EXTEND
790 || GET_CODE (op) == ZERO_EXTEND)
791 return simplify_gen_unary (FFS, mode, XEXP (op, 0),
792 GET_MODE (XEXP (op, 0)));
798 if (GET_CODE (op) == ZERO_EXTEND)
799 return simplify_gen_unary (code, mode, XEXP (op, 0),
800 GET_MODE (XEXP (op, 0)));
805 if (GET_CODE (op) == SIGN_EXTEND)
806 return simplify_gen_unary (FLOAT, mode, XEXP (op, 0),
807 GET_MODE (XEXP (op, 0)));
815 if (GET_CODE (op) == TRUNCATE
816 && GET_MODE (XEXP (op, 0)) == mode
817 && GET_CODE (XEXP (op, 0)) == MINUS
818 && GET_CODE (XEXP (XEXP (op, 0), 0)) == LABEL_REF
819 && GET_CODE (XEXP (XEXP (op, 0), 1)) == LABEL_REF)
820 return XEXP (op, 0);
825 if (GET_CODE (op) == SUBREG
826 && SUBREG_PROMOTED_VAR_P (op)
827 && ! SUBREG_PROMOTED_UNSIGNED_P (op)
828 && GET_MODE (XEXP (op, 0)) == mode)
829 return XEXP (op, 0);
833 && mode == Pmode && GET_MODE (op) == ptr_mode
834 && (CONSTANT_P (op)
835 || (GET_CODE (op) == SUBREG
836 && REG_P (SUBREG_REG (op))
837 && REG_POINTER (SUBREG_REG (op))
838 && GET_MODE (SUBREG_REG (op)) == Pmode)))
839 return convert_memory_address (Pmode, op);
847 if (GET_CODE (op) == SUBREG
848 && SUBREG_PROMOTED_VAR_P (op)
849 && SUBREG_PROMOTED_UNSIGNED_P (op) > 0
850 && GET_MODE (XEXP (op, 0)) == mode)
851 return XEXP (op, 0);
855 && mode == Pmode && GET_MODE (op) == ptr_mode
856 && (CONSTANT_P (op)
857 || (GET_CODE (op) == SUBREG
858 && REG_P (SUBREG_REG (op))
859 && REG_POINTER (SUBREG_REG (op))
860 && GET_MODE (SUBREG_REG (op)) == Pmode)))
861 return convert_memory_address (Pmode, op);
877 rtx op, enum machine_mode op_mode)
884 if (GET_MODE (op) != VOIDmode)
886 if (!VECTOR_MODE_P (GET_MODE (op)))
887 gcc_assert (GET_MODE_INNER (mode) == GET_MODE (op));
890 (GET_MODE (op)));
892 if (GET_CODE (op) == CONST_INT || GET_CODE (op) == CONST_DOUBLE
893 || GET_CODE (op) == CONST_VECTOR)
900 if (GET_CODE (op) != CONST_VECTOR)
902 RTVEC_ELT (v, i) = op;
905 enum machine_mode inmode = GET_MODE (op);
912 RTVEC_ELT (v, i) = CONST_VECTOR_ELT (op, i % in_n_elts);
918 if (VECTOR_MODE_P (mode) && GET_CODE (op) == CONST_VECTOR)
922 enum machine_mode opmode = GET_MODE (op);
932 CONST_VECTOR_ELT (op, i),
945 if (code == FLOAT && GET_MODE (op) == VOIDmode
946 && (GET_CODE (op) == CONST_DOUBLE || GET_CODE (op) == CONST_INT))
951 if (GET_CODE (op) == CONST_INT)
952 lv = INTVAL (op), hv = HWI_SIGN_EXTEND (lv);
954 lv = CONST_DOUBLE_LOW (op), hv = CONST_DOUBLE_HIGH (op);
960 else if (code == UNSIGNED_FLOAT && GET_MODE (op) == VOIDmode
961 && (GET_CODE (op) == CONST_DOUBLE
962 || GET_CODE (op) == CONST_INT))
967 if (GET_CODE (op) == CONST_INT)
968 lv = INTVAL (op), hv = HWI_SIGN_EXTEND (lv);
970 lv = CONST_DOUBLE_LOW (op), hv = CONST_DOUBLE_HIGH (op);
989 if (GET_CODE (op) == CONST_INT
992 HOST_WIDE_INT arg0 = INTVAL (op);
1114 else if (GET_MODE (op) == VOIDmode
1116 && (GET_CODE (op) == CONST_DOUBLE
1117 || GET_CODE (op) == CONST_INT))
1122 if (GET_CODE (op) == CONST_DOUBLE)
1123 l1 = CONST_DOUBLE_LOW (op), h1 = CONST_DOUBLE_HIGH (op);
1125 l1 = INTVAL (op), h1 = HWI_SIGN_EXTEND (l1);
1239 else if (GET_CODE (op) == CONST_DOUBLE
1243 REAL_VALUE_FROM_CONST_DOUBLE (d, op);
1273 real_to_target (tmp, &d, GET_MODE (op));
1285 else if (GET_CODE (op) == CONST_DOUBLE
1286 && SCALAR_FLOAT_MODE_P (GET_MODE (op))
1299 REAL_VALUE_FROM_CONST_DOUBLE (x, op);
1404 /* "(a op b) op (c op d)" becomes "((a op b) op c) op d)". */
1411 /* "a op (b op c)" becomes "(b op c) op a". */
1422 /* Canonicalize "(x op c) op y" as "(x op y) op c". */
1429 /* Attempt to simplify "(a op b) op c" as "a op (b op c)". */
1436 /* Attempt to simplify "(a op b) op c" as "(a op c) op b". */
3195 rtx op;
3206 result = (commutative_operand_precedence (d2->op)
3207 - commutative_operand_precedence (d1->op));
3212 if (REG_P (d1->op) && REG_P (d2->op))
3213 return REGNO (d1->op) - REGNO (d2->op);
3234 ops[0].op = op0;
3236 ops[1].op = op1;
3245 rtx this_op = ops[i].op;
3256 ops[n_ops].op = XEXP (this_op, 1);
3260 ops[i].op = XEXP (this_op, 0);
3267 ops[i].op = XEXP (this_op, 0);
3279 ops[i].op = XEXP (XEXP (this_op, 0), 0);
3280 ops[n_ops].op = XEXP (XEXP (this_op, 0), 1);
3292 ops[n_ops].op = constm1_rtx;
3294 ops[i].op = XEXP (this_op, 0);
3305 ops[i].op = neg_const_int (mode, this_op);
3334 lhs = gen_rtx_NEG (mode, ops[0].op);
3335 rhs = ops[1].op;
3339 lhs = ops[1].op;
3340 rhs = ops[0].op;
3344 lhs = ops[0].op;
3345 rhs = ops[1].op;
3378 rtx lhs = ops[j].op, rhs = ops[i].op;
3425 ops[i].op = tem;
3427 ops[j].op = NULL_RTX;
3435 if (ops[j].op)
3446 && GET_CODE (ops[1].op) == CONST_INT
3447 && CONSTANT_P (ops[0].op)
3449 return gen_rtx_fmt_ee (MINUS, mode, ops[1].op, ops[0].op);
3458 && GET_CODE (ops[n_ops - 1].op) == CONST_INT
3459 && CONSTANT_P (ops[n_ops - 2].op))
3461 rtx value = ops[n_ops - 1].op;
3464 ops[n_ops - 2].op = plus_constant (ops[n_ops - 2].op, INTVAL (value));
3473 ops[0].op = gen_rtx_NEG (mode, ops[0].op);
3476 tem = ops[0].op;
3478 ops[i].op = tem;
3483 result = ops[0].op;
3486 mode, result, ops[i].op);
4225 simplify_immed_subreg (enum machine_mode outermode, rtx op,
4248 if (GET_MODE_CLASS (outermode) == MODE_CC && GET_CODE (op) == CONST_INT)
4249 return op;
4257 if (GET_CODE (op) == CONST_VECTOR)
4259 num_elem = CONST_VECTOR_NUNITS (op);
4260 elems = &CONST_VECTOR_ELT (op, 0);
4266 elems = &op;
4488 simplify_subreg (enum machine_mode outermode, rtx op,
4497 gcc_assert (GET_MODE (op) == innermode
4498 || GET_MODE (op) == VOIDmode);
4504 return op;
4506 if (GET_CODE (op) == CONST_INT
4507 || GET_CODE (op) == CONST_DOUBLE
4508 || GET_CODE (op) == CONST_VECTOR)
4509 return simplify_immed_subreg (outermode, op, innermode, byte);
4512 or not at all if changing back op starting mode. */
4513 if (GET_CODE (op) == SUBREG)
4515 enum machine_mode innermostmode = GET_MODE (SUBREG_REG (op));
4516 int final_offset = byte + SUBREG_BYTE (op);
4520 && byte == 0 && SUBREG_BYTE (op) == 0)
4521 return SUBREG_REG (op);
4535 if (SUBREG_BYTE (op) == 0
4574 newx = simplify_subreg (outermode, SUBREG_REG (op), innermostmode,
4579 SUBREG_REG (op), final_offset))
4580 return gen_rtx_SUBREG (outermode, SUBREG_REG (op), final_offset);
4586 if (GET_CODE (op) == TRUNCATE
4589 return simplify_gen_unary (TRUNCATE, outermode, XEXP (op, 0),
4590 GET_MODE (XEXP (op, 0)));
4597 if (REG_P (op)
4598 && REGNO (op) < FIRST_PSEUDO_REGISTER
4600 && ! (REG_CANNOT_CHANGE_MODE_P (REGNO (op), innermode, outermode)
4605 || (REGNO (op) != FRAME_POINTER_REGNUM
4607 && REGNO (op) != HARD_FRAME_POINTER_REGNUM
4611 && REGNO (op) != ARG_POINTER_REGNUM
4613 && REGNO (op) != STACK_POINTER_REGNUM
4614 && subreg_offset_representable_p (REGNO (op), innermode,
4617 unsigned int regno = REGNO (op);
4642 x = gen_rtx_REG_offset (op, outermode, final_regno, final_offset);
4650 ORIGINAL_REGNO (x) = ORIGINAL_REGNO (op);
4660 if (MEM_P (op)
4661 && ! mode_dependent_address_p (XEXP (op, 0))
4664 && (! MEM_VOLATILE_P (op)
4666 && GET_MODE_SIZE (outermode) <= GET_MODE_SIZE (GET_MODE (op)))
4667 return adjust_address_nv (op, outermode, byte);
4671 if (GET_CODE (op) == CONCAT)
4677 part = byte < inner_size ? XEXP (op, 0) : XEXP (op, 1);
4691 if ((GET_CODE (op) == ZERO_EXTEND
4692 || GET_CODE (op) == SIGN_EXTEND)
4706 enum machine_mode origmode = GET_MODE (XEXP (op, 0));
4708 return XEXP (op, 0);
4710 return simplify_gen_subreg (outermode, XEXP (op, 0), origmode,
4714 return simplify_gen_unary (GET_CODE (op), outermode,
4715 XEXP (op, 0), origmode);
4720 if (GET_CODE (op) == ZERO_EXTEND
4721 && bitpos >= GET_MODE_BITSIZE (GET_MODE (XEXP (op, 0))))
4728 if ((GET_CODE (op) == LSHIFTRT
4729 || GET_CODE (op) == ASHIFTRT)
4736 && GET_CODE (XEXP (op, 1)) == CONST_INT
4737 && GET_CODE (XEXP (op, 0)) == SIGN_EXTEND
4738 && GET_MODE (XEXP (XEXP (op, 0), 0)) == outermode
4739 && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (outermode)
4742 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
4747 if ((GET_CODE (op) == LSHIFTRT
4748 || GET_CODE (op) == ASHIFTRT)
4751 && GET_CODE (XEXP (op, 1)) == CONST_INT
4752 && GET_CODE (XEXP (op, 0)) == ZERO_EXTEND
4753 && GET_MODE (XEXP (XEXP (op, 0), 0)) == outermode
4754 && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (outermode)
4757 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
4762 if (GET_CODE (op) == ASHIFT
4765 && GET_CODE (XEXP (op, 1)) == CONST_INT
4766 && (GET_CODE (XEXP (op, 0)) == ZERO_EXTEND
4767 || GET_CODE (XEXP (op, 0)) == SIGN_EXTEND)
4768 && GET_MODE (XEXP (XEXP (op, 0), 0)) == outermode
4769 && INTVAL (XEXP (op, 1)) < GET_MODE_BITSIZE (outermode)
4772 XEXP (XEXP (op, 0), 0), XEXP (op, 1));
4780 simplify_gen_subreg (enum machine_mode outermode, rtx op,
4785 newx = simplify_subreg (outermode, op, innermode, byte);
4789 if (GET_CODE (op) == SUBREG
4790 || GET_CODE (op) == CONCAT
4791 || GET_MODE (op) == VOIDmode)
4794 if (validate_subreg (outermode, innermode, op, byte))
4795 return gen_rtx_SUBREG (outermode, op, byte);