*** empty log message ***

From-SVN: r1471

gcc/collect2.c

@@ -28,7 +28,6 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 #include <sys/types.h>
 #include <stdio.h>
-#include <string.h>
 #include <ctype.h>
 #include <errno.h>
 #include <signal.h>

gcc/combine.c

@@ -249,10 +249,10 @@ static short label_tick;
 
    If an entry is zero, it means that we don't know anything special.  */
 
-static int *reg_significant;
+static HOST_WIDE_INT *reg_significant;
 
 /* Mode used to compute significance in reg_significant.  It is the largest
-   integer mode that can fit in HOST_BITS_PER_INT.  */
+   integer mode that can fit in HOST_BITS_PER_WIDE_INT.  */
 
 static enum machine_mode significant_mode;
 
@@ -364,7 +364,7 @@ static rtx make_field_assignment ();
 static rtx make_compound_operation ();
 static rtx apply_distributive_law ();
 static rtx simplify_and_const_int ();
-static unsigned significant_bits ();
+static unsigned HOST_WIDE_INT significant_bits ();
 static int merge_outer_ops ();
 static rtx simplify_shift_const ();
 static int recog_for_combine ();
@@ -403,15 +403,15 @@ combine_instructions (f, nregs)
   reg_last_set_value = (rtx *) alloca (nregs * sizeof (rtx));
   reg_last_set_table_tick = (short *) alloca (nregs * sizeof (short));
   reg_last_set_label = (short *) alloca (nregs * sizeof (short));
-  reg_last_set_invalid = (char *) alloca (nregs * sizeof (short));
-  reg_significant = (int *) alloca (nregs * sizeof (int));
+  reg_last_set_invalid = (char *) alloca (nregs * sizeof (char));
+  reg_significant = (HOST_WIDE_INT *) alloca (nregs * sizeof (HOST_WIDE_INT));
 
   bzero (reg_last_death, nregs * sizeof (rtx));
   bzero (reg_last_set, nregs * sizeof (rtx));
   bzero (reg_last_set_value, nregs * sizeof (rtx));
   bzero (reg_last_set_table_tick, nregs * sizeof (short));
   bzero (reg_last_set_invalid, nregs * sizeof (char));
-  bzero (reg_significant, nregs * sizeof (int));
+  bzero (reg_significant, nregs * sizeof (HOST_WIDE_INT));
 
   init_recog_no_volatile ();
 
@@ -423,7 +423,7 @@ combine_instructions (f, nregs)
 
   uid_cuid = (int *) alloca ((i + 1) * sizeof (int));
 
-  significant_mode = mode_for_size (HOST_BITS_PER_INT, MODE_INT, 0);
+  significant_mode = mode_for_size (HOST_BITS_PER_WIDE_INT, MODE_INT, 0);
 
   /* Don't use reg_significant when computing it.  This can cause problems
      when, for example, we have j <<= 1 in a loop.  */
@@ -466,7 +466,7 @@ combine_instructions (f, nregs)
 	  /* Try this insn with each insn it links back to.  */
 
 	  for (links = LOG_LINKS (insn); links; links = XEXP (links, 1))
-	    if ((next = try_combine (insn, XEXP (links, 0), 0)) != 0)
+	    if ((next = try_combine (insn, XEXP (links, 0), NULL_RTX)) != 0)
 	      goto retry;
 
 	  /* Try each sequence of three linked insns ending with this one.  */
@@ -491,7 +491,7 @@ combine_instructions (f, nregs)
 	      && GET_CODE (prev) == INSN
 	      && sets_cc0_p (PATTERN (prev)))
 	    {
-	      if ((next = try_combine (insn, prev, 0)) != 0)
+	      if ((next = try_combine (insn, prev, NULL_RTX)) != 0)
 		goto retry;
 
 	      for (nextlinks = LOG_LINKS (prev); nextlinks;
@@ -509,7 +509,7 @@ combine_instructions (f, nregs)
 	      && GET_CODE (PATTERN (insn)) == SET
 	      && reg_mentioned_p (cc0_rtx, SET_SRC (PATTERN (insn))))
 	    {
-	      if ((next = try_combine (insn, prev, 0)) != 0)
+	      if ((next = try_combine (insn, prev, NULL_RTX)) != 0)
 		goto retry;
 
 	      for (nextlinks = LOG_LINKS (prev); nextlinks;
@@ -557,7 +557,7 @@ combine_instructions (f, nregs)
 }
 
 /* Called via note_stores.  If X is a pseudo that is used in more than
-   one basic block, is narrower that HOST_BITS_PER_INT, and is being
+   one basic block, is narrower that HOST_BITS_PER_WIDE_INT, and is being
    set, record what bits are significant.  If we are clobbering X,
    ignore this "set" because the clobbered value won't be used. 
 
@@ -574,7 +574,7 @@ set_significant (x, set)
       && REGNO (x) >= FIRST_PSEUDO_REGISTER
       && reg_n_sets[REGNO (x)] > 1
       && reg_basic_block[REGNO (x)] < 0
-      && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_INT)
+      && GET_MODE_BITSIZE (GET_MODE (x)) <= HOST_BITS_PER_WIDE_INT)
     {
       if (GET_CODE (set) == CLOBBER)
 	return;
@@ -700,14 +700,14 @@ can_combine_p (insn, i3, pred, succ, pdest, psrc)
       || GET_CODE (dest) == ZERO_EXTRACT || GET_CODE (dest) == STRICT_LOW_PART
       /* Don't combine with an insn that sets a register to itself if it has
 	 a REG_EQUAL note.  This may be part of a REG_NO_CONFLICT sequence.  */
-      || (rtx_equal_p (src, dest) && find_reg_note (insn, REG_EQUAL, 0))
+      || (rtx_equal_p (src, dest) && find_reg_note (insn, REG_EQUAL, NULL_RTX))
       /* Can't merge a function call.  */
       || GET_CODE (src) == CALL
       /* Don't substitute into an incremented register.  */
       || FIND_REG_INC_NOTE (i3, dest)
       || (succ && FIND_REG_INC_NOTE (succ, dest))
       /* Don't combine the end of a libcall into anything.  */
-      || find_reg_note (insn, REG_RETVAL, 0)
+      || find_reg_note (insn, REG_RETVAL, NULL_RTX)
       /* Make sure that DEST is not used after SUCC but before I3.  */
       || (succ && ! all_adjacent
 	  && reg_used_between_p (dest, succ, i3))
@@ -1006,7 +1006,7 @@ try_combine (i3, i2, i1)
   if (GET_RTX_CLASS (GET_CODE (i3)) != 'i'
       || GET_RTX_CLASS (GET_CODE (i2)) != 'i'
       || (i1 && GET_RTX_CLASS (GET_CODE (i1)) != 'i')
-      || find_reg_note (i3, REG_LIBCALL, 0))
+      || find_reg_note (i3, REG_LIBCALL, NULL_RTX))
     return 0;
 
   combine_attempts++;
@@ -1145,8 +1145,8 @@ try_combine (i3, i2, i1)
 #endif
 
   /* Verify that I2 and I1 are valid for combining.  */
-  if (! can_combine_p (i2, i3, i1, 0, &i2dest, &i2src)
-      || (i1 && ! can_combine_p (i1, i3, 0, i2, &i1dest, &i1src)))
+  if (! can_combine_p (i2, i3, i1, NULL_RTX, &i2dest, &i2src)
+      || (i1 && ! can_combine_p (i1, i3, NULL_RTX, i2, &i1dest, &i1src)))
     {
       undo_all ();
       return 0;
@@ -1350,7 +1350,8 @@ try_combine (i3, i2, i1)
 	 above (see detailed comments there) that ensures  that I1DEST
 	 isn't mentioned in any SETs in NEWPAT that are field assignments. */
 
-      if (! combinable_i3pat (0, &newpat, i1dest, 0, 0, 0))
+      if (! combinable_i3pat (NULL_RTX, &newpat, i1dest, NULL_RTX,
+			      0, NULL_PTR))
 	{
 	  undo_all ();
 	  return 0;
@@ -1363,9 +1364,9 @@ try_combine (i3, i2, i1)
 
   /* Fail if an autoincrement side-effect has been duplicated.  Be careful
      to count all the ways that I2SRC and I1SRC can be used.  */
-  if ((FIND_REG_INC_NOTE (i2, 0) != 0
+  if ((FIND_REG_INC_NOTE (i2, NULL_RTX) != 0
        && i2_is_used + added_sets_2 > 1)
-      || (i1 != 0 && FIND_REG_INC_NOTE (i1, 0) != 0
+      || (i1 != 0 && FIND_REG_INC_NOTE (i1, NULL_RTX) != 0
 	  && (n_occurrences + added_sets_1 + (added_sets_2 && ! i1_feeds_i3)
 	      > 1))
       /* Fail if we tried to make a new register (we used to abort, but there's
@@ -1575,8 +1576,7 @@ try_combine (i3, i2, i1)
 	      && GET_CODE (XEXP (*split, 1)) == CONST_INT
 	      && (i = exact_log2 (INTVAL (XEXP (*split, 1)))) >= 0)
 	    SUBST (*split, gen_rtx_combine (ASHIFT, GET_MODE (*split),
-					    XEXP (*split, 0),
-					    gen_rtx (CONST_INT, VOIDmode, i)));
+					    XEXP (*split, 0), GEN_INT (i)));
 
 #ifdef INSN_SCHEDULING
 	  /* If *SPLIT is a paradoxical SUBREG, when we split it, it should
@@ -1643,7 +1643,7 @@ try_combine (i3, i2, i1)
 	     that destination.  */
 
 	  PATTERN (i3) = newpat;
-	  distribute_links (gen_rtx (INSN_LIST, VOIDmode, i3, 0));
+	  distribute_links (gen_rtx (INSN_LIST, VOIDmode, i3, NULL_RTX));
 
 	  /* I3 now uses what used to be its destination and which is
 	     now I2's destination.  That means we need a LOG_LINK from
@@ -1747,7 +1747,7 @@ try_combine (i3, i2, i1)
 	}
 
       distribute_notes (new_other_notes, undobuf.other_insn,
-			undobuf.other_insn, 0, 0, 0);
+			undobuf.other_insn, NULL_RTX, NULL_RTX, NULL_RTX);
     }
 
   /* We now know that we can do this combination.  Merge the insns and 
@@ -1859,33 +1859,40 @@ try_combine (i3, i2, i1)
 
     /* Distribute all the LOG_LINKS and REG_NOTES from I1, I2, and I3.  */
     if (i3notes)
-      distribute_notes (i3notes, i3, i3, newi2pat ? i2 : 0, elim_i2, elim_i1);
+      distribute_notes (i3notes, i3, i3, newi2pat ? i2 : NULL_RTX,
+			elim_i2, elim_i1);
     if (i2notes)
-      distribute_notes (i2notes, i2, i3, newi2pat ? i2 : 0, elim_i2, elim_i1);
+      distribute_notes (i2notes, i2, i3, newi2pat ? i2 : NULL_RTX,
+			elim_i2, elim_i1);
     if (i1notes)
-      distribute_notes (i1notes, i1, i3, newi2pat ? i2 : 0, elim_i2, elim_i1);
+      distribute_notes (i1notes, i1, i3, newi2pat ? i2 : NULL_RTX,
+			elim_i2, elim_i1);
     if (midnotes)
-      distribute_notes (midnotes, 0, i3, newi2pat ? i2 : 0, elim_i2, elim_i1);
+      distribute_notes (midnotes, NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
+			elim_i2, elim_i1);
 
     /* Distribute any notes added to I2 or I3 by recog_for_combine.  We
        know these are REG_UNUSED and want them to go to the desired insn,
        so we always pass it as i3.  */
     if (newi2pat && new_i2_notes)
-      distribute_notes (new_i2_notes, i2, i2, 0, 0, 0);
+      distribute_notes (new_i2_notes, i2, i2, NULL_RTX, NULL_RTX, NULL_RTX);
     if (new_i3_notes)
-      distribute_notes (new_i3_notes, i3, i3, 0, 0, 0);
+      distribute_notes (new_i3_notes, i3, i3, NULL_RTX, NULL_RTX, NULL_RTX);
 
     /* If I3DEST was used in I3SRC, it really died in I3.  We may need to
        put a REG_DEAD note for it somewhere.  Similarly for I2 and I1.  */
     if (i3dest_killed)
-      distribute_notes (gen_rtx (EXPR_LIST, REG_DEAD, i3dest_killed, 0),
-			0, i3, newi2pat ? i2 : 0, 0, 0);
+      distribute_notes (gen_rtx (EXPR_LIST, REG_DEAD, i3dest_killed, NULL_RTX),
+			NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
+			NULL_RTX, NULL_RTX);
     if (i2dest_in_i2src)
-      distribute_notes (gen_rtx (EXPR_LIST, REG_DEAD, i2dest, 0),
-			0, i3, newi2pat ? i2 : 0, 0, 0);
+      distribute_notes (gen_rtx (EXPR_LIST, REG_DEAD, i2dest, NULL_RTX),
+			NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
+			NULL_RTX, NULL_RTX);
     if (i1dest_in_i1src)
-      distribute_notes (gen_rtx (EXPR_LIST, REG_DEAD, i1dest, 0),
-			0, i3, newi2pat ? i2 : 0, 0, 0);
+      distribute_notes (gen_rtx (EXPR_LIST, REG_DEAD, i1dest, NULL_RTX),
+			NULL_RTX, i3, newi2pat ? i2 : NULL_RTX,
+			NULL_RTX, NULL_RTX);
 
     distribute_links (i3links);
     distribute_links (i2links);
@@ -1899,7 +1906,7 @@ try_combine (i3, i2, i1)
 	   I2 set the register to a value that depended on its old
 	   contents, we will get confused.  If this insn is used, thing
 	   will be set correctly in combine_instructions.  */
-	record_value_for_reg (i2dest, 0, 0);
+	record_value_for_reg (i2dest, NULL_RTX, NULL_RTX);
 
 	/* If the reg formerly set in I2 died only once and that was in I3,
 	   zero its use count so it won't make `reload' do any work.  */
@@ -1908,22 +1915,22 @@ try_combine (i3, i2, i1)
 	    regno = REGNO (i2dest);
 	    reg_n_sets[regno]--;
 	    if (reg_n_sets[regno] == 0
-		&& ! (basic_block_live_at_start[0][regno / HOST_BITS_PER_INT]
-		      & (1 << (regno % HOST_BITS_PER_INT))))
+		&& ! (basic_block_live_at_start[0][regno / REGSET_ELT_BITS]
+		      & ((REGSET_ELT_TYPE) 1 << (regno % REGSET_ELT_BITS))))
 	      reg_n_refs[regno] = 0;
 	  }
       }
 
     if (i1 && GET_CODE (i1dest) == REG)
       {
-	record_value_for_reg (i1dest, 0, 0);
+	record_value_for_reg (i1dest, NULL_RTX, NULL_RTX);
 	regno = REGNO (i1dest);
 	if (! added_sets_1)
 	  {
 	    reg_n_sets[regno]--;
 	    if (reg_n_sets[regno] == 0
-		&& ! (basic_block_live_at_start[0][regno / HOST_BITS_PER_INT]
-		      & (1 << (regno % HOST_BITS_PER_INT))))
+		&& ! (basic_block_live_at_start[0][regno / REGSET_ELT_BITS]
+		      & ((REGSET_ELT_TYPE) 1 << (regno % REGSET_ELT_BITS))))
 	      reg_n_refs[regno] = 0;
 	  }
       }
@@ -2080,7 +2087,7 @@ find_split_point (loc)
 	 so, this is an IOR of an AND, so split it into that.  */
       if (GET_CODE (SET_DEST (x)) == ZERO_EXTRACT
 	  && (GET_MODE_BITSIZE (GET_MODE (XEXP (SET_DEST (x), 0)))
-	      <= HOST_BITS_PER_INT)
+	      <= HOST_BITS_PER_WIDE_INT)
 	  && GET_CODE (XEXP (SET_DEST (x), 1)) == CONST_INT
 	  && GET_CODE (XEXP (SET_DEST (x), 2)) == CONST_INT
 	  && GET_CODE (SET_SRC (x)) == CONST_INT
@@ -2094,7 +2101,7 @@ find_split_point (loc)
 	  int src = INTVAL (SET_SRC (x));
 	  rtx dest = XEXP (SET_DEST (x), 0);
 	  enum machine_mode mode = GET_MODE (dest);
-	  unsigned int mask = (1 << len) - 1;
+	  unsigned HOST_WIDE_INT mask = ((HOST_WIDE_INT) 1 << len) - 1;
 
 #if BITS_BIG_ENDIAN
 	  pos = GET_MODE_BITSIZE (mode) - len - pos;
@@ -2102,16 +2109,14 @@ find_split_point (loc)
 
 	  if (src == mask)
 	    SUBST (SET_SRC (x),
-		   gen_binary (IOR, mode, dest,
-			       gen_rtx (CONST_INT, VOIDmode, src << pos)));
+		   gen_binary (IOR, mode, dest, GEN_INT (src << pos)));
 	  else
 	    SUBST (SET_SRC (x),
 		   gen_binary (IOR, mode,
 			       gen_binary (AND, mode, dest, 
-					   gen_rtx (CONST_INT, VOIDmode,
-						    (~ (mask << pos)
-						     & GET_MODE_MASK (mode)))),
-			       gen_rtx (CONST_INT, VOIDmode, src << pos)));
+					   GEN_INT (~ (mask << pos)
+						    & GET_MODE_MASK (mode))),
+			       GEN_INT (src << pos)));
 
 	  SUBST (SET_DEST (x), dest);
 
