optabs.c: Use gen_rtx_FOO (...) instead of gen_rtx (FOO, ...).

	* optabs.c: Use gen_rtx_FOO (...) instead of gen_rtx (FOO, ...).
	* expr.c: Likewise.
	* explow.c: Likewise.
	* combine.c: Likewise.
	* reload1.c: Likewise.
	* gcse.c: Likewise.

From-SVN: r20701

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 42f24ca98b2b78422a91b8a25f5e60790b8e6d0e..b96011120ded6798c9313eaa78c7b7b5c3901e40 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -6,6 +6,13 @@ Wed Jun 24 16:27:23 1998  John Carr  <jfc@mit.edu>
 
        * expmed.c (init_expmed): Initialize all elements of *_cost arrays.
 
+       * optabs.c: Use gen_rtx_FOO (...) instead of gen_rtx (FOO, ...).
+       * expr.c: Likewise.
+       * explow.c: Likewise.
+       * combine.c: Likewise.
+       * reload1.c: Likewise.
+       * gcse.c: Likewise.
+
 Wed Jun 24 15:13:01 1998  Dave Brolley  <brolley@cygnus.com>
 
        * README.gnat: Add patch for new lang_decode_options interface.

diff --git a/gcc/combine.c b/gcc/combine.c
index a453b574d21900d7388ceba873ea4ebc4198f5fb..f5252292494414718f752f5d4028ee2d9dca57a7 100644 (file)
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -11552,8 +11552,9 @@ distribute_notes (notes, from_insn, i3, i2, elim_i2, elim_i1)
                          if (! find_regno_note (tem, REG_UNUSED,
                                                 REGNO (XEXP (note, 0))))
                            REG_NOTES (tem)
