*** empty log message ***

From-SVN: r1475

diff --git a/gcc/regclass.c b/gcc/regclass.c
index d11d249addff77aeca4b91eca2311cd63e20cb89..58399dd4041753f851bcc74ce74661ac6e30bedc 100644 (file)
--- a/gcc/regclass.c
+++ b/gcc/regclass.c
@@ -536,7 +536,7 @@ regclass (f, nregs)
              if (GET_CODE (insn) == INSN
                  && (noperands = asm_noperands (PATTERN (insn))) >= 0)
                {
-                 decode_asm_operands (PATTERN (insn), recog_operand, 0,
+                 decode_asm_operands (PATTERN (insn), recog_operand, NULL_PTR,
                                       constraints, modes);
                  nalternatives = n_occurrences (',', constraints[0]) + 1;
                }
@@ -557,7 +557,8 @@ regclass (f, nregs)
 
                  if (set != 0 && GET_CODE (SET_DEST (set)) == REG
                      && GET_CODE (SET_SRC (set)) == MEM
-                     && (note = find_reg_note (insn, REG_EQUIV, 0)) != 0
+                     && (note = find_reg_note (insn, REG_EQUIV,
+                                               NULL_RTX)) != 0
                      && GET_CODE (XEXP (note, 0)) == MEM)
                    {
                      costs[REGNO (SET_DEST (set))].mem_cost
@@ -984,7 +985,7 @@ record_reg_classes (n_alts, n_ops, ops, modes, constraints, insn)
                /* Match any floating double constant, but only if
                   we can examine the bits of it reliably.  */
                if ((HOST_FLOAT_FORMAT != TARGET_FLOAT_FORMAT
-                    || HOST_BITS_PER_INT != BITS_PER_WORD)
+                    || HOST_BITS_PER_WIDE_INT != BITS_PER_WORD)
                    && GET_MODE (op) != VOIDmode && ! flag_pretend_float)
                  break;
                if (GET_CODE (op) == CONST_DOUBLE)

diff --git a/gcc/sdbout.c b/gcc/sdbout.c
index b8e0a4e2ee51e4e27eb9cc8e645c32e7ff16833b..8ebb5a8130ce175bfbce27d6f62a9345661cd423 100644 (file)
--- a/gcc/sdbout.c
+++ b/gcc/sdbout.c
@@ -1129,8 +1129,8 @@ sdbout_parms (parms)
        /* Perform any necessary register eliminations on the parameter's rtl,
           so that the debugging output will be accurate.  */
        DECL_INCOMING_RTL (parms) =
-         eliminate_regs (DECL_INCOMING_RTL (parms), 0, 0);
-       DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, 0);
+         eliminate_regs (DECL_INCOMING_RTL (parms), 0, NULL_RTX);
+       DECL_RTL (parms) = eliminate_regs (DECL_RTL (parms), 0, NULL_RTX);
 
        if (PARM_PASSED_IN_MEMORY (parms))
          {

diff --git a/gcc/stmt.c b/gcc/stmt.c
index b0cf3ff52c911c78ed13dd2b087a41fe5365e231..837726534a5455d3ac9a95692816b4677f0e1586 100644 (file)
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -531,7 +531,7 @@ void
 expand_computed_goto (exp)
      tree exp;
 {
-  rtx x = expand_expr (exp, 0, VOIDmode, 0);
+  rtx x = expand_expr (exp, NULL_RTX, VOIDmode, 0);
   emit_queue ();
   emit_indirect_jump (x);
 }
@@ -644,7 +644,7 @@ expand_goto (label)
            addr = replace_rtx (copy_rtx (addr),
                                virtual_stack_vars_rtx, frame_pointer_rtx);
 
-         emit_stack_restore (SAVE_NONLOCAL, addr, 0);
+         emit_stack_restore (SAVE_NONLOCAL, addr, NULL_RTX);
 
          /* Put in the static chain register the nonlocal label address.  */
          emit_move_insn (static_chain_rtx,
@@ -658,7 +658,7 @@ expand_goto (label)
        }
      }
   else
-    expand_goto_internal (label, label_rtx (label), 0);
+    expand_goto_internal (label, label_rtx (label), NULL_RTX);
 }
 
 /* Generate RTL code for a `goto' statement with target label BODY.
@@ -696,7 +696,7 @@ expand_goto_internal (body, label, last_insn)
          /* Execute the cleanups for blocks we are exiting.  */
          if (block->data.block.cleanups != 0)
            {
-             expand_cleanups (block->data.block.cleanups, 0);
+             expand_cleanups (block->data.block.cleanups, NULL_TREE);
              do_pending_stack_adjust ();
            }
        }
@@ -707,7 +707,7 @@ expand_goto_internal (body, label, last_insn)
             the stack pointer.  This one should be deleted as dead by flow. */
          clear_pending_stack_adjust ();
          do_pending_stack_adjust ();
-         emit_stack_restore (SAVE_BLOCK, stack_level, 0);
+         emit_stack_restore (SAVE_BLOCK, stack_level, NULL_RTX);
        }
 
       if (body != 0 && DECL_TOO_LATE (body))
@@ -824,7 +824,7 @@ expand_fixup (tree_label, rtl_label, last_insn)
 #endif
             )
            || block->data.block.cleanups)
-          ? tree_cons (0, block->data.block.cleanups,
+          ? tree_cons (NULL_TREE, block->data.block.cleanups,
                        block->data.block.outer_cleanups)
           : 0);
       fixup->next = goto_fixup_chain;
@@ -1062,7 +1062,7 @@ expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
          && TREE_CODE (val) != INDIRECT_REF)
        TREE_VALUE (tail) = save_expr (TREE_VALUE (tail));
 
-      output_rtx[i] = expand_expr (TREE_VALUE (tail), 0, VOIDmode, 0);
+      output_rtx[i] = expand_expr (TREE_VALUE (tail), NULL_RTX, VOIDmode, 0);
     }
 
   if (ninputs + noutputs > MAX_RECOG_OPERANDS)
@@ -1113,7 +1113,7 @@ expand_asm_operands (string, outputs, inputs, clobbers, vol, filename, line)
          }
 
       XVECEXP (body, 3, i)      /* argvec */
-       = expand_expr (TREE_VALUE (tail), 0, VOIDmode, 0);
+       = expand_expr (TREE_VALUE (tail), NULL_RTX, VOIDmode, 0);
       XVECEXP (body, 4, i)      /* constraints */
        = gen_rtx (ASM_INPUT, TYPE_MODE (TREE_TYPE (TREE_VALUE (tail))),
                   TREE_STRING_POINTER (TREE_PURPOSE (tail)));
@@ -1227,7 +1227,9 @@ expand_expr_stmt (exp)
     }
   last_expr_type = TREE_TYPE (exp);
   if (! flag_syntax_only)
