*** empty log message ***

From-SVN: r1263

16 files changed, 44 insertions, 20 deletions

diff --git a/gcc/calls.c b/gcc/calls.c
index 310bc4a..2fcafce 100644
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -442,7 +442,7 @@ expand_call (exp, target, ignore)
 #endif
 #endif
 
-  /* Size of the stack reserved for paramter registers.  */
+  /* Size of the stack reserved for parameter registers.  */
   int reg_parm_stack_space = 0;
 
   /* 1 if scanning parms front to back, -1 if scanning back to front.  */
diff --git a/gcc/cccp.c b/gcc/cccp.c
index 8216398..f247d9f 100644
--- a/gcc/cccp.c
+++ b/gcc/cccp.c
@@ -614,7 +614,7 @@ union hashval {
  *		{ wow(1, 2, 3); }	->	{ process( 2, 3, 1,  2, 3); }
  *		{ wow(one, two); }	->	{ process( two, one,  two); }
  * if this "rest_arg" is used with the concat token '##' and if it is not
- * supplied then the token attached to with ## will not be outputed.  Ex:
+ * supplied then the token attached to with ## will not be outputted.  Ex:
  * 		#define wow(a, b...)		process(b ## , a, ## b)
  *		{ wow(1, 2); }		->	{ process( 2, 1,2); }
  *		{ wow(one); }		->	{ process( one); {
@@ -6836,7 +6836,7 @@ macroexpand (hp, op)
       if (rest_args)
 	continue;
       if (i < nargs || (nargs == 0 && i == 0)) {
-	/* if we are working on last arg which absorbes rest of args... */
+	/* if we are working on last arg which absorbs rest of args... */
 	if (i == nargs - 1 && defn->rest_args)
 	  rest_args = 1;
 	parse_error = macarg (&args[i], rest_args);
diff --git a/gcc/collect2.c b/gcc/collect2.c
index fe1eefd..7b5feb2 100644
--- a/gcc/collect2.c
+++ b/gcc/collect2.c
@@ -1380,7 +1380,7 @@ scan_prog_file (prog_name, which_pass)
       load_cmd = load_end++;
       load_hdr = (load_union_t *) (obj + offset);
 
-      /* If modifing the program file, copy the header.  */
+      /* If modifying the program file, copy the header.  */
       if (rw)
 	{
 	  load_union_t *ptr = (load_union_t *) xmalloc (load_hdr->hdr.ldci_cmd_size);
diff --git a/gcc/combine.c b/gcc/combine.c
index 6026d45..79cc7e1 100644
--- a/gcc/combine.c
+++ b/gcc/combine.c
@@ -1965,7 +1965,7 @@ find_split_point (loc)
       /* If we have a PLUS whose second operand is a constant and the
 	 address is not valid, perhaps will can split it up using
 	 the machine-specific way to split large constants.  We use
-	 the first psuedo-reg (one of the virtual regs) as a placeholder;
+	 the first pseudo-reg (one of the virtual regs) as a placeholder;
 	 it will not remain in the result.  */
       if (GET_CODE (XEXP (x, 0)) == PLUS
 	  && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
diff --git a/gcc/cse.c b/gcc/cse.c
index aaff892..b05f014 100644
--- a/gcc/cse.c
+++ b/gcc/cse.c
@@ -2881,6 +2881,30 @@ simplify_unary_operation (code, mode, op, op_mode)
 	    return 0;
 	  break;
 
+	case ZERO_EXTEND:
+	  if (op_mode == VOIDmode
+	      || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_INT)
+	    return 0;
+
+	  hv = 0;
+	  lv = l1 & GET_MODE_MASK (op_mode);
+	  break;
+
+	case SIGN_EXTEND:
+	  if (op_mode == VOIDmode
+	      || GET_MODE_BITSIZE (op_mode) > HOST_BITS_PER_INT)
+	    return 0;
+	  else
+	    {
+	      lv = l1 & GET_MODE_MASK (op_mode);
+	      if (GET_MODE_BITSIZE (op_mode) < HOST_BITS_PER_INT
+		  && (lv & (1 << (GET_MODE_BITSIZE (op_mode) - 1))) != 0)
+		lv -= 1 << GET_MODE_BITSIZE (op_mode);
+
+	      hv = (lv < 0) ? ~0 : 0;
+	    }
+	  break;
+
 	case SQRT:
 	  return 0;
 
@@ -6775,7 +6799,7 @@ cse_around_loop (loop_start)
 
   /* If the last insn of the loop (the end test) was an NE comparison,
      we will interpret it as an EQ comparison, since we fell through
-     the loop.  Any equivalances resulting from that comparison are
+     the loop.  Any equivalences resulting from that comparison are
      therefore not valid and must be invalidated.  */
   if (last_jump_equiv_class)
     for (p = last_jump_equiv_class->first_same_value; p;
diff --git a/gcc/dbxout.c b/gcc/dbxout.c
index 09f6ece..d5ac243 100644
--- a/gcc/dbxout.c
+++ b/gcc/dbxout.c
@@ -1143,7 +1143,7 @@ dbxout_type (type, full, show_arg_types)
 	    }
 	  else
 	    {
-	      /* When outputing destructors, we need to write
+	      /* When outputting destructors, we need to write
 		 the argument types out longhand.  */
 	      dbxout_type (TYPE_METHOD_BASETYPE (type), 0, 0);
 	      putc (',', asmfile);
diff --git a/gcc/dwarf.h b/gcc/dwarf.h
index 1510d62..f73d551 100644
--- a/gcc/dwarf.h
+++ b/gcc/dwarf.h
@@ -77,7 +77,7 @@ enum dwarf_tag {
 
 #define TAG_lo_user	0x8000  /* implementation-defined range start */
 #define TAG_hi_user	0xffff  /* implementation-defined range end */
-#define TAG_source_file TAG_compile_unit  /* for backward compatability */
+#define TAG_source_file TAG_compile_unit  /* for backward compatibility */
 
 /* Form names and codes.  */
 
diff --git a/gcc/final.c b/gcc/final.c
index b77b548..57ac44b 100644
--- a/gcc/final.c
+++ b/gcc/final.c
@@ -161,7 +161,7 @@ static int new_block = 1;
    and assume that they will both give the same number to each block.
    Final uses these sequence numbers to generate assembler label names
    LBBnnn and LBEnnn for the beginning and end of the symbol-block.
-   Dbxout uses the sequence nunbers to generate references to the same labels
+   Dbxout uses the sequence numbers to generate references to the same labels
    from the dbx debugging information.
 
    Sdb records this level at the beginning of each function,
@@ -1029,7 +1029,7 @@ final_scan_insn (insn, file, optimize, prescan, nopeepholes)
 	      if (GET_CODE (note) != NOTE && GET_CODE (note) != CODE_LABEL)
 		break;
 	      /* These types of notes can be significant
-		 so make sure the preceeding line number stays.  */
+		 so make sure the preceding line number stays.  */
 	      else if (GET_CODE (note) == NOTE
 		       && (NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_BEG
 			   || NOTE_LINE_NUMBER (note) == NOTE_INSN_BLOCK_END
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index a8a3f37..a269109 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -1694,7 +1694,7 @@ operand_equal_for_comparison_p (arg0, arg1, other)
   return 0;
 }
 
-/* See if ARG is an expression is either a comparison or is peforming
+/* See if ARG is an expression that is either a comparison or is performing
    arithmetic on comparisons.  The comparisons must only be comparing
    two different values, which will be stored in *CVAL1 and *CVAL2; if
    they are non-zero it means that some operands have already been found.
@@ -1780,7 +1780,7 @@ twoval_comparison_p (arg, cval1, cval2)
 
 /* ARG is a tree that is known to contain just arithmetic operations and
    comparisons.  Evaluate the operations in the tree substituting NEW0 for
-   any occurrance of OLD0 as an operand of a comparison and likewise for
+   any occurrence of OLD0 as an operand of a comparison and likewise for
    NEW1 and OLD1.  */
 
 static tree
@@ -2806,7 +2806,7 @@ fold (expr)
 	       && DECL_BIT_FIELD (TREE_OPERAND (TREE_OPERAND (TREE_OPERAND (t, 0), 0), 1))))
 	{
 	  /* Don't leave an assignment inside a conversion
-	     unless assiging a bitfield.  */
+	     unless assigning a bitfield.  */
 	  tree prev = TREE_OPERAND (t, 0);
 	  TREE_OPERAND (t, 0) = TREE_OPERAND (prev, 1);
 	  /* First do the assignment, then return converted constant.  */
diff --git a/gcc/genattrtab.c b/gcc/genattrtab.c
index 870635c..dc96d81 100644
--- a/gcc/genattrtab.c
+++ b/gcc/genattrtab.c
@@ -838,7 +838,7 @@ check_attr_test (exp, is_const)
 	     so expressions using it can be permanent too.  */
 	  exp = attr_eq (XSTR (exp, 0), XSTR (exp, 1));
 
-	  /* It shouldn't be possible to simplfy the value given to a
+	  /* It shouldn't be possible to simplify the value given to a
 	     constant attribute, so don't expand this until it's time to
 	     write the test expression.  */	       
 	  if (attr->is_const)
diff --git a/gcc/ginclude/stddef.h b/gcc/ginclude/stddef.h
index 8f3ac5e..da50911 100644
--- a/gcc/ginclude/stddef.h
+++ b/gcc/ginclude/stddef.h
@@ -11,7 +11,7 @@
 #endif
 
 #ifndef __sys_stdtypes_h
-/* This avoids lossage on Sunos but only if stdtypes.h comes first.
+/* This avoids lossage on SunOS but only if stdtypes.h comes first.
    There's no way to win with the other order!  Sun lossage.  */
 
 /* In case nobody has defined these types, but we aren't running under
diff --git a/gcc/mips-tfile.c b/gcc/mips-tfile.c
index 1b11ee3..315f147 100644
--- a/gcc/mips-tfile.c
+++ b/gcc/mips-tfile.c
@@ -2691,7 +2691,7 @@ st_to_string(symbol_type)
 
 /* Read a line from standard input, and return the start of the buffer
    (which is grows if the line is too big).  We split lines at the
-   semi-colon, and return each logical line indpendently.  */
+   semi-colon, and return each logical line independently.  */
 
 STATIC char *
 read_line __proto((void))
diff --git a/gcc/protoize.c b/gcc/protoize.c
index 45ece42..ea3505c 100644
--- a/gcc/protoize.c
+++ b/gcc/protoize.c
@@ -50,7 +50,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 #ifdef POSIX /* We should be able to define _POSIX_SOURCE unconditionally,
 		but some systems respond in buggy ways to it,
-		including Sunos 4.1.1.  Which we don't classify as POSIX.  */
+		including SunOS 4.1.1.  Which we don't classify as POSIX.  */
 /* In case this is a POSIX system with an ANSI C compiler,
    ask for definition of all POSIX facilities.  */
 #undef _POSIX_SOURCE
diff --git a/gcc/recog.c b/gcc/recog.c
index b9c2710..d720101 100644
--- a/gcc/recog.c
+++ b/gcc/recog.c
@@ -84,7 +84,7 @@ init_recog ()
 
 /* Try recognizing the instruction INSN,
    and return the code number that results.
-   Remeber the code so that repeated calls do not
+   Remember the code so that repeated calls do not
    need to spend the time for actual rerecognition.
 
    This function is the normal interface to instruction recognition.
diff --git a/gcc/reload.c b/gcc/reload.c
index a17cc92..d9978b2 100644
--- a/gcc/reload.c
+++ b/gcc/reload.c
@@ -1696,7 +1696,7 @@ immune_p (x, y, ydata)
   return (xdata.start >= ydata.end || ydata.start >= xdata.end);
 }
 
-/* Similiar, but calls decompose.  */
+/* Similar, but calls decompose.  */
 
 int
 safe_from_earlyclobber (op, clobber)
diff --git a/gcc/stmt.c b/gcc/stmt.c
index 7a5648d..f4f6003 100644
--- a/gcc/stmt.c
+++ b/gcc/stmt.c
@@ -4256,7 +4256,7 @@ emit_jump_if_reachable (label)
    current node are arranged to target the subordinates associated
    code for out of bound conditions on the current node node.
 
-   We can asume that when control reaches the code generated here,
+   We can assume that when control reaches the code generated here,
    the index value has already been compared with the parents
    of this node, and determined to be on the same side of each parent
    as this node is.  Thus, if this node tests for the value 51,