-                             = gen_rtx (EXPR_LIST, REG_UNUSED, XEXP (note, 0),
-                                        REG_NOTES (tem));
+                             = gen_rtx_EXPR_LIST (REG_UNUSED,
+                                                  XEXP (note, 0),
+                                                  REG_NOTES (tem));
                        }
                      else
                        {

diff --git a/gcc/explow.c b/gcc/explow.c
index 8117836c7b04da8bdca00c6c4852e478a2b34a8f..7c74d6a620f4a18cb1007e4c10ff49883943a1c9 100644 (file)
--- a/gcc/explow.c
+++ b/gcc/explow.c
@@ -1258,9 +1258,9 @@ allocate_dynamic_stack_space (size, target, known_align)
        {
          rtx note_target = get_last_insn ();
 
-         REG_NOTES (note_target) = gen_rtx (EXPR_LIST, REG_SAVE_AREA,
-                                            setjmpless_size,
-                                            REG_NOTES (note_target));
+         REG_NOTES (note_target)
+           = gen_rtx_EXPR_LIST (REG_SAVE_AREA, setjmpless_size,
+                                REG_NOTES (note_target));
        }
 #endif /* SETJMP_VIA_SAVE_AREA */
 #ifdef STACK_GROWS_DOWNWARD

diff --git a/gcc/expr.c b/gcc/expr.c
index b429bcc60cf3cc0a5cb2a19f9ae8df073bd72423..ddb5bbbe418018f92ca1c1f60f9bf60d256f4e1d 100644 (file)
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -2289,7 +2289,7 @@ emit_move_insn_1 (x, y)
        {
          /* Show the output dies here.  */
          if (x != y)
-           emit_insn (gen_rtx (CLOBBER, VOIDmode, x));
+           emit_insn (gen_rtx_CLOBBER (VOIDmode, x));
 
          emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
                     (gen_realpart (submode, x), gen_realpart (submode, y)));
@@ -2639,7 +2639,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
            {
              rtx opalign = GEN_INT (align);
              enum machine_mode mode;
-             rtx target = gen_rtx (MEM, BLKmode, temp);
+             rtx target = gen_rtx_MEM (BLKmode, temp);
 
              for (mode = GET_CLASS_NARROWEST_MODE (MODE_INT);
                   mode != VOIDmode;

diff --git a/gcc/gcse.c b/gcc/gcse.c
index 8e73b19c25bd0c10463e576dc22959af3beba483..c40f68730659c7292c2cb00fb6859134f5a55ad4 100644 (file)
--- a/gcc/gcse.c
+++ b/gcc/gcse.c
@@ -805,8 +805,8 @@ compute_can_copy ()
 #ifdef AVOID_CCMODE_COPIES
          can_copy_p[i] = 0;
 #else
-         reg = gen_rtx (REG, (enum machine_mode) i, LAST_VIRTUAL_REGISTER + 1);
-         insn = emit_insn (gen_rtx (SET, VOIDmode, reg, reg));
+         reg = gen_rtx_REG ((enum machine_mode) i, LAST_VIRTUAL_REGISTER + 1);
+         insn = emit_insn (gen_rtx_SET (VOIDmode, reg, reg));
          if (recog (PATTERN (insn), insn, NULL_PTR) >= 0)
            can_copy_p[i] = 1;
 #endif
@@ -3139,8 +3139,9 @@ handle_avail_expr (insn, expr)
       /* Generate the new insn.  */
       /* ??? If the change fails, we return 0, even though we created
         an insn.  I think this is ok.  */
-      new_insn = emit_insn_after (gen_rtx (SET, VOIDmode, to,
-                                          SET_DEST (PATTERN (insn_computes_expr))),
+      new_insn
+       = emit_insn_after (gen_rtx_SET (VOIDmode, to,
+                                       SET_DEST (PATTERN (insn_computes_expr))),
                                  insn_computes_expr);
       /* Keep block number table up to date.  */
       set_block_num (new_insn, BLOCK_NUM (insn_computes_expr));
@@ -4321,7 +4322,7 @@ pre_insert_insn (expr, bb)
   int regno = REGNO (reg);
   rtx pat;
 
-  pat = gen_rtx (SET, VOIDmode, reg, copy_rtx (expr->expr));
+  pat = gen_rtx_SET (VOIDmode, reg, copy_rtx (expr->expr));
 
   /* If the last insn is a jump, insert EXPR in front [taking care to
      handle cc0, etc. properly].  */
@@ -4443,7 +4444,7 @@ pre_insert_copy_insn (expr, insn)
 
   if (!set)
     abort ();
-  new_insn = emit_insn_after (gen_rtx (SET, VOIDmode, reg, SET_DEST (set)),
+  new_insn = emit_insn_after (gen_rtx_SET (VOIDmode, reg, SET_DEST (set)),
                              insn);
   /* Keep block number table up to date.  */
   set_block_num (new_insn, BLOCK_NUM (insn));

diff --git a/gcc/optabs.c b/gcc/optabs.c
index 501f92f62997291642cdd98475ad0630b571e6b4..4b31fe0d106433960ea3f0e098e20e7d40218026 100644 (file)
--- a/gcc/optabs.c
+++ b/gcc/optabs.c
@@ -293,13 +293,13 @@ add_equal_note (seq, target, code, op0, op1)
        return 0;
 
   if (GET_RTX_CLASS (code) == '1')
-    note = gen_rtx (code, GET_MODE (target), copy_rtx (op0));
+    note = gen_rtx_fmt_e (code, GET_MODE (target), copy_rtx (op0));
   else
-    note = gen_rtx (code, GET_MODE (target), copy_rtx (op0), copy_rtx (op1));
+    note = gen_rtx_fmt_ee (code, GET_MODE (target), copy_rtx (op0), copy_rtx (op1));
 
   REG_NOTES (XVECEXP (seq, 0, XVECLEN (seq, 0) - 1))
-    = gen_rtx (EXPR_LIST, REG_EQUAL, note,
-              REG_NOTES (XVECEXP (seq, 0, XVECLEN (seq, 0) - 1)));
+    = gen_rtx_EXPR_LIST (REG_EQUAL, note,
+                        REG_NOTES (XVECEXP (seq, 0, XVECLEN (seq, 0) - 1)));
 
   return 1;
 }
@@ -330,13 +330,13 @@ widen_operand (op, mode, oldmode, unsignedp, no_extend)
   /* If MODE is no wider than a single word, we return a paradoxical
      SUBREG.  */
   if (GET_MODE_SIZE (mode) <= UNITS_PER_WORD)
-    return gen_rtx (SUBREG, mode, force_reg (GET_MODE (op), op), 0);
+    return gen_rtx_SUBREG (mode, force_reg (GET_MODE (op), op), 0);
 
   /* Otherwise, get an object of MODE, clobber it, and set the low-order
      part to OP.  */
 
   result = gen_reg_rtx (mode);
-  emit_insn (gen_rtx (CLOBBER, VOIDmode, result));
+  emit_insn (gen_rtx_CLOBBER (VOIDmode, result));
   emit_move_insn (gen_lowpart (GET_MODE (op), result), op);
   return result;
 }
@@ -630,7 +630,8 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
        {
          if (binoptab->code != UNKNOWN)
            equiv_value
-             = gen_rtx (binoptab->code, mode, copy_rtx (op0), copy_rtx (op1));
+             = gen_rtx_fmt_ee (binoptab->code, mode,
+                               copy_rtx (op0), copy_rtx (op1));
          else
            equiv_value = 0;
 
@@ -749,7 +750,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
       if (inter != 0)
        {
          if (binoptab->code != UNKNOWN)
-           equiv_value = gen_rtx (binoptab->code, mode, op0, op1);
+           equiv_value = gen_rtx_fmt_ee (binoptab->code, mode, op0, op1);
          else
            equiv_value = 0;
 
@@ -863,7 +864,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
       if (inter != 0)
        {
          if (binoptab->code != UNKNOWN)
-           equiv_value = gen_rtx (binoptab->code, mode, op0, op1);
+           equiv_value = gen_rtx_fmt_ee (binoptab->code, mode, op0, op1);
          else
            equiv_value = 0;
 
@@ -912,7 +913,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
 
       /* Indicate for flow that the entire target reg is being set.  */
       if (GET_CODE (target) == REG)
-       emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
+       emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
 
       /* Do the actual arithmetic.  */
       for (i = 0; i < nwords; i++)
@@ -981,11 +982,12 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
            {
              rtx temp = emit_move_insn (target, target);
 
-             REG_NOTES (temp) = gen_rtx (EXPR_LIST, REG_EQUAL,
-                                         gen_rtx (binoptab->code, mode,
-                                                  copy_rtx (xop0),
-                                                  copy_rtx (xop1)),
-                                         REG_NOTES (temp));
+             REG_NOTES (temp)
+               = gen_rtx_EXPR_LIST (REG_EQUAL,
+                                    gen_rtx_fmt_ee (binoptab->code, mode,
+                                                    copy_rtx (xop0),
+                                                    copy_rtx (xop1)),
+                                    REG_NOTES (temp));
            }
          return target;
        }
@@ -1163,11 +1165,12 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
              if (mov_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
                {
                  temp = emit_move_insn (product, product);
-                 REG_NOTES (temp) = gen_rtx (EXPR_LIST, REG_EQUAL,
-                                             gen_rtx (MULT, mode,
-                                                      copy_rtx (op0),
-                                                      copy_rtx (op1)),
-                                             REG_NOTES (temp));
+                 REG_NOTES (temp)
+                   = gen_rtx_EXPR_LIST (REG_EQUAL,
+                                        gen_rtx_fmt_ee (MULT, mode,
+                                                        copy_rtx (op0),
+                                                        copy_rtx (op1)),
+                                        REG_NOTES (temp));
                }
              return product;
            }
@@ -1501,7 +1504,8 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
        {
          if (binoptab->code != UNKNOWN)
            equiv_value
-             = gen_rtx (binoptab->code, mode, copy_rtx (op0), copy_rtx (op1));
+             = gen_rtx_fmt_ee (binoptab->code, mode,
+                               copy_rtx (op0), copy_rtx (op1));
          else
            equiv_value = 0;
          
@@ -1547,7 +1551,7 @@ expand_binop (mode, binoptab, op0, op1, target, unsignedp, methods)
 
       target = gen_reg_rtx (mode);
       emit_libcall_block (insns, target, value,
-                         gen_rtx (binoptab->code, mode, op0, op1));
+                         gen_rtx_fmt_ee (binoptab->code, mode, op0, op1));
 
       return target;
     }
@@ -1961,7 +1965,8 @@ expand_unop (mode, unoptab, op0, target, unsignedp)
       end_sequence ();
 
       emit_no_conflict_block (insns, target, op0, NULL_RTX,
-                             gen_rtx (unoptab->code, mode, copy_rtx (op0)));
+                             gen_rtx_fmt_e (unoptab->code, mode,
+                                            copy_rtx (op0)));
       return target;
     }
 
@@ -2005,7 +2010,8 @@ expand_unop (mode, unoptab, op0, target, unsignedp)
       end_sequence ();
 
       emit_no_conflict_block (seq, target, op0, 0,
-                             gen_rtx (unoptab->code, mode, copy_rtx (op0)));
+                             gen_rtx_fmt_e (unoptab->code, mode,
+                                            copy_rtx (op0)));
       return target;
     }
 