-    last_expr_value = expand_expr (exp, expr_stmts_for_value ? 0 : const0_rtx,
+    last_expr_value = expand_expr (exp,
+                                  (expr_stmts_for_value
+                                   ? NULL_RTX : const0_rtx),
                                   VOIDmode, 0);
 
   /* If all we do is reference a volatile value in memory,
@@ -1244,7 +1246,7 @@ expand_expr_stmt (exp)
          /* Compare the value with itself to reference it.  */
          emit_cmp_insn (last_expr_value, last_expr_value, EQ,
                         expand_expr (TYPE_SIZE (last_expr_type),
-                                     0, VOIDmode, 0),
+                                     NULL_RTX, VOIDmode, 0),
                         BLKmode, 0,
                         TYPE_ALIGN (last_expr_type) / BITS_PER_UNIT);
          emit_jump_insn ((*bcc_gen_fctn[(int) EQ]) (lab));
@@ -1539,7 +1541,7 @@ expand_start_try (try_clause, exitflag, escapeflag)
   except_stack = thishandler;
   nesting_stack = thishandler;
 
-  do_jump (try_clause, thishandler->data.except_stmt.except_label, NULL);
+  do_jump (try_clause, thishandler->data.except_stmt.except_label, NULL_RTX);
 }
 
 /* End of a TRY block.  Nothing to do for now.  */
@@ -1548,7 +1550,8 @@ void
 expand_end_try ()
 {
   except_stack->data.except_stmt.after_label = gen_label_rtx ();
-  expand_goto_internal (NULL, except_stack->data.except_stmt.after_label, 0);
+  expand_goto_internal (NULL_TREE, except_stack->data.except_stmt.after_label,
+                       NULL_RTX);
 }
 
 /* Start an `except' nesting contour.
@@ -1611,7 +1614,8 @@ expand_escape_except ()
   for (n = except_stack; n; n = n->next)
     if (n->data.except_stmt.escape_label != 0)
       {
-       expand_goto_internal (0, n->data.except_stmt.escape_label, 0);
+       expand_goto_internal (NULL_TREE,
+                             n->data.except_stmt.escape_label, NULL_RTX);
        return 1;
       }
 
@@ -1714,7 +1718,8 @@ expand_end_catch ()
 {
   if (except_stack == 0 || except_stack->data.except_stmt.after_label == 0)
     return 0;
-  expand_goto_internal (0, except_stack->data.except_stmt.after_label, 0);
+  expand_goto_internal (NULL_TREE, except_stack->data.except_stmt.after_label,
+                       NULL_RTX);
   return 1;
 }
 \f
@@ -1745,7 +1750,7 @@ expand_start_cond (cond, exitflag)
   cond_stack = thiscond;
   nesting_stack = thiscond;
 
-  do_jump (cond, thiscond->data.cond.next_label, NULL);
+  do_jump (cond, thiscond->data.cond.next_label, NULL_RTX);
 }
 
 /* Generate RTL between then-clause and the elseif-clause
@@ -1760,7 +1765,7 @@ expand_start_elseif (cond)
   emit_jump (cond_stack->data.cond.endif_label);
   emit_label (cond_stack->data.cond.next_label);
   cond_stack->data.cond.next_label = gen_label_rtx ();
-  do_jump (cond, cond_stack->data.cond.next_label, NULL);
+  do_jump (cond, cond_stack->data.cond.next_label, NULL_RTX);
 }
 
 /* Generate RTL between the then-clause and the else-clause
@@ -1821,7 +1826,7 @@ expand_start_loop (exit_flag)
 
   do_pending_stack_adjust ();
   emit_queue ();
-  emit_note (0, NOTE_INSN_LOOP_BEG);
+  emit_note (NULL_PTR, NOTE_INSN_LOOP_BEG);
   emit_label (thisloop->data.loop.start_label);
 
   return thisloop;
@@ -1848,7 +1853,7 @@ void
 expand_loop_continue_here ()
 {
   do_pending_stack_adjust ();
-  emit_note (0, NOTE_INSN_LOOP_CONT);
+  emit_note (NULL_PTR, NOTE_INSN_LOOP_CONT);
   emit_label (loop_stack->data.loop.continue_label);
 }
 
@@ -1952,7 +1957,7 @@ expand_end_loop ()
     }
 
   emit_jump (start_label);
-  emit_note (0, NOTE_INSN_LOOP_END);
+  emit_note (NULL_PTR, NOTE_INSN_LOOP_END);
   emit_label (loop_stack->data.loop.end_label);
 
   POPSTACK (loop_stack);
@@ -1974,7 +1979,8 @@ expand_continue_loop (whichloop)
     whichloop = loop_stack;
   if (whichloop == 0)
     return 0;
-  expand_goto_internal (0, whichloop->data.loop.continue_label, 0);
+  expand_goto_internal (NULL_TREE, whichloop->data.loop.continue_label,
+                       NULL_RTX);
   return 1;
 }
 
@@ -1990,7 +1996,7 @@ expand_exit_loop (whichloop)
     whichloop = loop_stack;
   if (whichloop == 0)
     return 0;
-  expand_goto_internal (0, whichloop->data.loop.end_label, 0);
+  expand_goto_internal (NULL_TREE, whichloop->data.loop.end_label, NULL_RTX);
   return 1;
 }
 
@@ -2008,7 +2014,7 @@ expand_exit_loop_if_false (whichloop, cond)
     whichloop = loop_stack;
   if (whichloop == 0)
     return 0;
-  do_jump (cond, whichloop->data.loop.end_label, NULL);
+  do_jump (cond, whichloop->data.loop.end_label, NULL_RTX);
   return 1;
 }
 
@@ -2055,7 +2061,7 @@ expand_exit_something ()
   for (n = nesting_stack; n; n = n->all)
     if (n->exit_label != 0)
       {
-       expand_goto_internal (0, n->exit_label, 0);
+       expand_goto_internal (NULL_TREE, n->exit_label, NULL_RTX);
        return 1;
       }
 
@@ -2133,7 +2139,7 @@ expand_null_return_1 (last_insn, use_goto)
     {
       if (end_label == 0)
        end_label = return_label = gen_label_rtx ();
-      expand_goto_internal (0, end_label, last_insn);
+      expand_goto_internal (NULL_TREE, end_label, last_insn);
       return;
     }
 
@@ -2149,7 +2155,7 @@ expand_null_return_1 (last_insn, use_goto)
 #endif
 
   /* Otherwise jump to the epilogue.  */
-  expand_goto_internal (0, end_label, last_insn);
+  expand_goto_internal (NULL_TREE, end_label, last_insn);
 }
 \f
 /* Generate RTL to evaluate the expression RETVAL and return it
@@ -2177,7 +2183,7 @@ expand_return (retval)
   /* If function wants no value, give it none.  */
   if (TREE_CODE (TREE_TYPE (TREE_TYPE (current_function_decl))) == VOID_TYPE)
     {
-      expand_expr (retval, 0, VOIDmode, 0);
+      expand_expr (retval, NULL_RTX, VOIDmode, 0);
       expand_null_return ();
       return;
     }