@@ -2154,15 +2159,15 @@ find_split_point (loc)
 	{
 	  enum machine_mode mode = GET_MODE (SET_SRC (x));
 
-	  if (unsignedp && len < HOST_BITS_PER_INT)
+	  if (unsignedp && len < HOST_BITS_PER_WIDE_INT)
 	    {
 	      SUBST (SET_SRC (x),
 		     gen_rtx_combine
 		     (AND, mode,
 		      gen_rtx_combine (LSHIFTRT, mode,
 				       gen_lowpart_for_combine (mode, inner),
-				       gen_rtx (CONST_INT, VOIDmode, pos)),
-		      gen_rtx (CONST_INT, VOIDmode, (1 << len) - 1)));
+				       GEN_INT (pos)),
+		      GEN_INT (((HOST_WIDE_INT) 1 << len) - 1)));
 
 	      split = find_split_point (&SET_SRC (x));
 	      if (split && split != &SET_SRC (x))
@@ -2175,11 +2180,9 @@ find_split_point (loc)
 		     (ASHIFTRT, mode,
 		      gen_rtx_combine (ASHIFT, mode,
 				       gen_lowpart_for_combine (mode, inner),
-				       gen_rtx (CONST_INT, VOIDmode,
-						(GET_MODE_BITSIZE (mode)
-						 - len - pos))),
-		      gen_rtx (CONST_INT, VOIDmode,
-			       GET_MODE_BITSIZE (mode) - len)));
+				       GEN_INT (GET_MODE_BITSIZE (mode)
+						- len - pos)),
+		      GEN_INT (GET_MODE_BITSIZE (mode) - len)));
 
 	      split = find_split_point (&SET_SRC (x));
 	      if (split && split != &SET_SRC (x))
@@ -2663,9 +2666,10 @@ subst (x, from, to, in_dest, unique_copy)
 	 of the AND.  Otherwise, it is the resulting expression.  */
       if (GET_MODE_SIZE (mode) < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
 	  && subreg_lowpart_p (x)
-	  && GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) <= HOST_BITS_PER_INT)
+	  && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
+	      <= HOST_BITS_PER_WIDE_INT))
 	{
-	  temp = simplify_and_const_int (0, GET_MODE (SUBREG_REG (x)),
+	  temp = simplify_and_const_int (NULL_RTX, GET_MODE (SUBREG_REG (x)),
 					 SUBREG_REG (x), GET_MODE_MASK (mode));
 	  if (GET_CODE (temp) == AND && GET_CODE (XEXP (temp, 1)) == CONST_INT
 	      && INTVAL (XEXP (temp, 1)) == GET_MODE_MASK (mode))
@@ -2746,9 +2750,8 @@ subst (x, from, to, in_dest, unique_copy)
 	 if (GET_CODE (in2) == NOT)
 	   in2 = XEXP (in2, 0);
  	 else if (GET_CODE (in2) == CONST_INT
-		  && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT)
-	   in2 = gen_rtx (CONST_INT, VOIDmode,
-			  GET_MODE_MASK (mode) & ~ INTVAL (in2));
+		  && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
+	   in2 = GEN_INT (GET_MODE_MASK (mode) & ~ INTVAL (in2));
 	 else
 	   in2 = gen_rtx_combine (NOT, GET_MODE (in2), in2);
 
@@ -2851,8 +2854,8 @@ subst (x, from, to, in_dest, unique_copy)
 	  && (i = exact_log2 (significant_bits (temp, mode))) >= 0)
 	{
 	  rtx temp1 = simplify_shift_const
-	    (0, ASHIFTRT, mode,
-	     simplify_shift_const (0, ASHIFT, mode, temp,
+	    (NULL_RTX, ASHIFTRT, mode,
+	     simplify_shift_const (NULL_RTX, ASHIFT, mode, temp,
 				   GET_MODE_BITSIZE (mode) - 1 - i),
 	     GET_MODE_BITSIZE (mode) - 1 - i);
 
@@ -2932,18 +2935,18 @@ subst (x, from, to, in_dest, unique_copy)
 	  && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
 	  && INTVAL (XEXP (x, 1)) == - INTVAL (XEXP (XEXP (x, 0), 1))
 	  && (i = exact_log2 (INTVAL (XEXP (XEXP (x, 0), 1)))) >= 0
-	  && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
+	  && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
 	  && ((GET_CODE (XEXP (XEXP (x, 0), 0)) == AND
 	       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
 	       && (INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1))
-		   == (1 << (i + 1)) - 1))
+		   == ((HOST_WIDE_INT) 1 << (i + 1)) - 1))
 	      || (GET_CODE (XEXP (XEXP (x, 0), 0)) == ZERO_EXTEND
 		  && (GET_MODE_BITSIZE (GET_MODE (XEXP (XEXP (XEXP (x, 0), 0), 0)))
 		      == i + 1))))
 	{
 	  x = simplify_shift_const
-	    (0, ASHIFTRT, mode,
-	     simplify_shift_const (0, ASHIFT, mode,
+	    (NULL_RTX, ASHIFTRT, mode,
+	     simplify_shift_const (NULL_RTX, ASHIFT, mode,
 				   XEXP (XEXP (XEXP (x, 0), 0), 0),
 				   GET_MODE_BITSIZE (mode) - (i + 1)),
 	     GET_MODE_BITSIZE (mode) - (i + 1));
@@ -2961,8 +2964,8 @@ subst (x, from, to, in_dest, unique_copy)
 	  && significant_bits (XEXP (x, 0), mode) == 1)
 	{
 	  x = simplify_shift_const
-	    (0, ASHIFTRT, mode,
-	     simplify_shift_const (0, ASHIFT, mode,
+	    (NULL_RTX, ASHIFTRT, mode,
+	     simplify_shift_const (NULL_RTX, ASHIFT, mode,
 				   gen_rtx_combine (XOR, mode,
 						    XEXP (x, 0), const1_rtx),
 				   GET_MODE_BITSIZE (mode) - 1),
@@ -2991,7 +2994,7 @@ subst (x, from, to, in_dest, unique_copy)
 	  && exact_log2 (- INTVAL (XEXP (XEXP (x, 1), 1))) >= 0
 	  && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
 	{
-	  x = simplify_and_const_int (0, mode, XEXP (x, 0),
+	  x = simplify_and_const_int (NULL_RTX, mode, XEXP (x, 0),
 				      - INTVAL (XEXP (XEXP (x, 1), 1)) - 1);
 	  goto restart;
 	}
@@ -3026,7 +3029,7 @@ subst (x, from, to, in_dest, unique_copy)
 	      || GET_CODE (XEXP (x, 0)) == ROTATE
 	      || GET_CODE (XEXP (x, 0)) == ROTATERT))
 	{
-	  x = simplify_shift_const (0, ASHIFT, mode, XEXP (x, 0), i);
+	  x = simplify_shift_const (NULL_RTX, ASHIFT, mode, XEXP (x, 0), i);
 	  goto restart;
 	}
 
@@ -3048,7 +3051,7 @@ subst (x, from, to, in_dest, unique_copy)
 	      || GET_CODE (XEXP (x, 0)) == ROTATE
 	      || GET_CODE (XEXP (x, 0)) == ROTATERT))
 	{
-	  x = simplify_shift_const (0, LSHIFTRT, mode, XEXP (x, 0), i);
+	  x = simplify_shift_const (NULL_RTX, LSHIFTRT, mode, XEXP (x, 0), i);
 	  goto restart;
 	}
       break;
@@ -3113,13 +3116,14 @@ subst (x, from, to, in_dest, unique_copy)
 	     STORE_FLAG_VALUE when we are done, since we are only going to
 	     test the sign bit.  */
 	  if (new_code == NE && GET_MODE_CLASS (mode) == MODE_INT
-	      && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
-	      && STORE_FLAG_VALUE == 1 << (GET_MODE_BITSIZE (mode) - 1)
+	      && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
+	      && (STORE_FLAG_VALUE
+		  == (HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (mode) - 1))
 	      && op1 == const0_rtx
 	      && mode == GET_MODE (op0)
 	      && (i = exact_log2 (significant_bits (op0, GET_MODE (op0)))) >= 0)
 	    {
-	      x = simplify_shift_const (0, ASHIFT, mode, op0,
+	      x = simplify_shift_const (NULL_RTX, ASHIFT, mode, op0,
 					GET_MODE_BITSIZE (mode) - 1 - i);
 	      if (GET_CODE (x) == AND && XEXP (x, 1) == const_true_rtx)
 		return XEXP (x, 0);
@@ -3297,7 +3301,8 @@ subst (x, from, to, in_dest, unique_copy)
 	      if (((old_code == NE && new_code == EQ)
 		   || (old_code == EQ && new_code == NE))
 		  && ! other_changed && op1 == const0_rtx
-		  && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_INT
+		  && (GET_MODE_BITSIZE (GET_MODE (op0))
+		      <= HOST_BITS_PER_WIDE_INT)
 		  && (exact_log2 (mask = significant_bits (op0,
 							   GET_MODE (op0)))
 		      >= 0))
@@ -3311,7 +3316,7 @@ subst (x, from, to, in_dest, unique_copy)
 		      other_insn = 0;
 
 		      op0 = gen_binary (XOR, GET_MODE (op0), op0,
-					gen_rtx (CONST_INT, VOIDmode, mask));
+					GEN_INT (mask));
 		    }
 		}
 
@@ -3383,9 +3388,8 @@ subst (x, from, to, in_dest, unique_copy)
 	      && GET_CODE (XEXP (x, 1)) == CONST_INT)
 	    {
 	      temp = gen_binary (AND, mode, XEXP (XEXP (x, 0), 0),
-				 gen_rtx (CONST_INT, VOIDmode,
-					  (INTVAL (XEXP (XEXP (x, 0), 1))
-					   & ~ INTVAL (XEXP (x, 1)))));
+				 GEN_INT (INTVAL (XEXP (XEXP (x, 0), 1))
+					  & ~ INTVAL (XEXP (x, 1))));
 	      return gen_binary (IOR, mode, temp, XEXP (x, 1));
 	    }
 
@@ -3631,8 +3635,9 @@ subst (x, from, to, in_dest, unique_copy)
 
       /* (xor (comparison foo bar) (const_int sign-bit))
 	 when STORE_FLAG_VALUE is the sign bit.  */
-      if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT
-	  && STORE_FLAG_VALUE == 1 << (GET_MODE_BITSIZE (mode) - 1)
+      if (GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
+	  && (STORE_FLAG_VALUE
+	      == (HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (mode) - 1))
 	  && XEXP (x, 1) == const_true_rtx
 	  && GET_RTX_CLASS (GET_CODE (XEXP (x, 0))) == '<'
 	  && reversible_comparison_p (XEXP (x, 0)))
@@ -3648,9 +3653,11 @@ subst (x, from, to, in_dest, unique_copy)
 
       /* If operand is something known to be positive, ignore the ABS.  */
       if (GET_CODE (XEXP (x, 0)) == FFS || GET_CODE (XEXP (x, 0)) == ABS
-	  || (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) <= HOST_BITS_PER_INT
+	  || ((GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0)))
+	       <= HOST_BITS_PER_WIDE_INT)
 	      && ((significant_bits (XEXP (x, 0), GET_MODE (XEXP (x, 0)))
-		   & (1 << (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - 1)))
+		   & ((HOST_WIDE_INT) 1
+		      << (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - 1)))
 		  == 0)))
 	return XEXP (x, 0);
 
@@ -3707,7 +3714,7 @@ subst (x, from, to, in_dest, unique_copy)
 	SUBST (XEXP (x, 1),
 	       force_to_mode (XEXP (x, 1), GET_MODE (x),
 			      exact_log2 (GET_MODE_BITSIZE (GET_MODE (x))),
-			      0));
+			      NULL_RTX));
 #endif
 
       break;
@@ -3813,19 +3820,20 @@ expand_compound_operation (x)
 
   modewidth = GET_MODE_BITSIZE (GET_MODE (x));
   if (modewidth >= pos - len)