@@ -2026,7 +2032,7 @@ expand_unop (mode, unoptab, op0, target, unsignedp)
 
       target = gen_reg_rtx (mode);
       emit_libcall_block (insns, target, value,
-                         gen_rtx (unoptab->code, mode, op0));
+                         gen_rtx_fmt_e (unoptab->code, mode, op0));
 
       return target;
     }
@@ -2335,7 +2341,7 @@ expand_complex_abs (mode, op0, target, unsignedp)
 
       target = gen_reg_rtx (submode);
       emit_libcall_block (insns, target, value,
-                         gen_rtx (abs_optab->code, mode, op0));
+                         gen_rtx_fmt_e (abs_optab->code, mode, op0));
 
       return target;
     }
@@ -2511,7 +2517,7 @@ emit_no_conflict_block (insns, target, op0, op1, equiv)
   /* Now write the CLOBBER of the output, followed by the setting of each
      of the words, followed by the final copy.  */
   if (target != op0 && target != op1)
-    emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
+    emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
 
   for (insn = insns; insn; insn = next)
     {
@@ -2519,12 +2525,12 @@ emit_no_conflict_block (insns, target, op0, op1, equiv)
       add_insn (insn);
 
       if (op1 && GET_CODE (op1) == REG)
-       REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_NO_CONFLICT, op1,
-                                   REG_NOTES (insn));
+       REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_NO_CONFLICT, op1,
+                                             REG_NOTES (insn));
 
       if (op0 && GET_CODE (op0) == REG)
