* alias.c: Change all uses of gen_rtx(FOO...) to gen_rtx_FOO;

change gen_rtx(expr...) to gen_rtx_fmt_foo(expr...).
* caller-save.c, calls.c, combine.c, cse.c: Likewise.
* dwarf2out.c, except.c, explow.c, expmed.c, expr.c: Likewise.
* final.c, flow.c, function.c, genpeep.c, haifa-sched.c: Likewise.
* halfpic.c, integrate.c, jump.c, local-alloc.c, loop.c: Likewise.
* profile.c, recog.c, reg-stack.c, regclass.c, regmove.c: Likewise.
* reload.c, reload1.c, reorg.c, sched.c, stmt.c, stupid.c: Likewise.
* unroll.c, varasm.c: Likewise.
* config/alpha/alpha.c, config/alpha/alpha.md: Likewise.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@17357 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 151 insertions, 147 deletions

diff --git a/gcc/expr.c b/gcc/expr.c
index c99d77945ff..05af3dac724 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -298,11 +298,11 @@ init_expr_once ()
   /* Try indexing by frame ptr and try by stack ptr.
      It is known that on the Convex the stack ptr isn't a valid index.
      With luck, one or the other is valid on any machine.  */
-  rtx mem = gen_rtx (MEM, VOIDmode, stack_pointer_rtx);
-  rtx mem1 = gen_rtx (MEM, VOIDmode, frame_pointer_rtx);
+  rtx mem = gen_rtx_MEM (VOIDmode, stack_pointer_rtx);
+  rtx mem1 = gen_rtx_MEM (VOIDmode, frame_pointer_rtx);
 
   start_sequence ();
-  insn = emit_insn (gen_rtx (SET, 0, NULL_RTX, NULL_RTX));
+  insn = emit_insn (gen_rtx_SET (0, NULL_RTX, NULL_RTX));
   pat = PATTERN (insn);
 
   for (mode = VOIDmode; (int) mode < NUM_MACHINE_MODES;
@@ -327,7 +327,7 @@ init_expr_once ()
 	    if (! HARD_REGNO_MODE_OK (regno, mode))
 	      continue;
 
-	    reg = gen_rtx (REG, mode, regno);
+	    reg = gen_rtx_REG (mode, regno);
 
 	    SET_SRC (pat) = mem;
 	    SET_DEST (pat) = reg;
@@ -421,8 +421,9 @@ static rtx
 enqueue_insn (var, body)
      rtx var, body;
 {
-  pending_chain = gen_rtx (QUEUED, GET_MODE (var),
-			   var, NULL_RTX, NULL_RTX, body, pending_chain);
+  pending_chain = gen_rtx_QUEUED (GET_MODE (var),
+				  var, NULL_RTX, NULL_RTX, body,
+				  pending_chain);
   return pending_chain;
 }
 
@@ -465,7 +466,7 @@ protect_from_queue (x, modify)
 	  && GET_CODE (XEXP (x, 0)) == QUEUED && !modify)
 	{
 	  register rtx y = XEXP (x, 0);
-	  register rtx new = gen_rtx (MEM, GET_MODE (x), QUEUED_VAR (y));
+	  register rtx new = gen_rtx_MEM (GET_MODE (x), QUEUED_VAR (y));
 
 	  MEM_IN_STRUCT_P (new) = MEM_IN_STRUCT_P (x);
 	  RTX_UNCHANGING_P (new) = RTX_UNCHANGING_P (x);
@@ -892,7 +893,7 @@ convert_move (to, from, unsignedp)
 		   != CODE_FOR_nothing))
 	{
 	  if (GET_CODE (to) == REG)
-	    emit_insn (gen_rtx (CLOBBER, VOIDmode, to));
+	    emit_insn (gen_rtx_CLOBBER (VOIDmode, to));
 	  convert_move (gen_lowpart (word_mode, to), from, unsignedp);
 	  emit_unop_insn (code, to,
 			  gen_lowpart (word_mode, to), equiv_code);
@@ -962,7 +963,7 @@ convert_move (to, from, unsignedp)
       end_sequence ();
 
       emit_no_conflict_block (insns, to, from, NULL_RTX,
-			      gen_rtx (equiv_code, to_mode, copy_rtx (from)));
+			      gen_rtx_fmt_e (equiv_code, to_mode, copy_rtx (from)));
       return;
     }
 
@@ -1550,7 +1551,7 @@ move_by_pieces_1 (genfun, mode, data)
       if (data->reverse) data->offset -= size;
 
       to1 = (data->autinc_to
-	     ? gen_rtx (MEM, mode, data->to_addr)
+	     ? gen_rtx_MEM (mode, data->to_addr)
 	     : copy_rtx (change_address (data->to, mode,
 					 plus_constant (data->to_addr,
 							data->offset))));
@@ -1558,7 +1559,7 @@ move_by_pieces_1 (genfun, mode, data)
 
       from1
 	= (data->autinc_from
-	   ? gen_rtx (MEM, mode, data->from_addr)
+	   ? gen_rtx_MEM (mode, data->from_addr)
 	   : copy_rtx (change_address (data->from, mode,
 				       plus_constant (data->from_addr,
 						      data->offset))));