-    tem = simplify_shift_const (0, unsignedp ? LSHIFTRT : ASHIFTRT,
+    tem = simplify_shift_const (NULL_RTX, unsignedp ? LSHIFTRT : ASHIFTRT,
+				GET_MODE (x),
+				simplify_shift_const (NULL_RTX, ASHIFT,
 						      GET_MODE (x),
-				simplify_shift_const (0, ASHIFT, GET_MODE (x),
 						      XEXP (x, 0),
 						      modewidth - pos - len),
 				modewidth - len);
 
-  else if (unsignedp && len < HOST_BITS_PER_INT)
-    tem = simplify_and_const_int (0, GET_MODE (x),
-				  simplify_shift_const (0, LSHIFTRT,
+  else if (unsignedp && len < HOST_BITS_PER_WIDE_INT)
+    tem = simplify_and_const_int (NULL_RTX, GET_MODE (x),
+				  simplify_shift_const (NULL_RTX, LSHIFTRT,
 							GET_MODE (x),
 							XEXP (x, 0), pos),
-				  (1 << len) - 1);
+				  ((HOST_WIDE_INT) 1 << len) - 1);
   else
     /* Any other cases we can't handle.  */
     return x;
@@ -3882,9 +3890,8 @@ expand_field_assignment (x)
 
 #if BITS_BIG_ENDIAN
 	  if (GET_CODE (pos) == CONST_INT)
-	    pos = gen_rtx (CONST_INT, VOIDmode,
-			   (GET_MODE_BITSIZE (GET_MODE (inner)) - len
-			    - INTVAL (pos)));
+	    pos = GEN_INT (GET_MODE_BITSIZE (GET_MODE (inner)) - len
+			   - INTVAL (pos));
 	  else if (GET_CODE (pos) == MINUS
 		   && GET_CODE (XEXP (pos, 1)) == CONST_INT
 		   && (INTVAL (XEXP (pos, 1))
@@ -3893,9 +3900,9 @@ expand_field_assignment (x)
 	    pos = XEXP (pos, 0);
 	  else
 	    pos = gen_binary (MINUS, GET_MODE (pos),
-			      gen_rtx (CONST_INT, VOIDmode,
-				       (GET_MODE_BITSIZE (GET_MODE (inner))
-					- len)), pos);
+			      GEN_INT (GET_MODE_BITSIZE (GET_MODE (inner))
+				       - len),
+			      pos);
 #endif
 	}
 
@@ -3921,8 +3928,8 @@ expand_field_assignment (x)
       compute_mode = GET_MODE (inner);
 
       /* Compute a mask of LEN bits, if we can do this on the host machine.  */
-      if (len < HOST_BITS_PER_INT)
-	mask = gen_rtx (CONST_INT, VOIDmode, (1 << len) - 1);
+      if (len < HOST_BITS_PER_WIDE_INT)
+	mask = GEN_INT (((HOST_WIDE_INT) 1 << len) - 1);
       else
 	break;
 
@@ -4149,10 +4156,10 @@ make_extraction (mode, inner, pos, pos_rtx, len,
   else
     pos_rtx
       = gen_rtx_combine (MINUS, GET_MODE (pos_rtx),
-			 gen_rtx (CONST_INT, VOIDmode,
-				  (MAX (GET_MODE_BITSIZE (is_mode),
+			 GEN_INT (MAX (GET_MODE_BITSIZE (is_mode),
 				       GET_MODE_BITSIZE (wanted_mem_mode))
-				   - len)), pos_rtx);
+				  - len),
+			 pos_rtx);
 #endif
 
   /* If INNER has a wider mode, make it smaller.  If this is a constant
@@ -4218,12 +4225,11 @@ make_extraction (mode, inner, pos, pos_rtx, len,
 
   /* Make POS_RTX unless we already have it and it is correct.  */
   if (pos_rtx == 0 || (pos >= 0 && INTVAL (pos_rtx) != pos))
-    pos_rtx = gen_rtx (CONST_INT, VOIDmode, pos);
+    pos_rtx = GEN_INT (pos);
 
   /* Make the required operation.  See if we can use existing rtx.  */
   new = gen_rtx_combine (unsignedp ? ZERO_EXTRACT : SIGN_EXTRACT,
-			 extraction_mode, inner,
-			 gen_rtx (CONST_INT, VOIDmode, len), pos_rtx);
+			 extraction_mode, inner, GEN_INT (len), pos_rtx);
   if (! in_dest)
     new = gen_lowpart_for_combine (mode, new);
 
@@ -4280,11 +4286,11 @@ make_compound_operation (x, in_code)
       /* Convert shifts by constants into multiplications if inside
 	 an address.  */
       if (in_code == MEM && GET_CODE (XEXP (x, 1)) == CONST_INT
-	  && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_INT
+	  && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT
 	  && INTVAL (XEXP (x, 1)) >= 0)
 	new = gen_rtx_combine (MULT, mode, XEXP (x, 0),
-			       gen_rtx (CONST_INT, VOIDmode,
-					1 << INTVAL (XEXP (x, 1))));
+			       GEN_INT ((HOST_WIDE_INT) 1
+					<< INTVAL (XEXP (x, 1))));
       break;
 
     case AND:
@@ -4322,7 +4328,7 @@ make_compound_operation (x, in_code)
 	new = make_extraction (mode, XEXP (XEXP (x, 0), 0),
 			       (GET_MODE_BITSIZE (mode)
 				- INTVAL (XEXP (XEXP (x, 0), 1))),
-			       0, i, 1, 0, in_code == COMPARE);
+			       NULL_RTX, i, 1, 0, in_code == COMPARE);
 
       /* On machines without logical shifts, if the operand of the AND is
 	 a logical shift and our mask turns off all the propagated sign
@@ -4341,10 +4347,10 @@ make_compound_operation (x, in_code)
 	       && GET_CODE (XEXP (x, 0)) == LSHIFTRT
 	       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
 	       && INTVAL (XEXP (XEXP (x, 0), 1)) >= 0
-	       && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_INT
-	       && mode_width <= HOST_BITS_PER_INT)
+	       && INTVAL (XEXP (XEXP (x, 0), 1)) < HOST_BITS_PER_WIDE_INT
+	       && mode_width <= HOST_BITS_PER_WIDE_INT)
 	{
-	  unsigned mask = GET_MODE_MASK (mode);
+	  unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
 
 	  mask >>= INTVAL (XEXP (XEXP (x, 0), 1));
 	  if ((INTVAL (XEXP (x, 1)) & ~mask) == 0)
@@ -4358,14 +4364,14 @@ make_compound_operation (x, in_code)
 	 If it doesn't end up being a ZERO_EXTEND, we will ignore it unless
 	 we are in a COMPARE.  */
       else if ((i = exact_log2 (INTVAL (XEXP (x, 1)) + 1)) >= 0)
-	new = make_extraction (mode, XEXP (x, 0), 0, 0, i, 1,
+	new = make_extraction (mode, XEXP (x, 0), 0, NULL_RTX, i, 1,
 			       0, in_code == COMPARE);
 
       /* If we are in a comparison and this is an AND with a power of two,
 	 convert this into the appropriate bit extract.  */
       else if (in_code == COMPARE
 	       && (i = exact_log2 (INTVAL (XEXP (x, 1)))) >= 0)
-	new = make_extraction (mode, XEXP (x, 0), i, 0, 1, 1, 0, 1);
+	new = make_extraction (mode, XEXP (x, 0), i, NULL_RTX, 1, 1, 0, 1);
 
       break;
 
@@ -4383,7 +4389,7 @@ make_compound_operation (x, in_code)
 #else
 	  && 1
 #endif
-	  && mode_width <= HOST_BITS_PER_INT
+	  && mode_width <= HOST_BITS_PER_WIDE_INT
 	  && (significant_bits (XEXP (x, 0), mode)
 	      & (1 << (mode_width - 1))) == 0)
 	{
@@ -4403,7 +4409,7 @@ make_compound_operation (x, in_code)
 	new = make_extraction (mode, XEXP (XEXP (x, 0), 0),
 			       (INTVAL (XEXP (x, 1))
 				- INTVAL (XEXP (XEXP (x, 0), 1))),
-			       0, mode_width - INTVAL (XEXP (x, 1)),
+			       NULL_RTX, mode_width - INTVAL (XEXP (x, 1)),
 			       code == LSHIFTRT, 0, in_code == COMPARE);
       break;
     }
@@ -4435,7 +4441,7 @@ make_compound_operation (x, in_code)
 
 static int
 get_pos_from_mask (m, plen)
-     unsigned int m;
+     unsigned HOST_WIDE_INT m;
      int *plen;
 {
   /* Get the bit number of the first 1 bit from the right, -1 if none.  */
@@ -4495,8 +4501,8 @@ force_to_mode (x, mode, bits, reg)
       break;
 
     case CONST_INT:
-      if (bits < HOST_BITS_PER_INT)
-	x = gen_rtx (CONST_INT, VOIDmode, INTVAL (x) & ((1 << bits) - 1));
+      if (bits < HOST_BITS_PER_WIDE_INT)
+	x = GEN_INT (INTVAL (x) & (((HOST_WIDE_INT) 1 << bits) - 1));
       return x;
 
     case SUBREG:
@@ -4511,7 +4517,7 @@ force_to_mode (x, mode, bits, reg)
 
       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
 	{
-	  int mask = INTVAL (XEXP (x, 1));
+	  HOST_WIDE_INT mask = INTVAL (XEXP (x, 1));
 	  int len = exact_log2 (mask + 1);
 	  rtx op = XEXP (x, 0);
 
@@ -4522,8 +4528,8 @@ force_to_mode (x, mode, bits, reg)
 	  op = force_to_mode (op, mode, len > 0 ? MIN (len, bits) : bits,
 			      reg);
 
-	  if (bits < HOST_BITS_PER_INT)
-	    mask &= (1 << bits) - 1;
+	  if (bits < HOST_BITS_PER_WIDE_INT)
+	    mask &= ((HOST_WIDE_INT) 1 << bits) - 1;
 
 	  x = simplify_and_const_int (x, mode, op, mask);
 
@@ -4532,8 +4538,8 @@ force_to_mode (x, mode, bits, reg)
 	     can't be wider), we don't need it.  */
 
 	  if (GET_CODE (x) == AND && GET_CODE (XEXP (x, 1)) == CONST_INT
-	      && bits < HOST_BITS_PER_INT
-	      && INTVAL (XEXP (x, 1)) == (1 << bits) - 1)
+	      && bits < HOST_BITS_PER_WIDE_INT
+	      && INTVAL (XEXP (x, 1)) == ((HOST_WIDE_INT) 1 << bits) - 1)
 	    x = XEXP (x, 0);
 	  return x;
 	}
@@ -4602,7 +4608,8 @@ make_field_assignment (x)
   rtx src = SET_SRC (x);
   rtx ourdest;
   rtx assign;
-  int c1, pos, len;
+  HOST_WIDE_INT c1;
+  int pos, len;
   rtx other;
   enum machine_mode mode;
 
@@ -4681,7 +4688,7 @@ make_field_assignment (x)
       || (c1 & significant_bits (other, GET_MODE (other))) != 0)
     return x;
 
-  assign = make_extraction (VOIDmode, dest, pos, 0, len, 1, 1, 0);
+  assign = make_extraction (VOIDmode, dest, pos, NULL_RTX, len, 1, 1, 0);
 
   /* The mode to use for the source is the mode of the assignment, or of
      what is inside a possible STRICT_LOW_PART.  */
@@ -4691,8 +4698,8 @@ make_field_assignment (x)
   /* Shift OTHER right POS places and make it the source, restricting it
      to the proper length and mode.  */
 
-  src = force_to_mode (simplify_shift_const (0, LSHIFTRT, GET_MODE (src),
-					     other, pos),
+  src = force_to_mode (simplify_shift_const (NULL_RTX, LSHIFTRT,
+					     GET_MODE (src), other, pos),
 		       mode, len, dest);
 
   return gen_rtx_combine (SET, VOIDmode, assign, src);
@@ -4827,11 +4834,11 @@ simplify_and_const_int (x, mode, varop, constop)
      rtx x;
      enum machine_mode mode;
      rtx varop;
-     unsigned constop;
+     unsigned HOST_WIDE_INT constop;
 {
   register enum machine_mode tmode;
   register rtx temp;
-  unsigned significant;
+  unsigned HOST_WIDE_INT significant;
 
   /* There is a large class of optimizations based on the principle that
      some operations produce results where certain bits are known to be zero,
@@ -4846,9 +4853,9 @@ simplify_and_const_int (x, mode, varop, constop)
 
   while (1)
     {
-      /* If we ever encounter a mode wider than the host machine's word
-	 size, we can't compute the masks accurately, so give up.  */
-      if (GET_MODE_BITSIZE (GET_MODE (varop)) > HOST_BITS_PER_INT)
+      /* If we ever encounter a mode wider than the host machine's widest
+	 integer size, we can't compute the masks accurately, so give up.  */
+      if (GET_MODE_BITSIZE (GET_MODE (varop)) > HOST_BITS_PER_WIDE_INT)
 	break;
 
       /* Unless one of the cases below does a `continue',
@@ -4927,15 +4934,14 @@ simplify_and_const_int (x, mode, varop, constop)
 	  if (GET_CODE (XEXP (varop, 0)) == LSHIFTRT
 	      && GET_CODE (XEXP (XEXP (varop, 0), 1)) == CONST_INT
 	      && INTVAL (XEXP (XEXP (varop, 0), 1)) >= 0
-	      && INTVAL (XEXP (XEXP (varop, 0), 1)) < HOST_BITS_PER_INT
+	      && INTVAL (XEXP (XEXP (varop, 0), 1)) < HOST_BITS_PER_WIDE_INT
 	      && GET_CODE (XEXP (varop, 1)) == CONST_INT
 	      && (INTVAL (XEXP (varop, 1))
 		  & ~ significant_bits (XEXP (varop, 0),
 					GET_MODE (varop)) == 0))
 	    {
-	      temp = gen_rtx (CONST_INT, VOIDmode,
-			      ((INTVAL (XEXP (varop, 1)) & constop)
-			       << INTVAL (XEXP (XEXP (varop, 0), 1))));
+	      temp = GEN_INT ((INTVAL (XEXP (varop, 1)) & constop)
+			      << INTVAL (XEXP (XEXP (varop, 0), 1)));
 	      temp = gen_binary (GET_CODE (varop), GET_MODE (varop),
 				 XEXP (XEXP (varop, 0), 0), temp);
 	      varop = gen_rtx_combine (LSHIFTRT, GET_MODE (varop),
@@ -4953,9 +4959,9 @@ simplify_and_const_int (x, mode, varop, constop)
 	      (mode, apply_distributive_law
 	       (gen_rtx_combine
 		(GET_CODE (varop), GET_MODE (varop),
-		 simplify_and_const_int (0, GET_MODE (varop),
+		 simplify_and_const_int (NULL_RTX, GET_MODE (varop),
 					 XEXP (varop, 0), constop),
-		 simplify_and_const_int (0, GET_MODE (varop),
+		 simplify_and_const_int (NULL_RTX, GET_MODE (varop),
 					 XEXP (varop, 1), constop))));
 
 	case NOT:
@@ -4965,10 +4971,9 @@ simplify_and_const_int (x, mode, varop, constop)
 	  if (GET_CODE (XEXP (varop, 0)) == LSHIFTRT
 	      && GET_CODE (XEXP (XEXP (varop, 0), 1)) == CONST_INT
 	      && INTVAL (XEXP (XEXP (varop, 0), 1)) >= 0
-	      && INTVAL (XEXP (XEXP (varop, 0), 1)) < HOST_BITS_PER_INT)
+	      && INTVAL (XEXP (XEXP (varop, 0), 1)) < HOST_BITS_PER_WIDE_INT)
 	    {
-	      temp = gen_rtx (CONST_INT, VOIDmode,
-			      constop << INTVAL (XEXP (XEXP (varop, 0), 1)));
+	      temp = GEN_INT (constop << INTVAL (XEXP (XEXP (varop, 0), 1)));
 	      temp = gen_binary (XOR, GET_MODE (varop),
 				 XEXP (XEXP (varop, 0), 0), temp);
 	      varop = gen_rtx_combine (LSHIFTRT, GET_MODE (varop),
@@ -4980,7 +4985,8 @@ simplify_and_const_int (x, mode, varop, constop)
 	case ASHIFTRT:
 	  /* If we are just looking for the sign bit, we don't need this
 	     shift at all, even if it has a variable count.  */
-	  if (constop == 1 << (GET_MODE_BITSIZE (GET_MODE (varop)) - 1))
+	  if (constop == ((HOST_WIDE_INT) 1
+			  << (GET_MODE_BITSIZE (GET_MODE (varop)) - 1)))
 	    {
 	      varop = XEXP (varop, 0);
 	      continue;
@@ -4995,7 +5001,7 @@ simplify_and_const_int (x, mode, varop, constop)
 	     the appropriate location.  */
 	  if (GET_CODE (XEXP (varop, 1)) == CONST_INT
 	      && INTVAL (XEXP (varop, 1)) >= 0
-	      && INTVAL (XEXP (varop, 1)) < HOST_BITS_PER_INT)
+	      && INTVAL (XEXP (varop, 1)) < HOST_BITS_PER_WIDE_INT)
 	    {
 	      int i = -1;
 
@@ -5076,7 +5082,7 @@ simplify_and_const_int (x, mode, varop, constop)
 
   /* If we have reached a constant, this whole thing is constant.  */
   if (GET_CODE (varop) == CONST_INT)
-    return gen_rtx (CONST_INT, VOIDmode, constop & INTVAL (varop));
+    return GEN_INT (constop & INTVAL (varop));
 
   /* See what bits are significant in VAROP.  */
   significant = significant_bits (varop, mode);
@@ -5110,14 +5116,13 @@ simplify_and_const_int (x, mode, varop, constop)
 
   /* Otherwise, return an AND.  See how much, if any, of X we can use.  */
   else if (x == 0 || GET_CODE (x) != AND || GET_MODE (x) != mode)
-    x = gen_rtx_combine (AND, mode, varop,
-			 gen_rtx (CONST_INT, VOIDmode, constop));
+    x = gen_rtx_combine (AND, mode, varop, GEN_INT (constop));
 
   else
     {
       if (GET_CODE (XEXP (x, 1)) != CONST_INT
 	  || INTVAL (XEXP (x, 1)) != constop)
-	SUBST (XEXP (x, 1), gen_rtx (CONST_INT, VOIDmode, constop));
+	SUBST (XEXP (x, 1), GEN_INT (constop));
 
       SUBST (XEXP (x, 0), varop);
     }
@@ -5131,13 +5136,13 @@ simplify_and_const_int (x, mode, varop, constop)
    For most X this is simply GET_MODE_MASK (GET_MODE (MODE)), but if X is
    a shift, AND, or zero_extract, we can do better.  */
 
-static unsigned
+static unsigned HOST_WIDE_INT
 significant_bits (x, mode)
      rtx x;
      enum machine_mode mode;
 {
-  unsigned significant = GET_MODE_MASK (mode);
-  unsigned inner_sig;
+  unsigned HOST_WIDE_INT significant = GET_MODE_MASK (mode);
+  unsigned HOST_WIDE_INT inner_sig;
   enum rtx_code code;
   int mode_width = GET_MODE_BITSIZE (mode);
   rtx tem;
@@ -5150,7 +5155,7 @@ significant_bits (x, mode)
       mode_width = GET_MODE_BITSIZE (mode);
     }
 
-  if (mode_width > HOST_BITS_PER_INT)
+  if (mode_width > HOST_BITS_PER_WIDE_INT)
     /* Our only callers in this case look for single bit values.  So
        just return the mode mask.  Those tests will then be false.  */
     return significant;
@@ -5250,7 +5255,8 @@ significant_bits (x, mode)
 	{
 	  inner_sig &= GET_MODE_MASK (GET_MODE (XEXP (x, 0)));
 	  if (inner_sig &
-	      (1 << (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - 1)))
+	      (((HOST_WIDE_INT) 1
+		<< (GET_MODE_BITSIZE (GET_MODE (XEXP (x, 0))) - 1))))
 	    inner_sig |= (GET_MODE_MASK (mode)
 			  & ~ GET_MODE_MASK (GET_MODE (XEXP (x, 0))));
 	}
@@ -5278,8 +5284,8 @@ significant_bits (x, mode)
 	 computing the width (position of the highest-order non-zero bit)
 	 and the number of low-order zero bits for each value.  */
       {
-	unsigned sig0 = significant_bits (XEXP (x, 0), mode);
-	unsigned sig1 = significant_bits (XEXP (x, 1), mode);
+	unsigned HOST_WIDE_INT sig0 = significant_bits (XEXP (x, 0), mode);
+	unsigned HOST_WIDE_INT sig1 = significant_bits (XEXP (x, 1), mode);
 	int width0 = floor_log2 (sig0) + 1;
 	int width1 = floor_log2 (sig1) + 1;
 	int low0 = floor_log2 (sig0 & -sig0);
@@ -5321,17 +5327,17 @@ significant_bits (x, mode)
 	  }
 
 	if (result_width < mode_width)
-	  significant &= (1 << result_width) - 1;
+	  significant &= ((HOST_WIDE_INT) 1 << result_width) - 1;
 
 	if (result_low > 0)
-	  significant &= ~ ((1 << result_low) - 1);
+	  significant &= ~ (((HOST_WIDE_INT) 1 << result_low) - 1);
       }
       break;
 
     case ZERO_EXTRACT:
       if (GET_CODE (XEXP (x, 1)) == CONST_INT
-	  && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_INT)
-	significant &= (1 << INTVAL (XEXP (x, 1))) - 1;
+	  && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
+	significant &= ((HOST_WIDE_INT) 1 << INTVAL (XEXP (x, 1))) - 1;
       break;
 
     case SUBREG:
@@ -5339,7 +5345,8 @@ significant_bits (x, mode)
 	 machines, we can compute this from which bits of the inner
 	 object are known significant.  */
       if (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) <= BITS_PER_WORD
-	  && GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x))) <= HOST_BITS_PER_INT)
+	  && (GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (x)))
+	      <= HOST_BITS_PER_WIDE_INT))
 	{
 	  significant &= significant_bits (SUBREG_REG (x), mode);
 #ifndef BYTE_LOADS_ZERO_EXTEND
@@ -5367,15 +5374,16 @@ significant_bits (x, mode)
 	 low-order bits by left shifts.  */
       if (GET_CODE (XEXP (x, 1)) == CONST_INT
 	  && INTVAL (XEXP (x, 1)) >= 0
-	  && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_INT)
+	  && INTVAL (XEXP (x, 1)) < HOST_BITS_PER_WIDE_INT)
 	{
 	  enum machine_mode inner_mode = GET_MODE (x);
 	  int width = GET_MODE_BITSIZE (inner_mode);
 	  int count = INTVAL (XEXP (x, 1));
-	  unsigned mode_mask = GET_MODE_MASK (inner_mode);
-	  unsigned op_significant = significant_bits (XEXP (x, 0), mode);
-	  unsigned inner = op_significant & mode_mask;
-	  unsigned outer = 0;
+	  unsigned HOST_WIDE_INT mode_mask = GET_MODE_MASK (inner_mode);
+	  unsigned HOST_WIDE_INT op_significant
+	    = significant_bits (XEXP (x, 0), mode);
+	  unsigned HOST_WIDE_INT inner = op_significant & mode_mask;
+	  unsigned HOST_WIDE_INT outer = 0;
 
 	  if (mode_width > width)
 	    outer = (op_significant & significant & ~ mode_mask);
@@ -5389,8 +5397,8 @@ significant_bits (x, mode)
 	      /* If the sign bit was significant at before the shift, we
 		 need to mark all the places it could have been copied to
 		 by the shift significant.  */
-	      if (inner & (1 << (width - 1 - count)))
-		inner |= ((1 << count) - 1) << (width - count);
+	      if (inner & ((HOST_WIDE_INT) 1 << (width - 1 - count)))
+		inner |= (((HOST_WIDE_INT) 1 << count) - 1) << (width - count);
 	    }
 	  else if (code == LSHIFT || code == ASHIFT)
 	    inner <<= count;
