*** empty log message ***

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

16 files changed, 44 insertions, 20 deletions

diff --git a/gcc/calls.c b/gcc/calls.c
index 310bc4a5585..2fcafcedaa8 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 821639877cc..f247d9fbafb 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 fe1eefda730..7b5feb23e9f 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 6026d4544df..79cc7e14822 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 aaff8924399..b05f0149892 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 09f6ece6bc9..d5ac243aaa5 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 1510d6230f3..f73d55196a8 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 b77b5480c6b..57ac44b2bf3 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 a8a3f370727..a2691096ba1 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 870635c8058..dc96d815ab2 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 8f3ac5e429d..da509119f1d 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 1b11ee3085b..315f147dcfd 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 45ece42b6d1..ea3505c8e03 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 b9c27106398..d72010120f5 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 a17cc92600e..d9978b28aff 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 7a5648da8e3..f4f60039c2d 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,