@@ -1722,7 +1723,7 @@ move_block_to_reg (regno, x, nregs, mode)
   if (HAVE_load_multiple)
     {
       last = get_last_insn ();
-      pat = gen_load_multiple (gen_rtx (REG, word_mode, regno), x,
+      pat = gen_load_multiple (gen_rtx_REG (word_mode, regno), x,
 			       GEN_INT (nregs));
       if (pat)
 	{
@@ -1735,7 +1736,7 @@ move_block_to_reg (regno, x, nregs, mode)
 #endif
 
   for (i = 0; i < nregs; i++)
-    emit_move_insn (gen_rtx (REG, word_mode, regno + i),
+    emit_move_insn (gen_rtx_REG (word_mode, regno + i),
 		    operand_subword_force (x, i, mode));
 }
 
@@ -1761,7 +1762,7 @@ move_block_from_reg (regno, x, nregs, size)
       && (mode = mode_for_size (size * BITS_PER_UNIT, MODE_INT, 0)) != BLKmode)
     {
       emit_move_insn (change_address (x, mode, NULL),
-		      gen_rtx (REG, mode, regno));
+		      gen_rtx_REG (mode, regno));
       return;
     }
     
@@ -1777,7 +1778,7 @@ move_block_from_reg (regno, x, nregs, size)
 	abort ();
 
       shift = expand_shift (LSHIFT_EXPR, word_mode,
-			    gen_rtx (REG, word_mode, regno),
+			    gen_rtx_REG (word_mode, regno),
 			    build_int_2 ((UNITS_PER_WORD - size)
 					 * BITS_PER_UNIT, 0), NULL_RTX, 0);
       emit_move_insn (tem, shift);
@@ -1789,7 +1790,7 @@ move_block_from_reg (regno, x, nregs, size)
   if (HAVE_store_multiple)
     {
       last = get_last_insn ();
-      pat = gen_store_multiple (x, gen_rtx (REG, word_mode, regno),
+      pat = gen_store_multiple (x, gen_rtx_REG (word_mode, regno),
 				GEN_INT (nregs));
       if (pat)
 	{
@@ -1808,7 +1809,7 @@ move_block_from_reg (regno, x, nregs, size)
       if (tem == 0)
 	abort ();
 
-      emit_move_insn (tem, gen_rtx (REG, word_mode, regno + i));
+      emit_move_insn (tem, gen_rtx_REG (word_mode, regno + i));
     }
 }
 
@@ -1923,8 +1924,8 @@ use_reg (call_fusage, reg)
     abort();
 
   *call_fusage
-    = gen_rtx (EXPR_LIST, VOIDmode,
-	       gen_rtx (USE, VOIDmode, reg), *call_fusage);
+    = gen_rtx_EXPR_LIST (VOIDmode,
+			 gen_rtx_USE (VOIDmode, reg), *call_fusage);
 }
 
 /* Add USE expressions to *CALL_FUSAGE for each of NREGS consecutive regs,
@@ -1942,7 +1943,7 @@ use_regs (call_fusage, regno, nregs)
     abort ();
 
   for (i = 0; i < nregs; i++)
-    use_reg (call_fusage, gen_rtx (REG, reg_raw_mode[regno + i], regno + i));
+    use_reg (call_fusage, gen_rtx_REG (reg_raw_mode[regno + i], regno + i));
 }
 
 /* Add USE expressions to *CALL_FUSAGE for each REG contained in the
@@ -2075,7 +2076,7 @@ clear_by_pieces_1 (genfun, mode, data)
       if (data->reverse) data->offset -= size;
 
       to1 = (data->autinc_to
-	     ? gen_rtx (MEM, mode, data->to_addr)
+	     ? gen_rtx_MEM (mode, data->to_addr)
 	     : copy_rtx (change_address (data->to, mode,
 					 plus_constant (data->to_addr,
 							data->offset))));
@@ -2286,17 +2287,17 @@ emit_move_insn_1 (x, y)
 	     regardless of machine's endianness.  */
 #ifdef STACK_GROWS_DOWNWARD
 	  emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
-		     (gen_rtx (MEM, submode, (XEXP (x, 0))),
+		     (gen_rtx_MEM (submode, (XEXP (x, 0))),
 		      gen_imagpart (submode, y)));
 	  emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
-		     (gen_rtx (MEM, submode, (XEXP (x, 0))),
+		     (gen_rtx_MEM (submode, (XEXP (x, 0))),
 		      gen_realpart (submode, y)));
 #else
 	  emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
-		     (gen_rtx (MEM, submode, (XEXP (x, 0))),
+		     (gen_rtx_MEM (submode, (XEXP (x, 0))),
 		      gen_realpart (submode, y)));
 	  emit_insn (GEN_FCN (mov_optab->handlers[(int) submode].insn_code)
-		     (gen_rtx (MEM, submode, (XEXP (x, 0))),
+		     (gen_rtx_MEM (submode, (XEXP (x, 0))),
 		      gen_imagpart (submode, y)));
 #endif
 	}
@@ -2332,7 +2333,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));
 
       for (i = 0;
 	   i < (GET_MODE_SIZE (mode)  + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
@@ -2405,10 +2406,10 @@ push_block (size, extra, below)
     temp = plus_constant (virtual_outgoing_args_rtx,
 			  - INTVAL (size) - (below ? 0 : extra));
   else if (extra != 0 && !below)
-    temp = gen_rtx (PLUS, Pmode, virtual_outgoing_args_rtx,
+    temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
 		    negate_rtx (Pmode, plus_constant (size, extra)));
   else
-    temp = gen_rtx (PLUS, Pmode, virtual_outgoing_args_rtx,
+    temp = gen_rtx_PLUS (Pmode, virtual_outgoing_args_rtx,
 		    negate_rtx (Pmode, size));
 #endif
 
@@ -2418,7 +2419,7 @@ push_block (size, extra, below)
 rtx
 gen_push_operand ()
 {
-  return gen_rtx (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
+  return gen_rtx_fmt_e (STACK_PUSH_CODE, Pmode, stack_pointer_rtx);
 }
 
 /* Return an rtx for the address of the beginning of a as-if-it-was-pushed
@@ -2431,9 +2432,9 @@ get_push_address (size)
   register rtx temp;
 
   if (STACK_PUSH_CODE == POST_DEC)
-    temp = gen_rtx (PLUS, Pmode, stack_pointer_rtx, GEN_INT (size));
+    temp = gen_rtx_PLUS (Pmode, stack_pointer_rtx, GEN_INT (size));
   else if (STACK_PUSH_CODE == POST_INC)
-    temp = gen_rtx (MINUS, Pmode, stack_pointer_rtx, GEN_INT (size));
+    temp = gen_rtx_MINUS (Pmode, stack_pointer_rtx, GEN_INT (size));
   else
     temp = stack_pointer_rtx;
 
@@ -2557,7 +2558,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
 	      && where_pad != none && where_pad != stack_direction)
 	    anti_adjust_stack (GEN_INT (extra));
 
-	  move_by_pieces (gen_rtx (MEM, BLKmode, gen_push_operand ()), xinner,
+	  move_by_pieces (gen_rtx_MEM (BLKmode, gen_push_operand ()), xinner,
 			  INTVAL (size) - used, align);
 
 	  if (flag_check_memory_usage && ! in_check_memory_usage)
@@ -2613,8 +2614,9 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
 						  skip + INTVAL (args_so_far)));
 	  else
 	    temp = memory_address (BLKmode,
-				   plus_constant (gen_rtx (PLUS, Pmode,
-							   args_addr, args_so_far),
+				   plus_constant (gen_rtx_PLUS (Pmode,
+								args_addr,
+								args_so_far),
 						  skip));
 	  if (flag_check_memory_usage && ! in_check_memory_usage)
 	    {
@@ -2641,7 +2643,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
 	      && (move_by_pieces_ninsns ((unsigned) INTVAL (size), align)
 		  < MOVE_RATIO))
 	    {
-	      move_by_pieces (gen_rtx (MEM, BLKmode, temp), xinner,
+	      move_by_pieces (gen_rtx_MEM (BLKmode, temp), xinner,
 			      INTVAL (size), align);
 	      goto ret;
 	    }
@@ -2654,7 +2656,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
 	      && ((unsigned) INTVAL (size)
 		  < (1 << (GET_MODE_BITSIZE (QImode) - 1))))
 	    {
-	      rtx pat = gen_movstrqi (gen_rtx (MEM, BLKmode, temp),
+	      rtx pat = gen_movstrqi (gen_rtx_MEM (BLKmode, temp),
 				      xinner, size, GEN_INT (align));
 	      if (pat != 0)
 		{
@@ -2669,7 +2671,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
 	      && ((unsigned) INTVAL (size)
 		  < (1 << (GET_MODE_BITSIZE (HImode) - 1))))
 	    {
-	      rtx pat = gen_movstrhi (gen_rtx (MEM, BLKmode, temp),
+	      rtx pat = gen_movstrhi (gen_rtx_MEM (BLKmode, temp),
 				      xinner, size, GEN_INT (align));
 	      if (pat != 0)
 		{
@@ -2681,7 +2683,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
 #ifdef HAVE_movstrsi
 	  if (HAVE_movstrsi)
 	    {
-	      rtx pat = gen_movstrsi (gen_rtx (MEM, BLKmode, temp),
+	      rtx pat = gen_movstrsi (gen_rtx_MEM (BLKmode, temp),
 				      xinner, size, GEN_INT (align));
 	      if (pat != 0)
 		{
@@ -2693,7 +2695,7 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
 #ifdef HAVE_movstrdi
 	  if (HAVE_movstrdi)
 	    {
-	      rtx pat = gen_movstrdi (gen_rtx (MEM, BLKmode, temp),
+	      rtx pat = gen_movstrdi (gen_rtx_MEM (BLKmode, temp),
 				      xinner, size, GEN_INT (align));
 	      if (pat != 0)
 		{
@@ -2821,12 +2823,12 @@ emit_push_insn (x, mode, type, size, align, partial, reg, extra,
 				plus_constant (args_addr, 
 					       INTVAL (args_so_far)));
           else
-	    addr = memory_address (mode, gen_rtx (PLUS, Pmode, args_addr,
-						  args_so_far));
+	    addr = memory_address (mode, gen_rtx_PLUS (Pmode, args_addr,
+						       args_so_far));
 	  target = addr;
 	}
 
-      emit_move_insn (gen_rtx (MEM, mode, addr), x);
+      emit_move_insn (gen_rtx_MEM (mode, addr), x);
 
       if (flag_check_memory_usage && ! in_check_memory_usage)
 	{
@@ -2949,8 +2951,8 @@ expand_assignment (to, from, want_value, suggest_reg)
 	  if (GET_CODE (to_rtx) != MEM)
 	    abort ();
 	  to_rtx = change_address (to_rtx, VOIDmode,
-				   gen_rtx (PLUS, ptr_mode, XEXP (to_rtx, 0),
-					    force_reg (ptr_mode, offset_rtx)));
+				   gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
+						 force_reg (ptr_mode, offset_rtx)));
 	}
       if (volatilep)
 	{
@@ -3627,7 +3629,7 @@ store_constructor (exp, target, cleared)
       /* Inform later passes that the whole union value is dead.  */
       if (TREE_CODE (type) == UNION_TYPE
 	  || TREE_CODE (type) == QUAL_UNION_TYPE)
-	emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
+	emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
 
       /* If we are building a static constructor into a register,
 	 set the initial value as zero so we can fold the value into
@@ -3657,7 +3659,7 @@ store_constructor (exp, target, cleared)
 	}
       else
 	/* Inform later passes that the old value is dead.  */
-	emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
+	emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
 
       /* Store each element of the constructor into
 	 the corresponding field of TARGET.  */
@@ -3716,7 +3718,7 @@ store_constructor (exp, target, cleared)
 
 	      to_rtx
 		= change_address (to_rtx, VOIDmode,
-				  gen_rtx (PLUS, ptr_mode, XEXP (to_rtx, 0),
+				  gen_rtx_PLUS (ptr_mode, XEXP (to_rtx, 0),
 					   force_reg (ptr_mode, offset_rtx)));
 	    }
 	  if (TREE_READONLY (field))
@@ -3793,7 +3795,7 @@ store_constructor (exp, target, cleared)
 	}
       else
 	/* Inform later passes that the old value is dead.  */
-	emit_insn (gen_rtx (CLOBBER, VOIDmode, target));
+	emit_insn (gen_rtx_CLOBBER (VOIDmode, target));
 
       /* Store each element of the constructor into
 	 the corresponding element of TARGET, determined
@@ -3879,7 +3881,7 @@ store_constructor (exp, target, cleared)
 						     TYPE_MIN_VALUE (domain)),
 					 position);
 		  pos_rtx = expand_expr (position, 0, VOIDmode, 0);
-		  addr = gen_rtx (PLUS, Pmode, XEXP (target, 0), pos_rtx);
+		  addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
 		  xtarget = change_address (target, mode, addr);
 		  if (TREE_CODE (value) == CONSTRUCTOR)
 		    store_constructor (value, xtarget, cleared);
@@ -3899,7 +3901,7 @@ store_constructor (exp, target, cleared)
 		  /* Needed by stupid register allocation. to extend the
 		     lifetime of pseudo-regs used by target past the end
 		     of the loop.  */
-		  emit_insn (gen_rtx (USE, GET_MODE (target), target));
+		  emit_insn (gen_rtx_USE (GET_MODE (target), target));
 		}
 	    }
 	  else if ((index != 0 && TREE_CODE (index) != INTEGER_CST)
@@ -3918,7 +3920,7 @@ store_constructor (exp, target, cleared)
 				     size_int (BITS_PER_UNIT));
 	      position = size_binop (MULT_EXPR, index, position);
 	      pos_rtx = expand_expr (position, 0, VOIDmode, 0);
-	      addr = gen_rtx (PLUS, Pmode, XEXP (target, 0), pos_rtx);
+	      addr = gen_rtx_PLUS (Pmode, XEXP (target, 0), pos_rtx);
 	      xtarget = change_address (target, mode, addr);
 	      store_expr (value, xtarget, 0);
 	    }