@@ -5404,7 +5412,7 @@ significant_bits (x, mode)
 
     case FFS:
       /* This is at most the number of bits in the mode.  */
-      significant = (1 << (floor_log2 (mode_width) + 1)) - 1;
+      significant = ((HOST_WIDE_INT) 1 << (floor_log2 (mode_width) + 1)) - 1;
       break;
     }
 
@@ -5423,7 +5431,7 @@ significant_bits (x, mode)
 
    MODE is the mode in which the operation will be done.  No bits outside
    the width of this mode matter.  It is assumed that the width of this mode
-   is smaller than or equal to HOST_BITS_PER_INT.
+   is smaller than or equal to HOST_BITS_PER_WIDE_INT.
 
    If *POP0 or OP1 are NIL, it means no operation is required.  Only NEG, PLUS,
    IOR, XOR, and AND are supported.  We may set *POP0 to SET if the proper
@@ -5435,14 +5443,14 @@ significant_bits (x, mode)
 static int
 merge_outer_ops (pop0, pconst0, op1, const1, mode, pcomp_p)
      enum rtx_code *pop0;
-     int *pconst0;
+     HOST_WIDE_INT *pconst0;
      enum rtx_code op1;
-     int const1;
+     HOST_WIDE_INT const1;
      enum machine_mode mode;
      int *pcomp_p;
 {
   enum rtx_code op0 = *pop0;
-  int const0 = *pconst0;
+  HOST_WIDE_INT const0 = *pconst0;
 
   const0 &= GET_MODE_MASK (mode);
   const1 &= GET_MODE_MASK (mode);
@@ -5562,7 +5570,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
     = (GET_MODE_SIZE (mode) + (UNITS_PER_WORD - 1)) / UNITS_PER_WORD;
   /* We form (outer_op (code varop count) (outer_const)).  */
   enum rtx_code outer_op = NIL;
-  int outer_const;
+  HOST_WIDE_INT outer_const;
   rtx const_rtx;
   int complement_p = 0;
   rtx new;
@@ -5575,7 +5583,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
       if (x)
 	return x;
 
-      return gen_rtx (code, mode, varop, gen_rtx (CONST_INT, VOIDmode, count));
+      return gen_rtx (code, mode, varop, GEN_INT (count));
     }
 
   /* Unless one of the branches of the `if' in this loop does a `continue',
@@ -5643,10 +5651,11 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	 ASHIFTRT to LSHIFTRT if we know the sign bit is clear.
 	 `make_compound_operation' will convert it to a ASHIFTRT for
 	 those machines (such as Vax) that don't have a LSHIFTRT.  */
-      if (GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_INT
+      if (GET_MODE_BITSIZE (shift_mode) <= HOST_BITS_PER_WIDE_INT
 	  && code == ASHIFTRT
-	  && (significant_bits (varop, shift_mode)
-	      & (1 << (GET_MODE_BITSIZE (shift_mode) - 1))) == 0)
+	  && ((significant_bits (varop, shift_mode)
+	       & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (shift_mode) - 1)))
+	      == 0))
 	code = LSHIFTRT;
 
       switch (GET_CODE (varop))
@@ -5740,8 +5749,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	      && exact_log2 (INTVAL (XEXP (varop, 1))) >= 0)
 	    {
 	      varop = gen_binary (ASHIFT, GET_MODE (varop), XEXP (varop, 0),
-				  gen_rtx (CONST_INT, VOIDmode,
-					   exact_log2 (INTVAL (XEXP (varop, 1)))));
+				  GEN_INT (exact_log2 (INTVAL (XEXP (varop, 1)))));;
 	      continue;
 	    }
 	  break;
@@ -5752,8 +5760,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	      && exact_log2 (INTVAL (XEXP (varop, 1))) >= 0)
 	    {
 	      varop = gen_binary (LSHIFTRT, GET_MODE (varop), XEXP (varop, 0),
-				  gen_rtx (CONST_INT, VOIDmode,
-					   exact_log2 (INTVAL (XEXP (varop, 1)))));
+				  GEN_INT (exact_log2 (INTVAL (XEXP (varop, 1)))));
 	      continue;
 	    }
 	  break;
@@ -5778,12 +5785,12 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	  if (GET_CODE (XEXP (varop, 1)) == CONST_INT
 	      && INTVAL (XEXP (varop, 1)) >= 0
 	      && INTVAL (XEXP (varop, 1)) < GET_MODE_BITSIZE (GET_MODE (varop))
-	      && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_INT
-	      && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT)
+	      && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
+	      && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
 	    {
 	      enum rtx_code first_code = GET_CODE (varop);
 	      int first_count = INTVAL (XEXP (varop, 1));
-	      unsigned int mask;
+	      unsigned HOST_WIDE_INT mask;
 	      rtx mask_rtx;
 	      rtx inner;
 
@@ -5803,11 +5810,12 @@ simplify_shift_const (x, code, result_mode, varop, count)
 		{
 		  /* C3 has the low-order C1 bits zero.  */
 		  
-		  mask = GET_MODE_MASK (mode) & ~ ((1 << first_count) - 1);
+		  mask = (GET_MODE_MASK (mode)
+			  & ~ (((HOST_WIDE_INT) 1 << first_count) - 1));
 
-		  varop = simplify_and_const_int (0, result_mode,
+		  varop = simplify_and_const_int (NULL_RTX, result_mode,
 						  XEXP (varop, 0), mask);
-		  varop = simplify_shift_const (0, ASHIFT, result_mode,
+		  varop = simplify_shift_const (NULL_RTX, ASHIFT, result_mode,
 						varop, count);
 		  count = first_count;
 		  code = ASHIFTRT;
@@ -5830,8 +5838,12 @@ simplify_shift_const (x, code, result_mode, varop, count)
 		  && (inner = get_last_value (XEXP (varop, 0))) != 0)
 		{
 		  if ((GET_CODE (inner) == CONST_INT
-		       && (INTVAL (inner) >> (HOST_BITS_PER_INT - (first_count + 1)) == 0
-			   || (INTVAL (inner) >> (HOST_BITS_PER_INT - (first_count + 1)) == -1)))
+		       && (((INTVAL (inner)
+			     >> (HOST_BITS_PER_WIDE_INT - (first_count + 1)))
+			    == 0)
+			   || ((INTVAL (inner)
+				>> (HOST_BITS_PER_WIDE_INT - (first_count + 1)))
+			       == -1)))
 		      || (GET_CODE (inner) == SIGN_EXTEND
 			  && ((GET_MODE_BITSIZE (GET_MODE (inner))
 			       - GET_MODE_BITSIZE (GET_MODE (SUBREG_REG (inner))))
@@ -5876,7 +5888,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
 
 	      if (code == ASHIFTRT
 		  || (code == ROTATE && first_code == ASHIFTRT)
-		  || GET_MODE_BITSIZE (mode) > HOST_BITS_PER_INT
+		  || GET_MODE_BITSIZE (mode) > HOST_BITS_PER_WIDE_INT
 		  || (GET_MODE (varop) != result_mode
 		      && (first_code == ASHIFTRT || first_code == ROTATE
 			  || code == ROTATE)))
@@ -5886,13 +5898,11 @@ simplify_shift_const (x, code, result_mode, varop, count)
 		 significant bits of the inner shift the same way the 
 		 outer shift will.  */
 
-	      mask_rtx = gen_rtx (CONST_INT, VOIDmode,
-				  significant_bits (varop, GET_MODE (varop)));
+	      mask_rtx = GEN_INT (significant_bits (varop, GET_MODE (varop)));
 
 	      mask_rtx
 		= simplify_binary_operation (code, result_mode, mask_rtx,
-					     gen_rtx (CONST_INT, VOIDmode,
-						      count));
+					     GEN_INT (count));
 				  
 	      /* Give up if we can't compute an outer operation to use.  */
 	      if (mask_rtx == 0
@@ -5934,9 +5944,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
 		   && 0 != (new
 			    = simplify_binary_operation (code, mode,
 							 XEXP (varop, 0),
-							 gen_rtx (CONST_INT,
-								  VOIDmode,
-								  count))))
+							 GEN_INT (count))))
 	    {
 	      varop = gen_rtx_combine (code, mode, new, XEXP (varop, 1));
 	      count = 0;
@@ -5947,8 +5955,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	case NOT:
 	  /* Make this fit the case below.  */
 	  varop = gen_rtx_combine (XOR, mode, XEXP (varop, 0),
-				   gen_rtx (CONST_INT, VOIDmode,
-					    GET_MODE_MASK (mode)));
+				   GEN_INT (GET_MODE_MASK (mode)));
 	  continue;
 
 	case IOR:
@@ -5987,9 +5994,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	  if (GET_CODE (XEXP (varop, 1)) == CONST_INT
 	      && (new = simplify_binary_operation (code, result_mode,
 						   XEXP (varop, 1),
-						   gen_rtx (CONST_INT,
-							    VOIDmode,
-							    count))) != 0
+						   GEN_INT (count))) != 0
 	      && merge_outer_ops (&outer_op, &outer_const, GET_CODE (varop),
 				  INTVAL (new), result_mode, &complement_p))
 	    {
@@ -6001,9 +6006,9 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	     logical expression, make a new logical expression, and apply
 	     the inverse distributive law.  */
 	  {
-	    rtx lhs = simplify_shift_const (0, code, result_mode,
+	    rtx lhs = simplify_shift_const (NULL_RTX, code, result_mode,
 					    XEXP (varop, 0), count);
-	    rtx rhs = simplify_shift_const (0, code, result_mode,
+	    rtx rhs = simplify_shift_const (NULL_RTX, code, result_mode,
 					    XEXP (varop, 1), count);
 
 	    varop = gen_binary (GET_CODE (varop), result_mode, lhs, rhs);
@@ -6022,12 +6027,13 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	      && XEXP (varop, 1) == const0_rtx
 	      && GET_MODE (XEXP (varop, 0)) == result_mode
 	      && count == GET_MODE_BITSIZE (result_mode) - 1
-	      && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_INT
+	      && GET_MODE_BITSIZE (result_mode) <= HOST_BITS_PER_WIDE_INT
 	      && ((STORE_FLAG_VALUE
-		   & (1 << (GET_MODE_BITSIZE (result_mode) - 1))))
+		   & ((HOST_WIDE_INT) 1 << (GET_MODE_BITSIZE (result_mode) - 1))))
 	      && significant_bits (XEXP (varop, 0), result_mode) == 1
-	      && merge_outer_ops (&outer_op, &outer_const, XOR, 1,
-				  result_mode, &complement_p))
+	      && merge_outer_ops (&outer_op, &outer_const, XOR,
+				  (HOST_WIDE_INT) 1, result_mode,
+				  &complement_p))
 	    {
 	      varop = XEXP (varop, 0);
 	      count = 0;
@@ -6048,8 +6054,9 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	  /* NEG commutes with ASHIFT since it is multiplication.  Move the
 	     NEG outside to allow shifts to combine.  */
 	  if (code == ASHIFT
-	      && merge_outer_ops (&outer_op, &outer_const, NEG, 0,
-				  result_mode, &complement_p))
+	      && merge_outer_ops (&outer_op, &outer_const, NEG,
+				  (HOST_WIDE_INT) 0, result_mode,
+				  &complement_p))
 	    {
 	      varop = XEXP (varop, 0);
 	      continue;
@@ -6071,8 +6078,9 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	  if (code == LSHIFTRT && count == GET_MODE_BITSIZE (result_mode) - 1
 	      && XEXP (varop, 1) == constm1_rtx
 	      && significant_bits (XEXP (varop, 0), result_mode) == 1
-	      && merge_outer_ops (&outer_op, &outer_const, XOR, 1,
-				  result_mode, &complement_p))
+	      && merge_outer_ops (&outer_op, &outer_const, XOR,
+				  (HOST_WIDE_INT) 1, result_mode,
+				  &complement_p))
 	    {
 	      count = 0;
 	      varop = XEXP (varop, 0);
@@ -6086,7 +6094,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	     we are computing the size of a variable-size array.  */
 
 	  if ((code == ASHIFTRT || code == LSHIFTRT)
-	      && count < HOST_BITS_PER_INT
+	      && count < HOST_BITS_PER_WIDE_INT
 	      && significant_bits (XEXP (varop, 1), result_mode) >> count == 0
 	      && (significant_bits (XEXP (varop, 1), result_mode)
 		  & significant_bits (XEXP (varop, 0), result_mode)) == 0)
@@ -6095,7 +6103,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	      continue;
 	    }
 	  else if ((code == ASHIFTRT || code == LSHIFTRT)
-		   && count < HOST_BITS_PER_INT
+		   && count < HOST_BITS_PER_WIDE_INT
 		   && 0 == (significant_bits (XEXP (varop, 0), result_mode)
 			    >> count)
 		   && 0 == (significant_bits (XEXP (varop, 0), result_mode)
@@ -6111,9 +6119,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
 	      && GET_CODE (XEXP (varop, 1)) == CONST_INT
 	      && (new = simplify_binary_operation (ASHIFT, result_mode,
 						   XEXP (varop, 1),
-						   gen_rtx (CONST_INT,
-							    VOIDmode,
-							    count))) != 0
+						   GEN_INT (count))) != 0
 	      && merge_outer_ops (&outer_op, &outer_const, PLUS,
 				  INTVAL (new), result_mode, &complement_p))
 	    {
@@ -6174,7 +6180,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
       && INTVAL (XEXP (x, 1)) == count)
     const_rtx = XEXP (x, 1);
   else