-       REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_NO_CONFLICT, op0,
-                                   REG_NOTES (insn));
+       REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_NO_CONFLICT, op0,
+                                             REG_NOTES (insn));
     }
 
   if (mov_optab->handlers[(int) GET_MODE (target)].insn_code
@@ -2533,7 +2539,7 @@ emit_no_conflict_block (insns, target, op0, op1, equiv)
       last = emit_move_insn (target, target);
       if (equiv)
        REG_NOTES (last)
-         = gen_rtx (EXPR_LIST, REG_EQUAL, equiv, REG_NOTES (last));
+         = gen_rtx_EXPR_LIST (REG_EQUAL, equiv, REG_NOTES (last));
     }
   else
     last = get_last_insn ();
@@ -2544,9 +2550,9 @@ emit_no_conflict_block (insns, target, op0, op1, equiv)
     first = NEXT_INSN (prev);
 
   /* Encapsulate the block so it gets manipulated as a unit.  */
-  REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
-                              REG_NOTES (first));
-  REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first, REG_NOTES (last));
+  REG_NOTES (first) = gen_rtx_INSN_LIST (REG_LIBCALL, last,
+                                        REG_NOTES (first));
+  REG_NOTES (last) = gen_rtx_INSN_LIST (REG_RETVAL, first, REG_NOTES (last));
 
   return last;
 }
@@ -2631,8 +2637,8 @@ emit_libcall_block (insns, target, result, equiv)
   last = emit_move_insn (target, result);
   if (mov_optab->handlers[(int) GET_MODE (target)].insn_code
       != CODE_FOR_nothing)
-    REG_NOTES (last) = gen_rtx (EXPR_LIST,
-                               REG_EQUAL, copy_rtx (equiv), REG_NOTES (last));
+    REG_NOTES (last) = gen_rtx_EXPR_LIST (REG_EQUAL, copy_rtx (equiv),
+                                         REG_NOTES (last));
 
   if (prev == 0)
     first = get_insns ();
@@ -2640,9 +2646,9 @@ emit_libcall_block (insns, target, result, equiv)
     first = NEXT_INSN (prev);
 
   /* Encapsulate the block so it gets manipulated as a unit.  */