@@ -4103,7 +4105,7 @@ store_constructor (exp, target, cleared)
 	  else
 #endif
 	    {
-	      emit_library_call (gen_rtx (SYMBOL_REF, Pmode, "__setbits"),
+	      emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__setbits"),
 				 0, VOIDmode, 4, XEXP (targetx, 0), Pmode,
 				 bitlength_rtx, TYPE_MODE (sizetype),
 				 startbit_rtx, TYPE_MODE (sizetype),
@@ -4997,15 +4999,16 @@ expand_expr (exp, target, tmode, modifier)
 	    push_obstacks (p->function_obstack,
 			   p->function_maybepermanent_obstack);
 
-	    p->forced_labels = gen_rtx (EXPR_LIST, VOIDmode,
-					label_rtx (exp), p->forced_labels);
+	    p->forced_labels = gen_rtx_EXPR_LIST (VOIDmode,
+						  label_rtx (exp),
+						  p->forced_labels);
 	    pop_obstacks ();
 	  }
 	else if (modifier == EXPAND_INITIALIZER)
-	  forced_labels = gen_rtx (EXPR_LIST, VOIDmode,
-				   label_rtx (exp), forced_labels);
-	temp = gen_rtx (MEM, FUNCTION_MODE,
-			gen_rtx (LABEL_REF, Pmode, label_rtx (exp)));
+	  forced_labels = gen_rtx_EXPR_LIST (VOIDmode,
+					     label_rtx (exp), forced_labels);
+	temp = gen_rtx_MEM (FUNCTION_MODE,
+			    gen_rtx_LABEL_REF (Pmode, label_rtx (exp)));
 	if (function != current_function_decl
 	    && function != inline_function_decl && function != 0)
 	  LABEL_REF_NONLOCAL_P (XEXP (temp, 0)) = 1;
@@ -5099,8 +5102,8 @@ expand_expr (exp, target, tmode, modifier)
 	    abort ();
 	  addr = XEXP (DECL_RTL (exp), 0);
 	  if (GET_CODE (addr) == MEM)
-	    addr = gen_rtx (MEM, Pmode,
-			    fix_lexical_addr (XEXP (addr, 0), exp));
+	    addr = gen_rtx_MEM (Pmode,
+				fix_lexical_addr (XEXP (addr, 0), exp));
 	  else
 	    addr = fix_lexical_addr (addr, exp);
 	  temp = change_address (DECL_RTL (exp), mode, addr);
@@ -5154,7 +5157,7 @@ expand_expr (exp, target, tmode, modifier)
 	      != promote_mode (type, DECL_MODE (exp), &unsignedp, 0))
 	    abort ();
 