@@ -2213,7 +2219,7 @@ expand_return (retval)
          || TREE_CODE (TREE_OPERAND (retval_rhs, 2)) == CALL_EXPR))
     {
       rtx label = gen_label_rtx ();
-      do_jump (TREE_OPERAND (retval_rhs, 0), label, 0);
+      do_jump (TREE_OPERAND (retval_rhs, 0), label, NULL_RTX);
       expand_return (build (MODIFY_EXPR, TREE_TYPE (current_function_decl),
                            DECL_RESULT (current_function_decl),
                            TREE_OPERAND (retval_rhs, 1)));
@@ -2246,7 +2252,7 @@ expand_return (retval)
                            tail_recursion_reentry);
        }
       emit_queue ();
-      expand_goto_internal (0, tail_recursion_label, last_insn);
+      expand_goto_internal (NULL_TREE, tail_recursion_label, last_insn);
       emit_barrier ();
       return;
     }
@@ -2292,7 +2298,7 @@ expand_return (retval)
       && GET_CODE (DECL_RTL (DECL_RESULT (current_function_decl))) == REG)
     {
       /* Calculate the return value into a pseudo reg.  */
-      val = expand_expr (retval_rhs, 0, VOIDmode, 0);
+      val = expand_expr (retval_rhs, NULL_RTX, VOIDmode, 0);
       emit_queue ();
       /* All temporaries have now been used.  */
       free_temp_slots ();
@@ -2303,7 +2309,7 @@ expand_return (retval)
     {
       /* No cleanups or no hard reg used;
         calculate value into hard return reg.  */
-      expand_expr (retval, 0, VOIDmode, 0);
+      expand_expr (retval, NULL_RTX, VOIDmode, 0);
       emit_queue ();
       free_temp_slots ();
       expand_value_return (DECL_RTL (DECL_RESULT (current_function_decl)));
@@ -2358,7 +2364,7 @@ tail_recursion_args (actuals, formals)
   argvec = (rtx *) alloca (i * sizeof (rtx));
 
   for (a = actuals, i = 0; a; a = TREE_CHAIN (a), i++)
-    argvec[i] = expand_expr (TREE_VALUE (a), 0, VOIDmode, 0);
+    argvec[i] = expand_expr (TREE_VALUE (a), NULL_RTX, VOIDmode, 0);
 
   /* Find which actual values refer to current values of previous formals.
      Copy each of them now, before any formal is changed.  */
@@ -2402,7 +2408,7 @@ expand_start_bindings (exit_flag)
 {
   struct nesting *thisblock = ALLOC_NESTING ();
 
-  rtx note = emit_note (0, NOTE_INSN_BLOCK_BEG);
+  rtx note = emit_note (NULL_PTR, NOTE_INSN_BLOCK_BEG);
 
   /* Make an entry on block_stack for the block we are entering.  */
 
@@ -2475,7 +2481,7 @@ expand_end_bindings (vars, mark_ends, dont_jump_in)
   /* Mark the beginning and end of the scope if requested.  */
 
   if (mark_ends)
-    emit_note (0, NOTE_INSN_BLOCK_END);
+    emit_note (NULL_PTR, NOTE_INSN_BLOCK_END);
   else
     /* Get rid of the beginning-mark if we don't make an end-mark.  */
     NOTE_LINE_NUMBER (thisblock->data.block.first_insn) = NOTE_INSN_DELETED;
@@ -2633,7 +2639,7 @@ expand_end_bindings (vars, mark_ends, dont_jump_in)
       expr_stmts_for_value = 0;
 
       /* Do the cleanups.  */
-      expand_cleanups (thisblock->data.block.cleanups, 0);
+      expand_cleanups (thisblock->data.block.cleanups, NULL_TREE);
       do_pending_stack_adjust ();
 
       expr_stmts_for_value = old_expr_stmts_for_value;
@@ -2645,9 +2651,10 @@ expand_end_bindings (vars, mark_ends, dont_jump_in)
       if (thisblock->data.block.stack_level != 0)
        {
          emit_stack_restore (thisblock->next ? SAVE_BLOCK : SAVE_FUNCTION,
-                             thisblock->data.block.stack_level, 0);
+                             thisblock->data.block.stack_level, NULL_RTX);
          if (nonlocal_goto_handler_slot != 0)
-           emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, 0);
+           emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level,
+                            NULL_RTX);
        }
 
       /* Any gotos out of this block must also do these things.
@@ -2816,17 +2823,18 @@ expand_decl (decl)
       size = expand_expr (size_binop (CEIL_DIV_EXPR,
                                      DECL_SIZE (decl),
                                      size_int (BITS_PER_UNIT)),
-                         0, VOIDmode, 0);
+                         NULL_RTX, VOIDmode, 0);
       free_temp_slots ();
 
       /* This is equivalent to calling alloca.  */
       current_function_calls_alloca = 1;
 
       /* Allocate space on the stack for the variable.  */
-      address = allocate_dynamic_stack_space (size, 0, DECL_ALIGN (decl));
+      address = allocate_dynamic_stack_space (size, NULL_RTX,
+                                             DECL_ALIGN (decl));
 
       if (nonlocal_goto_handler_slot != 0)
-       emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, 0);
+       emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
 
       /* Reference the variable indirect through that rtx.  */
       DECL_RTL (decl) = gen_rtx (MEM, DECL_MODE (decl), address);
@@ -3030,7 +3038,7 @@ fixup_cleanups (list, before_jump)
   rtx beyond_jump = get_last_insn ();
   rtx new_before_jump;
 
-  expand_cleanups (list, 0);
+  expand_cleanups (list, NULL_TREE);
   /* Pop any pushes done in the cleanups,
      in case function is about to return.  */
   do_pending_stack_adjust ();
@@ -3144,7 +3152,7 @@ expand_start_case (exit_flag, expr, type, printname)
   /* Make sure case_stmt.start points to something that won't
      need any transformation before expand_end_case.  */
   if (GET_CODE (get_last_insn ()) != NOTE)
-    emit_note (0, NOTE_INSN_DELETED);
+    emit_note (NULL_PTR, NOTE_INSN_DELETED);
 
   thiscase->data.case_stmt.start = get_last_insn ();
 }