-  REG_NOTES (first) = gen_rtx (INSN_LIST, REG_LIBCALL, last,
-                              REG_NOTES (first));
-  REG_NOTES (last) = gen_rtx (INSN_LIST, REG_RETVAL, first, REG_NOTES (last));
+  REG_NOTES (first) = gen_rtx_INSN_LIST (REG_LIBCALL, last,
+                                        REG_NOTES (first));
+  REG_NOTES (last) = gen_rtx_INSN_LIST (REG_RETVAL, first, REG_NOTES (last));
 }
 \f
 /* Generate code to store zero in X.  */
@@ -3376,7 +3382,7 @@ gen_move_insn (x, y)
          x = gen_lowpart_common (tmode, x1);
          if (x == 0 && GET_CODE (x1) == MEM)
            {
-             x = gen_rtx (MEM, tmode, XEXP (x1, 0));
+             x = gen_rtx_MEM (tmode, XEXP (x1, 0));
              RTX_UNCHANGING_P (x) = RTX_UNCHANGING_P (x1);
              MEM_IN_STRUCT_P (x) = MEM_IN_STRUCT_P (x1);
              MEM_VOLATILE_P (x) = MEM_VOLATILE_P (x1);
@@ -3386,7 +3392,7 @@ gen_move_insn (x, y)
          y = gen_lowpart_common (tmode, y1);
          if (y == 0 && GET_CODE (y1) == MEM)
            {
-             y = gen_rtx (MEM, tmode, XEXP (y1, 0));
+             y = gen_rtx_MEM (tmode, XEXP (y1, 0));
              RTX_UNCHANGING_P (y) = RTX_UNCHANGING_P (y1);
              MEM_IN_STRUCT_P (y) = MEM_IN_STRUCT_P (y1);
              MEM_VOLATILE_P (y) = MEM_VOLATILE_P (y1);
@@ -3714,7 +3720,7 @@ expand_float (to, from, unsignedp)
       end_sequence ();
 
       emit_libcall_block (insns, target, value,
-                         gen_rtx (FLOAT, GET_MODE (to), from));
+                         gen_rtx_FLOAT (GET_MODE (to), from));
     }
 
  done:
@@ -3860,10 +3866,12 @@ expand_fix (to, from, unsignedp)
            {
              /* Make a place for a REG_NOTE and add it.  */
              insn = emit_move_insn (to, to);
-             REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL,
-                                         gen_rtx (UNSIGNED_FIX, GET_MODE (to),
-                                                  copy_rtx (from)),
-                                         REG_NOTES (insn));
+             REG_NOTES (insn)
+               = gen_rtx_EXPR_LIST (REG_EQUAL,
+                                    gen_rtx_fmt_e (UNSIGNED_FIX,
+                                                   GET_MODE (to),
+                                                   copy_rtx (from)),
+                                    REG_NOTES (insn));
            }
          return;
        }
@@ -3946,8 +3954,8 @@ expand_fix (to, from, unsignedp)
       end_sequence ();
 
       emit_libcall_block (insns, target, value,
-                         gen_rtx (unsignedp ? UNSIGNED_FIX : FIX,
-                                  GET_MODE (to), from));
+                         gen_rtx_fmt_e (unsignedp ? UNSIGNED_FIX : FIX,
+                                        GET_MODE (to), from));
     }
       
   if (target != to)
@@ -4026,7 +4034,7 @@ init_libfuncs (optable, first_mode, last_mode, opname, suffix)
       *p++ = suffix;
       *p++ = '\0';
       optable->handlers[(int) mode].libfunc
-       = gen_rtx (SYMBOL_REF, Pmode, libfunc_name);
+       = gen_rtx_SYMBOL_REF (Pmode, libfunc_name);
     }
 }
 
@@ -4207,181 +4215,181 @@ init_optabs ()
 
 #ifdef MULSI3_LIBCALL
   smul_optab->handlers[(int) SImode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, MULSI3_LIBCALL);
+    = gen_rtx_SYMBOL_REF (Pmode, MULSI3_LIBCALL);
 #endif
 #ifdef MULDI3_LIBCALL
   smul_optab->handlers[(int) DImode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, MULDI3_LIBCALL);