-    const_rtx = gen_rtx (CONST_INT, VOIDmode, count);
+    const_rtx = GEN_INT (count);
 
   if (x && GET_CODE (XEXP (x, 0)) == SUBREG
       && GET_MODE (XEXP (x, 0)) == shift_mode
@@ -6202,7 +6208,7 @@ simplify_shift_const (x, code, result_mode, varop, count)
   /* If we were doing a LSHIFTRT in a wider mode than it was originally,
      turn off all the bits that the shift would have turned off.  */
   if (orig_code == LSHIFTRT && result_mode != shift_mode)
-    x = simplify_and_const_int (0, shift_mode, x,
+    x = simplify_and_const_int (NULL_RTX, shift_mode, x,
 				GET_MODE_MASK (result_mode) >> orig_count);
       
   /* Do the remainder of the processing in RESULT_MODE.  */
@@ -6215,20 +6221,19 @@ simplify_shift_const (x, code, result_mode, varop, count)
 
   if (outer_op != NIL)
     {
-      if (GET_MODE_BITSIZE (result_mode) < HOST_BITS_PER_INT)
+      if (GET_MODE_BITSIZE (result_mode) < HOST_BITS_PER_WIDE_INT)
 	outer_const &= GET_MODE_MASK (result_mode);
 
       if (outer_op == AND)
-	x = simplify_and_const_int (0, result_mode, x, outer_const);
+	x = simplify_and_const_int (NULL_RTX, result_mode, x, outer_const);
       else if (outer_op == SET)
 	/* This means that we have determined that the result is
 	   equivalent to a constant.  This should be rare.  */
-	x = gen_rtx (CONST_INT, VOIDmode, outer_const);
+	x = GEN_INT (outer_const);
       else if (GET_RTX_CLASS (outer_op) == '1')
 	x = gen_unary (outer_op, result_mode, x);
       else
-	x = gen_binary (outer_op, result_mode, x,
-			gen_rtx (CONST_INT, VOIDmode, outer_const));
+	x = gen_binary (outer_op, result_mode, x, GEN_INT (outer_const));
     }
 
   return x;
@@ -6565,7 +6570,7 @@ simplify_comparison (code, pop0, pop1)
 	 this shift are not significant for either input and if the type of
 	 comparison is compatible with the shift.  */
       if (GET_CODE (op0) == GET_CODE (op1)
-	  && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_INT
+	  && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
 	  && ((GET_CODE (op0) == ROTATE && (code == NE || code == EQ))
 	      || ((GET_CODE (op0) == LSHIFTRT
 		   || GET_CODE (op0) == ASHIFT || GET_CODE (op0) == LSHIFT)
@@ -6575,11 +6580,11 @@ simplify_comparison (code, pop0, pop1)
 		      && code != GEU && code != GEU)))
 	  && GET_CODE (XEXP (op0, 1)) == CONST_INT
 	  && INTVAL (XEXP (op0, 1)) >= 0
-	  && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_INT
+	  && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
 	  && XEXP (op0, 1) == XEXP (op1, 1))
 	{
 	  enum machine_mode mode = GET_MODE (op0);
-	  unsigned mask = GET_MODE_MASK (mode);
+	  unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
 	  int shift_count = INTVAL (XEXP (op0, 1));
 
 	  if (GET_CODE (op0) == LSHIFTRT || GET_CODE (op0) == ASHIFTRT)
@@ -6647,11 +6652,11 @@ simplify_comparison (code, pop0, pop1)
     {
       enum machine_mode mode = GET_MODE (op0);
       int mode_width = GET_MODE_BITSIZE (mode);
-      unsigned mask = GET_MODE_MASK (mode);
+      unsigned HOST_WIDE_INT mask = GET_MODE_MASK (mode);
       int equality_comparison_p;
       int sign_bit_comparison_p;
       int unsigned_comparison_p;
-      int const_op;
+      HOST_WIDE_INT const_op;
 
       /* We only want to handle integral modes.  This catches VOIDmode,
 	 CCmode, and the floating-point modes.  An exception is that we
@@ -6667,7 +6672,7 @@ simplify_comparison (code, pop0, pop1)
       /* Get the constant we are comparing against and turn off all bits
 	 not on in our mode.  */
       const_op = INTVAL (op1);
-      if (mode_width <= HOST_BITS_PER_INT)
+      if (mode_width <= HOST_BITS_PER_WIDE_INT)
 	const_op &= mask;
 
       /* If we are comparing against a constant power of two and the value
@@ -6677,7 +6682,7 @@ simplify_comparison (code, pop0, pop1)
       if (const_op
 	  && (code == EQ || code == NE || code == GE || code == GEU
 	      || code == LT || code == LTU)
-	  && mode_width <= HOST_BITS_PER_INT
+	  && mode_width <= HOST_BITS_PER_WIDE_INT
 	  && exact_log2 (const_op) >= 0
 	  && significant_bits (op0, mode) == const_op)
 	{
@@ -6696,7 +6701,7 @@ simplify_comparison (code, pop0, pop1)
 	  if (const_op > 0)
 	    {
 	      const_op -= 1;
-	      op1 = gen_rtx (CONST_INT, VOIDmode, const_op);
+	      op1 = GEN_INT (const_op);
 	      code = LE;
 	      /* ... fall through to LE case below.  */
 	    }
@@ -6708,16 +6713,16 @@ simplify_comparison (code, pop0, pop1)
 	  if (const_op < 0)
 	    {
 	      const_op += 1;
-	      op1 = gen_rtx (CONST_INT, VOIDmode, const_op);
+	      op1 = GEN_INT (const_op);
 	      code = LT;
 	    }
 
 	  /* If we are doing a <= 0 comparison on a value known to have
 	     a zero sign bit, we can replace this with == 0.  */
 	  else if (const_op == 0
-		   && mode_width <= HOST_BITS_PER_INT
+		   && mode_width <= HOST_BITS_PER_WIDE_INT
 		   && (significant_bits (op0, mode)
-		       & (1 << (mode_width - 1))) == 0)
+		       & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)
 	    code = EQ;
 	  break;
 
@@ -6726,7 +6731,7 @@ simplify_comparison (code, pop0, pop1)
 	  if (const_op > 0)
 	    {
 	      const_op -= 1;
-	      op1 = gen_rtx (CONST_INT, VOIDmode, const_op);
+	      op1 = GEN_INT (const_op);
 	      code = GT;
 	      /* ... fall through to GT below.  */
 	    }
@@ -6738,16 +6743,16 @@ simplify_comparison (code, pop0, pop1)
 	  if (const_op < 0)
 	    {
 	      const_op += 1;
-	      op1 = gen_rtx (CONST_INT, VOIDmode, const_op);
+	      op1 = GEN_INT (const_op);
 	      code = GE;
 	    }
 
 	  /* If we are doing a > 0 comparison on a value known to have
 	     a zero sign bit, we can replace this with != 0.  */
 	  else if (const_op == 0
-		   && mode_width <= HOST_BITS_PER_INT
+		   && mode_width <= HOST_BITS_PER_WIDE_INT
 		   && (significant_bits (op0, mode)
-		       & (1 << (mode_width - 1))) == 0)
+		       & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)
 	    code = NE;
 	  break;
 
@@ -6756,7 +6761,7 @@ simplify_comparison (code, pop0, pop1)
 	  if (const_op > 0)
 	    {
 	      const_op -= 1;
-	      op1 = gen_rtx (CONST_INT, VOIDmode, const_op);
+	      op1 = GEN_INT (const_op);
 	      code = LEU;
 	      /* ... fall through ... */
 	    }
@@ -6774,7 +6779,7 @@ simplify_comparison (code, pop0, pop1)
 	  if (const_op > 1)
 	    {
 	      const_op -= 1;
-	      op1 = gen_rtx (CONST_INT, VOIDmode, const_op);
+	      op1 = GEN_INT (const_op);
 	      code = GTU;
 	      /* ... fall through ... */
 	    }
@@ -6821,7 +6826,7 @@ simplify_comparison (code, pop0, pop1)
 #endif
 
 	      op0 = XEXP (op0, 2);
-	      op1 = gen_rtx (CONST_INT, VOIDmode, i);
+	      op1 = GEN_INT (i);
 	      const_op = i;
 
 	      /* Result is nonzero iff shift count is equal to I.  */
@@ -6880,9 +6885,9 @@ simplify_comparison (code, pop0, pop1)
 
 	  if (sign_bit_comparison_p
 	      && (GET_CODE (XEXP (op0, 0)) == ABS
-		  || (mode_width <= HOST_BITS_PER_INT
+		  || (mode_width <= HOST_BITS_PER_WIDE_INT
 		      && (significant_bits (XEXP (op0, 0), mode)
-			  & (1 << (mode_width - 1))) == 0)))
+			  & ((HOST_WIDE_INT) 1 << (mode_width - 1))) == 0)))
 	    {
 	      op0 = XEXP (op0, 0);
 	      code = (code == LT ? NE : EQ);
@@ -6935,11 +6940,12 @@ simplify_comparison (code, pop0, pop1)
 	     bit.  This will be converted into a ZERO_EXTRACT.  */
 	  if (const_op == 0 && sign_bit_comparison_p
 	      && GET_CODE (XEXP (op0, 1)) == CONST_INT
-	      && mode_width <= HOST_BITS_PER_INT)
+	      && mode_width <= HOST_BITS_PER_WIDE_INT)
 	    {
-	      op0 = simplify_and_const_int (0, mode, XEXP (op0, 0),
-					    1 << (mode_width - 1
-						  - INTVAL (XEXP (op0, 1))));
+	      op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
+					    ((HOST_WIDE_INT) 1
+					     << (mode_width - 1
+						 - INTVAL (XEXP (op0, 1)))));
 	      code = (code == LT ? NE : EQ);
 	      continue;
 	    }
@@ -6963,9 +6969,10 @@ simplify_comparison (code, pop0, pop1)
 	     with ZERO_EXTEND or a signed comparison with SIGN_EXTEND.  */
 	  if (! unsigned_comparison_p
 	      && (GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0)))
-		  <= HOST_BITS_PER_INT)
-	      && ((unsigned) const_op
-		  < (1 << (GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0))) - 1))))
+		  <= HOST_BITS_PER_WIDE_INT)
+	      && ((unsigned HOST_WIDE_INT) const_op
+		  < (((HOST_WIDE_INT) 1
+		      << (GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0))) - 1)))))
 	    {
 	      op0 = XEXP (op0, 0);
 	      continue;
@@ -6984,8 +6991,8 @@ simplify_comparison (code, pop0, pop1)
 	case ZERO_EXTEND:
 	  if ((unsigned_comparison_p || equality_comparison_p)
 	      && (GET_MODE_BITSIZE (GET_MODE (XEXP (op0, 0)))
-		  <= HOST_BITS_PER_INT)
-	      && ((unsigned) const_op
+		  <= HOST_BITS_PER_WIDE_INT)
+	      && ((unsigned HOST_WIDE_INT) const_op
 		  < GET_MODE_MASK (GET_MODE (XEXP (op0, 0)))))
 	    {
 	      op0 = XEXP (op0, 0);
@@ -7065,10 +7072,11 @@ simplify_comparison (code, pop0, pop1)
 	     earlier test or the opposite of that result.  */
 	  if (code == NE
 	      || (code == EQ && reversible_comparison_p (op0))
-	      || (GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_INT
+	      || (GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
 		  && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
 		  && (STORE_FLAG_VALUE
-		      & (1 << (GET_MODE_BITSIZE (GET_MODE (op0)) - 1)))
+		      & (((HOST_WIDE_INT) 1
+			  << (GET_MODE_BITSIZE (GET_MODE (op0)) - 1))))
 		  && (code == LT
 		      || (code == GE && reversible_comparison_p (op0)))))
 	    {
@@ -7104,7 +7112,7 @@ simplify_comparison (code, pop0, pop1)
 		(op0, mode, gen_rtx_combine (LSHIFTRT, mode,
 					     XEXP (op0, 1),
 					     XEXP (XEXP (op0, 0), 1)),
-		 1);
+		 (HOST_WIDE_INT) 1);
 	      continue;
 	    }
 
@@ -7112,12 +7120,12 @@ simplify_comparison (code, pop0, pop1)
 	     zero and X is a comparison and C1 and C2 describe only bits set
 	     in STORE_FLAG_VALUE, we can compare with X.  */
 	  if (const_op == 0 && equality_comparison_p
-	      && mode_width <= HOST_BITS_PER_INT
+	      && mode_width <= HOST_BITS_PER_WIDE_INT
 	      && GET_CODE (XEXP (op0, 1)) == CONST_INT
 	      && GET_CODE (XEXP (op0, 0)) == LSHIFTRT
 	      && GET_CODE (XEXP (XEXP (op0, 0), 1)) == CONST_INT
 	      && INTVAL (XEXP (XEXP (op0, 0), 1)) >= 0
-	      && INTVAL (XEXP (XEXP (op0, 0), 1)) < HOST_BITS_PER_INT)
+	      && INTVAL (XEXP (XEXP (op0, 0), 1)) < HOST_BITS_PER_WIDE_INT)
 	    {
 	      mask = ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
 		      << INTVAL (XEXP (XEXP (op0, 0), 1)));
@@ -7137,9 +7145,9 @@ simplify_comparison (code, pop0, pop1)
 	  if (equality_comparison_p
 	      && const_op == 0
 	      && GET_CODE (XEXP (op0, 1)) == CONST_INT
-	      && mode_width <= HOST_BITS_PER_INT
+	      && mode_width <= HOST_BITS_PER_WIDE_INT
 	      && ((INTVAL (XEXP (op0, 1)) & GET_MODE_MASK (mode))
-		  == 1 << (mode_width - 1)))
+		  == (HOST_WIDE_INT) 1 << (mode_width - 1)))
 	    {
 	      op0 = XEXP (op0, 0);
 	      code = (code == EQ ? GE : LT);
@@ -7173,15 +7181,17 @@ simplify_comparison (code, pop0, pop1)
 	  if (GET_CODE (XEXP (op0, 1)) == CONST_INT
 	      && INTVAL (XEXP (op0, 1)) >= 0
 	      && ((INTVAL (XEXP (op0, 1)) + ! equality_comparison_p)
-		  < HOST_BITS_PER_INT)
-	      && (const_op &  ~ ((1 << INTVAL (XEXP (op0, 1))) - 1)) == 0
-	      && mode_width <= HOST_BITS_PER_INT
+		  < HOST_BITS_PER_WIDE_INT)
+	      && ((const_op
+		   &  ~ (((HOST_WIDE_INT) 1
+			  << INTVAL (XEXP (op0, 1))) - 1)) == 0)
+	      && mode_width <= HOST_BITS_PER_WIDE_INT
 	      && (significant_bits (XEXP (op0, 0), mode)
 		  & ~ (mask >> (INTVAL (XEXP (op0, 1))
 				+ ! equality_comparison_p))) == 0)
 	    {
 	      const_op >>= INTVAL (XEXP (op0, 1));
-	      op1 = gen_rtx (CONST_INT, VOIDmode, const_op);
+	      op1 = GEN_INT (const_op);
 	      op0 = XEXP (op0, 0);
 	      continue;
 	    }
@@ -7189,11 +7199,12 @@ simplify_comparison (code, pop0, pop1)
 	  /* If we are doing a sign bit comparison, it means we are testing
 	     a particular bit.  Convert it to the appropriate AND.  */
 	  if (sign_bit_comparison_p && GET_CODE (XEXP (op0, 1)) == CONST_INT
-	      && mode_width <= HOST_BITS_PER_INT)
+	      && mode_width <= HOST_BITS_PER_WIDE_INT)
 	    {
-	      op0 = simplify_and_const_int (0, mode, XEXP (op0, 0),
-					    1 << ( mode_width - 1
-						  - INTVAL (XEXP (op0, 1))));
+	      op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
+					    ((HOST_WIDE_INT) 1
+					     << (mode_width - 1
+						 - INTVAL (XEXP (op0, 1)))));
 	      code = (code == LT ? NE : EQ);
 	      continue;
 	    }
@@ -7205,7 +7216,8 @@ simplify_comparison (code, pop0, pop1)
 	      && GET_CODE (XEXP (op0, 1)) == CONST_INT
 	      && INTVAL (XEXP (op0, 1)) == mode_width - 1)
 	    {
-	      op0 = simplify_and_const_int (0, mode, XEXP (op0, 0), 1);
+	      op0 = simplify_and_const_int (NULL_RTX, mode, XEXP (op0, 0),
+					    (HOST_WIDE_INT) 1);
 	      continue;
 	    }
 	  break;
@@ -7219,8 +7231,9 @@ simplify_comparison (code, pop0, pop1)
 	      && XEXP (op0, 1) == XEXP (XEXP (op0, 0), 1)
 	      && (tmode = mode_for_size (mode_width - INTVAL (XEXP (op0, 1)),
 					 MODE_INT, 1)) != VOIDmode
-	      && ((unsigned) const_op <= GET_MODE_MASK (tmode)
-		  || (unsigned) - const_op <= GET_MODE_MASK (tmode)))
+	      && ((unsigned HOST_WIDE_INT) const_op <= GET_MODE_MASK (tmode)
+		  || ((unsigned HOST_WIDE_INT) - const_op
+		      <= GET_MODE_MASK (tmode))))
 	    {
 	      op0 = gen_lowpart_for_combine (tmode, XEXP (XEXP (op0, 0), 0));
 	      continue;
@@ -7234,16 +7247,16 @@ simplify_comparison (code, pop0, pop1)
 	     overflow occurs.  */
 	  if (GET_CODE (XEXP (op0, 1)) == CONST_INT
 	      && INTVAL (XEXP (op0, 1)) >= 0
-	      && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_INT
-	      && mode_width <= HOST_BITS_PER_INT
+	      && INTVAL (XEXP (op0, 1)) < HOST_BITS_PER_WIDE_INT
+	      && mode_width <= HOST_BITS_PER_WIDE_INT
 	      && (significant_bits (XEXP (op0, 0), mode)
-		  & ((1 << INTVAL (XEXP (op0, 1))) - 1)) == 0
+		  & (((HOST_WIDE_INT) 1 << INTVAL (XEXP (op0, 1))) - 1)) == 0
 	      && (const_op == 0
 		  || (floor_log2 (const_op) + INTVAL (XEXP (op0, 1))
 		      < mode_width)))
 	    {
 	      const_op <<= INTVAL (XEXP (op0, 1));
-	      op1 = gen_rtx (CONST_INT, VOIDmode, const_op);
+	      op1 = GEN_INT (const_op);
 	      op0 = XEXP (op0, 0);
 	      continue;
 	    }