@@ -3661,7 +3669,8 @@ expand_end_case (orig_index)
 
       else if (TREE_INT_CST_HIGH (range) != 0
               || count < CASE_VALUES_THRESHOLD
-              || (unsigned) (TREE_INT_CST_LOW (range)) > 10 * count
+              || ((unsigned HOST_WIDE_INT) (TREE_INT_CST_LOW (range))
+                  > 10 * count)
               || TREE_CODE (index_expr) == INTEGER_CST
               /* These will reduce to a constant.  */
               || (TREE_CODE (index_expr) == CALL_EXPR
@@ -3671,7 +3680,7 @@ expand_end_case (orig_index)
               || (TREE_CODE (index_expr) == COMPOUND_EXPR
                   && TREE_CODE (TREE_OPERAND (index_expr, 1)) == INTEGER_CST))
        {
-         index = expand_expr (index_expr, 0, VOIDmode, 0);
+         index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
 
          /* If the index is a short or char that we do not have
             an insn to handle comparisons directly, convert it to
@@ -3749,7 +3758,8 @@ expand_end_case (orig_index)
              use_cost_table
                = (TREE_CODE (TREE_TYPE (orig_index)) != ENUMERAL_TYPE
                   && estimate_case_costs (thiscase->data.case_stmt.case_list));
-             balance_case_nodes (&thiscase->data.case_stmt.case_list, 0);
+             balance_case_nodes (&thiscase->data.case_stmt.case_list, 
+                                 NULL_PTR);
              emit_case_nodes (index, thiscase->data.case_stmt.case_list,
                               default_label, TREE_TYPE (index_expr));
              emit_jump_if_reachable (default_label);
@@ -3769,14 +3779,14 @@ expand_end_case (orig_index)
                  > GET_MODE_BITSIZE (index_mode))
                {
                  enum machine_mode omode = TYPE_MODE (TREE_TYPE (index_expr));
-                 rtx rangertx = expand_expr (range, 0, VOIDmode, 0);
+                 rtx rangertx = expand_expr (range, NULL_RTX, VOIDmode, 0);
 
                  /* We must handle the endpoints in the original mode.  */
                  index_expr = build (MINUS_EXPR, TREE_TYPE (index_expr),
                                      index_expr, minval);
                  minval = integer_zero_node;
-                 index = expand_expr (index_expr, 0, VOIDmode, 0);
-                 emit_cmp_insn (rangertx, index, LTU, 0, omode, 0, 0);
+                 index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
+                 emit_cmp_insn (rangertx, index, LTU, NULL_RTX, omode, 0, 0);
                  emit_jump_insn (gen_bltu (default_label));
                  /* Now we can safely truncate.  */
                  index = convert_to_mode (index_mode, index, 0);
@@ -3786,14 +3796,16 @@ expand_end_case (orig_index)
                  if (TYPE_MODE (TREE_TYPE (index_expr)) != index_mode)
                    index_expr = convert (type_for_size (index_bits, 0),
                                          index_expr);
-                 index = expand_expr (index_expr, 0, VOIDmode, 0);
+                 index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
                }
              emit_queue ();
              index = protect_from_queue (index, 0);
              do_pending_stack_adjust ();
 
-             emit_jump_insn (gen_casesi (index, expand_expr (minval, 0, VOIDmode, 0),
-                                         expand_expr (range, 0, VOIDmode, 0),
+             emit_jump_insn (gen_casesi (index, expand_expr (minval, NULL_RTX,
+                                                             VOIDmode, 0),
+                                         expand_expr (range, NULL_RTX,
+                                                      VOIDmode, 0),
                                          table_label, default_label));
              win = 1;
            }
@@ -3805,13 +3817,13 @@ expand_end_case (orig_index)
                                    fold (build (MINUS_EXPR,
                                                 TREE_TYPE (index_expr),
                                                 index_expr, minval)));
-             index = expand_expr (index_expr, 0, VOIDmode, 0);
+             index = expand_expr (index_expr, NULL_RTX, VOIDmode, 0);
              emit_queue ();
              index = protect_from_queue (index, 0);
              do_pending_stack_adjust ();
 
              do_tablejump (index, TYPE_MODE (TREE_TYPE (index_expr)),
-                           expand_expr (range, 0, VOIDmode, 0),
+                           expand_expr (range, NULL_RTX, VOIDmode, 0),
                            table_label, default_label);
              win = 1;
            }
@@ -3827,7 +3839,7 @@ expand_end_case (orig_index)
 
          for (n = thiscase->data.case_stmt.case_list; n; n = n->right)
            {
-             register int i
+             register HOST_WIDE_INT i
                = TREE_INT_CST_LOW (n->low) - TREE_INT_CST_LOW (minval);
 
              while (1)
@@ -3903,7 +3915,7 @@ do_jump_if_equal (op1, op2, label, unsignedp)
       enum machine_mode mode = GET_MODE (op1);
       if (mode == VOIDmode)
        mode = GET_MODE (op2);
-      emit_cmp_insn (op1, op2, EQ, 0, mode, unsignedp, 0);
+      emit_cmp_insn (op1, op2, EQ, NULL_RTX, mode, unsignedp, 0);
       emit_jump_insn (gen_beq (label));
     }
 }
@@ -4318,7 +4330,7 @@ emit_case_nodes (index, node, default_label, index_type)
       /* Node is single valued.  First see if the index expression matches
         this node and then check our children, if any. */
 
-      do_jump_if_equal (index, expand_expr (node->low, 0, VOIDmode, 0),
+      do_jump_if_equal (index, expand_expr (node->low, NULL_RTX, VOIDmode, 0),
                        label_rtx (node->code_label), unsignedp);
 
       if (node->right != 0 && node->left != 0)
@@ -4331,8 +4343,9 @@ emit_case_nodes (index, node, default_label, index_type)
 
          if (node_is_bounded (node->right, index_type))
            {
-             emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
-                            GT, 0, mode, unsignedp, 0);
+             emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
+                                                VOIDmode, 0),
+                            GT, NULL_RTX, mode, unsignedp, 0);
 
              emit_jump_insn ((*gen_bgt_pat) (label_rtx (node->right->code_label)));
              emit_case_nodes (index, node->left, default_label, index_type);
@@ -4340,9 +4353,9 @@ emit_case_nodes (index, node, default_label, index_type)
 
          else if (node_is_bounded (node->left, index_type))
            {
-             emit_cmp_insn (index, expand_expr (node->high, 0,
+             emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
                                                 VOIDmode, 0),
-                            LT, 0, mode, unsignedp, 0);
+                            LT, NULL_RTX, mode, unsignedp, 0);
              emit_jump_insn ((*gen_blt_pat) (label_rtx (node->left->code_label)));
              emit_case_nodes (index, node->right, default_label, index_type);
            }
@@ -4356,9 +4369,9 @@ emit_case_nodes (index, node, default_label, index_type)
                = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);
 
              /* See if the value is on the right.  */
-             emit_cmp_insn (index, expand_expr (node->high, 0,
+             emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
                                                 VOIDmode, 0),
-                            GT, 0, mode, unsignedp, 0);
+                            GT, NULL_RTX, mode, unsignedp, 0);
              emit_jump_insn ((*gen_bgt_pat) (label_rtx (test_label)));
 
              /* Value must be on the left.
@@ -4387,8 +4400,9 @@ emit_case_nodes (index, node, default_label, index_type)
            {
              if (!node_has_low_bound (node, index_type))
                {
-                 emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
-                                LT, 0, mode, unsignedp, 0);
+                 emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
+                                                    VOIDmode, 0),
+                                LT, NULL_RTX, mode, unsignedp, 0);
                  emit_jump_insn ((*gen_blt_pat) (default_label));
                }
 
@@ -4399,7 +4413,8 @@ emit_case_nodes (index, node, default_label, index_type)
               since we haven't ruled out the numbers less than
               this node's value.  So handle node->right explicitly.  */
            do_jump_if_equal (index,
-                             expand_expr (node->right->low, 0, VOIDmode, 0),
+                             expand_expr (node->right->low, NULL_RTX,
+                                          VOIDmode, 0),
                              label_rtx (node->right->code_label), unsignedp);
        }
 