-	  temp = gen_rtx (SUBREG, mode, DECL_RTL (exp), 0);
+	  temp = gen_rtx_SUBREG (mode, DECL_RTL (exp), 0);
 	  SUBREG_PROMOTED_VAR_P (temp) = 1;
 	  SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
 	  return temp;
@@ -5245,8 +5248,8 @@ expand_expr (exp, target, tmode, modifier)
 
 	  SAVE_EXPR_RTL (exp) = temp;
 	  if (!optimize && GET_CODE (temp) == REG)
-	    save_expr_regs = gen_rtx (EXPR_LIST, VOIDmode, temp,
-				      save_expr_regs);
+	    save_expr_regs = gen_rtx_EXPR_LIST (VOIDmode, temp,
+						save_expr_regs);
 
 	  /* If the mode of TEMP does not match that of the expression, it
 	     must be a promoted value.  We pass store_expr a SUBREG of the
@@ -5256,7 +5259,7 @@ expand_expr (exp, target, tmode, modifier)
 
 	  if (GET_CODE (temp) == REG && GET_MODE (temp) != mode)
 	    {
-	      temp = gen_rtx (SUBREG, mode, SAVE_EXPR_RTL (exp), 0);
+	      temp = gen_rtx_SUBREG (mode, SAVE_EXPR_RTL (exp), 0);
 	      SUBREG_PROMOTED_VAR_P (temp) = 1;
 	      SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
 	    }
@@ -5277,7 +5280,7 @@ expand_expr (exp, target, tmode, modifier)
 	{
 	  /* Compute the signedness and make the proper SUBREG.  */
 	  promote_mode (type, mode, &unsignedp, 0);
-	  temp = gen_rtx (SUBREG, mode, SAVE_EXPR_RTL (exp), 0);
+	  temp = gen_rtx_SUBREG (mode, SAVE_EXPR_RTL (exp), 0);
 	  SUBREG_PROMOTED_VAR_P (temp) = 1;
 	  SUBREG_PROMOTED_UNSIGNED_P (temp) = unsignedp;
 	  return temp;
@@ -5524,7 +5527,7 @@ expand_expr (exp, target, tmode, modifier)
 	      }
 	  }
 
-	temp = gen_rtx (MEM, mode, op0);
+	temp = gen_rtx_MEM (mode, op0);
 	/* If address was computed by addition,
 	   mark this as an element of an aggregate.  */
 	if (TREE_CODE (TREE_OPERAND (exp, 0)) == PLUS_EXPR
@@ -5752,8 +5755,8 @@ expand_expr (exp, target, tmode, modifier)
 #endif
 
 	    op0 = change_address (op0, VOIDmode,
-				  gen_rtx (PLUS, ptr_mode, XEXP (op0, 0),
-					   force_reg (ptr_mode, offset_rtx)));
+				  gen_rtx_PLUS (ptr_mode, XEXP (op0, 0),
+						force_reg (ptr_mode, offset_rtx)));
 	  }
 
 	/* Don't forget about volatility even if this is a bitfield.  */
