# Fix misspellings in comments.

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

diff --git a/gcc/dwarfout.c b/gcc/dwarfout.c
index e8b70fc..b70a467 100644 (file)
--- a/gcc/dwarfout.c
+++ b/gcc/dwarfout.c
@@ -1851,7 +1851,7 @@ field_byte_offset (decl)
      for the declared type of the field) which it can possibly use, subject
      to the condition that there is still enough available space remaining
      in the containing object (when allocated at the selected point) to
-     fully accomodate all of the bits of the bit-field itself.
+     fully accommodate all of the bits of the bit-field itself.
 
      This simple rule makes it obvious why GCC allocates 8 bytes for each
      object of the structure type shown above.  When looking for a place to
@@ -1932,16 +1932,16 @@ location_attribute (rtl)
      don't do that.  Instead we output a zero-length location descriptor
      value as part of the location attribute.
 
-     A variable which has been optimized out of existance will have a
+     A variable which has been optimized out of existence will have a
      DECL_RTL value which denotes a pseudo-reg.
 
      Currently, in some rare cases, variables can have DECL_RTL values
      which look like (MEM (REG pseudo-reg#)).  These cases are due to
      bugs elsewhere in the compiler.  We treat such cases
-     as if the variable(s) in question had been optimized out of existance.
+     as if the variable(s) in question had been optimized out of existence.
 
      Note that in all cases where we wish to express the fact that a
-     variable has been optimized out of existance, we do not simply
+     variable has been optimized out of existence, we do not simply
      suppress the generation of the entire location attribute because
      the absence of a location attribute in certain kinds of DIEs is
      used to indicate something else entirely... i.e. that the DIE

diff --git a/gcc/explow.c b/gcc/explow.c
index 0bc635b..d2519c6 100644 (file)
--- a/gcc/explow.c
+++ b/gcc/explow.c
@@ -31,7 +31,7 @@ the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
 
 /* Return an rtx for the sum of X and the integer C.
 
-   This fucntion should be used via the `plus_constant' macro.  */
+   This function should be used via the `plus_constant' macro.  */
 
 rtx
 plus_constant_wide (x, c)

diff --git a/gcc/expr.c b/gcc/expr.c
index 04a4d39..990da71 100644 (file)
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -1357,7 +1357,7 @@ emit_block_move (x, y, size, align)
          if (code != CODE_FOR_nothing
              /* We don't need MODE to be narrower than BITS_PER_HOST_WIDE_INT
                 here because if SIZE is less than the mode mask, as it is
-                returned by the macro, it will definately be less than the
+                returned by the macro, it will definitely be less than the
                 actual mode mask.  */
              && (unsigned) INTVAL (size) <= GET_MODE_MASK (mode)
              && (insn_operand_predicate[(int) code][0] == 0
@@ -3122,7 +3122,7 @@ force_operand (value, target)
       return expand_binop (GET_MODE (value), binoptab, tmp,
                           force_operand (op2, NULL_RTX),
                           target, 0, OPTAB_LIB_WIDEN);
-      /* We give UNSIGNEP = 0 to expand_binop
+      /* We give UNSIGNEDP = 0 to expand_binop
         because the only operations we are expanding here are signed ones.  */
     }
   return value;
@@ -3974,7 +3974,7 @@ expand_expr (exp, target, tmode, modifier)
        op0 = expand_expr (tem, NULL_RTX, VOIDmode, EXPAND_SUM);
 
        /* If this is a constant, put it into a register if it is a
-          legimate constant and memory if it isn't.  */
+          legitimate constant and memory if it isn't.  */
        if (CONSTANT_P (op0))
          {
            enum machine_mode mode = TYPE_MODE (TREE_TYPE (tem));
@@ -7139,7 +7139,7 @@ compare_from_rtx (op0, op1, code, unsignedp, mode, size, align)
      unsigned comparison since zero-extension is cheaper than sign
      extension and comparisons with zero are done as unsigned.  This is
      the case even on machines that can do fast sign extension, since
-     zero-extension is easier to combinen with other operations than
+     zero-extension is easier to combine with other operations than
      sign-extension is.  If we are comparing against a constant, we must
      convert it to what it would look like unsigned.  */
   if ((code == EQ || code == NE) && ! unsignedp

diff --git a/gcc/flags.h b/gcc/flags.h
index 19d2ead..7238899 100644 (file)
--- a/gcc/flags.h
+++ b/gcc/flags.h
@@ -237,7 +237,7 @@ extern int flag_fast_math;
 extern int flag_inline_functions;
 
 /* Nonzero for -fkeep-inline-functions: even if we make a function
-   go inline everywhere, keep its defintion around for debugging
+   go inline everywhere, keep its definition around for debugging
    purposes.  */
 
 extern int flag_keep_inline_functions;

diff --git a/gcc/function.c b/gcc/function.c
index 2c5e17e..35c464c 100644 (file)
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -2021,7 +2021,7 @@ instantiate_decls_1 (let, valid_only)
     instantiate_decls_1 (t, valid_only);
 }
 
-/* Subroutine of the preceeding procedures: Given RTL representing a
+/* Subroutine of the preceding procedures: Given RTL representing a
    decl and the size of the object, do any instantiation required.
 
    If VALID_ONLY is non-zero, it means that the RTL should only be