@@ -4425,8 +4440,9 @@ emit_case_nodes (index, node, default_label, index_type)
            {
              if (!node_has_high_bound (node, index_type))
                {
-                 emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
-                                GT, 0, mode, unsignedp, 0);
+                 emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
+                                                    VOIDmode, 0),
+                                GT, NULL_RTX, mode, unsignedp, 0);
                  emit_jump_insn ((*gen_bgt_pat) (default_label));
                }
 
@@ -4437,7 +4453,8 @@ emit_case_nodes (index, node, default_label, index_type)
               since we haven't ruled out the numbers less than
               this node's value.  So handle node->left explicitly.  */
            do_jump_if_equal (index,
-                             expand_expr (node->left->low, 0, VOIDmode, 0),
+                             expand_expr (node->left->low, NULL_RTX,
+                                          VOIDmode, 0),
                              label_rtx (node->left->code_label), unsignedp);
        }
     }
@@ -4456,8 +4473,9 @@ emit_case_nodes (index, node, default_label, index_type)
             then handle the two subtrees.  */
          tree test_label = 0;
 
-         emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
-                        GT, 0, mode, unsignedp, 0);
+         emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
+                                            VOIDmode, 0),
+                        GT, NULL_RTX, mode, unsignedp, 0);
 
          if (node_is_bounded (node->right, index_type))
            /* Right hand node is fully bounded so we can eliminate any
@@ -4474,8 +4492,8 @@ emit_case_nodes (index, node, default_label, index_type)
 
          /* Value belongs to this node or to the left-hand subtree.  */
 
-         emit_cmp_insn (index, expand_expr (node->low, 0, VOIDmode, 0),
-                        GE, 0, mode, unsignedp, 0);
+         emit_cmp_insn (index, expand_expr (node->low, NULL_RTX, VOIDmode, 0),
+                        GE, NULL_RTX, mode, unsignedp, 0);
          emit_jump_insn ((*gen_bge_pat) (label_rtx (node->code_label)));
 
          /* Handle the left-hand subtree.  */
@@ -4500,15 +4518,17 @@ emit_case_nodes (index, node, default_label, index_type)
             if they are possible.  */
          if (!node_has_low_bound (node, index_type))
            {
-             emit_cmp_insn (index, expand_expr (node->low, 0, VOIDmode, 0),
-                            LT, 0, mode, unsignedp, 0);
+             emit_cmp_insn (index, expand_expr (node->low, NULL_RTX,
+                                                VOIDmode, 0),
+                            LT, NULL_RTX, mode, unsignedp, 0);
              emit_jump_insn ((*gen_blt_pat) (default_label));
            }
 
          /* Value belongs to this node or to the right-hand subtree.  */
 
-         emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
-                        LE, 0, mode, unsignedp, 0);
+         emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
+                                            VOIDmode, 0),
+                        LE, NULL_RTX, mode, unsignedp, 0);
          emit_jump_insn ((*gen_ble_pat) (label_rtx (node->code_label)));
 
          emit_case_nodes (index, node->right, default_label, index_type);
@@ -4520,15 +4540,16 @@ emit_case_nodes (index, node, default_label, index_type)
             if they are possible.  */
          if (!node_has_high_bound (node, index_type))
            {
-             emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
-                            GT, 0, mode, unsignedp, 0);
+             emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
+                                                VOIDmode, 0),
+                            GT, NULL_RTX, mode, unsignedp, 0);
              emit_jump_insn ((*gen_bgt_pat) (default_label));
            }
 
          /* Value belongs to this node or to the left-hand subtree.  */
 
-         emit_cmp_insn (index, expand_expr (node->low, 0, VOIDmode, 0),
-                        GE, 0, mode, unsignedp, 0);
+         emit_cmp_insn (index, expand_expr (node->low, NULL_RTX, VOIDmode, 0),
+                        GE, NULL_RTX, mode, unsignedp, 0);
          emit_jump_insn ((*gen_bge_pat) (label_rtx (node->code_label)));
 
          emit_case_nodes (index, node->left, default_label, index_type);
@@ -4542,15 +4563,17 @@ emit_case_nodes (index, node, default_label, index_type)
 
          if (!node_has_high_bound (node, index_type))
            {
-             emit_cmp_insn (index, expand_expr (node->high, 0, VOIDmode, 0),
-                            GT, 0, mode, unsignedp, 0);
+             emit_cmp_insn (index, expand_expr (node->high, NULL_RTX,
+                                                VOIDmode, 0),
+                            GT, NULL_RTX, mode, unsignedp, 0);
              emit_jump_insn ((*gen_bgt_pat) (default_label));
            }
 
          if (!node_has_low_bound (node, index_type))
            {
-             emit_cmp_insn (index, expand_expr (node->low, 0, VOIDmode, 0),
-                            LT, 0, mode, unsignedp, 0);
+             emit_cmp_insn (index, expand_expr (node->low, NULL_RTX,
+                                                VOIDmode, 0),
+                            LT, NULL_RTX, mode, unsignedp, 0);
              emit_jump_insn ((*gen_blt_pat) (default_label));
            }
 

