* dbxout.c: Fix comment formatting.

	* dependence.c: Likewise.
	* df.c: Likewise.
	* diagnostic.c: Likewise.
	* dominance.c: Likewise.
	* doprint.c: Likewise.
	* dwarf2out.c: Likewise.
	* dwarfout.c: Likewise.
	* emit-rtl.c: Likewise.
	* except.c: Likewise.
	* explow.c: Likewise.
	* expmed.c: Likewise.
	* expr.c: Likewise.
	* flow.c: Likewise.
	* fold-const.c: Likewise.
	* function.c: Likewise.


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

17 files changed, 110 insertions, 91 deletions

diff --git a/gcc/ChangeLog b/gcc/ChangeLog
index 500a0894d9f..7ca9c060881 100644
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,22 @@
+2001-08-08  Kazu Hirata  <kazu@hxi.com>
+
+	* dbxout.c: Fix comment formatting.
+	* dependence.c: Likewise.
+	* df.c: Likewise.
+	* diagnostic.c: Likewise.
+	* dominance.c: Likewise.
+	* doprint.c: Likewise.
+	* dwarf2out.c: Likewise.
+	* dwarfout.c: Likewise.
+	* emit-rtl.c: Likewise.
+	* except.c: Likewise.
+	* explow.c: Likewise.
+	* expmed.c: Likewise.
+	* expr.c: Likewise.
+	* flow.c: Likewise.
+	* fold-const.c: Likewise.
+	* function.c: Likewise.
+
 2001-08-08  Franz Sirl  <Franz.Sirl-kernel@lauterbach.com>
 
 	* global.c (retry_global_alloc): Avoid shadowing allocno.
diff --git a/gcc/dbxout.c b/gcc/dbxout.c
index 60a91fe185f..18ea19694d7 100644
--- a/gcc/dbxout.c
+++ b/gcc/dbxout.c
@@ -2737,7 +2737,7 @@ dbxout_block (block, depth, args)
 	  did_output = 1;
 #else
 	  /* In dbx format, the syms of a block come before the N_LBRAC.
-	     If nothing is output, we don't need the N_LBRAC, either. */
+	     If nothing is output, we don't need the N_LBRAC, either.  */
 	  did_output = 0;
 	  if (debug_info_level != DINFO_LEVEL_TERSE || depth == 0)
 	    did_output = dbxout_syms (BLOCK_VARS (block));
diff --git a/gcc/dependence.c b/gcc/dependence.c
index 103380bc491..9a54ac6251f 100644
--- a/gcc/dependence.c
+++ b/gcc/dependence.c
@@ -79,7 +79,7 @@ enum complexity_type {ziv, strong_siv, weak_siv, weak_zero_siv,
 
 /* Given a def/use one can chase the next chain to follow the def/use
    for that variable.  Alternately one can sequentially follow each
-   element of def_use_chain. */
+   element of def_use_chain.  */
 
 typedef struct def_use
 {
@@ -104,7 +104,7 @@ typedef struct def_use
 /* Given a loop* one can chase the next_nest chain to follow the nested
    loops for that loop.  Alternately one can sequentially follow each
    element of loop_chain and check outer_loop to get all loops
-   contained within a certain loop. */
+   contained within a certain loop.  */
 
 typedef struct loop
 {
@@ -118,11 +118,11 @@ typedef struct loop
   enum loop_status_type status;
   /* loop* for loop contained in this loop */
   struct loop *next_nest;
-  /* induction variables for this loop.  Currently only the index variable. */
+  /* induction variables for this loop.  Currently only the index variable.  */
   struct induction *ind;
 } loop;
 
-/* Pointed to by loop. One per induction variable. */
+/* Pointed to by loop. One per induction variable.  */
 
 typedef struct induction
 {
@@ -134,11 +134,11 @@ typedef struct induction
   int  low_bound;
   /* upper bound */
   int  high_bound;
-  /* next induction variable for this loop.  Currently null. */
+  /* next induction variable for this loop.  Currently null.  */
   struct induction *next;
 } induction;
 
-/* Pointed to by def/use.  One per dependence. */
+/* Pointed to by def/use.  One per dependence.  */
 
 typedef struct dependence
 {
@@ -163,11 +163,11 @@ typedef struct subscript
   int offset;
   /* our name */
   const char *variable;
-  /* next subscript term.  Currently null. */
+  /* next subscript term.  Currently null.  */
   struct subscript *next;
 } subscript;
 
-/* Remember the destination the front end encountered. */
+/* Remember the destination the front end encountered.  */
 
 static tree dest_to_remember;
 
@@ -221,7 +221,7 @@ int have_dependence_p PARAMS ((rtx, rtx, enum direction_type[], int[]));
 void end_dependence_analysis PARAMS ((void));
 
 /* Build dependence chain 'dep_chain', which is used by have_dependence_p,
-   for the function given by EXP. */
+   for the function given by EXP.  */
 
 void
 init_dependence_analysis (exp)
@@ -433,7 +433,7 @@ add_loop (loop_node, outer_loop, nloop)
 }
 
 /* Update LOOP_DEF if for loop's COND_NODE and INCR_NODE define an index that
-   is a normalized induction variable. */
+   is a normalized induction variable.  */
 
 static int
 find_induction_variable (init_node, cond_node, incr_node, loop_def)
@@ -579,7 +579,7 @@ get_low_bound (node, variable)
 
 
 /* Return the ordinal subscript position for IND_VAR if it is an induction
-   variable contained in OUTER_LOOP, otherwise return -1. */
+   variable contained in OUTER_LOOP, otherwise return -1.  */
 
 static int
 have_induction_variable (outer_loop, ind_var)
@@ -605,7 +605,7 @@ have_induction_variable (outer_loop, ind_var)
   return -1;
 }
 