+    = gen_rtx_SYMBOL_REF (Pmode, MULDI3_LIBCALL);
 #endif
 
 #ifdef DIVSI3_LIBCALL
   sdiv_optab->handlers[(int) SImode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, DIVSI3_LIBCALL);
+    = gen_rtx_SYMBOL_REF (Pmode, DIVSI3_LIBCALL);
 #endif
 #ifdef DIVDI3_LIBCALL
   sdiv_optab->handlers[(int) DImode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, DIVDI3_LIBCALL);
+    = gen_rtx_SYMBOL_REF (Pmode, DIVDI3_LIBCALL);
 #endif
 
 #ifdef UDIVSI3_LIBCALL
   udiv_optab->handlers[(int) SImode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, UDIVSI3_LIBCALL);
+    = gen_rtx_SYMBOL_REF (Pmode, UDIVSI3_LIBCALL);
 #endif
 #ifdef UDIVDI3_LIBCALL
   udiv_optab->handlers[(int) DImode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, UDIVDI3_LIBCALL);
+    = gen_rtx_SYMBOL_REF (Pmode, UDIVDI3_LIBCALL);
 #endif
 
 #ifdef MODSI3_LIBCALL
   smod_optab->handlers[(int) SImode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, MODSI3_LIBCALL);
+    = gen_rtx_SYMBOL_REF (Pmode, MODSI3_LIBCALL);
 #endif
 #ifdef MODDI3_LIBCALL
   smod_optab->handlers[(int) DImode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, MODDI3_LIBCALL);
+    = gen_rtx_SYMBOL_REF (Pmode, MODDI3_LIBCALL);
 #endif
 
 #ifdef UMODSI3_LIBCALL
   umod_optab->handlers[(int) SImode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, UMODSI3_LIBCALL);
+    = gen_rtx_SYMBOL_REF (Pmode, UMODSI3_LIBCALL);
 #endif
 #ifdef UMODDI3_LIBCALL
   umod_optab->handlers[(int) DImode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, UMODDI3_LIBCALL);
+    = gen_rtx_SYMBOL_REF (Pmode, UMODDI3_LIBCALL);
 #endif
 
   /* Use cabs for DC complex abs, since systems generally have cabs.
      Don't define any libcall for SCmode, so that cabs will be used.  */
   abs_optab->handlers[(int) DCmode].libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, "cabs");
+    = gen_rtx_SYMBOL_REF (Pmode, "cabs");
 
   /* The ffs function operates on `int'.  */
 #ifndef INT_TYPE_SIZE
 #define INT_TYPE_SIZE BITS_PER_WORD
 #endif
   ffs_optab->handlers[(int) mode_for_size (INT_TYPE_SIZE, MODE_INT, 0)] .libfunc
-    = gen_rtx (SYMBOL_REF, Pmode, "ffs");
-
-  extendsfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsfdf2");
-  extendsfxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsfxf2");
-  extendsftf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extendsftf2");
-  extenddfxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extenddfxf2");
-  extenddftf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__extenddftf2");
-
-  truncdfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__truncdfsf2");
-  truncxfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__truncxfsf2");
-  trunctfsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__trunctfsf2");
-  truncxfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__truncxfdf2");
-  trunctfdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__trunctfdf2");
-
-  memcpy_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memcpy");
-  bcopy_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bcopy");
-  memcmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memcmp");
-  bcmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gcc_bcmp");
-  memset_libfunc = gen_rtx (SYMBOL_REF, Pmode, "memset");
-  bzero_libfunc = gen_rtx (SYMBOL_REF, Pmode, "bzero");
-
-  throw_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__throw");
-  sjthrow_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__sjthrow");
-  sjpopnthrow_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__sjpopnthrow");
-  terminate_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__terminate");
+    = gen_rtx_SYMBOL_REF (Pmode, "ffs");
+
+  extendsfdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extendsfdf2");
+  extendsfxf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extendsfxf2");
+  extendsftf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extendsftf2");
+  extenddfxf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extenddfxf2");
+  extenddftf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__extenddftf2");
+
+  truncdfsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__truncdfsf2");
+  truncxfsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__truncxfsf2");
+  trunctfsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__trunctfsf2");
+  truncxfdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__truncxfdf2");
+  trunctfdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__trunctfdf2");
+
+  memcpy_libfunc = gen_rtx_SYMBOL_REF (Pmode, "memcpy");
+  bcopy_libfunc = gen_rtx_SYMBOL_REF (Pmode, "bcopy");
+  memcmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "memcmp");
+  bcmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gcc_bcmp");
+  memset_libfunc = gen_rtx_SYMBOL_REF (Pmode, "memset");
+  bzero_libfunc = gen_rtx_SYMBOL_REF (Pmode, "bzero");
+
+  throw_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__throw");
+  sjthrow_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__sjthrow");
+  sjpopnthrow_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__sjpopnthrow");
+  terminate_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__terminate");
 #ifndef DONT_USE_BUILTIN_SETJMP
