*** empty log message ***

From-SVN: r1263

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.  */

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);

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);

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

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;

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);

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.  */
 

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

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.  */

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)

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

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))

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

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.

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)

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,