re PR target/63848 (FAIL: c-c++-common/torture/builtin-arith-overflow-17.c -O0...

	PR target/63848
	PR target/63975
	* internal-fn.c (expand_arith_overflow_result_store,
	expand_addsub_overflow, expand_neg_overflow, expand_mul_overflow): Use
	do_compare_rtx_and_jump instead of emit_cmp_and_jump_insns everywhere,
	adjust arguments to those functions.  Use unsignedp = true for
	EQ, NE, GEU, LEU, LTU and GTU comparisons.

From-SVN: r217946

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 1254751c63a872cbb4c2d8459de1b8362454f737..cf542cacaa24f4f9d547eed8745e80635139a6f7 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,5 +1,13 @@
 2014-11-21  Jakub Jelinek  <jakub@redhat.com>
 
+       PR target/63848
+       PR target/63975
+       * internal-fn.c (expand_arith_overflow_result_store,
+       expand_addsub_overflow, expand_neg_overflow, expand_mul_overflow): Use
+       do_compare_rtx_and_jump instead of emit_cmp_and_jump_insns everywhere,
+       adjust arguments to those functions.  Use unsignedp = true for
+       EQ, NE, GEU, LEU, LTU and GTU comparisons.
+
        PR tree-optimization/64006
        * tree-vrp.c (stmt_interesting_for_vrp): Return true
        for {ADD,SUB,MUL}_OVERFLOW internal calls.

diff --git a/gcc/internal-fn.c b/gcc/internal-fn.c
index 0ba20245d679aa432858004361d5371968741f1c..0bd24396c2e17308c2ff6c83bf921c6968d45323 100644 (file)
--- a/gcc/internal-fn.c
+++ b/gcc/internal-fn.c
@@ -386,8 +386,8 @@ expand_arith_overflow_result_store (tree lhs, rtx target,
       int uns = TYPE_UNSIGNED (TREE_TYPE (TREE_TYPE (lhs)));
       lres = convert_modes (tgtmode, mode, res, uns);
       gcc_assert (GET_MODE_PRECISION (tgtmode) < GET_MODE_PRECISION (mode));
-      emit_cmp_and_jump_insns (res, convert_modes (mode, tgtmode, lres, uns),
-                              EQ, NULL_RTX, mode, false, done_label,
+      do_compare_rtx_and_jump (res, convert_modes (mode, tgtmode, lres, uns),
+                              EQ, true, mode, NULL_RTX, NULL_RTX, done_label,
                               PROB_VERY_LIKELY);
       write_complex_part (target, const1_rtx, true);
       emit_label (done_label);
@@ -533,8 +533,8 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
              ? (CONST_SCALAR_INT_P (op0) && REG_P (op1))
              : CONST_SCALAR_INT_P (op1)))
        tem = op1;
-      emit_cmp_and_jump_insns (res, tem, code == PLUS_EXPR ? GEU : LEU,
-                              NULL_RTX, mode, false, done_label,
+      do_compare_rtx_and_jump (res, tem, code == PLUS_EXPR ? GEU : LEU,
+                              true, mode, NULL_RTX, NULL_RTX, done_label,
                               PROB_VERY_LIKELY);
       goto do_error_label;
     }
@@ -549,7 +549,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
       rtx tem = expand_binop (mode, add_optab,
                              code == PLUS_EXPR ? res : op0, sgn,
                              NULL_RTX, false, OPTAB_LIB_WIDEN);
-      emit_cmp_and_jump_insns (tem, op1, GEU, NULL_RTX, mode, false,
+      do_compare_rtx_and_jump (tem, op1, GEU, true, mode, NULL_RTX, NULL_RTX,
                               done_label, PROB_VERY_LIKELY);
       goto do_error_label;
     }
@@ -591,9 +591,9 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
        emit_jump (do_error);
       else if (pos_neg == 3)
        /* If ARG0 is not known to be always positive, check at runtime.  */
-       emit_cmp_and_jump_insns (op0, const0_rtx, LT, NULL_RTX, mode, false,
-                                do_error, PROB_VERY_UNLIKELY);
-      emit_cmp_and_jump_insns (op1, op0, LEU, NULL_RTX, mode, false,
+       do_compare_rtx_and_jump (op0, const0_rtx, LT, false, mode, NULL_RTX,
+                                NULL_RTX, do_error, PROB_VERY_UNLIKELY);
+      do_compare_rtx_and_jump (op1, op0, LEU, true, mode, NULL_RTX, NULL_RTX,
                               done_label, PROB_VERY_LIKELY);
       goto do_error_label;
     }
@@ -607,7 +607,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
                          OPTAB_LIB_WIDEN);
       rtx tem = expand_binop (mode, add_optab, op1, sgn, NULL_RTX, false,
                              OPTAB_LIB_WIDEN);