-  setjmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__builtin_setjmp");
-  longjmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__builtin_longjmp");
+  setjmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__builtin_setjmp");
+  longjmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__builtin_longjmp");
 #else
-  setjmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "setjmp");
-  longjmp_libfunc = gen_rtx (SYMBOL_REF, Pmode, "longjmp");
+  setjmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "setjmp");
+  longjmp_libfunc = gen_rtx_SYMBOL_REF (Pmode, "longjmp");
 #endif
 
-  eqhf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqhf2");
-  nehf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nehf2");
-  gthf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gthf2");
-  gehf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gehf2");
-  lthf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lthf2");
-  lehf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lehf2");
-
-  eqsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqsf2");
-  nesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nesf2");
-  gtsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gtsf2");
-  gesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gesf2");
-  ltsf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ltsf2");
-  lesf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lesf2");
-
-  eqdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqdf2");
-  nedf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nedf2");
-  gtdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gtdf2");
-  gedf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gedf2");
-  ltdf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ltdf2");
-  ledf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ledf2");
-
-  eqxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqxf2");
-  nexf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__nexf2");
-  gtxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gtxf2");
-  gexf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gexf2");
-  ltxf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__ltxf2");
-  lexf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lexf2");
-
-  eqtf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__eqtf2");
-  netf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__netf2");
-  gttf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__gttf2");
-  getf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__getf2");
-  lttf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__lttf2");
-  letf2_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__letf2");
-
-  floatsisf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsisf");
-  floatdisf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdisf");
-  floattisf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattisf");
-
-  floatsidf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsidf");
-  floatdidf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdidf");
-  floattidf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattidf");
-
-  floatsixf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsixf");
-  floatdixf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatdixf");
-  floattixf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattixf");
-
-  floatsitf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatsitf");
-  floatditf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floatditf");
-  floattitf_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__floattitf");
-
-  fixsfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixsfsi");
-  fixsfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixsfdi");
-  fixsfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixsfti");
-
-  fixdfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixdfsi");
-  fixdfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixdfdi");
-  fixdfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixdfti");
-
-  fixxfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixxfsi");
-  fixxfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixxfdi");
-  fixxfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixxfti");
-
-  fixtfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixtfsi");
-  fixtfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixtfdi");
-  fixtfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixtfti");
-
-  fixunssfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunssfsi");
-  fixunssfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunssfdi");
-  fixunssfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunssfti");
-
-  fixunsdfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsdfsi");
-  fixunsdfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsdfdi");
-  fixunsdfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsdfti");
-
-  fixunsxfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsxfsi");
-  fixunsxfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsxfdi");
-  fixunsxfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunsxfti");
-
-  fixunstfsi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunstfsi");
-  fixunstfdi_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunstfdi");
-  fixunstfti_libfunc = gen_rtx (SYMBOL_REF, Pmode, "__fixunstfti");
+  eqhf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__eqhf2");
+  nehf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__nehf2");
+  gthf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gthf2");
+  gehf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gehf2");
+  lthf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__lthf2");
+  lehf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__lehf2");
+
+  eqsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__eqsf2");
+  nesf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__nesf2");
+  gtsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gtsf2");
+  gesf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gesf2");
+  ltsf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__ltsf2");
+  lesf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__lesf2");
+
+  eqdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__eqdf2");
+  nedf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__nedf2");
+  gtdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gtdf2");
+  gedf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gedf2");
+  ltdf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__ltdf2");
+  ledf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__ledf2");
+
+  eqxf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__eqxf2");
+  nexf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__nexf2");
+  gtxf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gtxf2");
+  gexf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gexf2");
+  ltxf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__ltxf2");
+  lexf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__lexf2");
+
+  eqtf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__eqtf2");
+  netf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__netf2");
+  gttf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__gttf2");
+  getf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__getf2");
+  lttf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__lttf2");
+  letf2_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__letf2");
+
+  floatsisf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatsisf");
+  floatdisf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatdisf");
+  floattisf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floattisf");
+
+  floatsidf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatsidf");
+  floatdidf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatdidf");
+  floattidf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floattidf");
+
+  floatsixf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatsixf");
+  floatdixf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatdixf");
+  floattixf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floattixf");
+
+  floatsitf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatsitf");
+  floatditf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floatditf");
+  floattitf_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__floattitf");
+
+  fixsfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixsfsi");
+  fixsfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixsfdi");
+  fixsfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixsfti");
+
+  fixdfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixdfsi");
+  fixdfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixdfdi");
+  fixdfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixdfti");
+
+  fixxfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixxfsi");
+  fixxfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixxfdi");
+  fixxfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixxfti");
+
+  fixtfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixtfsi");
+  fixtfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixtfdi");
+  fixtfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixtfti");
+
+  fixunssfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunssfsi");
+  fixunssfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunssfdi");
+  fixunssfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunssfti");
+
+  fixunsdfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsdfsi");
+  fixunsdfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsdfdi");
+  fixunsdfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsdfti");
+
+  fixunsxfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsxfsi");
+  fixunsxfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsxfdi");
+  fixunsxfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunsxfti");
+
+  fixunstfsi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunstfsi");
+  fixunstfdi_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunstfdi");
+  fixunstfti_libfunc = gen_rtx_SYMBOL_REF (Pmode, "__fixunstfti");
 
   /* For check-memory-usage.  */