@@ -5880,8 +5883,8 @@ expand_expr (exp, target, tmode, modifier)
 	/* Get a reference to just this component.  */
 	if (modifier == EXPAND_CONST_ADDRESS
 	    || modifier == EXPAND_SUM || modifier == EXPAND_INITIALIZER)
-	  op0 = gen_rtx (MEM, mode1, plus_constant (XEXP (op0, 0),
-						    (bitpos / BITS_PER_UNIT)));
+	  op0 = gen_rtx_MEM (mode1, plus_constant (XEXP (op0, 0),
+						   (bitpos / BITS_PER_UNIT)));
 	else
 	  op0 = change_address (op0, mode1,
 				plus_constant (XEXP (op0, 0),
@@ -5999,7 +6002,7 @@ expand_expr (exp, target, tmode, modifier)
 
 	/* Extract the bit we want to examine */
 	bit = expand_shift (RSHIFT_EXPR, byte_mode,
-			    gen_rtx (MEM, byte_mode, addr),
+			    gen_rtx_MEM (byte_mode, addr),
 			    make_tree (TREE_TYPE (index), rem),
 			    NULL_RTX, 1);
 	result = expand_binop (byte_mode, and_optab, bit, const1_rtx,
@@ -6121,7 +6124,7 @@ expand_expr (exp, target, tmode, modifier)
 			 op0, TREE_UNSIGNED (TREE_TYPE (TREE_OPERAND (exp, 0))));
 
       if (modifier == EXPAND_INITIALIZER)
-	return gen_rtx (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
+	return gen_rtx_fmt_e (unsignedp ? ZERO_EXTEND : SIGN_EXTEND, mode, op0);
 
       if (target == 0)
 	return
@@ -6244,9 +6247,9 @@ expand_expr (exp, target, tmode, modifier)
 	    op0 = temp;
 	  /* Ensure that MULT comes first if there is one.  */
 	  else if (GET_CODE (op0) == MULT)
-	    op0 = gen_rtx (PLUS, mode, op0, XEXP (op1, 0));
+	    op0 = gen_rtx_PLUS (mode, op0, XEXP (op1, 0));
 	  else
-	    op0 = gen_rtx (PLUS, mode, XEXP (op1, 0), op0);
+	    op0 = gen_rtx_PLUS (mode, XEXP (op1, 0), op0);
 
 	  /* Let's also eliminate constants from op0 if possible.  */
 	  op0 = eliminate_constant_term (op0, &constant_term);
@@ -6260,7 +6263,7 @@ expand_expr (exp, target, tmode, modifier)
 	  if (temp != 0)
 	    op1 = temp;
 	  else
-	    op1 = gen_rtx (PLUS, mode, constant_term, XEXP (op1, 1));
+	    op1 = gen_rtx_PLUS (mode, constant_term, XEXP (op1, 1));
 	}
 
       /* Put a constant term last and put a multiplication first.  */
@@ -6268,7 +6271,7 @@ expand_expr (exp, target, tmode, modifier)
 	temp = op1, op1 = op0, op0 = temp;
 
       temp = simplify_binary_operation (PLUS, mode, op0, op1);
-      return temp ? temp : gen_rtx (PLUS, mode, op0, op1);
+      return temp ? temp : gen_rtx_PLUS (mode, op0, op1);
 
     case MINUS_EXPR:
       /* For initializers, we are allowed to return a MINUS of two
@@ -6290,7 +6293,7 @@ expand_expr (exp, target, tmode, modifier)
 	  if (GET_CODE (op1) == CONST_INT)
 	    return plus_constant (op0, - INTVAL (op1));
 	  else
-	    return gen_rtx (MINUS, mode, op0, op1);
+	    return gen_rtx_MINUS (mode, op0, op1);
 	}
       /* Convert A - const to A + (-const).  */
       if (TREE_CODE (TREE_OPERAND (exp, 1)) == INTEGER_CST)
@@ -6347,9 +6350,9 @@ expand_expr (exp, target, tmode, modifier)
 	  /* Apply distributive law if OP0 is x+c.  */
 	  if (GET_CODE (op0) == PLUS
 	      && GET_CODE (XEXP (op0, 1)) == CONST_INT)
-	    return gen_rtx (PLUS, mode,
-			    gen_rtx (MULT, mode, XEXP (op0, 0),
-				     GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
+	    return gen_rtx_PLUS (mode,
+				 gen_rtx_MULT (mode, XEXP (op0, 0),
+					       GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1)))),
 			    GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))
 				     * INTVAL (XEXP (op0, 1))));
 
@@ -6358,8 +6361,8 @@ expand_expr (exp, target, tmode, modifier)
 	  if (GET_CODE (op0) != REG)
 	    op0 = copy_to_mode_reg (mode, op0);
 
-	  return gen_rtx (MULT, mode, op0,
-			  GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
+	  return gen_rtx_MULT (mode, op0,
+			       GEN_INT (TREE_INT_CST_LOW (TREE_OPERAND (exp, 1))));
 	}
 
       if (! safe_from_p (subtarget, TREE_OPERAND (exp, 1)))
@@ -7389,14 +7392,14 @@ expand_expr (exp, target, tmode, modifier)
     case POPDCC_EXPR:
       {
 	rtx dcc = get_dynamic_cleanup_chain ();
-	emit_move_insn (dcc, validize_mem (gen_rtx (MEM, Pmode, dcc)));
+	emit_move_insn (dcc, validize_mem (gen_rtx_MEM (Pmode, dcc)));
 	return const0_rtx;
       }
 
     case POPDHC_EXPR:
       {
 	rtx dhc = get_dynamic_handler_chain ();
-	emit_move_insn (dhc, validize_mem (gen_rtx (MEM, Pmode, dhc)));
+	emit_move_insn (dhc, validize_mem (gen_rtx_MEM (Pmode, dhc)));
 	return const0_rtx;
       }
 
@@ -8151,7 +8154,7 @@ expand_builtin_return_addr (fndecl_code, count, tem)
       tem = DYNAMIC_CHAIN_ADDRESS (tem);
 #endif
       tem = memory_address (Pmode, tem);