diff --git a/gcc/toplev.c b/gcc/toplev.c
index 7bb918ec2885bae068710c49c816f58235438027..1e831935b72317c4675dfc846d30dbdd15da9a48 100644 (file)
--- a/gcc/toplev.c
+++ b/gcc/toplev.c
@@ -853,13 +853,16 @@ report_error_function (file)
 }
 
 /* Report an error at the current line number.
-   S and V are a string and an arg for `printf'.  */
+   S is a string and V and V2 are args for `printf'.  We use HOST_WIDE_INT
+   as the type for these args assuming it is wide enough to hold a
+   pointer.  This isn't terribly portable, but is the best we can do
+   without vprintf universally available.  */
 
 void
 error (s, v, v2)
      char *s;
-     int v;                    /* @@also used as pointer */
-     int v2;                   /* @@also used as pointer */
+     HOST_WIDE_INT v;          /* Also used as pointer */
+     HOST_WIDE_INT v2;         /* Also used as pointer */
 {
   error_with_file_and_line (input_filename, lineno, s, v, v2);
 }
@@ -872,8 +875,8 @@ error_with_file_and_line (file, line, s, v, v2)
      char *file;
      int line;
      char *s;
-     int v;
-     int v2;
+     HOST_WIDE_INT v;
+     HOST_WIDE_INT v2;
 {
   count_error (0);
 
@@ -888,13 +891,14 @@ error_with_file_and_line (file, line, s, v, v2)
 }
 
 /* Report an error at the declaration DECL.
-   S and V are a string and an arg which uses %s to substitute the declaration name.  */
+   S and V are a string and an arg which uses %s to substitute
+   the declaration name.  */
 
 void
 error_with_decl (decl, s, v)
      tree decl;
      char *s;
-     int v;
+     HOST_WIDE_INT v;
 {
   char *junk;
   count_error (0);
@@ -920,8 +924,8 @@ void
 error_for_asm (insn, s, v, v2)
      rtx insn;
      char *s;
-     int v;                    /* @@also used as pointer */
-     int v2;                   /* @@also used as pointer */
+     HOST_WIDE_INT v;          /* Also used as pointer */
+     HOST_WIDE_INT v2;         /* Also used as pointer */
 {
   char *filename;
   int line;
@@ -954,9 +958,7 @@ warning_with_file_and_line (file, line, s, v, v2, v3)
      char *file;
      int line;
      char *s;
-     int v;
-     int v2;
-     int v3;
+     HOST_WIDE_INT v, v2, v3;
 {
   if (count_error (1) == 0)
     return;
@@ -979,9 +981,7 @@ warning_with_file_and_line (file, line, s, v, v2, v3)
 void
 warning (s, v, v2, v3)
      char *s;
-     int v;                    /* @@also used as pointer */
-     int v2;
-     int v3;
+     HOST_WIDE_INT v, v2, v3;  /* Also used as pointer */
 {
   warning_with_file_and_line (input_filename, lineno, s, v, v2, v3);
 }
@@ -994,7 +994,7 @@ void
 warning_with_decl (decl, s, v)
      tree decl;
      char *s;
-     int v;
+     HOST_WIDE_INT v;
 {
   char *junk;
 
@@ -1023,8 +1023,8 @@ void
 warning_for_asm (insn, s, v, v2)
      rtx insn;
      char *s;
-     int v;                    /* @@also used as pointer */
-     int v2;                   /* @@also used as pointer */
+     HOST_WIDE_INT v;          /* Also used as pointer */
+     HOST_WIDE_INT v2;         /* Also used as pointer */
 {
   char *filename;
   int line;
@@ -1055,8 +1055,8 @@ warning_for_asm (insn, s, v, v2)
 void
 pedwarn (s, v, v2)
      char *s;
-     int v;                    /* @@also used as pointer */
-     int v2;
+     HOST_WIDE_INT v;          /* Also used as pointer */
+     HOST_WIDE_INT v2;
 {
   if (flag_pedantic_errors)
     error (s, v, v2);
@@ -1068,7 +1068,7 @@ void
 pedwarn_with_decl (decl, s, v)
      tree decl;
      char *s;
-     int v;
+     HOST_WIDE_INT v;
 {
   if (flag_pedantic_errors)
     error_with_decl (decl, s, v);
@@ -1081,8 +1081,8 @@ pedwarn_with_file_and_line (file, line, s, v, v2)
      char *file;
      int line;
      char *s;
-     int v;
-     int v2;
+     HOST_WIDE_INT v;
+     HOST_WIDE_INT v2;
 {
   if (flag_pedantic_errors)
     error_with_file_and_line (file, line, s, v, v2);
@@ -1096,7 +1096,7 @@ pedwarn_with_file_and_line (file, line, s, v, v2)
 void
 sorry (s, v, v2)
      char *s;
-     int v, v2;
+     HOST_WIDE_INT v, v2;
 {
   sorrycount++;
   if (input_filename)
@@ -1115,7 +1115,7 @@ sorry (s, v, v2)
 void
 really_sorry (s, v, v2)
      char *s;
-     int v, v2;
+     HOST_WIDE_INT v, v2;
 {
   if (input_filename)
     fprintf (stderr, "%s:%d: ", input_filename, lineno);
@@ -1185,11 +1185,13 @@ xrealloc (ptr, size)
 }
 \f
 /* Return the logarithm of X, base 2, considering X unsigned,
-   if X is a power of 2.  Otherwise, returns -1.  */
+   if X is a power of 2.  Otherwise, returns -1.
+
+   This should be used via the `exact_log2' macro.  */
 
 int
-exact_log2 (x)
-     register unsigned int x;
+exact_log2_wide (x)
+     register unsigned HOST_WIDE_INT x;
 {
   register int log = 0;
   /* Test for 0 or a power of 2.  */
@@ -1201,11 +1203,13 @@ exact_log2 (x)
 }
 
 /* Given X, an unsigned number, return the largest int Y such that 2**Y <= X.
-   If X is 0, return -1.  */
+   If X is 0, return -1.
+
+   This should be used via the floor_log2 macro.  */
 
 int
-floor_log2 (x)
-     register unsigned int x;
+floor_log2_wide (x)
+     register unsigned HOST_WIDE_INT x;
 {
   register int log = -1;
   while (x != 0)
@@ -1686,7 +1690,7 @@ compile_file (name)
                || TREE_USED (decl)
                || TREE_ADDRESSABLE (decl)
                || TREE_ADDRESSABLE (DECL_ASSEMBLER_NAME (decl)))
-             rest_of_decl_compilation (decl, 0, 1, 1);
+             rest_of_decl_compilation (decl, NULL_PTR, 1, 1);
            else
              /* Cancel the RTL for this decl so that, if debugging info
                 output for global variables is still to come,
@@ -2171,7 +2175,7 @@ rest_of_compilation (decl)
     {
       TIMEVAR (loop_time,
               {
-                loop_optimize (insns, loop_dump ? loop_dump_file : 0);
+                loop_optimize (insns, loop_dump_file);
               });
     }
 
@@ -2349,10 +2353,9 @@ rest_of_compilation (decl)
   TIMEVAR (global_alloc_time,
           {
             if (!obey_regdecls)
-              failure = global_alloc (global_reg_dump ? global_reg_dump_file : 0);
+              failure = global_alloc (global_reg_dump_file);
             else
-              failure = reload (insns, 0,
-                                global_reg_dump ? global_reg_dump_file : 0);
+              failure = reload (insns, 0, global_reg_dump_file);
           });
 
   if (global_reg_dump)
@@ -2521,7 +2524,7 @@ rest_of_compilation (decl)
      queued up for sdb output.  */
 #ifdef SDB_DEBUGGING_INFO
   if (write_symbols == SDB_DEBUG)
-    sdbout_types (0);
+    sdbout_types (NULL_TREE);
 #endif
 
   /* Put back the tree of subblocks from before we copied it.

diff --git a/gcc/tree.c b/gcc/tree.c
index 4eea2c9c949dfb41245e4384bfd4aa0dc8eac86e..b5c50717fb8dd1848993481163b429c090c752ed 100644 (file)
--- a/gcc/tree.c
+++ b/gcc/tree.c
@@ -537,7 +537,7 @@ obfree (ptr)
 
 char *
 permalloc (size)
-     long size;
+     int size;
 {
   return (char *) obstack_alloc (&permanent_obstack, size);
 }
@@ -1055,11 +1055,13 @@ set_identifier_size (size)
 \f
 /* Return a newly constructed INTEGER_CST node whose constant value
    is specified by the two ints LOW and HI.
-   The TREE_TYPE is set to `int'.  */
+   The TREE_TYPE is set to `int'. 
+
+   This function should be used via the `build_int_2' macro.  */
 
 tree
