*** empty log message ***

From-SVN: r1263

diff --git a/gcc/calls.c b/gcc/calls.c
index 310bc4a558530cec21e3641e9640b4604226b8e5..2fcafcedaa8560427b143800e27075ed322bb804 100644 (file)
--- 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 821639877cce12ad31be38726f342d3e1f72a7f0..f247d9fbafb8b3b1355359b3b9d47602b17413ef 100644 (file)
--- 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 fe1eefda730ace9e059f2ffe2ba861d2336b8bec..7b5feb23e9f1f4c049aeb66ee5df94821613cef5 100644 (file)
--- 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 6026d4544df23b02c7a848331f82a15ea9eeb607..79cc7e14822f01387fedc11fd324e6604a1efdae 100644 (file)
--- 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 aaff89243992460a45f38887f15472df268ddf4c..b05f014989256660ebd3a4e442e5b786c9d9feb5 100644 (file)
--- 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 09f6ece6bc9fc2a72a33da933dc61700fe982f23..d5ac243aaa589ce5908934a4e1c3f02721727877 100644 (file)
--- 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 1510d6230f364b59ec94e9d0462d39779961e317..f73d55196a8bb9e9ddf829381c00a96869e4981d 100644 (file)
--- 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 b77b5480c6b313a0578a3e05092563a53c7381e7..57ac44b2bf3c2389269e2378c7f8dcbc7e17336e 100644 (file)
--- 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 a8a3f370727ab7bea18bc6d81eda879e52c379da..a2691096ba1649eb7da4958b130b4a5c0419a453 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -1694,7 +1694,7 @@ operand_equal_for_comparison_p (arg0, arg1, other)
   return 0;
 }
 \f
-/* 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)
 \f
 /* 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 870635c805824aae1ec4813963d3d4d49c8e2c38..dc96d815ab294d87e44f9c970bd51b0df3f27ad1 100644 (file)
--- 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 8f3ac5e429d72103cdb696f384f9f7687e787d4f..da509119f1dc22c456c4aa2f473359993ec7d245 100644 (file)
--- 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 1b11ee3085bfa92d4992c534b05efb50e62ed2a0..315f147dcfd013656c3c745595738d43ded7e81b 100644 (file)
--- a/gcc/mips-tfile.c
+++ b/gcc/mips-tfile.c
@@ -2691,7 +2691,7 @@ st_to_string(symbol_type)
 \f
 /* 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 45ece42b6d135582f308de2cfbf5e44cce40c032..ea3505c8e03422b2022d58695e0d0bc12c17c29a 100644 (file)
--- 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 b9c271063982fd73fd49c5233396490f779629a1..d72010120f578accb976dffb395861fac3a749f3 100644 (file)
--- 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 a17cc92600e176b2c6dba94d1e62e706b734fc85..d9978b28aff31dbb7e4546fa81b113592150483a 100644 (file)
--- 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 7a5648da8e3243716dec62cec414092360124f05..f4f60039c2d5ac9e3c861b60ed40cb118369ad45 100644 (file)
--- 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,