-/* Chain the nodes of 'loop_chain'. */
+/* Chain the nodes of 'loop_chain'.  */
 
 static void
 link_loops ()
@@ -627,7 +627,7 @@ link_loops ()
     }
 }
 
-/* Check the dependence for each member of 'def_use_chain'. */
+/* Check the dependence for each member of 'def_use_chain'.  */
 
 static void
 get_node_dependence ()
@@ -645,7 +645,7 @@ get_node_dependence ()
     }
 }
 
-/* Check the dependence for definition DU. */
+/* Check the dependence for definition DU.  */
 
 static void
 check_node_dependence (du)
@@ -807,7 +807,7 @@ check_node_dependence (du)
     }
 }
 
-/* Get the COEFFICIENTS and offset for def/use DU. */
+/* Get the COEFFICIENTS and offset for def/use DU.  */
 
 static int
 get_coefficients (du, coefficients)
@@ -851,7 +851,7 @@ get_coefficients (du, coefficients)
   return array_count;
 }
 
-/* Get the COEFFICIENTS and offset for NODE having TYPE and defined in DU. */
+/* Get the COEFFICIENTS and offset for NODE having TYPE and defined in DU.  */
 
 static int
 get_one_coefficient (node, coefficients, du, type)
@@ -940,7 +940,7 @@ get_one_coefficient (node, coefficients, du, type)
   return 0;
 }
 
-/* Adjust the COEFFICIENTS as if loop LOOP_PTR were normalized to start at 0. */
+/* Adjust the COEFFICIENTS as if loop LOOP_PTR were normalized to start at 0.  */
 
 static void
 normalize_coefficients (coefficients, loop_ptr, count)
@@ -1091,7 +1091,7 @@ siv_test (icoefficients, ocoefficients, direction, distance, loop_ptr, sub)
   coef_diff = icoefficients[sub].offset - ocoefficients[sub].offset;
   /* strong_siv requires equal coefficients.  weak_crossing_siv requires
      coefficients to have equal absolute value.  weak_zero_siv uses the
-     nonzero coefficient. */
+     nonzero coefficient.  */
 
   if (ocoefficients[sub].coefficient == INT_MIN)
     coef = icoefficients[sub].coefficient;
@@ -1180,7 +1180,7 @@ gcd_test (icoefficients, ocoefficients, direction, distance, loop_ptr, sub)
 	}
     }
   /* ?? gcd does not yield direction and distance.  Wolfe's direction
-     vector hierarchy can be used to give this. */
+     vector hierarchy can be used to give this.  */
 }     
 
 /* Find the gcd of X and Y using Euclid's algorithm */
@@ -1263,7 +1263,7 @@ merge_dependencies (direction, distance, loop_count, subscript_count)
     }
 }
 
-/* Dump ARRAY_REF NODE. */
+/* Dump ARRAY_REF NODE.  */
 
 static void
 dump_array_ref (node)
@@ -1299,7 +1299,7 @@ dump_array_ref (node)
     }
 }
 
-/* Dump def/use DU. */
+/* Dump def/use DU.  */
 
 #if 0
 static void
@@ -1346,7 +1346,7 @@ dump_one_node (du, seen)
     }
 }
 
-/* Dump dependence info. */
+/* Dump dependence info.  */
 
 static void
 dump_node_dependence (void)