-build_int_2 (low, hi)
-     int low, hi;
+build_int_2_wide (low, hi)
+     HOST_WIDE_INT low, hi;
 {
   register tree t = make_node (INTEGER_CST);
   TREE_INT_CST_LOW (t) = low;
@@ -1105,17 +1107,17 @@ real_value_from_int_cst (i)
   if (TREE_INT_CST_HIGH (i) < 0)
     {
       d = (double) (~ TREE_INT_CST_HIGH (i));
-      d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
-           * (double) (1 << (HOST_BITS_PER_INT / 2)));
-      d += (double) (unsigned) (~ TREE_INT_CST_LOW (i));
+      d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
+           * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
+      d += (double) (unsigned HOST_WIDE_INT) (~ TREE_INT_CST_LOW (i));
       d = (- d - 1.0);
     }
   else
     {
       d = (double) TREE_INT_CST_HIGH (i);
-      d *= ((double) (1 << (HOST_BITS_PER_INT / 2))
-           * (double) (1 << (HOST_BITS_PER_INT / 2)));
-      d += (double) (unsigned) TREE_INT_CST_LOW (i);
+      d *= ((double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2))
+           * (double) ((HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT / 2)));
+      d += (double) (unsigned HOST_WIDE_INT) TREE_INT_CST_LOW (i);
     }
 #endif /* not REAL_ARITHMETIC */
   return d;
@@ -1258,27 +1260,27 @@ integer_all_onesp (expr)
     return TREE_INT_CST_LOW (expr) == -1 && TREE_INT_CST_HIGH (expr) == -1;
 
   prec = TYPE_PRECISION (TREE_TYPE (expr));
-  if (prec >= HOST_BITS_PER_INT)
+  if (prec >= HOST_BITS_PER_WIDE_INT)
     {
       int high_value, shift_amount;
 
-      shift_amount = prec - HOST_BITS_PER_INT;
+      shift_amount = prec - HOST_BITS_PER_WIDE_INT;
 
-      if (shift_amount > HOST_BITS_PER_INT)
+      if (shift_amount > HOST_BITS_PER_WIDE_INT)
        /* Can not handle precisions greater than twice the host int size.  */
        abort ();
-      else if (shift_amount == HOST_BITS_PER_INT)
+      else if (shift_amount == HOST_BITS_PER_WIDE_INT)
        /* Shifting by the host word size is undefined according to the ANSI
           standard, so we must handle this as a special case.  */
        high_value = -1;
       else
-       high_value = (1 << shift_amount) - 1;
+       high_value = ((HOST_WIDE_INT) 1 << shift_amount) - 1;
 
       return TREE_INT_CST_LOW (expr) == -1
        && TREE_INT_CST_HIGH (expr) == high_value;
     }
   else
-    return TREE_INT_CST_LOW (expr) == (1 << prec) - 1;
+    return TREE_INT_CST_LOW (expr) == ((HOST_WIDE_INT) 1 << prec) - 1;
 }
 
 /* Return 1 if EXPR is an integer constant that is a power of 2 (i.e., has only
@@ -1288,7 +1290,7 @@ int
 integer_pow2p (expr)
      tree expr;
 {
-  int high, low;
+  HOST_WIDE_INT high, low;
 
   while (TREE_CODE (expr) == NON_LVALUE_EXPR)
     expr = TREE_OPERAND (expr, 0);
@@ -1646,7 +1648,7 @@ size_in_bytes (type)
   type = TYPE_MAIN_VARIANT (type);
   if (TYPE_SIZE (type) == 0)
     {
-      incomplete_type_error (0, type);
+      incomplete_type_error (NULL_TREE, type);
       return integer_zero_node;
     }
   return size_binop (CEIL_DIV_EXPR, TYPE_SIZE (type),
@@ -1747,7 +1749,7 @@ save_expr (expr)
       || TREE_CODE (t) == SAVE_EXPR)
     return t;
 
-  t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL);
+  t = build (SAVE_EXPR, TREE_TYPE (expr), t, current_function_decl, NULL_TREE);
 
   /* This expression might be placed ahead of a jump to ensure that the
      value was computed on both sides of the jump.  So make sure it isn't
@@ -2628,7 +2630,7 @@ build_index_type (maxval)
   TYPE_ALIGN (itype) = TYPE_ALIGN (sizetype);
   if (TREE_CODE (maxval) == INTEGER_CST)
     {
-      int maxint = TREE_INT_CST_LOW (maxval);
+      HOST_WIDE_INT maxint = TREE_INT_CST_LOW (maxval);
       return type_hash_canon (maxint > 0 ? maxint : - maxint, itype);
     }
   else
@@ -2652,9 +2654,9 @@ build_index_2_type (lowval,highval)
   if ((TREE_CODE (lowval) == INTEGER_CST)
       && (TREE_CODE (highval) == INTEGER_CST))
     {
-      int highint = TREE_INT_CST_LOW (highval);
-      int lowint = TREE_INT_CST_LOW (lowval);
-      int maxint = highint - lowint;
+      HOST_WIDE_INT highint = TREE_INT_CST_LOW (highval);
+      HOST_WIDE_INT lowint = TREE_INT_CST_LOW (lowval);
+      HOST_WIDE_INT maxint = highint - lowint;
       return type_hash_canon (maxint > 0 ? maxint : - maxint, itype);
     }
   else
@@ -2818,7 +2820,8 @@ build_method_type (basetype, type)
      which is "this".  Put it into the list of argument types.  */
 
   TYPE_ARG_TYPES (t)
-    = tree_cons (NULL, build_pointer_type (basetype), TYPE_ARG_TYPES (type));
+    = tree_cons (NULL_TREE,
+                build_pointer_type (basetype), TYPE_ARG_TYPES (type));
 
   /* If we already have such a type, use the old one and free this one.  */
   hashcode = TYPE_HASH (basetype) + TYPE_HASH (type);

diff --git a/gcc/varasm.c b/gcc/varasm.c
index 6c25b9282b2c66b3c7335457e32a4015622bf747..38ce48fa28a1c8e4a01f094d70a3d5803464bc0b 100644 (file)
--- a/gcc/varasm.c
+++ b/gcc/varasm.c
@@ -1217,7 +1217,7 @@ assemble_real (d, mode)
       abort ();
     }
 
-  set_float_handler (0);
+  set_float_handler (NULL_PTR);
 }
 \f
 /* Here we combine duplicate floating constants to make
@@ -1238,7 +1238,7 @@ static rtx const_double_chain;
 
 rtx
 immed_double_const (i0, i1, mode)
-     int i0, i1;
+     HOST_WIDE_INT i0, i1;
      enum machine_mode mode;
 {
   register rtx r;
@@ -1250,22 +1250,24 @@ immed_double_const (i0, i1, mode)
         sign bit are all one.  So we get either a reasonable negative value
         or a reasonable unsigned value for this mode.  */
       int width = GET_MODE_BITSIZE (mode);