-  chkr_check_addr_libfunc = gen_rtx (SYMBOL_REF, VOIDmode, "chkr_check_addr");
-  chkr_set_right_libfunc = gen_rtx (SYMBOL_REF, VOIDmode, "chkr_set_right");
-  chkr_copy_bitmap_libfunc = gen_rtx (SYMBOL_REF, VOIDmode, "chkr_copy_bitmap");
-  chkr_check_exec_libfunc = gen_rtx (SYMBOL_REF, VOIDmode, "chkr_check_exec");
-  chkr_check_str_libfunc = gen_rtx (SYMBOL_REF, VOIDmode, "chkr_check_str");
+  chkr_check_addr_libfunc = gen_rtx_SYMBOL_REF (VOIDmode, "chkr_check_addr");
+  chkr_set_right_libfunc = gen_rtx_SYMBOL_REF (VOIDmode, "chkr_set_right");
+  chkr_copy_bitmap_libfunc = gen_rtx_SYMBOL_REF (VOIDmode, "chkr_copy_bitmap");
+  chkr_check_exec_libfunc = gen_rtx_SYMBOL_REF (VOIDmode, "chkr_check_exec");
+  chkr_check_str_libfunc = gen_rtx_SYMBOL_REF (VOIDmode, "chkr_check_str");
 
 #ifdef HAVE_conditional_trap
   init_traps ();

diff --git a/gcc/reload1.c b/gcc/reload1.c
index 3d0c3cb1beaa0bf1121608f748c95df8ea5a0fbf..9acf695679af997c1eeeeaeb54b59e649b963f53 100644 (file)
--- a/gcc/reload1.c
+++ b/gcc/reload1.c
@@ -7478,7 +7478,7 @@ gen_reload (out, in, opnum, type)
            {
              /* Add a REG_EQUIV note so that find_equiv_reg can find it.  */
              REG_NOTES (insn)
-               = gen_rtx (EXPR_LIST, REG_EQUIV, in, REG_NOTES (insn));
+               = gen_rtx_EXPR_LIST (REG_EQUIV, in, REG_NOTES (insn));
              return insn;
            }
        }
@@ -7487,7 +7487,7 @@ gen_reload (out, in, opnum, type)
 
       gen_reload (out, op1, opnum, type);
       insn = emit_insn (gen_add2_insn (out, op0));
-      REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUIV, in, REG_NOTES (insn));
+      REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUIV, in, REG_NOTES (insn));
     }
 
 #ifdef SECONDARY_MEMORY_NEEDED