@@ -7288,7 +7301,7 @@ simplify_comparison (code, pop0, pop1)
   else if (GET_CODE (op0) == SUBREG && subreg_lowpart_p (op0)
 	   && GET_MODE_CLASS (GET_MODE (op0)) == MODE_INT
 	   && (code == NE || code == EQ)
-	   && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_INT
+	   && GET_MODE_BITSIZE (GET_MODE (op0)) <= HOST_BITS_PER_WIDE_INT
 	   && (significant_bits (SUBREG_REG (op0), GET_MODE (SUBREG_REG (op0)))
 	       & ~ GET_MODE_MASK (GET_MODE (op0))) == 0
 	   && (tem = gen_lowpart_for_combine (GET_MODE (SUBREG_REG (op0)),
@@ -7311,14 +7324,15 @@ simplify_comparison (code, pop0, pop1)
       && GET_MODE_SIZE (mode) < UNITS_PER_WORD
       && cmp_optab->handlers[(int) mode].insn_code == CODE_FOR_nothing)
     for (tmode = GET_MODE_WIDER_MODE (mode);
-	 tmode != VOIDmode && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_INT;
+	 (tmode != VOIDmode
+	  && GET_MODE_BITSIZE (tmode) <= HOST_BITS_PER_WIDE_INT);
 	 tmode = GET_MODE_WIDER_MODE (tmode))
       if (cmp_optab->handlers[(int) tmode].insn_code != CODE_FOR_nothing
 	  && (significant_bits (op0, tmode) & ~ GET_MODE_MASK (mode)) == 0
 	  && (significant_bits (op1, tmode) & ~ GET_MODE_MASK (mode)) == 0
 	  && (code == EQ || code == NE
 	      || (op1 == const0_rtx && (code == LT || code == GE)
-		  && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_INT)))
+		  && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)))
 	{
 	  op0 = gen_lowpart_for_combine (tmode, op0);
 	  op1 = gen_lowpart_for_combine (tmode, op1);
@@ -7326,8 +7340,8 @@ simplify_comparison (code, pop0, pop1)
 	  if (code == LT || code == GE)
 	    {
 	      op0 = gen_binary (AND, tmode, op0,
-				gen_rtx (CONST_INT, VOIDmode,
-					 1 << (GET_MODE_BITSIZE (mode) - 1)));
+				GEN_INT ((HOST_WIDE_INT) 1
+					 << (GET_MODE_BITSIZE (mode) - 1)));
 	      code = (code == LT) ? NE : EQ;
 	    }
 
@@ -7501,7 +7515,7 @@ record_dead_and_set_regs_1 (dest, setter)
 	   gen_lowpart_for_combine (GET_MODE (SET_DEST (setter)),
 				    SET_SRC (setter)));
       else
-	record_value_for_reg (dest, record_dead_insn, 0);
+	record_value_for_reg (dest, record_dead_insn, NULL_RTX);
     }
   else if (GET_CODE (dest) == MEM
 	   /* Ignore pushes, they clobber nothing.  */
@@ -7527,7 +7541,7 @@ record_dead_and_set_regs (insn)
       if (REG_NOTE_KIND (link) == REG_DEAD)
 	reg_last_death[REGNO (XEXP (link, 0))] = insn;
       else if (REG_NOTE_KIND (link) == REG_INC)
-	record_value_for_reg (XEXP (link, 0), insn, 0);
+	record_value_for_reg (XEXP (link, 0), insn, NULL_RTX);
     }
 
   if (GET_CODE (insn) == CALL_INSN)
@@ -7766,8 +7780,8 @@ reg_dead_at_p (reg, insn)
     }
 
   for (i = reg_dead_regno; i < reg_dead_endregno; i++)
-    if (basic_block_live_at_start[block][i / HOST_BITS_PER_INT]
-	& (1 << (i % HOST_BITS_PER_INT)))
+    if (basic_block_live_at_start[block][i / REGSET_ELT_BITS]
+	& ((REGSET_ELT_TYPE) 1 << (i % REGSET_ELT_BITS)))
       return 0;
 
   return 1;