-      if (width < HOST_BITS_PER_INT
-         && ((i0 & ((-1) << (width - 1))) != ((-1) << (width - 1))))
-       i0 &= (1 << width) - 1, i1 = 0;
-      else if (width == HOST_BITS_PER_INT
+      if (width < HOST_BITS_PER_WIDE_INT
+         && ((i0 & ((HOST_WIDE_INT) (-1) << (width - 1)))
+             != ((HOST_WIDE_INT) (-1) << (width - 1))))
+       i0 &= ((HOST_WIDE_INT) 1 << width) - 1, i1 = 0;
+      else if (width == HOST_BITS_PER_WIDE_INT
               && ! (i1 == ~0 && i0 < 0))
        i1 = 0;
-      else if (width > 2 * HOST_BITS_PER_INT)
+      else if (width > 2 * HOST_BITS_PER_WIDE_INT)
        /* We cannot represent this value as a constant.  */
        abort ();
 
-      /* If MODE fits within HOST_BITS_PER_INT, always use a CONST_INT.
+      /* If MODE fits within HOST_BITS_PER_WIDE_INT, always use a CONST_INT.
 
         ??? Strictly speaking, this is wrong if we create a CONST_INT
         for a large unsigned constant with the size of MODE being
-        HOST_BITS_PER_INT and later try to interpret that constant in a wider
-        mode.  In that case we will mis-interpret it as a negative number.
+        HOST_BITS_PER_WIDE_INT and later try to interpret that constant in a
+        wider mode.  In that case we will mis-interpret it as a negative
+        number.
 
         Unfortunately, the only alternative is to make a CONST_DOUBLE
         for any constant in any mode if it is an unsigned constant larger
@@ -1276,13 +1278,13 @@ immed_double_const (i0, i1, mode)
         We have always been making CONST_INTs in this case, so nothing new
         is being broken.  */
 
-      if (width <= HOST_BITS_PER_INT)
+      if (width <= HOST_BITS_PER_WIDE_INT)
        i1 = (i0 < 0) ? ~0 : 0;
 
       /* If this integer fits in one word, return a CONST_INT.  */
       if ((i1 == 0 && i0 >= 0)
          || (i1 == ~0 && i0 < 0))
-       return gen_rtx (CONST_INT, VOIDmode, i0);
+       return GEN_INT (i0);
 
       /* We use VOIDmode for integers.  */
       mode = VOIDmode;
@@ -1345,7 +1347,7 @@ immed_real_const_1 (d, mode)
   else if (REAL_VALUES_EQUAL (dconst1, d))
     return CONST1_RTX (mode);
 
-  if (sizeof u == 2 * sizeof (int))
+  if (sizeof u == 2 * sizeof (HOST_WIDE_INT))
     return immed_double_const (u.i[0], u.i[1], mode);
 
   /* The rest of this function handles the case where
@@ -2579,7 +2581,7 @@ output_constant (exp, size)
             || TREE_CODE (exp) == NON_LVALUE_EXPR)
        exp = TREE_OPERAND (exp, 0);
 
-      if (! assemble_integer (expand_expr (exp, 0, VOIDmode,
+      if (! assemble_integer (expand_expr (exp, NULL_RTX, VOIDmode,
                                           EXPAND_INITIALIZER),
                              size, 0))
        error ("initializer for integer value is too complicated");
@@ -2654,7 +2656,7 @@ output_constructor (exp, size)
   int byte_buffer_in_use = 0;
   register int byte;
 
-  if (HOST_BITS_PER_INT < BITS_PER_UNIT)
+  if (HOST_BITS_PER_WIDE_INT < BITS_PER_UNIT)
     abort ();
 
   if (TREE_CODE (TREE_TYPE (exp)) == RECORD_TYPE)
@@ -2809,26 +2811,27 @@ output_constructor (exp, size)
              shift = end_offset - next_offset - this_time;
              /* Don't try to take a bunch of bits that cross
                 the word boundary in the INTEGER_CST.  */
-             if (shift < HOST_BITS_PER_INT
-                 && shift + this_time > HOST_BITS_PER_INT)
+             if (shift < HOST_BITS_PER_WIDE_INT
+                 && shift + this_time > HOST_BITS_PER_WIDE_INT)
                {
-                 this_time -= (HOST_BITS_PER_INT - shift);
-                 shift = HOST_BITS_PER_INT;
+                 this_time -= (HOST_BITS_PER_WIDE_INT - shift);
+                 shift = HOST_BITS_PER_WIDE_INT;
                }
 
              /* Now get the bits from the appropriate constant word.  */
-             if (shift < HOST_BITS_PER_INT)
+             if (shift < HOST_BITS_PER_WIDE_INT)
                {
                  value = TREE_INT_CST_LOW (val);
                }
-             else if (shift < 2 * HOST_BITS_PER_INT)
+             else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
                {
                  value = TREE_INT_CST_HIGH (val);
-                 shift -= HOST_BITS_PER_INT;
+                 shift -= HOST_BITS_PER_WIDE_INT;
                }
              else
                abort ();
-             byte |= (((value >> shift) & ((1 << this_time) - 1))
+             byte |= (((value >> shift)
+                       & (((HOST_WIDE_INT) 1 << this_time) - 1))
                       << (BITS_PER_UNIT - this_time - next_bit));
 #else
              /* On little-endian machines,
@@ -2839,24 +2842,25 @@ output_constructor (exp, size)
                       - TREE_INT_CST_LOW (DECL_FIELD_BITPOS (field)));
              /* Don't try to take a bunch of bits that cross
                 the word boundary in the INTEGER_CST.  */
-             if (shift < HOST_BITS_PER_INT
-                 && shift + this_time > HOST_BITS_PER_INT)
+             if (shift < HOST_BITS_PER_WIDE_INT
+                 && shift + this_time > HOST_BITS_PER_WIDE_INT)
                {
-                 this_time -= (HOST_BITS_PER_INT - shift);
-                 shift = HOST_BITS_PER_INT;
+                 this_time -= (HOST_BITS_PER_WIDE_INT - shift);
+                 shift = HOST_BITS_PER_WIDE_INT;
                }
 
              /* Now get the bits from the appropriate constant word.  */
              if (shift < HOST_BITS_PER_INT)
                value = TREE_INT_CST_LOW (val);
-             else if (shift < 2 * HOST_BITS_PER_INT)
+             else if (shift < 2 * HOST_BITS_PER_WIDE_INT)
                {
                  value = TREE_INT_CST_HIGH (val);
-                 shift -= HOST_BITS_PER_INT;
+                 shift -= HOST_BITS_PER_WIDE_INT;
                }
              else
                abort ();
-             byte |= ((value >> shift) & ((1 << this_time) - 1)) << next_bit;
+             byte |= ((value >> shift)
+                      & (((HOST_WIDE_INT) 1 << this_time) - 1)) << next_bit;
 #endif
              next_offset += this_time;
              byte_buffer_in_use = 1;