@@ -1373,7 +1373,7 @@ dump_node_dependence (void)
 
 /* Return the index into 'dep_chain' if there is a dependency for destination
    dest_to_remember (set by remember_dest_for_dependence) and source node.
-   Called by the front end, which adds the index onto a MEM rtx. */
+   Called by the front end, which adds the index onto a MEM rtx.  */
 
 int
 search_dependence (node)
@@ -1402,7 +1402,7 @@ search_dependence (node)
   return 0;
 }
 
-/* Remember a destination NODE for search_dependence. */
+/* Remember a destination NODE for search_dependence.  */
 
 void
 remember_dest_for_dependence (node)
@@ -1422,7 +1422,7 @@ remember_dest_for_dependence (node)
 #endif
 
 /* Return 1 along with the dependence DIRECTION and DISTANCE if there is a 
-   dependence from dest_rtx to src_rtx. */
+   dependence from dest_rtx to src_rtx.  */
 
 int
 have_dependence_p (dest_rtx, src_rtx, direction, distance)
@@ -1461,7 +1461,7 @@ have_dependence_p (dest_rtx, src_rtx, direction, distance)
   return 0;
 }
 
-/* Cleanup when dependency analysis is complete. */
+/* Cleanup when dependency analysis is complete.  */
 
 void
 end_dependence_analysis ()
diff --git a/gcc/df.c b/gcc/df.c
index 776f4feebc8..505ed7b2ec5 100644
--- a/gcc/df.c
+++ b/gcc/df.c
@@ -1176,7 +1176,7 @@ df_uses_record (df, loc, ref_type, bb, insn)
       /* Catch the def of the register being modified.  */
       df_ref_record (df, XEXP (x, 0), &XEXP (x, 0), bb, insn, DF_REF_REG_DEF);
 
-      /* ... Fall through to handle uses ... */
+      /* ... Fall through to handle uses ...  */
 
     default:
       break;
@@ -1600,7 +1600,7 @@ df_ud_chain_create (df, blocks)
 
 
 /* Use depth first order, and the worklist, to figure out what block
-   to look at next. */
+   to look at next.  */
 
 static int
 df_visit_next (df, blocks)
diff --git a/gcc/diagnostic.c b/gcc/diagnostic.c
index 14cd98647ff..0efcfd6b58b 100644
--- a/gcc/diagnostic.c
+++ b/gcc/diagnostic.c
@@ -58,7 +58,7 @@ Boston, MA 02111-1307, USA.  */
 #define diagnostic_args output_buffer_ptr_to_format_args (diagnostic_buffer)
 #define diagnostic_msg output_buffer_text_cursor (diagnostic_buffer)
 
-/* Prototypes. */
+/* Prototypes.  */
 static void diagnostic_finish PARAMS ((output_buffer *));
 static void output_do_verbatim PARAMS ((output_buffer *,
                                         const char *, va_list *));
@@ -1125,7 +1125,7 @@ pedwarn_with_decl VPARAMS ((tree decl, const char *msgid, ...))
   va_end (ap);
 }
 