-      emit_cmp_and_jump_insns (op0, tem, LTU, NULL_RTX, mode, false,
+      do_compare_rtx_and_jump (op0, tem, LTU, true, mode, NULL_RTX, NULL_RTX,
                               done_label, PROB_VERY_LIKELY);
       goto do_error_label;
     }
@@ -619,8 +619,8 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
         unsigned.  */
       res = expand_binop (mode, add_optab, op0, op1, NULL_RTX, false,
                          OPTAB_LIB_WIDEN);
-      emit_cmp_and_jump_insns (res, const0_rtx, LT, NULL_RTX, mode, false,
-                              do_error, PROB_VERY_UNLIKELY);
+      do_compare_rtx_and_jump (res, const0_rtx, LT, false, mode, NULL_RTX,
+                              NULL_RTX, do_error, PROB_VERY_UNLIKELY);
       rtx tem = op1;
       /* The operation is commutative, so we can pick operand to compare
         against.  For prec <= BITS_PER_WORD, I think preferring REG operand
@@ -633,7 +633,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
          ? (CONST_SCALAR_INT_P (op1) && REG_P (op0))
          : CONST_SCALAR_INT_P (op0))
        tem = op0;
-      emit_cmp_and_jump_insns (res, tem, GEU, NULL_RTX, mode, false,
+      do_compare_rtx_and_jump (res, tem, GEU, true, mode, NULL_RTX, NULL_RTX,
                               done_label, PROB_VERY_LIKELY);
       goto do_error_label;
     }
@@ -663,25 +663,26 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
          tem = expand_binop (mode, ((pos_neg == 1) ^ (code == MINUS_EXPR))
                                    ? and_optab : ior_optab,
                              op0, res, NULL_RTX, false, OPTAB_LIB_WIDEN);
-         emit_cmp_and_jump_insns (tem, const0_rtx, GE, NULL_RTX, mode, false,
-                                  done_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (tem, const0_rtx, GE, false, mode, NULL_RTX,
+                                  NULL_RTX, done_label, PROB_VERY_LIKELY);
        }
       else
        {
          rtx_code_label *do_ior_label = gen_label_rtx ();
-         emit_cmp_and_jump_insns (op1, const0_rtx,
-                                  code == MINUS_EXPR ? GE : LT, NULL_RTX,
-                                  mode, false, do_ior_label, PROB_EVEN);
+         do_compare_rtx_and_jump (op1, const0_rtx,
+                                  code == MINUS_EXPR ? GE : LT, false, mode,
+                                  NULL_RTX, NULL_RTX, do_ior_label,
+                                  PROB_EVEN);
          tem = expand_binop (mode, and_optab, op0, res, NULL_RTX, false,
                              OPTAB_LIB_WIDEN);
-         emit_cmp_and_jump_insns (tem, const0_rtx, GE, NULL_RTX, mode, false,
-                                  done_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (tem, const0_rtx, GE, false, mode, NULL_RTX,
+                                  NULL_RTX, done_label, PROB_VERY_LIKELY);
          emit_jump (do_error);
          emit_label (do_ior_label);
          tem = expand_binop (mode, ior_optab, op0, res, NULL_RTX, false,
                              OPTAB_LIB_WIDEN);
-         emit_cmp_and_jump_insns (tem, const0_rtx, GE, NULL_RTX, mode, false,
-                                  done_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (tem, const0_rtx, GE, false, mode, NULL_RTX,
+                                  NULL_RTX, done_label, PROB_VERY_LIKELY);
        }
       goto do_error_label;
     }
@@ -694,14 +695,14 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
       res = expand_binop (mode, sub_optab, op0, op1, NULL_RTX, false,
                          OPTAB_LIB_WIDEN);
       rtx_code_label *op0_geu_op1 = gen_label_rtx ();
-      emit_cmp_and_jump_insns (op0, op1, GEU, NULL_RTX, mode, false,
+      do_compare_rtx_and_jump (op0, op1, GEU, true, mode, NULL_RTX, NULL_RTX,
                               op0_geu_op1, PROB_EVEN);
-      emit_cmp_and_jump_insns (res, const0_rtx, LT, NULL_RTX, mode, false,
-                              done_label, PROB_VERY_LIKELY);
+      do_compare_rtx_and_jump (res, const0_rtx, LT, false, mode, NULL_RTX,
+                              NULL_RTX, done_label, PROB_VERY_LIKELY);
       emit_jump (do_error);
       emit_label (op0_geu_op1);
-      emit_cmp_and_jump_insns (res, const0_rtx, GE, NULL_RTX, mode, false,
-                              done_label, PROB_VERY_LIKELY);
+      do_compare_rtx_and_jump (res, const0_rtx, GE, false, mode, NULL_RTX,
+                              NULL_RTX, done_label, PROB_VERY_LIKELY);
       goto do_error_label;
     }
 
@@ -754,7 +755,7 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
         and conditional jump instead of 2 at runtime, 3 present in the
         emitted code.  If one of the arguments is CONST_INT, all we
         need is to make sure it is op1, then the first
-        emit_cmp_and_jump_insns will be just folded.  Otherwise try
+        do_compare_rtx_and_jump will be just folded.  Otherwise try
         to use range info if available.  */
       if (code == PLUS_EXPR && CONST_INT_P (op0))
        {
@@ -779,13 +780,13 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
 
       /* If the op1 is negative, we have to use a different check.  */
       if (pos_neg == 3)
-       emit_cmp_and_jump_insns (op1, const0_rtx, LT, NULL_RTX, mode,
-                                false, sub_check, PROB_EVEN);
+       do_compare_rtx_and_jump (op1, const0_rtx, LT, false, mode, NULL_RTX,
+                                NULL_RTX, sub_check, PROB_EVEN);
 
       /* Compare the result of the operation with one of the operands.  */
       if (pos_neg & 1)
-       emit_cmp_and_jump_insns (res, op0, code == PLUS_EXPR ? GE : LE,
-                                NULL_RTX, mode, false, done_label,
+       do_compare_rtx_and_jump (res, op0, code == PLUS_EXPR ? GE : LE,
+                                false, mode, NULL_RTX, NULL_RTX, done_label,
                                 PROB_VERY_LIKELY);
 
       /* If we get here, we have to print the error.  */
@@ -798,8 +799,8 @@ expand_addsub_overflow (location_t loc, tree_code code, tree lhs,
 
       /* We have k = a + b for b < 0 here.  k <= a must hold.  */
       if (pos_neg & 2)
-       emit_cmp_and_jump_insns (res, op0, code == PLUS_EXPR ? LE : GE,
-                                NULL_RTX, mode, false, done_label,
+       do_compare_rtx_and_jump (res, op0, code == PLUS_EXPR ? LE : GE,
+                                false, mode, NULL_RTX, NULL_RTX, done_label,
                                 PROB_VERY_LIKELY);
     }
 
@@ -895,7 +896,7 @@ expand_neg_overflow (location_t loc, tree lhs, tree arg1, bool is_ubsan)
 
       /* Compare the operand with the most negative value.  */
       rtx minv = expand_normal (TYPE_MIN_VALUE (TREE_TYPE (arg1)));
-      emit_cmp_and_jump_insns (op1, minv, NE, NULL_RTX, mode, false,
+      do_compare_rtx_and_jump (op1, minv, NE, true, mode, NULL_RTX, NULL_RTX,
                               done_label, PROB_VERY_LIKELY);
     }
 
@@ -1031,16 +1032,16 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
          ops.op2 = NULL_TREE;
          ops.location = loc;
          res = expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
-         emit_cmp_and_jump_insns (op1, const0_rtx, EQ, NULL_RTX, mode,
-                                  false, done_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (op1, const0_rtx, EQ, true, mode, NULL_RTX,
+                                  NULL_RTX, done_label, PROB_VERY_LIKELY);
          goto do_error_label;
        case 3:
          rtx_code_label *do_main_label;
          do_main_label = gen_label_rtx ();
-         emit_cmp_and_jump_insns (op0, const0_rtx, GE, NULL_RTX, mode,
-                                  false, do_main_label, PROB_VERY_LIKELY);
-         emit_cmp_and_jump_insns (op1, const0_rtx, EQ, NULL_RTX, mode,
-                                  false, do_main_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (op0, const0_rtx, GE, false, mode, NULL_RTX,
+                                  NULL_RTX, do_main_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (op1, const0_rtx, EQ, true, mode, NULL_RTX,
+                                  NULL_RTX, do_main_label, PROB_VERY_LIKELY);
          write_complex_part (target, const1_rtx, true);
          emit_label (do_main_label);
          goto do_main;
@@ -1076,16 +1077,16 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
          ops.op2 = NULL_TREE;
          ops.location = loc;
          res = expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
-         emit_cmp_and_jump_insns (op0, const0_rtx, EQ, NULL_RTX, mode,
-                                  false, done_label, PROB_VERY_LIKELY);
-         emit_cmp_and_jump_insns (op0, constm1_rtx, NE, NULL_RTX, mode,
-                                  false, do_error, PROB_VERY_UNLIKELY);
+         do_compare_rtx_and_jump (op0, const0_rtx, EQ, true, mode, NULL_RTX,
+                                  NULL_RTX, done_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (op0, constm1_rtx, NE, true, mode, NULL_RTX,
+                                  NULL_RTX, do_error, PROB_VERY_UNLIKELY);
          int prec;
          prec = GET_MODE_PRECISION (mode);
          rtx sgn;
          sgn = immed_wide_int_const (wi::min_value (prec, SIGNED), mode);
-         emit_cmp_and_jump_insns (op1, sgn, EQ, NULL_RTX, mode,
-                                  false, done_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (op1, sgn, EQ, true, mode, NULL_RTX,
+                                  NULL_RTX, done_label, PROB_VERY_LIKELY);
          goto do_error_label;
        case 3:
          /* Rest of handling of this case after res is computed.  */
@@ -1130,8 +1131,9 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
              res = expand_expr_real_2 (&ops, NULL_RTX, mode, EXPAND_NORMAL);
              tem = expand_binop (mode, and_optab, op0, op1, NULL_RTX, false,
                                  OPTAB_LIB_WIDEN);
-             emit_cmp_and_jump_insns (tem, const0_rtx, EQ, NULL_RTX, mode,
-                                      false, done_label, PROB_VERY_LIKELY);
+             do_compare_rtx_and_jump (tem, const0_rtx, EQ, true, mode,
+                                      NULL_RTX, NULL_RTX, done_label,
+                                      PROB_VERY_LIKELY);
              goto do_error_label;
            }
          /* The general case, do all the needed comparisons at runtime.  */
@@ -1147,8 +1149,9 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
          after_negate_label = gen_label_rtx ();
          tem = expand_binop (mode, and_optab, op0, op1, NULL_RTX, false,
                              OPTAB_LIB_WIDEN);
-         emit_cmp_and_jump_insns (tem, const0_rtx, GE, NULL_RTX, mode, false,
-                                  after_negate_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (tem, const0_rtx, GE, false, mode, NULL_RTX,
+                                  NULL_RTX, after_negate_label,
+                                  PROB_VERY_LIKELY);
          /* Both arguments negative here, negate them and continue with
             normal unsigned overflow checking multiplication.  */
          emit_move_insn (op0, expand_unop (mode, neg_optab, op0,
@@ -1163,14 +1166,14 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
          emit_label (after_negate_label);
          tem2 = expand_binop (mode, xor_optab, op0, op1, NULL_RTX, false,
                               OPTAB_LIB_WIDEN);
-         emit_cmp_and_jump_insns (tem2, const0_rtx, GE, NULL_RTX, mode, false,
-                                  do_main_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (tem2, const0_rtx, GE, false, mode, NULL_RTX,
+                                  NULL_RTX, do_main_label, PROB_VERY_LIKELY);
          /* One argument is negative here, the other positive.  This
             overflows always, unless one of the arguments is 0.  But
             if e.g. s2 is 0, (U) s1 * 0 doesn't overflow, whatever s1
             is, thus we can keep do_main code oring in overflow as is.  */
-         emit_cmp_and_jump_insns (tem, const0_rtx, EQ, NULL_RTX, mode, false,
-                                  do_main_label, PROB_VERY_LIKELY);
+         do_compare_rtx_and_jump (tem, const0_rtx, EQ, true, mode, NULL_RTX,
+                                  NULL_RTX, do_main_label, PROB_VERY_LIKELY);
          write_complex_part (target, const1_rtx, true);
          emit_label (do_main_label);
          goto do_main;
@@ -1235,8 +1238,9 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
          if (uns)
            /* For the unsigned multiplication, there was overflow if
               HIPART is non-zero.  */
-           emit_cmp_and_jump_insns (hipart, const0_rtx, EQ, NULL_RTX, mode,
-                                    false, done_label, PROB_VERY_LIKELY);
+           do_compare_rtx_and_jump (hipart, const0_rtx, EQ, true, mode,
+                                    NULL_RTX, NULL_RTX, done_label,
+                                    PROB_VERY_LIKELY);
          else
            {
              rtx signbit = expand_shift (RSHIFT_EXPR, mode, res, prec - 1,
@@ -1244,8 +1248,9 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
              /* RES is low half of the double width result, HIPART
                 the high half.  There was overflow if
                 HIPART is different from RES < 0 ? -1 : 0.  */
-             emit_cmp_and_jump_insns (signbit, hipart, EQ, NULL_RTX, mode,
-                                      false, done_label, PROB_VERY_LIKELY);
+             do_compare_rtx_and_jump (signbit, hipart, EQ, true, mode,
+                                      NULL_RTX, NULL_RTX, done_label,
+                                      PROB_VERY_LIKELY);
            }
        }
       else if (hmode != BLKmode && 2 * GET_MODE_PRECISION (hmode) == prec)
@@ -1336,12 +1341,13 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
            }
 
          if (!op0_small_p)
-           emit_cmp_and_jump_insns (signbit0, hipart0, NE, NULL_RTX, hmode,
-                                    false, large_op0, PROB_UNLIKELY);
+           do_compare_rtx_and_jump (signbit0, hipart0, NE, true, hmode,
+                                    NULL_RTX, NULL_RTX, large_op0,
+                                    PROB_UNLIKELY);
 
          if (!op1_small_p)
-           emit_cmp_and_jump_insns (signbit1, hipart1, NE, NULL_RTX, hmode,
-                                    false, small_op0_large_op1,
+           do_compare_rtx_and_jump (signbit1, hipart1, NE, true, hmode,
+                                    NULL_RTX, NULL_RTX, small_op0_large_op1,
                                     PROB_UNLIKELY);
 
          /* If both op0 and op1 are sign (!uns) or zero (uns) extended from
@@ -1386,8 +1392,9 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
          emit_label (large_op0);
 
          if (!op1_small_p)
-           emit_cmp_and_jump_insns (signbit1, hipart1, NE, NULL_RTX, hmode,
-                                    false, both_ops_large, PROB_UNLIKELY);
+           do_compare_rtx_and_jump (signbit1, hipart1, NE, true, hmode,
+                                    NULL_RTX, NULL_RTX, both_ops_large,
+                                    PROB_UNLIKELY);
 
          /* If op1 is sign (!uns) or zero (uns) extended from hmode to mode,
             but op0 is not, prepare larger, hipart and lopart pseudos and
@@ -1422,8 +1429,8 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
              if (larger_sign == 0)
                emit_jump (after_hipart_neg);
              else if (larger_sign != -1)
-               emit_cmp_and_jump_insns (hipart, const0_rtx, GE, NULL_RTX,
-                                        hmode, false, after_hipart_neg,
+               do_compare_rtx_and_jump (hipart, const0_rtx, GE, false, hmode,
+                                        NULL_RTX, NULL_RTX, after_hipart_neg,
                                         PROB_EVEN);
 
              tem = convert_modes (mode, hmode, lopart, 1);
@@ -1438,8 +1445,8 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
              if (smaller_sign == 0)
                emit_jump (after_lopart_neg);
              else if (smaller_sign != -1)
-               emit_cmp_and_jump_insns (lopart, const0_rtx, GE, NULL_RTX,
-                                        hmode, false, after_lopart_neg,
+               do_compare_rtx_and_jump (lopart, const0_rtx, GE, false, hmode,
+                                        NULL_RTX, NULL_RTX, after_lopart_neg,
                                         PROB_EVEN);
 
              tem = expand_simple_binop (mode, MINUS, loxhi, larger, NULL_RTX,
@@ -1467,8 +1474,8 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
                                         gen_lowpart (hmode, loxhi),
                                         hprec - 1, NULL_RTX, 0);
 
-         emit_cmp_and_jump_insns (signbitloxhi, hipartloxhi, NE, NULL_RTX,
-                                  hmode, false, do_overflow,
+         do_compare_rtx_and_jump (signbitloxhi, hipartloxhi, NE, true, hmode,
+                                  NULL_RTX, NULL_RTX, do_overflow,
                                   PROB_VERY_UNLIKELY);
 
          /* res = (loxhi << (bitsize / 2)) | (hmode) lo0xlo1;  */
@@ -1503,8 +1510,8 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
                {
                  tem = expand_simple_binop (hmode, PLUS, hipart0, const1_rtx,
                                             NULL_RTX, 1, OPTAB_DIRECT);
-                 emit_cmp_and_jump_insns (tem, const1_rtx, GTU, NULL_RTX,
-                                          hmode, true, do_error,
+                 do_compare_rtx_and_jump (tem, const1_rtx, GTU, true, hmode,
+                                          NULL_RTX, NULL_RTX, do_error,
                                           PROB_VERY_UNLIKELY);
                }
 
@@ -1512,8 +1519,8 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
                {
                  tem = expand_simple_binop (hmode, PLUS, hipart1, const1_rtx,
                                             NULL_RTX, 1, OPTAB_DIRECT);
-                 emit_cmp_and_jump_insns (tem, const1_rtx, GTU, NULL_RTX,
-                                          hmode, true, do_error,
+                 do_compare_rtx_and_jump (tem, const1_rtx, GTU, true, hmode,
+                                          NULL_RTX, NULL_RTX, do_error,
                                           PROB_VERY_UNLIKELY);
                }
 
@@ -1523,17 +1530,20 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
              if (op0_sign != 1 && op1_sign != 1 && op0_sign != op1_sign)
                emit_jump (hipart_different);
              else if (op0_sign == 1 || op1_sign == 1)
-               emit_cmp_and_jump_insns (hipart0, hipart1, NE, NULL_RTX, hmode,
-                                        true, hipart_different, PROB_EVEN);
+               do_compare_rtx_and_jump (hipart0, hipart1, NE, true, hmode,
+                                        NULL_RTX, NULL_RTX, hipart_different,
+                                        PROB_EVEN);
 
-             emit_cmp_and_jump_insns (res, const0_rtx, LT, NULL_RTX, mode,
-                                      false, do_error, PROB_VERY_UNLIKELY);
+             do_compare_rtx_and_jump (res, const0_rtx, LT, false, mode,
+                                      NULL_RTX, NULL_RTX, do_error,
+                                      PROB_VERY_UNLIKELY);
              emit_jump (done_label);
 
              emit_label (hipart_different);
 
-             emit_cmp_and_jump_insns (res, const0_rtx, GE, NULL_RTX, mode,
-                                      false, do_error, PROB_VERY_UNLIKELY);
+             do_compare_rtx_and_jump (res, const0_rtx, GE, false, mode,
+                                      NULL_RTX, NULL_RTX, do_error,
+                                      PROB_VERY_UNLIKELY);
              emit_jump (done_label);
            }
 
@@ -1577,8 +1587,8 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
   if (uns0_p && uns1_p && !unsr_p)
     {
       rtx_code_label *all_done_label = gen_label_rtx ();
-      emit_cmp_and_jump_insns (res, const0_rtx, GE, NULL_RTX, mode,
-                              false, all_done_label, PROB_VERY_LIKELY);
+      do_compare_rtx_and_jump (res, const0_rtx, GE, false, mode, NULL_RTX,
+                              NULL_RTX, all_done_label, PROB_VERY_LIKELY);
       write_complex_part (target, const1_rtx, true);
       emit_label (all_done_label);
     }
@@ -1588,15 +1598,15 @@ expand_mul_overflow (location_t loc, tree lhs, tree arg0, tree arg1,
     {
       rtx_code_label *all_done_label = gen_label_rtx ();
       rtx_code_label *set_noovf = gen_label_rtx ();
-      emit_cmp_and_jump_insns (op1, const0_rtx, GE, NULL_RTX, mode,
-                              false, all_done_label, PROB_VERY_LIKELY);
+      do_compare_rtx_and_jump (op1, const0_rtx, GE, false, mode, NULL_RTX,
+                              NULL_RTX, all_done_label, PROB_VERY_LIKELY);
       write_complex_part (target, const1_rtx, true);
-      emit_cmp_and_jump_insns (op0, const0_rtx, EQ, NULL_RTX, mode,
-                              false, set_noovf, PROB_VERY_LIKELY);
-      emit_cmp_and_jump_insns (op0, constm1_rtx, NE, NULL_RTX, mode,
-                              false, all_done_label, PROB_VERY_UNLIKELY);
-      emit_cmp_and_jump_insns (op1, res, NE, NULL_RTX, mode,
-                              false, all_done_label, PROB_VERY_UNLIKELY);
+      do_compare_rtx_and_jump (op0, const0_rtx, EQ, true, mode, NULL_RTX,
+                              NULL_RTX, set_noovf, PROB_VERY_LIKELY);
+      do_compare_rtx_and_jump (op0, constm1_rtx, NE, true, mode, NULL_RTX,
+                              NULL_RTX, all_done_label, PROB_VERY_UNLIKELY);
+      do_compare_rtx_and_jump (op1, res, NE, true, mode, NULL_RTX, NULL_RTX,
+                              all_done_label, PROB_VERY_UNLIKELY);
       emit_label (set_noovf);
       write_complex_part (target, const0_rtx, true);
       emit_label (all_done_label);