-      tem = copy_to_reg (gen_rtx (MEM, Pmode, tem));
+      tem = copy_to_reg (gen_rtx_MEM (Pmode, tem));
     }
 
   /* For __builtin_frame_address, return what we've got.  */
@@ -8165,7 +8168,7 @@ expand_builtin_return_addr (fndecl_code, count, tem)
 #else
   tem = memory_address (Pmode,
 			plus_constant (tem, GET_MODE_SIZE (Pmode)));
-  tem = gen_rtx (MEM, Pmode, tem);
+  tem = gen_rtx_MEM (Pmode, tem);
 #endif
   return tem;
 }
@@ -8215,22 +8218,22 @@ expand_builtin_setjmp (buf_addr, target)
   /* We store the frame pointer and the address of lab1 in the buffer
      and use the rest of it for the stack save area, which is
      machine-dependent.  */
-  emit_move_insn (gen_rtx (MEM, Pmode, buf_addr),
+  emit_move_insn (gen_rtx_MEM (Pmode, buf_addr),
 		  virtual_stack_vars_rtx);
   emit_move_insn
-    (validize_mem (gen_rtx (MEM, Pmode,
-			    plus_constant (buf_addr,
-					   GET_MODE_SIZE (Pmode)))),
-     gen_rtx (LABEL_REF, Pmode, lab1));
+    (validize_mem (gen_rtx_MEM (Pmode,
+				plus_constant (buf_addr,
+					       GET_MODE_SIZE (Pmode)))),
+     gen_rtx_LABEL_REF (Pmode, lab1));
 
 #ifdef HAVE_save_stack_nonlocal
   if (HAVE_save_stack_nonlocal)
     sa_mode = insn_operand_mode[(int) CODE_FOR_save_stack_nonlocal][0];
 #endif
 
-  stack_save = gen_rtx (MEM, sa_mode,
-			plus_constant (buf_addr,
-				       2 * GET_MODE_SIZE (Pmode)));
+  stack_save = gen_rtx_MEM (sa_mode,
+			    plus_constant (buf_addr,
+					   2 * GET_MODE_SIZE (Pmode)));
   emit_stack_save (SAVE_NONLOCAL, &stack_save, NULL_RTX);
 
 #ifdef HAVE_setjmp
@@ -8246,11 +8249,11 @@ expand_builtin_setjmp (buf_addr, target)
 
   /* Note that setjmp clobbers FP when we get here, so we have to make
      sure it's marked as used by this function.  */
-  emit_insn (gen_rtx (USE, VOIDmode, hard_frame_pointer_rtx));
+  emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
 
   /* Mark the static chain as clobbered here so life information
      doesn't get messed up for it.  */
-  emit_insn (gen_rtx (CLOBBER, VOIDmode, static_chain_rtx));
+  emit_insn (gen_rtx_CLOBBER (VOIDmode, static_chain_rtx));
 
   /* Now put in the code to restore the frame pointer, and argument
      pointer, if needed.  The code below is from expand_end_bindings
@@ -8303,13 +8306,13 @@ expand_builtin_setjmp (buf_addr, target)
   op0 = memory_address (FUNCTION_MODE, op0);
 
   INIT_CUMULATIVE_ARGS (args_so_far, NULL_TREE,
-			gen_rtx (SYMBOL_REF, Pmode, "__dummy"), 1);
+			gen_rtx_SYMBOL_REF (Pmode, "__dummy"), 1);
   next_arg_reg = FUNCTION_ARG (args_so_far, VOIDmode, void_type_node, 1);
 
 #ifndef ACCUMULATE_OUTGOING_ARGS
 #ifdef HAVE_call_pop
   if (HAVE_call_pop)
-    emit_call_insn (gen_call_pop (gen_rtx (MEM, FUNCTION_MODE, op0),
+    emit_call_insn (gen_call_pop (gen_rtx_MEM (FUNCTION_MODE, op0),
 				  const0_rtx, next_arg_reg,
 				  GEN_INT (return_pops)));
   else
@@ -8318,7 +8321,7 @@ expand_builtin_setjmp (buf_addr, target)
 
 #ifdef HAVE_call
     if (HAVE_call)
-      emit_call_insn (gen_call (gen_rtx (MEM, FUNCTION_MODE, op0),
+      emit_call_insn (gen_call (gen_rtx_MEM (FUNCTION_MODE, op0),
 				const0_rtx, next_arg_reg, const0_rtx));
     else
 #endif
@@ -8448,7 +8451,7 @@ expand_builtin (exp, target, subtarget, mode, ignore)
 	    rtx errno_rtx = GEN_ERRNO_RTX;
 #else
 	    rtx errno_rtx
-	      = gen_rtx (MEM, word_mode, gen_rtx (SYMBOL_REF, Pmode, "errno"));
+	      = gen_rtx_MEM (word_mode, gen_rtx_SYMBOL_REF (Pmode, "errno"));
 #endif
 
 	    emit_move_insn (errno_rtx, GEN_INT (TARGET_EDOM));
@@ -8919,7 +8922,7 @@ expand_builtin (exp, target, subtarget, mode, ignore)
 	    char_rtx = copy_to_mode_reg (char_mode, char_rtx);
 
 	  emit_insn (GEN_FCN (icode) (result,
-				      gen_rtx (MEM, BLKmode, src_rtx),
+				      gen_rtx_MEM (BLKmode, src_rtx),
 				      char_rtx, GEN_INT (align)));
 
 	  /* Return the value in the proper mode for this function.  */
@@ -8997,16 +9000,16 @@ expand_builtin (exp, target, subtarget, mode, ignore)
 	    }
 
 	  dest_rtx = expand_expr (dest, NULL_RTX, ptr_mode, EXPAND_SUM);
-	  dest_mem = gen_rtx (MEM, BLKmode,
-			      memory_address (BLKmode, dest_rtx));
+	  dest_mem = gen_rtx_MEM (BLKmode,
+				  memory_address (BLKmode, dest_rtx));
 	  /* There could be a void* cast on top of the object.  */
 	  while (TREE_CODE (dest) == NOP_EXPR)
 	    dest = TREE_OPERAND (dest, 0);
 	  type = TREE_TYPE (TREE_TYPE (dest));
 	  MEM_IN_STRUCT_P (dest_mem) = AGGREGATE_TYPE_P (type);
 	  src_rtx = expand_expr (src, NULL_RTX, ptr_mode, EXPAND_SUM);