-/* Same as above but within the context FILE and LINE. */
+/* Same as above but within the context FILE and LINE.  */
 
 void
 pedwarn_with_file_and_line VPARAMS ((const char *file, int line,
diff --git a/gcc/dominance.c b/gcc/dominance.c
index 8f5e0d370a0..3c35268dc5c 100644
--- a/gcc/dominance.c
+++ b/gcc/dominance.c
@@ -95,7 +95,7 @@ struct dom_info
      is true for every basic block bb, but not the opposite.  */
   basic_block *dfs_to_bb;
 
-  /* This is the next free DFS number when creating the DFS tree or forest. */
+  /* This is the next free DFS number when creating the DFS tree or forest.  */
   unsigned int dfsnum;
   /* The number of nodes in the DFS tree (==dfsnum-1).  */
   unsigned int nodes;
@@ -193,7 +193,7 @@ calc_dfs_tree_nonrec (di, bb, reverse)
      basic_block bb;
      enum cdi_direction reverse;
 {
-  /* We never call this with bb==EXIT_BLOCK_PTR (ENTRY_BLOCK_PTR if REVERSE). */
+  /* We never call this with bb==EXIT_BLOCK_PTR (ENTRY_BLOCK_PTR if REVERSE).  */
   /* We call this _only_ if bb is not already visited.  */
   edge e;
   TBB child_i, my_i = 0;
diff --git a/gcc/doprint.c b/gcc/doprint.c
index 5564421df0b..114dcb7f77e 100644
--- a/gcc/doprint.c
+++ b/gcc/doprint.c
@@ -20,7 +20,7 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
 #include "system.h"
 #undef _doprnt
 
-#ifdef TEST /* Make sure to use the internal one. */
+#ifdef TEST /* Make sure to use the internal one.  */
 #define _doprnt my_doprnt
 #endif
 
@@ -28,8 +28,8 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
   do { \
 	 const int value = abs (va_arg (ap, int)); \
 	 char buf[32]; \
-	 ptr++; /* Go past the asterisk. */ \
-	 *sptr = '\0'; /* NULL terminate sptr. */ \
+	 ptr++; /* Go past the asterisk.  */ \
+	 *sptr = '\0'; /* NULL terminate sptr.  */ \
 	 sprintf(buf, "%d", value); \
 	 strcat(sptr, buf); \
 	 while (*sptr) sptr++; \
@@ -47,8 +47,8 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
   do { \
 	int result; \
 	TYPE value = va_arg (ap, TYPE); \
-	*sptr++ = *ptr++; /* Copy the type specifier. */ \
-	*sptr = '\0'; /* NULL terminate sptr. */ \
+	*sptr++ = *ptr++; /* Copy the type specifier.  */ \
+	*sptr = '\0'; /* NULL terminate sptr.  */ \
 	result = fprintf(stream, specifier, value); \
 	if (result == -1) \
 	  return -1; \
@@ -71,31 +71,31 @@ _doprnt (format, ap, stream)
   
   while (*ptr != '\0')
     {
-      if (*ptr != '%') /* While we have regular characters, print them. */
+      if (*ptr != '%') /* While we have regular characters, print them.  */
 	PRINT_CHAR(*ptr);
       else /* We got a format specifier! */
 	{
 	  char * sptr = specifier;
 	  int wide_width = 0, short_width = 0;
 	  
-	  *sptr++ = *ptr++; /* Copy the % and move forward. */
+	  *sptr++ = *ptr++; /* Copy the % and move forward.  */
 
-	  while (strchr ("-+ #0", *ptr)) /* Move past flags. */
+	  while (strchr ("-+ #0", *ptr)) /* Move past flags.  */
 	    *sptr++ = *ptr++;
 
 	  if (*ptr == '*')
 	    COPY_VA_INT;
 	  else
-	    while (ISDIGIT(*ptr)) /* Handle explicit numeric value. */
+	    while (ISDIGIT(*ptr)) /* Handle explicit numeric value.  */
 	      *sptr++ = *ptr++;
 	  
 	  if (*ptr == '.')
 	    {
-	      *sptr++ = *ptr++; /* Copy and go past the period. */
+	      *sptr++ = *ptr++; /* Copy and go past the period.  */
 	      if (*ptr == '*')
 		COPY_VA_INT;
 	      else
-		while (ISDIGIT(*ptr)) /* Handle explicit numeric value. */
+		while (ISDIGIT(*ptr)) /* Handle explicit numeric value.  */
 		  *sptr++ = *ptr++;
 	    }
 	  while (strchr ("hlL", *ptr))
@@ -129,7 +129,7 @@ _doprnt (format, ap, stream)
 	      {
 		/* Short values are promoted to int, so just copy it
                    as an int and trust the C library printf to cast it
-                   to the right width. */
+                   to the right width.  */
 		if (short_width)
 		  PRINT_TYPE(int);
 		else
@@ -147,7 +147,7 @@ _doprnt (format, ap, stream)
 #if defined(__GNUC__) || defined(HAVE_LONG_LONG)
 			PRINT_TYPE(long long);
 #else
-			PRINT_TYPE(long); /* Fake it and hope for the best. */
+			PRINT_TYPE(long); /* Fake it and hope for the best.  */
 #endif
 			break;
 		      } /* End of switch (wide_width) */
@@ -167,7 +167,7 @@ _doprnt (format, ap, stream)
 #if defined(__GNUC__) || defined(HAVE_LONG_DOUBLE)
 		    PRINT_TYPE(long double);
 #else
-		    PRINT_TYPE(double); /* Fake it and hope for the best. */
+		    PRINT_TYPE(double); /* Fake it and hope for the best.  */
 #endif
 		  }
 	      }
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c
index bedbf8ec957..f940dda4ca8 100644
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -877,7 +877,7 @@ initial_return_save (rtl)
 }
 
 /* Given a SET, calculate the amount of stack adjustment it
-   contains. */
+   contains.  */
 
 static long
 stack_adjust_offset (pattern)
@@ -981,7 +981,7 @@ dwarf2out_stack_adjust (insn)
 	   || GET_CODE (PATTERN (insn)) == SEQUENCE)
     {
       /* There may be stack adjustments inside compound insns.  Search
-         for them. */
+         for them.  */
       int j;
 
       offset = 0;
@@ -2201,7 +2201,7 @@ dw_loc_descr_node;
 
 /* Location lists are ranges + location descriptions for that range,
    so you can track variables that are in different places over
-   their entire life. */
+   their entire life.  */
 typedef struct dw_loc_list_struct
 {
   dw_loc_list_ref dw_loc_next;
@@ -6030,7 +6030,7 @@ output_die_symbol (die)
 /* Return a new location list, given the begin and end range, and the
    expression. gensym tells us whether to generate a new internal
    symbol for this location list node, which is done for the head of
-   the list only. */ 
+   the list only.  */ 
 static inline dw_loc_list_ref
 new_loc_list (expr, begin, end, section, gensym)
      register dw_loc_descr_ref expr;
@@ -6061,7 +6061,7 @@ add_loc_descr_to_loc_list (list_head, descr, begin, end, section)
 {
   register dw_loc_list_ref *d;
   
-  /* Find the end of the chain. */
+  /* Find the end of the chain.  */
   for (d = list_head; (*d) != NULL; d = &(*d)->dw_loc_next)
     ;
   /* Add a new location list node to the list */
@@ -11543,7 +11543,7 @@ dwarf2out_source_line (line, filename)
     }
 }
 
-/* Record the beginning of a new source file. */
+/* Record the beginning of a new source file.  */
 
 static void
 dwarf2out_start_source_file (lineno, filename)
@@ -11833,7 +11833,7 @@ dwarf2out_finish (input_filename)
   /* Output location list section if necessary.  */
   if (have_location_lists)
     {
-      /* Output the location lists info. */
+      /* Output the location lists info.  */
       named_section_flags (DEBUG_LOC_SECTION, SECTION_DEBUG, 1);
       output_location_lists (die);
       have_location_lists = 0;
@@ -11846,7 +11846,7 @@ dwarf2out_finish (input_filename)
       output_ranges ();
     }
 
-  /* Have to end the primary source file. */
+  /* Have to end the primary source file.  */
   if (debug_info_level >= DINFO_LEVEL_VERBOSE)
     { 
       named_section_flags (DEBUG_MACINFO_SECTION, SECTION_DEBUG, 1);
diff --git a/gcc/dwarfout.c b/gcc/dwarfout.c
index a61ffc38347..057dee29d82 100644
--- a/gcc/dwarfout.c
+++ b/gcc/dwarfout.c
@@ -2382,7 +2382,7 @@ output_bound_representation (bound, dim_num, u_or_l)
 	   comprehend that a missing upper bound specification in a
 	   array type used for a storage class `auto' local array variable
 	   indicates that the upper bound is both unknown (at compile-
-	   time) and unknowable (at run-time) due to optimization. */
+	   time) and unknowable (at run-time) due to optimization.  */
 
 	if (! optimize)
 	  {
@@ -2584,7 +2584,7 @@ field_byte_offset (decl)
 
      The value we deduce is then used (by the callers of this routine) to
      generate AT_location and AT_bit_offset attributes for fields (both
-     bit-fields and, in the case of AT_location, regular fields as well). */
+     bit-fields and, in the case of AT_location, regular fields as well).  */
 
   /* Figure out the bit-distance from the start of the structure to the
      "deepest" bit of the bit-field.  */
diff --git a/gcc/emit-rtl.c b/gcc/emit-rtl.c
index 755527fa3af..c3ba4525a3e 100644
--- a/gcc/emit-rtl.c
+++ b/gcc/emit-rtl.c
@@ -379,7 +379,7 @@ gen_rtx_SUBREG (mode, reg, offset)
 
 /* Generate a SUBREG representing the least-significant part
  * of REG if MODE is smaller than mode of REG, otherwise
- * paradoxical SUBREG. */
+ * paradoxical SUBREG.  */
 rtx
 gen_lowpart_SUBREG (mode, reg)
      enum machine_mode mode;
@@ -1483,12 +1483,12 @@ operand_subword (op, offset, validate_address, mode)
   if (mode == VOIDmode)
     abort ();
 
-  /* If OP is narrower than a word, fail. */
+  /* If OP is narrower than a word, fail.  */
   if (mode != BLKmode
       && (GET_MODE_SIZE (mode) < UNITS_PER_WORD))
     return 0;
 
-  /* If we want a word outside OP, return zero. */
+  /* If we want a word outside OP, return zero.  */
   if (mode != BLKmode
       && (offset + 1) * UNITS_PER_WORD > GET_MODE_SIZE (mode))
     return const0_rtx;
@@ -1886,7 +1886,7 @@ unshare_all_decls (blk)
 }
 
 /* Go through all virtual stack slots of a function and mark them as
-   not shared. */
+   not shared.  */
 static void
 reset_used_decls (blk)
      tree blk;
@@ -3606,7 +3606,7 @@ force_next_line_note ()
 }
 
 /* Place a note of KIND on insn INSN with DATUM as the datum. If a
-   note of this type already exists, remove it first. */
+   note of this type already exists, remove it first.  */
 
 void
 set_unique_reg_note (insn, kind, datum)
@@ -3867,7 +3867,7 @@ gen_sequence ()
   if (len == 1
       && ! RTX_FRAME_RELATED_P (first_insn)
       && GET_CODE (first_insn) == INSN
-      /* Don't throw away any reg notes. */
+      /* Don't throw away any reg notes.  */
       && REG_NOTES (first_insn) == 0)
     return PATTERN (first_insn);
 
diff --git a/gcc/except.c b/gcc/except.c
index 822c35682ae..3058e10f8f1 100644
--- a/gcc/except.c
+++ b/gcc/except.c
@@ -2865,7 +2865,7 @@ void
 expand_builtin_unwind_init ()
 {
   /* Set this so all the registers get saved in our frame; we need to be
-     able to copy the saved values for any registers from frames we unwind. */
+     able to copy the saved values for any registers from frames we unwind.  */
   current_function_has_nonlocal_label = 1;
 
 #ifdef SETUP_FRAME_ADDRESSES
diff --git a/gcc/explow.c b/gcc/explow.c
index a8249999c98..9f2357aff44 100644
--- a/gcc/explow.c
+++ b/gcc/explow.c
@@ -678,7 +678,7 @@ set_mem_attributes (ref, t, objectp)
   MEM_IN_STRUCT_P (ref) = AGGREGATE_TYPE_P (type);
 
   /* If we are making an object of this type, we know that it is a scalar if
-     the type is not an aggregate. */
+     the type is not an aggregate.  */
   if (objectp && ! AGGREGATE_TYPE_P (type))
     MEM_SCALAR_P (ref) = 1;
 
@@ -1663,7 +1663,7 @@ probe_stack_range (first, size)
    otherwise 0.
    OUTGOING is 1 if on a machine with register windows this function
    should return the register in which the function will put its result
-   and 0 otherwise. */
+   and 0 otherwise.  */
 
 rtx
 hard_function_value (valtype, func, outgoing)
diff --git a/gcc/expmed.c b/gcc/expmed.c
index d334f6dad1f..68efa79a851 100644
--- a/gcc/expmed.c
+++ b/gcc/expmed.c
@@ -4557,7 +4557,7 @@ emit_store_flag (target, code, op0, op1, mode, unsignedp, normalizep)
 
       /* Note that ABS doesn't yield a positive number for INT_MIN, but 
 	 that is compensated by the subsequent overflow when subtracting 
-	 one / negating. */
+	 one / negating.  */
 
       if (abs_optab->handlers[(int) mode].insn_code != CODE_FOR_nothing)
 	tem = expand_unop (mode, abs_optab, op0, subtarget, 1);
diff --git a/gcc/expr.c b/gcc/expr.c
index 2ba1b5a6b4c..11aa3dce538 100644
--- a/gcc/expr.c
+++ b/gcc/expr.c
@@ -6647,7 +6647,7 @@ expand_expr (exp, target, tmode, modifier)
     case LABELED_BLOCK_EXPR:
       if (LABELED_BLOCK_BODY (exp))
 	expand_expr_stmt (LABELED_BLOCK_BODY (exp));
-      /* Should perhaps use expand_label, but this is simpler and safer. */
+      /* Should perhaps use expand_label, but this is simpler and safer.  */
       do_pending_stack_adjust ();
       emit_label (label_rtx (LABELED_BLOCK_LABEL (exp)));
       return const0_rtx;
diff --git a/gcc/flow.c b/gcc/flow.c
index 7fe007485c1..f7d32196a86 100644
--- a/gcc/flow.c
+++ b/gcc/flow.c
@@ -3822,7 +3822,7 @@ try_crossjump_to_edge (mode, e1, e2)
   if (e1->flags & EDGE_COMPLEX)
     return false;
 
-  /* Look for the common insn sequence, part the first ... */
+  /* Look for the common insn sequence, part the first ...  */
   if (!outgoing_edges_match (src1, src2))
     return false;
 
@@ -5802,7 +5802,7 @@ insn_dead_p (pbi, x, call_ok, notes)
 	     If so, this memory write is dead (remember, we're walking
 	     backwards from the end of the block to the start).  Since
 	     rtx_equal_p does not check the alias set or flags, we also
-	     must have the potential for them to conflict (anti_dependence). */
+	     must have the potential for them to conflict (anti_dependence).  */
 	  for (temp = pbi->mem_set_list; temp != 0; temp = XEXP (temp, 1))
 	    if (anti_dependence (r, XEXP (temp, 0)))
 	      {
@@ -8385,7 +8385,7 @@ verify_flow_info ()
   for (i = n_basic_blocks - 1; i >= 0; i--)
     {
       basic_block bb = BASIC_BLOCK (i);
-      /* Check correctness of edge lists. */
+      /* Check correctness of edge lists.  */
       edge e;
       int has_fallthru = 0;
 
@@ -9676,7 +9676,7 @@ flow_loop_pre_header_scan (loop)
 
       /* Count number of edges along trace from loop header to
 	 root of pre-header extended basic block.  Usually this is
-	 only one or two edges. */
+	 only one or two edges.  */
       num++;
       while (ebb->pred->src != ENTRY_BLOCK_PTR && ! ebb->pred->pred_next)
 	{
diff --git a/gcc/fold-const.c b/gcc/fold-const.c
index 6a606eaa612..5ffaf105742 100644
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -1354,7 +1354,7 @@ split_tree (in, code, conp, litp, negate_p)
   *conp = 0;
   *litp = 0;
 
-  /* Strip any conversions that don't change the machine mode or signedness. */
+  /* Strip any conversions that don't change the machine mode or signedness.  */
   STRIP_SIGN_NOPS (in);
 
   if (TREE_CODE (in) == INTEGER_CST || TREE_CODE (in) == REAL_CST)
@@ -1385,7 +1385,7 @@ split_tree (in, code, conp, litp, negate_p)
 	*conp = op1, neg_conp_p = neg1_p, op1 = 0;
 
       /* If we haven't dealt with either operand, this is not a case we can
-	 decompose.  Otherwise, VAR is either of the ones remaining, if any. */
+	 decompose.  Otherwise, VAR is either of the ones remaining, if any.  */
       if (op0 != 0 && op1 != 0)
 	var = in;
       else if (op0 != 0)
@@ -1546,7 +1546,7 @@ int_const_binop (code, arg1, arg2, notrunc, forsize)
 	  break;
 	}
 
-      /* ... fall through ... */
+      /* ... fall through ...  */
 
     case ROUND_DIV_EXPR:
       if (int2h == 0 && int2l == 1)
@@ -1579,7 +1579,7 @@ int_const_binop (code, arg1, arg2, notrunc, forsize)
 	  break;
 	}
 
-      /* ... fall through ... */
+      /* ... fall through ...  */
 
     case ROUND_MOD_EXPR:
       overflow = div_and_round_double (code, uns,
@@ -1745,11 +1745,11 @@ const_binop (code, arg1, arg2, notrunc)
       args.code = code;
 
       if (do_float_handler (const_binop_1, (PTR) &args))
-	/* Receive output from const_binop_1. */
+	/* Receive output from const_binop_1.  */
 	t = args.t;
       else
 	{
-	  /* We got an exception from const_binop_1. */
+	  /* We got an exception from const_binop_1.  */
 	  t = copy_node (arg1);
 	  overflow = 1;
 	}
@@ -1980,9 +1980,9 @@ size_diffop (arg0, arg1)
 /* This structure is used to communicate arguments to fold_convert_1.  */
 struct fc_args
 {
-  tree arg1;			/* Input: value to convert. */
-  tree type;			/* Input: type to convert value to. */
-  tree t;			/* Ouput: result of conversion. */
+  tree arg1;			/* Input: value to convert.  */
+  tree type;			/* Input: type to convert value to.  */
+  tree t;			/* Ouput: result of conversion.  */
 };
 
 /* Function to convert floating-point constants, protected by floating
@@ -2383,7 +2383,7 @@ operand_equal_p (arg0, arg1, only_const)
 
     case 'r':
       /* If either of the pointer (or reference) expressions we are dereferencing
-	 contain a side effect, these cannot be equal. */
+	 contain a side effect, these cannot be equal.  */
       if (TREE_SIDE_EFFECTS (arg0)
 	  || TREE_SIDE_EFFECTS (arg1))
 	return 0;
@@ -3265,7 +3265,7 @@ range_binop (code, type, arg0, upper0_p, arg1, upper1_p)
      the same. But, this is computer arithmetic, where numbers are finite.
      We can therefore make the transformation of any unbounded range with
      the value Z, Z being greater than any representable number. This permits
-     us to treat unbounded ranges as equal. */
+     us to treat unbounded ranges as equal.  */
   sgn0 = arg0 != 0 ? 0 : (upper0_p ? 1 : -1);
   sgn1 = arg1 != 0 ? 0 : (upper1_p ? 1 : -1);
   switch (code)
@@ -4552,7 +4552,7 @@ extract_muldiv (t, c, code, wide_type)
 
       /* The last case is if we are a multiply.  In that case, we can
 	 apply the distributive law to commute the multiply and addition
-	 if the multiplication of the constants doesn't overflow. */
+	 if the multiplication of the constants doesn't overflow.  */
       if (code == MULT_EXPR)
 	return fold (build (tcode, ctype, fold (build (code, ctype,
 						       convert (ctype, op0),
@@ -4570,7 +4570,7 @@ extract_muldiv (t, c, code, wide_type)
 	  && integer_zerop (const_binop (TRUNC_MOD_EXPR, op1, c, 0)))
 	return omit_one_operand (type, integer_zero_node, op0);
 
-      /* ... fall through ... */
+      /* ... fall through ...  */
 
     case TRUNC_DIV_EXPR:  case CEIL_DIV_EXPR:  case FLOOR_DIV_EXPR:
     case ROUND_DIV_EXPR:  case EXACT_DIV_EXPR:
@@ -5564,7 +5564,7 @@ fold (expr)
 	     associate each group together, the constants with literals,
 	     then the result with variables.  This increases the chances of
 	     literals being recombined later and of generating relocatable
-	     expressions for the sum of a constant and literal. */
+	     expressions for the sum of a constant and literal.  */
 	  var0 = split_tree (arg0, code, &con0, &lit0, 0);
 	  var1 = split_tree (arg1, code, &con1, &lit1, code == MINUS_EXPR);
 
@@ -5854,7 +5854,7 @@ fold (expr)
 	      && 0 != (tem = const_binop (code, build_real (type, dconst1),
 					  arg1, 0)))
 	    return fold (build (MULT_EXPR, type, arg0, tem));
-	  /* Find the reciprocal if optimizing and the result is exact. */
+	  /* Find the reciprocal if optimizing and the result is exact.  */
 	  else if (optimize)
 	    {
 	      REAL_VALUE_TYPE r;
@@ -6045,7 +6045,7 @@ fold (expr)
 	 truth and/or operations and the transformation will still be
 	 valid.   Also note that we only care about order for the
 	 ANDIF and ORIF operators.  If B contains side effects, this
-	 might change the truth-value of A. */
+	 might change the truth-value of A.  */
       if (TREE_CODE (arg0) == TREE_CODE (arg1)
 	  && (TREE_CODE (arg0) == TRUTH_ANDIF_EXPR
 	      || TREE_CODE (arg0) == TRUTH_ORIF_EXPR
@@ -7342,7 +7342,7 @@ multiple_of_p (type, top, bottom)
 	      < TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (top, 0)))))
 	return 0;
 
-      /* .. fall through ... */
+      /* .. fall through ...  */
 
     case SAVE_EXPR:
       return multiple_of_p (type, TREE_OPERAND (top, 0), bottom);
diff --git a/gcc/function.c b/gcc/function.c
index 5a169c69f6b..f344cb53fdb 100644
--- a/gcc/function.c
+++ b/gcc/function.c
@@ -811,7 +811,7 @@ assign_stack_temp_for_type (mode, size, keep, type)
      alias set for the memory.  */
   set_mem_alias_set (p->slot, type ? get_alias_set (type) : 0);
 
-  /* If a type is specified, set the relevant flags. */
+  /* If a type is specified, set the relevant flags.  */
   if (type != 0)
     {
       RTX_UNCHANGING_P (p->slot) = TYPE_READONLY (type);
@@ -5703,7 +5703,7 @@ round_trampoline_addr (tramp)
 
 /* Given a trampoline address, round it then apply any
    platform-specific adjustments so that the result can be used for a
-   function call . */
+   function call .  */
 
 static rtx
 adjust_trampoline_addr (tramp)