@@ -8035,7 +8049,7 @@ distribute_notes (notes, from_insn, i3, i2, elim_i2, elim_i1)
 	    place = from_insn;
 	  else
 	    {
-	      tem = find_reg_note (XEXP (note, 0), REG_LIBCALL, 0);
+	      tem = find_reg_note (XEXP (note, 0), REG_LIBCALL, NULL_RTX);
 	      place = prev_real_insn (from_insn);
 	      if (tem && place)
 		XEXP (tem, 0) = place;
@@ -8048,7 +8062,7 @@ distribute_notes (notes, from_insn, i3, i2, elim_i2, elim_i1)
 	    place = from_insn;
 	  else
 	    {
-	      tem = find_reg_note (XEXP (note, 0), REG_RETVAL, 0);
+	      tem = find_reg_note (XEXP (note, 0), REG_RETVAL, NULL_RTX);
 	      place = next_real_insn (from_insn);
 	      if (tem && place)
 		XEXP (tem, 0) = place;
@@ -8105,7 +8119,8 @@ distribute_notes (notes, from_insn, i3, i2, elim_i2, elim_i1)
 
 			PATTERN (tem) = pc_rtx;
 
-			distribute_notes (REG_NOTES (tem), tem, tem, 0, 0, 0);
+			distribute_notes (REG_NOTES (tem), tem, tem,
+					  NULL_RTX, NULL_RTX, NULL_RTX);
 			distribute_links (LOG_LINKS (tem));
 
 			PUT_CODE (tem, NOTE);

gcc/flow.c

@@ -455,7 +455,7 @@ find_basic_blocks (f, nonlocal_label_list)
 	/* Make a list of all labels referred to other than by jumps.  */
 	if (code == INSN || code == CALL_INSN)
 	  {
-	    rtx note = find_reg_note (insn, REG_LABEL, 0);
+	    rtx note = find_reg_note (insn, REG_LABEL, NULL_RTX);
 	    if (note != 0)
 	      label_value_list = gen_rtx (EXPR_LIST, VOIDmode, XEXP (note, 0),
 					  label_value_list);
@@ -787,7 +787,7 @@ life_analysis (f, nregs)
 	      && REGNO (SET_DEST (PATTERN (insn))) ==
 			REGNO (SET_SRC (PATTERN (insn)))
 	      /* Insns carrying these notes are useful later on.  */
-	      && ! find_reg_note (insn, REG_EQUAL, 0))
+	      && ! find_reg_note (insn, REG_EQUAL, NULL_RTX))
 	    {
 	      PUT_CODE (insn, NOTE);
 	      NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
@@ -814,7 +814,7 @@ life_analysis (f, nregs)
 		
 	      if (i == XVECLEN (PATTERN (insn), 0)
 		  /* Insns carrying these notes are useful later on.  */
-		  && ! find_reg_note (insn, REG_EQUAL, 0))
+		  && ! find_reg_note (insn, REG_EQUAL, NULL_RTX))
 		{
 		  PUT_CODE (insn, NOTE);
 		  NOTE_LINE_NUMBER (insn) = NOTE_INSN_DELETED;
@@ -906,7 +906,8 @@ life_analysis (f, nregs)
 
 	      for (j = 0; j < regset_size; j++)
 		{
-		  register int x = (basic_block_new_live_at_end[i][j]
+		  register REGSET_ELT_TYPE x
+		    = (basic_block_new_live_at_end[i][j]
 		       & ~basic_block_live_at_end[i][j]);
 		  if (x)
 		    consider = 1;
@@ -933,8 +934,9 @@ life_analysis (f, nregs)
 		 as live at start as well.  */
 	      for (j = 0; j < regset_size; j++)
 		{
-		  register int x = basic_block_new_live_at_end[i][j]
-			& ~basic_block_live_at_end[i][j];
+		  register REGSET_ELT_TYPE x
+		    = (basic_block_new_live_at_end[i][j]
+		       & ~basic_block_live_at_end[i][j]);
 		  basic_block_live_at_start[i][j] |= x;
 		  basic_block_live_at_end[i][j] |= x;
 		}
@@ -949,7 +951,8 @@ life_analysis (f, nregs)
 		     basic_block_live_at_start[i], regset_bytes);
 	      propagate_block (basic_block_live_at_start[i],
 			       basic_block_head[i], basic_block_end[i], 0,
-			       first_pass ? basic_block_significant[i] : 0,
+			       first_pass ? basic_block_significant[i]
+			       : (regset) 0,
 			       i);
 	    }
 
@@ -996,7 +999,7 @@ life_analysis (f, nregs)
   if (n_basic_blocks > 0)
     for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
       if (basic_block_live_at_start[0][i / REGSET_ELT_BITS]
-	  & (1 << (i % REGSET_ELT_BITS)))
+	  & ((REGSET_ELT_TYPE) 1 << (i % REGSET_ELT_BITS)))
 	reg_basic_block[i] = REG_BLOCK_GLOBAL;
 
   /* Now the life information is accurate.
@@ -1014,7 +1017,8 @@ life_analysis (f, nregs)
   for (i = 0; i < n_basic_blocks; i++)
     {
       propagate_block (basic_block_live_at_end[i],
-		       basic_block_head[i], basic_block_end[i], 1, 0, i);
+		       basic_block_head[i], basic_block_end[i], 1,
+		       (regset) 0, i);
 #ifdef USE_C_ALLOCA
       alloca (0);
 #endif
@@ -1028,7 +1032,8 @@ life_analysis (f, nregs)
      ANSI says only volatile variables need this.  */
 #ifdef LONGJMP_RESTORE_FROM_STACK
   for (i = FIRST_PSEUDO_REGISTER; i < nregs; i++)
-    if (regs_live_at_setjmp[i / REGSET_ELT_BITS] & (1 << (i % REGSET_ELT_BITS))
+    if (regs_live_at_setjmp[i / REGSET_ELT_BITS]
+	& ((REGSET_ELT_TYPE) 1 << (i % REGSET_ELT_BITS))
 	&& regno_reg_rtx[i] != 0 && ! REG_USERVAR_P (regno_reg_rtx[i]))
       {
 	reg_live_length[i] = -1;
@@ -1047,14 +1052,15 @@ life_analysis (f, nregs)
      that hard reg where this pseudo is dead, thus clobbering the pseudo.
      Conclusion: such a pseudo must not go in a hard reg.  */
   for (i = FIRST_PSEUDO_REGISTER; i < nregs; i++)
-    if (regs_live_at_setjmp[i / REGSET_ELT_BITS] & (1 << (i % REGSET_ELT_BITS))
+    if ((regs_live_at_setjmp[i / REGSET_ELT_BITS]
+	 & ((REGSET_ELT_TYPE) 1 << (i % REGSET_ELT_BITS)))
 	&& regno_reg_rtx[i] != 0)
       {
 	reg_live_length[i] = -1;
 	reg_basic_block[i] = -1;
       }
 
-  obstack_free (&flow_obstack, 0);
+  obstack_free (&flow_obstack, NULL_PTR);
 }
 
 /* Subroutines of life analysis.  */
@@ -1193,7 +1199,8 @@ propagate_block (old, first, last, final, significant, bnum)
 
   if (final)
     {
-      register int i, offset, bit;
+      register int i, offset;
+      REGSET_ELT_TYPE bit;
 
       num_scratch = 0;
       maxlive = (regset) alloca (regset_bytes);
@@ -1260,7 +1267,7 @@ propagate_block (old, first, last, final, significant, bnum)
       if (GET_RTX_CLASS (GET_CODE (insn)) == 'i')
 	{
 	  register int i;
-	  rtx note = find_reg_note (insn, REG_RETVAL, 0);
+	  rtx note = find_reg_note (insn, REG_RETVAL, NULL_RTX);
 	  int insn_is_dead
 	    = (insn_dead_p (PATTERN (insn), old, 0)
 	       /* Don't delete something that refers to volatile storage!  */
@@ -1337,7 +1344,7 @@ propagate_block (old, first, last, final, significant, bnum)
 	  if (libcall_is_dead)
 	    {
 	      /* Mark the dest reg as `significant'.  */
-	      mark_set_regs (old, dead, PATTERN (insn), 0, significant);
+	      mark_set_regs (old, dead, PATTERN (insn), NULL_RTX, significant);
 
 	      insn = XEXP (note, 0);
 	      prev = PREV_INSN (insn);
@@ -1358,8 +1365,8 @@ propagate_block (old, first, last, final, significant, bnum)
 		 DEAD gets those set by it.  Dead insns don't make anything
 		 live.  */
 
-	      mark_set_regs (old, dead, PATTERN (insn), final ? insn : 0,
-			     significant);
+	      mark_set_regs (old, dead, PATTERN (insn),
+			     final ? insn : NULL_RTX, significant);
 
 	      /* If an insn doesn't use CC0, it becomes dead since we 
 		 assume that every insn clobbers it.  So show it dead here;
@@ -1388,11 +1395,12 @@ propagate_block (old, first, last, final, significant, bnum)
 		  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 		    if (call_used_regs[i] && ! global_regs[i])
 		      dead[i / REGSET_ELT_BITS]
-			|= (1 << (i % REGSET_ELT_BITS));
+			|= ((REGSET_ELT_TYPE) 1 << (i % REGSET_ELT_BITS));
 
 		  /* The stack ptr is used (honorarily) by a CALL insn.  */
 		  live[STACK_POINTER_REGNUM / REGSET_ELT_BITS]
-		    |= (1 << (STACK_POINTER_REGNUM % REGSET_ELT_BITS));
+		    |= ((REGSET_ELT_TYPE) 1
+			<< (STACK_POINTER_REGNUM % REGSET_ELT_BITS));
 
 		  /* Calls may also reference any of the global registers,
 		     so they are made live.  */
@@ -1400,7 +1408,7 @@ propagate_block (old, first, last, final, significant, bnum)
 		  for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 		    if (global_regs[i])
 		      live[i / REGSET_ELT_BITS]
-			|= (1 << (i % REGSET_ELT_BITS));
+			|= ((REGSET_ELT_TYPE) 1 << (i % REGSET_ELT_BITS));
 
 		  /* Calls also clobber memory.  */
 		  last_mem_set = 0;
@@ -1435,18 +1443,18 @@ propagate_block (old, first, last, final, significant, bnum)
 	    {
 	      for (i = 0; i < regset_size; i++)
 		{
-		  register int diff = live[i] & ~maxlive[i];
+		  register REGSET_ELT_TYPE diff = live[i] & ~maxlive[i];
 
 		  if (diff)
 		    {
 		      register int regno;
 		      maxlive[i] |= diff;
 		      for (regno = 0; diff && regno < REGSET_ELT_BITS; regno++)
-			if (diff & (1 << regno))
+			if (diff & ((REGSET_ELT_TYPE) 1 << regno))
 			  {
 			    regs_sometimes_live[sometimes_max].offset = i;
 			    regs_sometimes_live[sometimes_max].bit = regno;
-			    diff &= ~ (1 << regno);
+			    diff &= ~ ((REGSET_ELT_TYPE) 1 << regno);
 			    sometimes_max++;
 			  }
 		    }
@@ -1456,7 +1464,7 @@ propagate_block (old, first, last, final, significant, bnum)
 		register struct foo *p = regs_sometimes_live;
 		for (i = 0; i < sometimes_max; i++, p++)
 		  {
-		    if (old[p->offset] & (1 << p->bit))
+		    if (old[p->offset] & ((REGSET_ELT_TYPE) 1 << p->bit))
 		      reg_live_length[p->offset * REGSET_ELT_BITS + p->bit]++;
 		  }
 	      }
@@ -1513,7 +1521,8 @@ insn_dead_p (x, needed, call_ok)
 	{
 	  register int regno = REGNO (r);
 	  register int offset = regno / REGSET_ELT_BITS;
-	  register int bit = 1 << (regno % REGSET_ELT_BITS);
+	  register REGSET_ELT_TYPE bit
+	    = (REGSET_ELT_TYPE) 1 << (regno % REGSET_ELT_BITS);
 
 	  if ((regno < FIRST_PSEUDO_REGISTER && global_regs[regno])
 	      /* Make sure insns to set frame pointer aren't deleted.  */
@@ -1535,7 +1544,8 @@ insn_dead_p (x, needed, call_ok)
 
 	      while (--n > 0)
 		if ((needed[(regno + n) / REGSET_ELT_BITS]
-		     & 1 << ((regno + n) % REGSET_ELT_BITS)) != 0)
+		     & ((REGSET_ELT_TYPE) 1
+			<< ((regno + n) % REGSET_ELT_BITS))) != 0)
 		  return 0;
 	    }
 
@@ -1639,7 +1649,7 @@ regno_uninitialized (regno)
     return 0;
 
   return (basic_block_live_at_start[0][regno / REGSET_ELT_BITS]
-	  & (1 << (regno % REGSET_ELT_BITS)));
+	  & ((REGSET_ELT_TYPE) 1 << (regno % REGSET_ELT_BITS)));
 }
 
 /* 1 if register REGNO was alive at a place where `setjmp' was called
@@ -1655,9 +1665,9 @@ regno_clobbered_at_setjmp (regno)
 
   return ((reg_n_sets[regno] > 1
 	   || (basic_block_live_at_start[0][regno / REGSET_ELT_BITS]
-	       & (1 << (regno % REGSET_ELT_BITS))))
+	       & ((REGSET_ELT_TYPE) 1 << (regno % REGSET_ELT_BITS))))
 	  && (regs_live_at_setjmp[regno / REGSET_ELT_BITS]
-	      & (1 << (regno % REGSET_ELT_BITS))));
+	      & ((REGSET_ELT_TYPE) 1 << (regno % REGSET_ELT_BITS))));
 }
 
 /* Process the registers that are set within X.
@@ -1750,9 +1760,10 @@ mark_set_1 (needed, dead, x, insn, significant)
     /* && regno != STACK_POINTER_REGNUM) -- let's try without this.  */
     {
       register int offset = regno / REGSET_ELT_BITS;
-      register int bit = 1 << (regno % REGSET_ELT_BITS);
-      int all_needed = (needed[offset] & bit) != 0;
-      int some_needed = (needed[offset] & bit) != 0;
+      register REGSET_ELT_TYPE bit
+	= (REGSET_ELT_TYPE) 1 << (regno % REGSET_ELT_BITS);
+      REGSET_ELT_TYPE all_needed = (needed[offset] & bit);
+      REGSET_ELT_TYPE some_needed = (needed[offset] & bit);
 
       /* Mark it as a significant register for this basic block.  */
       if (significant)
@@ -1777,13 +1788,15 @@ mark_set_1 (needed, dead, x, insn, significant)
 	    {
 	      if (significant)
 		significant[(regno + n) / REGSET_ELT_BITS]
-		  |= 1 << ((regno + n) % REGSET_ELT_BITS);
+		  |= (REGSET_ELT_TYPE) 1 << ((regno + n) % REGSET_ELT_BITS);
 	      dead[(regno + n) / REGSET_ELT_BITS]
-		|= 1 << ((regno + n) % REGSET_ELT_BITS);
-	      some_needed |= (needed[(regno + n) / REGSET_ELT_BITS]
-			      & 1 << ((regno + n) % REGSET_ELT_BITS));
-	      all_needed &= (needed[(regno + n) / REGSET_ELT_BITS]
-			     & 1 << ((regno + n) % REGSET_ELT_BITS));
+		|= (REGSET_ELT_TYPE) 1 << ((regno + n) % REGSET_ELT_BITS);
+	      some_needed
+		|= (needed[(regno + n) / REGSET_ELT_BITS]
+		    & (REGSET_ELT_TYPE) 1 << ((regno + n) % REGSET_ELT_BITS));
+	      all_needed
+		&= (needed[(regno + n) / REGSET_ELT_BITS]
+		    & (REGSET_ELT_TYPE) 1 << ((regno + n) % REGSET_ELT_BITS));
 	    }
 	}
       /* Additional data to record if this is the final pass.  */
@@ -1870,7 +1883,8 @@ mark_set_1 (needed, dead, x, insn, significant)
 	      for (i = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1;
 		   i >= 0; i--)
 		if ((needed[(regno + i) / REGSET_ELT_BITS]
-		     & 1 << ((regno + i) % REGSET_ELT_BITS)) == 0)
+		     & ((REGSET_ELT_TYPE) 1
+			<< ((regno + i) % REGSET_ELT_BITS))) == 0)
 		  REG_NOTES (insn)
 		    = gen_rtx (EXPR_LIST, REG_UNUSED,
 			       gen_rtx (REG, word_mode, regno + i),
@@ -2002,7 +2016,7 @@ find_auto_inc (needed, x, insn)
 		 it as needed, we'll put a REG_DEAD note for it
 		 on this insn, which is incorrect.  */
 	      needed[regno / REGSET_ELT_BITS]
-		|= 1 << (regno % REGSET_ELT_BITS);
+		|= (REGSET_ELT_TYPE) 1 << (regno % REGSET_ELT_BITS);
 
 	      /* If there are any calls between INSN and INCR, show
 		 that REGNO now crosses them.  */
@@ -2119,7 +2133,8 @@ mark_used_regs (needed, live, x, final, insn)
       regno = REGNO (x);
       {
 	register int offset = regno / REGSET_ELT_BITS;
-	register int bit = 1 << (regno % REGSET_ELT_BITS);
+	register REGSET_ELT_TYPE bit
+	  = (REGSET_ELT_TYPE) 1 << (regno % REGSET_ELT_BITS);
 	int all_needed = (needed[offset] & bit) != 0;
 	int some_needed = (needed[offset] & bit) != 0;
 
@@ -2158,11 +2173,13 @@ mark_used_regs (needed, live, x, final, insn)
 	    while (--n > 0)
 	      {
 		live[(regno + n) / REGSET_ELT_BITS]
-		  |= 1 << ((regno + n) % REGSET_ELT_BITS);
-		some_needed |= (needed[(regno + n) / REGSET_ELT_BITS]
-				& 1 << ((regno + n) % REGSET_ELT_BITS));
-		all_needed &= (needed[(regno + n) / REGSET_ELT_BITS]
-			       & 1 << ((regno + n) % REGSET_ELT_BITS));
+		  |= (REGSET_ELT_TYPE) 1 << ((regno + n) % REGSET_ELT_BITS);
+		some_needed
+		  |= (needed[(regno + n) / REGSET_ELT_BITS]
+		      & (REGSET_ELT_TYPE) 1 << ((regno + n) % REGSET_ELT_BITS));
+		all_needed
+		  &= (needed[(regno + n) / REGSET_ELT_BITS]
+		      & (REGSET_ELT_TYPE) 1 << ((regno + n) % REGSET_ELT_BITS));
 	      }
 	  }
 	if (final)
@@ -2231,7 +2248,8 @@ mark_used_regs (needed, live, x, final, insn)
 		    for (i = HARD_REGNO_NREGS (regno, GET_MODE (x)) - 1;
 			 i >= 0; i--)
 		      if ((needed[(regno + i) / REGSET_ELT_BITS]
-			   & 1 << ((regno + i) % REGSET_ELT_BITS)) == 0
+			   & ((REGSET_ELT_TYPE) 1
+			      << ((regno + i) % REGSET_ELT_BITS))) == 0
 			  && ! dead_or_set_regno_p (insn, regno + i))
 			REG_NOTES (insn)
 			  = gen_rtx (EXPR_LIST, REG_DEAD,
@@ -2313,11 +2331,12 @@ mark_used_regs (needed, live, x, final, insn)
 	  || (! FRAME_POINTER_REQUIRED && flag_omit_frame_pointer))
 #endif
 	live[STACK_POINTER_REGNUM / REGSET_ELT_BITS]
-	  |= 1 << (STACK_POINTER_REGNUM % REGSET_ELT_BITS);
+	  |= (REGSET_ELT_TYPE) 1 << (STACK_POINTER_REGNUM % REGSET_ELT_BITS);
 
       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 	if (global_regs[i])
-	  live[i / REGSET_ELT_BITS] |= 1 << (i % REGSET_ELT_BITS);
+	  live[i / REGSET_ELT_BITS]
+	    |= (REGSET_ELT_TYPE) 1 << (i % REGSET_ELT_BITS);
       break;
     }
 
@@ -2358,7 +2377,7 @@ try_pre_increment_1 (insn)
   /* Find the next use of this reg.  If in same basic block,
      make it do pre-increment or pre-decrement if appropriate.  */
   rtx x = PATTERN (insn);
-  int amount = ((GET_CODE (SET_SRC (x)) == PLUS ? 1 : -1)
+  HOST_WIDE_INT amount = ((GET_CODE (SET_SRC (x)) == PLUS ? 1 : -1)
 		* INTVAL (XEXP (SET_SRC (x), 1)));
   int regno = REGNO (SET_DEST (x));
   rtx y = reg_next_use[regno];
@@ -2396,7 +2415,7 @@ try_pre_increment_1 (insn)
 static int
 try_pre_increment (insn, reg, amount)
      rtx insn, reg;
-     int amount;
+     HOST_WIDE_INT amount;
 {
   register rtx use;
 

gcc/function.c

@@ -1205,7 +1205,7 @@ fixup_var_refs_1 (var, loc, insn, replacements)
 		  /* Make the change and see if the insn remains valid.  */
 		  INSN_CODE (insn) = -1;
 		  XEXP (x, 0) = newmem;
-		  XEXP (x, 2) = gen_rtx (CONST_INT, VOIDmode, pos);
+		  XEXP (x, 2) = GEN_INT (pos);
 
 		  if (recog_memoized (insn) >= 0)
 		    return;
@@ -1270,7 +1270,7 @@ fixup_var_refs_1 (var, loc, insn, replacements)
 	optimize_bit_field (x, insn, 0);
       if (GET_CODE (SET_SRC (x)) == SIGN_EXTRACT
 	  || GET_CODE (SET_SRC (x)) == ZERO_EXTRACT)
-	optimize_bit_field (x, insn, 0);
+	optimize_bit_field (x, insn, NULL_PTR);
 
       /* If SET_DEST is now a paradoxical SUBREG, put the result of this
 	 insn into a pseudo and store the low part of the pseudo into VAR. */
@@ -1362,7 +1362,7 @@ fixup_var_refs_1 (var, loc, insn, replacements)
 		    /* Make the change and see if the insn remains valid.  */
 		    INSN_CODE (insn) = -1;
 		    XEXP (outerdest, 0) = newmem;
-		    XEXP (outerdest, 2) = gen_rtx (CONST_INT, VOIDmode, pos);
+		    XEXP (outerdest, 2) = GEN_INT (pos);
 		    
 		    if (recog_memoized (insn) >= 0)
 		      return;
@@ -1867,7 +1867,7 @@ instantiate_virtual_regs (fndecl, insns)
 	|| GET_CODE (insn) == CALL_INSN)
       {
 	instantiate_virtual_regs_1 (&PATTERN (insn), insn, 1);
-	instantiate_virtual_regs_1 (&REG_NOTES (insn), 0, 0);
+	instantiate_virtual_regs_1 (&REG_NOTES (insn), NULL_RTX, 0);
       }
 
   /* Now instantiate the remaining register equivalences for debugging info.
@@ -1904,11 +1904,13 @@ instantiate_decls (fndecl, valid_only)
     {
       if (DECL_RTL (decl) && GET_CODE (DECL_RTL (decl)) == MEM)
 	instantiate_virtual_regs_1 (&XEXP (DECL_RTL (decl), 0),
-				    valid_only ? DECL_RTL (decl) : 0, 0);
+				    (valid_only ? DECL_RTL (decl) : NULL_RTX),
+				    0);
       if (DECL_INCOMING_RTL (decl)
 	  && GET_CODE (DECL_INCOMING_RTL (decl)) == MEM)
 	instantiate_virtual_regs_1 (&XEXP (DECL_INCOMING_RTL (decl), 0),
-				    valid_only ? DECL_INCOMING_RTL (decl) : 0,
+				    (valid_only ? DECL_INCOMING_RTL (decl)
+				     : NULL_RTX),
 				    0);
     }
 
@@ -1938,7 +1940,7 @@ instantiate_decls_1 (let, valid_only)
   for (t = BLOCK_VARS (let); t; t = TREE_CHAIN (t))
     if (DECL_RTL (t) && GET_CODE (DECL_RTL (t)) == MEM)
       instantiate_virtual_regs_1 (& XEXP (DECL_RTL (t), 0),
-				  valid_only ? DECL_RTL (t) : 0, 0);
+				  valid_only ? DECL_RTL (t) : NULL_RTX, 0);
 
   /* Process all subblocks.  */
   for (t = BLOCK_SUBBLOCKS (let); t; t = TREE_CHAIN (t))
@@ -2023,10 +2025,10 @@ instantiate_virtual_regs_1 (loc, object, extra_insns)
 
 	  start_sequence ();
 	  if (GET_CODE (SET_SRC (x)) != REG)
-	    temp = force_operand (SET_SRC (x), 0);
+	    temp = force_operand (SET_SRC (x), NULL_RTX);
 	  else
 	    temp = SET_SRC (x);
-	  temp = force_operand (plus_constant (temp, offset), 0);
+	  temp = force_operand (plus_constant (temp, offset), NULL_RTX);
 	  seq = get_insns ();
 	  end_sequence ();
 
@@ -2128,7 +2130,7 @@ instantiate_virtual_regs_1 (loc, object, extra_insns)
 		  XEXP (x, 0) = old;
 
 		  start_sequence ();
-		  temp = force_operand (new, 0);
+		  temp = force_operand (new, NULL_RTX);
 		  seq = get_insns ();
 		  end_sequence ();
 
@@ -2267,7 +2269,7 @@ instantiate_virtual_regs_1 (loc, object, extra_insns)
 		return 0;
 
 	      start_sequence ();
-	      temp = force_operand (temp, 0);
+	      temp = force_operand (temp, NULL_RTX);
 	      seq = get_insns ();
 	      end_sequence ();
 
@@ -2490,7 +2492,7 @@ assign_parms (fndecl, second_time)
     {
       tree type = build_pointer_type (fntype);
 
-      function_result_decl = build_decl (PARM_DECL, 0, type);
+      function_result_decl = build_decl (PARM_DECL, NULL_TREE, type);
 
       DECL_ARG_TYPE (function_result_decl) = type;
       TREE_CHAIN (function_result_decl) = fnargs;
@@ -2501,9 +2503,9 @@ assign_parms (fndecl, second_time)
   bzero (parm_reg_stack_loc, nparmregs * sizeof (rtx));
 
 #ifdef INIT_CUMULATIVE_INCOMING_ARGS
-  INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, 0);
+  INIT_CUMULATIVE_INCOMING_ARGS (args_so_far, fntype, NULL_PTR);
 #else
-  INIT_CUMULATIVE_ARGS (args_so_far, fntype, 0);
+  INIT_CUMULATIVE_ARGS (args_so_far, fntype, NULL_PTR);
 #endif
 
   /* We haven't yet found an argument that we must push and pretend the
@@ -2849,7 +2851,7 @@ assign_parms (fndecl, second_time)
 		  && REGNO (entry_parm) < FIRST_PSEUDO_REGISTER
 		  && ! HARD_REGNO_MODE_OK (REGNO (entry_parm),
 					   GET_MODE (entry_parm)))
-		convert_move (parmreg, copy_to_reg (entry_parm));
+		convert_move (parmreg, copy_to_reg (entry_parm), 0);
 	      else
 		convert_move (parmreg, validize_mem (entry_parm), 0);
 	    }
@@ -2953,11 +2955,10 @@ assign_parms (fndecl, second_time)
 
 #ifdef ARGS_GROW_DOWNWARD
   current_function_arg_offset_rtx
-    = (stack_args_size.var == 0 ? gen_rtx (CONST_INT, VOIDmode,
-					   -stack_args_size.constant)
+    = (stack_args_size.var == 0 ? GEN_INT (-stack_args_size.constant)
        : expand_expr (size_binop (MINUS_EXPR, stack_args_size.var,	
 				  size_int (-stack_args_size.constant)),   
-		      0, VOIDmode, 0));
+		      NULL_RTX, VOIDmode, 0));
 #else
   current_function_arg_offset_rtx = ARGS_SIZE_RTX (stack_args_size);
 #endif
@@ -3497,10 +3498,10 @@ round_trampoline_addr (tramp)
   /* Round address up to desired boundary.  */
   rtx temp = gen_reg_rtx (Pmode);
   temp = expand_binop (Pmode, add_optab, tramp,
-		       gen_rtx (CONST_INT, VOIDmode, TRAMPOLINE_ALIGNMENT - 1),
+		       GEN_INT (TRAMPOLINE_ALIGNMENT - 1),
 		       temp, 0, OPTAB_LIB_WIDEN);
   tramp = expand_binop (Pmode, and_optab, temp,
-			gen_rtx (CONST_INT, VOIDmode, - TRAMPOLINE_ALIGNMENT),
+			GEN_INT (- TRAMPOLINE_ALIGNMENT),
 			temp, 0, OPTAB_LIB_WIDEN);
 #endif
   return tramp;
@@ -3615,7 +3616,7 @@ init_function_start (subr, filename, line)
   /* Make sure first insn is a note even if we don't want linenums.
      This makes sure the first insn will never be deleted.
      Also, final expects a note to appear there.  */
-  emit_note (0, NOTE_INSN_DELETED);
+  emit_note (NULL_PTR, NOTE_INSN_DELETED);
 
   /* Set flags used by final.c.  */
   if (aggregate_value_p (DECL_RESULT (subr)))
@@ -3795,12 +3796,12 @@ expand_function_start (subr, parms_have_cleanups)
      The move is supposed to make sdb output more accurate.  */
   /* Indicate the beginning of the function body,
      as opposed to parm setup.  */
-  emit_note (0, NOTE_INSN_FUNCTION_BEG);
+  emit_note (NULL_PTR, NOTE_INSN_FUNCTION_BEG);
 
   /* If doing stupid allocation, mark parms as born here.  */
 
   if (GET_CODE (get_last_insn ()) != NOTE)
-    emit_note (0, NOTE_INSN_DELETED);
+    emit_note (NULL_PTR, NOTE_INSN_DELETED);
   parm_birth_insn = get_last_insn ();
 
   if (obey_regdecls)
@@ -3841,11 +3842,11 @@ expand_function_start (subr, parms_have_cleanups)
   /* After the display initializations is where the tail-recursion label
      should go, if we end up needing one.   Ensure we have a NOTE here
      since some things (like trampolines) get placed before this.  */
-  tail_recursion_reentry = emit_note (0, NOTE_INSN_DELETED);
+  tail_recursion_reentry = emit_note (NULL_PTR, NOTE_INSN_DELETED);
 
   /* Evaluate now the sizes of any types declared among the arguments.  */
   for (tem = nreverse (get_pending_sizes ()); tem; tem = TREE_CHAIN (tem))
-    expand_expr (TREE_VALUE (tem), 0, VOIDmode, 0);
+    expand_expr (TREE_VALUE (tem), NULL_RTX, VOIDmode, 0);
 
   /* Make sure there is a line number after the function entry setup code.  */
   force_next_line_note ();
@@ -3905,8 +3906,7 @@ expand_function_end (filename, line)
       start_sequence ();
       tramp = change_address (initial_trampoline, BLKmode,
 			      round_trampoline_addr (XEXP (tramp, 0)));
-      emit_block_move (tramp, initial_trampoline,
-		       gen_rtx (CONST_INT, VOIDmode, TRAMPOLINE_SIZE),
+      emit_block_move (tramp, initial_trampoline, GEN_INT (TRAMPOLINE_SIZE),
 		       FUNCTION_BOUNDARY / BITS_PER_UNIT);
       INITIALIZE_TRAMPOLINE (XEXP (tramp, 0),
 			     XEXP (DECL_RTL (function), 0), context);
@@ -3938,7 +3938,7 @@ expand_function_end (filename, line)
 
   /* End any sequences that failed to be closed due to syntax errors.  */
   while (in_sequence_p ())
-    end_sequence (0);
+    end_sequence ();
 
   /* Outside function body, can't compute type's actual size
      until next function's body starts.  */
@@ -3971,7 +3971,7 @@ expand_function_end (filename, line)
   /* Mark the end of the function body.
      If control reaches this insn, the function can drop through
      without returning a value.  */
-  emit_note (0, NOTE_INSN_FUNCTION_END);
+  emit_note (NULL_PTR, NOTE_INSN_FUNCTION_END);
 
   /* Output a linenumber for the end of the function.
      SDB depends on this.  */
@@ -3997,7 +3997,7 @@ expand_function_end (filename, line)
 	rtx tem = 0;
 
 	emit_stack_save (SAVE_FUNCTION, &tem, parm_birth_insn);
-	emit_stack_restore (SAVE_FUNCTION, tem, 0);
+	emit_stack_restore (SAVE_FUNCTION, tem, NULL_RTX);
       }
 
   /* If scalar return value was computed in a pseudo-reg,
@@ -4072,7 +4072,7 @@ expand_function_end (filename, line)
   /* If you have any cleanups to do at this point,
      and they need to create temporary variables,
      then you will lose.  */
-  fixup_gotos (0, 0, 0, get_insns (), 0);
+  fixup_gotos (NULL_PTR, NULL_RTX, NULL_TREE, get_insns (), 0);
 }
 
 /* These arrays record the INSN_UIDs of the prologue and epilogue insns.  */

gcc/genpeep.c

@@ -106,7 +106,7 @@ gen_peephole (peep)
       /* Walk the insn's pattern, remembering at all times the path
 	 down to the walking point.  */
 
-      match_rtx (XVECEXP (peep, 0, i), 0, insn_code_number);
+      match_rtx (XVECEXP (peep, 0, i), NULL_PTR, insn_code_number);
     }
 
   /* We get this far if the pattern matches.

gcc/halfpic.c

@@ -34,7 +34,6 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #include "tree.h"
 #include "rtl.h"
 #include <stdio.h>
-#include <string.h>
 #include "obstack.h"
 
 #define obstack_chunk_alloc xmalloc

gcc/jump.c

 /* Optimize jump instructions, for GNU compiler.
-   Copyright (C) 1987, 1988, 1989, 1991 Free Software Foundation, Inc.
+   Copyright (C) 1987, 1988, 1989, 1991, 1992 Free Software Foundation, Inc.
 
 This file is part of GNU CC.
 
@@ -368,8 +368,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
 		  }
 		else
 		  XEXP (SET_SRC (PATTERN (stack_adjust_insn)), 1)
-		    = gen_rtx (CONST_INT, VOIDmode, 
-			       stack_adjust_amount - total_pushed);
+		    = GEN_INT (stack_adjust_amount - total_pushed);
 
 		/* Change the appropriate push insns to ordinary stores.  */
 		p = insn;
@@ -396,7 +395,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
 		    if (total_pushed < 0)
 		      {
 			emit_insn_before (gen_add2_insn (stack_pointer_rtx,
-							 gen_rtx (CONST_INT, VOIDmode, - total_pushed)),
+							 GEN_INT (- total_pushed)),
 					  p);
 			break;
 		      }