-	  src_mem = gen_rtx (MEM, BLKmode,
-			     memory_address (BLKmode, src_rtx));
+	  src_mem = gen_rtx_MEM (BLKmode,
+				 memory_address (BLKmode, src_rtx));
 	  len_rtx = expand_expr (len, NULL_RTX, VOIDmode, 0);
 
 	  /* Just copy the rights of SRC to the rights of DEST.  */
@@ -9077,8 +9080,8 @@ expand_builtin (exp, target, subtarget, mode, ignore)
 	    break;
 
 	  dest_rtx = expand_expr (dest, NULL_RTX, ptr_mode, EXPAND_SUM);
-	  dest_mem = gen_rtx (MEM, BLKmode,
-			      memory_address (BLKmode, dest_rtx));
+	  dest_mem = gen_rtx_MEM (BLKmode,
+				  memory_address (BLKmode, dest_rtx));
 	   
 	  /* Just check DST is writable and mark it as readable.  */
 	  if (flag_check_memory_usage)
@@ -9211,14 +9214,14 @@ expand_builtin (exp, target, subtarget, mode, ignore)
 	  result = gen_reg_rtx (insn_mode);
 
 	emit_insn (gen_cmpstrsi (result,
-				 gen_rtx (MEM, BLKmode,
-					  expand_expr (arg1, NULL_RTX,
-						       ptr_mode,
-						       EXPAND_NORMAL)),
-				 gen_rtx (MEM, BLKmode,
-					  expand_expr (arg2, NULL_RTX,
-						       ptr_mode,
-						       EXPAND_NORMAL)),
+				 gen_rtx_MEM (BLKmode,
+					      expand_expr (arg1, NULL_RTX,
+							   ptr_mode,
+							   EXPAND_NORMAL)),
+				 gen_rtx_MEM (BLKmode,
+					      expand_expr (arg2, NULL_RTX,
+							   ptr_mode,
+							   EXPAND_NORMAL)),
 				 expand_expr (len, NULL_RTX, VOIDmode, 0),
 				 GEN_INT (MIN (arg1_align, arg2_align))));
 
@@ -9276,9 +9279,10 @@ expand_builtin (exp, target, subtarget, mode, ignore)
 					   NULL_RTX,
 					   VOIDmode, 0));
 #endif
-	rtx fp = gen_rtx (MEM, Pmode, buf_addr);
-	rtx lab = gen_rtx (MEM, Pmode,
-			   plus_constant (buf_addr, GET_MODE_SIZE (Pmode)));
+	rtx fp = gen_rtx_MEM (Pmode, buf_addr);
+	rtx lab = gen_rtx_MEM (Pmode,
+			       plus_constant (buf_addr,
+					      GET_MODE_SIZE (Pmode)));
 	enum machine_mode sa_mode
 #ifdef HAVE_save_stack_nonlocal
 	  = (HAVE_save_stack_nonlocal
@@ -9287,9 +9291,9 @@ expand_builtin (exp, target, subtarget, mode, ignore)
 #else
 	= Pmode;
 #endif
-	rtx stack = gen_rtx (MEM, sa_mode,
-			     plus_constant (buf_addr,
-					    2 * GET_MODE_SIZE (Pmode)));
+	rtx stack = gen_rtx_MEM (sa_mode,
+				 plus_constant (buf_addr,
+						2 * GET_MODE_SIZE (Pmode)));
 
 	DECL_EXTERNAL (dummy_decl) = 1;
 	TREE_PUBLIC (dummy_decl) = 1;
@@ -9317,9 +9321,9 @@ expand_builtin (exp, target, subtarget, mode, ignore)
 	  /* Put in the static chain register the address of the dummy
 	     function.  */
 	  emit_move_insn (static_chain_rtx, XEXP (DECL_RTL (dummy_decl), 0));
-	  emit_insn (gen_rtx (USE, VOIDmode, hard_frame_pointer_rtx));
-	  emit_insn (gen_rtx (USE, VOIDmode, stack_pointer_rtx));
-	  emit_insn (gen_rtx (USE, VOIDmode, static_chain_rtx));
+	  emit_insn (gen_rtx_USE (VOIDmode, hard_frame_pointer_rtx));
+	  emit_insn (gen_rtx_USE (VOIDmode, stack_pointer_rtx));
+	  emit_insn (gen_rtx_USE (VOIDmode, static_chain_rtx));
 	  emit_indirect_jump (lab);
 	}
 
@@ -9550,15 +9554,15 @@ result_vector (savep, result)
 	align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
 	if (size % align != 0)
 	  size = CEIL (size, align) * align;
-	reg = gen_rtx (REG, mode, savep ? regno : INCOMING_REGNO (regno));
+	reg = gen_rtx_REG (mode, savep ? regno : INCOMING_REGNO (regno));
 	mem = change_address (result, mode,
 			      plus_constant (XEXP (result, 0), size));
 	savevec[nelts++] = (savep
-			    ? gen_rtx (SET, VOIDmode, mem, reg)
-			    : gen_rtx (SET, VOIDmode, reg, mem));
+			    ? gen_rtx_SET (VOIDmode, mem, reg)
+			    : gen_rtx_SET (VOIDmode, reg, mem));
 	size += GET_MODE_SIZE (mode);
       }
-  return gen_rtx (PARALLEL, VOIDmode, gen_rtvec_v (nelts, savevec));
+  return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (nelts, savevec));
 }
 #endif /* HAVE_untyped_call or HAVE_untyped_return */
 
@@ -9591,13 +9595,13 @@ expand_builtin_apply_args ()
 	if (size % align != 0)
 	  size = CEIL (size, align) * align;
 
-	tem = gen_rtx (REG, mode, INCOMING_REGNO (regno));
+	tem = gen_rtx_REG (mode, INCOMING_REGNO (regno));
 
 #ifdef STACK_REGS
         /* For reg-stack.c's stack register household.
 	   Compare with a similar piece of code in function.c.  */
 