@@ -433,8 +432,8 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
 		else if (sreg >= 0 && dreg >= 0)
 		  {
 		    rtx trial;
-		    rtx tem = find_equiv_reg (0, insn, 0,
-					      sreg, 0, dreg,
+		    rtx tem = find_equiv_reg (NULL_RTX, insn, 0,
+					      sreg, NULL_PTR, dreg,
 					      GET_MODE (SET_SRC (body)));
 
 #ifdef PRESERVE_DEATH_INFO_REGNO_P
@@ -463,8 +462,9 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
 		      }
 		  }
 		else if (dreg >= 0 && CONSTANT_P (SET_SRC (body))
-			 && find_equiv_reg (SET_SRC (body), insn, 0, dreg, 0,
-					    0, GET_MODE (SET_DEST (body))))
+			 && find_equiv_reg (SET_SRC (body), insn, 0, dreg,
+					    NULL_PTR, 0,
+					    GET_MODE (SET_DEST (body))))
 		  {
 		    /* This handles the case where we have two consecutive
 		       assignments of the same constant to pseudos that didn't
@@ -629,7 +629,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
 	     it into a RETURN insn, possibly a conditional one.  */
 	  if (JUMP_LABEL (insn)
 	      && next_active_insn (JUMP_LABEL (insn)) == 0)
-	    changed |= redirect_jump (insn, 0);
+	    changed |= redirect_jump (insn, NULL_RTX);
 
 	  /* Detect jump to following insn.  */
 	  if (reallabelprev == insn && condjump_p (insn))
@@ -902,7 +902,7 @@ jump_optimize (f, cross_jump, noop_moves, after_regscan)
 		  if (normalizep != 1)
 		    target = expand_and (yes, target,
 					 (GET_CODE (target) == REG
-					  ? target : 0));
+					  ? target : NULL_RTX));
 		  seq = gen_sequence ();
 		  end_sequence ();
 		  emit_insn_before (seq, temp5);
@@ -1718,8 +1718,8 @@ duplicate_loop_exit_test (loop_start)
 	case JUMP_INSN:
 	case INSN:
 	  if (++num_insns > 20
-	      || find_reg_note (insn, REG_RETVAL, 0)
-	      || find_reg_note (insn, REG_LIBCALL, 0))
+	      || find_reg_note (insn, REG_RETVAL, NULL_RTX)
+	      || find_reg_note (insn, REG_LIBCALL, NULL_RTX))
 	    return 0;
 	  break;
 	}
@@ -1996,10 +1996,10 @@ find_cross_jump (e1, e2, minimum, f1, f2)
 	  rtx equiv2;
 
 	  if (!lose && GET_CODE (p1) == GET_CODE (p2)
-	      && ((equiv1 = find_reg_note (i1, REG_EQUAL, 0)) != 0
-		  || (equiv1 = find_reg_note (i1, REG_EQUIV, 0)) != 0)
-	      && ((equiv2 = find_reg_note (i2, REG_EQUAL, 0)) != 0
-		  || (equiv2 = find_reg_note (i2, REG_EQUIV, 0)) != 0)
+	      && ((equiv1 = find_reg_note (i1, REG_EQUAL, NULL_RTX)) != 0
+		  || (equiv1 = find_reg_note (i1, REG_EQUIV, NULL_RTX)) != 0)
+	      && ((equiv2 = find_reg_note (i2, REG_EQUAL, NULL_RTX)) != 0
+		  || (equiv2 = find_reg_note (i2, REG_EQUIV, NULL_RTX)) != 0)
 	      /* If the equivalences are not to a constant, they may
 		 reference pseudos that no longer exist, so we can't
 		 use them.  */
@@ -2743,7 +2743,7 @@ mark_jump_label (x, insn, cross_jump)
 	int eltnum = code == ADDR_DIFF_VEC ? 1 : 0;
 
 	for (i = 0; i < XVECLEN (x, eltnum); i++)
-	  mark_jump_label (XVECEXP (x, eltnum, i), 0, cross_jump);
+	  mark_jump_label (XVECEXP (x, eltnum, i), NULL_RTX, cross_jump);
 	return;
       }
     }
@@ -2788,7 +2788,7 @@ delete_jump (insn)
 	  && sets_cc0_p (PATTERN (prev)))
 	{
 	  if (sets_cc0_p (PATTERN (prev)) > 0
-	      && !FIND_REG_INC_NOTE (prev, 0))
+	      && !FIND_REG_INC_NOTE (prev, NULL_RTX))
 	    delete_insn (prev);
 	  else
 	    /* Otherwise, show that cc0 won't be used.  */
@@ -2834,7 +2834,7 @@ delete_jump (insn)
 
 		if (reg_set_p (XEXP (note, 0), PATTERN (our_prev)))
 		  {
-		    if (FIND_REG_INC_NOTE (our_prev, 0))
+		    if (FIND_REG_INC_NOTE (our_prev, NULL_RTX))
 		      break;
 
 		    if (GET_CODE (PATTERN (our_prev)) == PARALLEL)
@@ -3463,6 +3463,11 @@ rtx_renumbered_equal_p (x, y)
       register int j;
       switch (fmt[i])
 	{
+	case 'w':
+	  if (XWINT (x, i) != XWINT (y, i))
+	    return 0;
+	  break;
+
 	case 'i':
 	  if (XINT (x, i) != XINT (y, i))
 	    return 0;
@@ -3875,6 +3880,11 @@ rtx_equal_for_thread_p (x, y, yinsn)
     {
       switch (fmt[i])
 	{
+	case 'w':
+	  if (XWINT (x, i) != XWINT (y, i))
+	    return 0;
+	  break;
+
 	case 'n':
 	case 'i':
 	  if (XINT (x, i) != XINT (y, i))

gcc/machmode.h

@@ -33,6 +33,34 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
 #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
 
+/* Find the largest host integer type and set its size and type.  */
+
+#ifndef HOST_BITS_PER_WIDE_INT
+
+#if HOST_BITS_PER_LONG > HOST_BITS_PER_INT
+#define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_LONG
+#define HOST_WIDE_INT long
+#else
+#define HOST_BITS_PER_WIDE_INT HOST_BITS_PER_INT
+#define HOST_WIDE_INT int
+#endif
+
+#endif
+
+/* Define the number of entries in an 8-bit `shorts' array needed to represent
+   the largest supported constant, which is twice the width of the largest
+   host integer type.  */
+
+#ifndef MAX_SHORTS
+#define MAX_SHORTS (HOST_BITS_PER_WIDE_INT * 2 / 8)
+#endif
+
+/* Provide a default way to print an address in hex via printf.  */
+
+#ifndef HOST_PTR_PRINTF
+#define HOST_PTR_PRINTF sizeof (int) == sizeof (char *) ? "%x" : "%lx"
+#endif
+
 /* Make an enum class that gives all the machine modes.  */
 
 #define DEF_MACHMODE(SYM, NAME, TYPE, SIZE, UNIT, WIDER)  SYM,
@@ -90,8 +118,8 @@ extern int mode_unit_size[];
    that fit within mode MODE.  */
 
 #define GET_MODE_MASK(MODE)  \
-   ((GET_MODE_BITSIZE (MODE) >= HOST_BITS_PER_INT)  \
-    ? -1 : ((1 << GET_MODE_BITSIZE (MODE)) - 1))
+   ((GET_MODE_BITSIZE (MODE) >= HOST_BITS_PER_WIDE_INT)  \
+    ?(HOST_WIDE_INT) ~0 : (((HOST_WIDE_INT) 1 << GET_MODE_BITSIZE (MODE)) - 1))
 
 /* Get the next wider natural mode (eg, QI -> HI -> SI -> DI -> TI).  */
 

gcc/rtl.def

@@ -464,7 +464,7 @@ DEF_RTL_EXPR(TRAP_IF, "trap_if", "ei", 'x')
    ---------------------------------------------------------------------- */
 
 /* numeric integer constant */
-DEF_RTL_EXPR(CONST_INT, "const_int", "i", 'o')
+DEF_RTL_EXPR(CONST_INT, "const_int", "w", 'o')
 
 /* numeric double constant.
    Operand 0 is the MEM that stores this constant in memory,
@@ -473,7 +473,7 @@ DEF_RTL_EXPR(CONST_INT, "const_int", "i", 'o')
    Remaining operands hold the actual value.
    The number of operands may be more than 2 if cross-compiling;
    see init_rtl.  */
-DEF_RTL_EXPR(CONST_DOUBLE, "const_double", "e0ii", 'o')
+DEF_RTL_EXPR(CONST_DOUBLE, "const_double", "e0ww", 'o')
 
 /* String constant.  Used only for attributes right now.  */
 DEF_RTL_EXPR(CONST_STRING, "const_string", "s", 'o')

gcc/rtl.h

@@ -55,6 +55,7 @@ extern char rtx_class[];
 
 typedef union rtunion_def
 {
+  HOST_WIDE_INT rtwint;
   int rtint;
   char *rtstr;
   struct rtx_def *rtx;
@@ -132,6 +133,16 @@ typedef struct rtx_def
 
 #define NULL_RTX (rtx) 0
 
+/* Define a generic NULL if one hasn't already been defined.  */
+
+#ifndef NULL
+#define NULL 0
+#endif
+
+#ifndef NULL_PTR
+#define NULL_PTR (char *) NULL
+#endif
+
 /* Define macros to access the `code' field of the rtx.  */
 
 #ifdef SHORT_ENUM_BUG
@@ -179,6 +190,7 @@ typedef struct rtvec_def{
 
 #define XEXP(RTX, N)	((RTX)->fld[N].rtx)
 #define XINT(RTX, N)	((RTX)->fld[N].rtint)
+#define XWINT(RTX, N)	((RTX)->fld[N].rtwint)
 #define XSTR(RTX, N)	((RTX)->fld[N].rtstr)
 #define XVEC(RTX, N)	((RTX)->fld[N].rtvec)
 #define XVECLEN(RTX, N)	((RTX)->fld[N].rtvec->num_elem)
@@ -399,7 +411,7 @@ extern char *note_insn_name[];
 
 /* For a CONST_INT rtx, INTVAL extracts the integer.  */
 
-#define INTVAL(RTX) ((RTX)->fld[0].rtint)
+#define INTVAL(RTX) ((RTX)->fld[0].rtwint)
 
 /* For a SUBREG rtx, SUBREG_REG extracts the value we want a subreg of.
    SUBREG_WORD extracts the word-number.  */
@@ -532,17 +544,36 @@ extern char *note_insn_name[];
 
 /* Generally useful functions.  */
 
+/* The following functions accept a wide integer argument.  Rather than
+   having to cast on every function call, we use a macro instead, that is
+   defined here and in tree.h.  */
+
+#ifndef exact_log2
+#define exact_log2(N) exact_log2_wide ((HOST_WIDE_INT) (N))
+#define floor_log2(N) floor_log2_wide ((HOST_WIDE_INT) (N))
+#endif
+
+#define plus_constant(X,C) plus_constant_wide (X, (HOST_WIDE_INT) (C))
+
+#define plus_constant_for_output(X,C)  \
+  plus_constant_for_output_wide (X, (HOST_WIDE_INT) (C))
+
+extern rtx plus_constant_wide (), plus_constant_for_output_wide ();
+
+#define GEN_INT(N) gen_rtx (CONST_INT, VOIDmode, (N))
+
+extern rtx gen_rtx ();
+
 extern char *xmalloc ();
 extern void free ();
 extern rtx rtx_alloc ();
 extern rtvec rtvec_alloc ();
 extern rtx find_reg_note ();
 extern rtx find_regno_note ();
-extern int get_integer_term ();
+extern HOST_WIDE_INT get_integer_term ();
 extern rtx get_related_value ();
 extern rtx single_set ();
 extern rtx find_last_value ();
-extern rtx gen_rtx ();
 extern rtx copy_rtx ();
 extern rtx copy_rtx_if_shared ();
 extern rtx copy_most_rtx ();
@@ -623,7 +654,6 @@ extern enum rtx_code reverse_condition ();
 extern enum rtx_code swap_condition ();
 extern enum rtx_code unsigned_condition ();
 extern enum rtx_code signed_condition ();
-extern rtx plus_constant (), plus_constant_for_output ();
 extern rtx find_equiv_reg ();
 extern rtx squeeze_notes ();
 extern rtx delete_insn ();