-        emit_insn (gen_rtx (USE, mode, tem));
+        emit_insn (gen_rtx_USE (mode, tem));
 #endif
 
 	emit_move_insn (change_address (registers, mode,
@@ -9648,7 +9652,7 @@ expand_builtin_apply (function, arguments, argsize)
   /* Fetch the arg pointer from the ARGUMENTS block.  */
   incoming_args = gen_reg_rtx (Pmode);
   emit_move_insn (incoming_args,
-		  gen_rtx (MEM, Pmode, arguments));
+		  gen_rtx_MEM (Pmode, arguments));
 #ifndef STACK_GROWS_DOWNWARD
   incoming_args = expand_binop (Pmode, sub_optab, incoming_args, argsize,
 				incoming_args, 0, OPTAB_LIB_WIDEN);
@@ -9674,14 +9678,14 @@ expand_builtin_apply (function, arguments, argsize)
      but it's likely that the source and/or destination addresses in
      the block copy will need updating in machine specific ways.  */
   dest = allocate_dynamic_stack_space (argsize, 0, 0);
-  emit_block_move (gen_rtx (MEM, BLKmode, dest),
-		   gen_rtx (MEM, BLKmode, incoming_args),
+  emit_block_move (gen_rtx_MEM (BLKmode, dest),
+		   gen_rtx_MEM (BLKmode, incoming_args),
 		   argsize,
 		   PARM_BOUNDARY / BITS_PER_UNIT);
 
   /* Refer to the argument block.  */
   apply_args_size ();
-  arguments = gen_rtx (MEM, BLKmode, arguments);
+  arguments = gen_rtx_MEM (BLKmode, arguments);
 
   /* Walk past the arg-pointer and structure value address.  */
   size = GET_MODE_SIZE (Pmode);
@@ -9696,7 +9700,7 @@ expand_builtin_apply (function, arguments, argsize)
 	align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
 	if (size % align != 0)
 	  size = CEIL (size, align) * align;
-	reg = gen_rtx (REG, mode, regno);
+	reg = gen_rtx_REG (mode, regno);
 	emit_move_insn (reg,
 			change_address (arguments, mode,
 					plus_constant (XEXP (arguments, 0),
@@ -9734,7 +9738,7 @@ expand_builtin_apply (function, arguments, argsize)
   /* Generate the actual call instruction and save the return value.  */
 #ifdef HAVE_untyped_call
   if (HAVE_untyped_call)
-    emit_call_insn (gen_untyped_call (gen_rtx (MEM, FUNCTION_MODE, function),
+    emit_call_insn (gen_untyped_call (gen_rtx_MEM (FUNCTION_MODE, function),
 				      result, result_vector (1, result)));
   else
 #endif
@@ -9752,11 +9756,11 @@ expand_builtin_apply (function, arguments, argsize)
 	  {
 	    if (valreg)
 	      abort (); /* HAVE_untyped_call required.  */
-	    valreg = gen_rtx (REG, mode, regno);
+	    valreg = gen_rtx_REG (mode, regno);
 	  }
 
       emit_call_insn (gen_call_value (valreg,
-				      gen_rtx (MEM, FUNCTION_MODE, function),
+				      gen_rtx_MEM (FUNCTION_MODE, function),
 				      const0_rtx, NULL_RTX, const0_rtx));
 
       emit_move_insn (change_address (result, GET_MODE (valreg),
@@ -9815,7 +9819,7 @@ expand_builtin_return (result)
   rtx call_fusage = 0;
 
   apply_result_size ();
-  result = gen_rtx (MEM, BLKmode, result);
+  result = gen_rtx_MEM (BLKmode, result);
 
 #ifdef HAVE_untyped_return
   if (HAVE_untyped_return)
@@ -9834,14 +9838,14 @@ expand_builtin_return (result)
 	align = GET_MODE_ALIGNMENT (mode) / BITS_PER_UNIT;
 	if (size % align != 0)
 	  size = CEIL (size, align) * align;
-	reg = gen_rtx (REG, mode, INCOMING_REGNO (regno));
+	reg = gen_rtx_REG (mode, INCOMING_REGNO (regno));
 	emit_move_insn (reg,
 			change_address (result, mode,
 					plus_constant (XEXP (result, 0),
 						       size)));
 
 	push_to_sequence (call_fusage);
-	emit_insn (gen_rtx (USE, VOIDmode, reg));
+	emit_insn (gen_rtx_USE (VOIDmode, reg));
 	call_fusage = get_insns ();
 	end_sequence ();
 	size += GET_MODE_SIZE (mode);
@@ -10994,7 +10998,7 @@ compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
 	
   emit_cmp_insn (op0, op1, code, size, mode, unsignedp, align);
 
-  return gen_rtx (code, VOIDmode, cc0_rtx, const0_rtx);
+  return gen_rtx_fmt_ee (code, VOIDmode, cc0_rtx, const0_rtx);
 }
 
 /* Generate code to calculate EXP using a store-flag instruction
@@ -11312,10 +11316,10 @@ do_tablejump (index, mode, range, table_label, default_label)
      GET_MODE_SIZE, because this indicates how large insns are.  The other
      uses should all be Pmode, because they are addresses.  This code
      could fail if addresses and insns are not the same size.  */
-  index = gen_rtx (PLUS, Pmode,
-		   gen_rtx (MULT, Pmode, index,
-			    GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
-		   gen_rtx (LABEL_REF, Pmode, table_label));
+  index = gen_rtx_PLUS (Pmode,
+			gen_rtx_MULT (Pmode, index,
+				      GEN_INT (GET_MODE_SIZE (CASE_VECTOR_MODE))),
+			gen_rtx_LABEL_REF (Pmode, table_label));
 #ifdef PIC_CASE_VECTOR_ADDRESS
   if (flag_pic)
     index = PIC_CASE_VECTOR_ADDRESS (index);
@@ -11323,7 +11327,7 @@ do_tablejump (index, mode, range, table_label, default_label)
 #endif
     index = memory_address_noforce (CASE_VECTOR_MODE, index);
   temp = gen_reg_rtx (CASE_VECTOR_MODE);
-  vector = gen_rtx (MEM, CASE_VECTOR_MODE, index);
+  vector = gen_rtx_MEM (CASE_VECTOR_MODE, index);
   RTX_UNCHANGING_P (vector) = 1;
   convert_move (temp, vector, 0);