[patch] gcc/*: Fix comment typos.

Kazu Hirata kazu@codesourcery.com
Fri Dec 22 01:20:00 GMT 2006


Hi,

Committed as obvious.

Kazu Hirata

2006-12-22  Kazu Hirata  <kazu@codesourcery.com>

	* cgraphunit.c, config/i386/i386.c, config/ia64/ia64.c, cse.c,
	output.h, toplev.c, tree-affine.h, tree-flow.h,
	tree-ssa-alias.c, tree-ssa-coalesce.c, tree-ssa-live.c,
	tree-ssa-live.h, tree-ssa-operands.c, tree-ssa-ter.c,
	tree-vrp.c, varpool.c: Fix comment typos.

Index: cgraphunit.c
===================================================================
--- cgraphunit.c	(revision 120136)
+++ cgraphunit.c	(working copy)
@@ -66,7 +66,7 @@ Software Foundation, 51 Franklin Street,
       data structure must be updated accordingly by this function.
       There should be little need to call this function and all the references
       should be made explicit to cgraph code.  At present these functions are
-      used by C++ frotend to explicitely mark the keyed methods.
+      used by C++ frontend to explicitely mark the keyed methods.
 
     - analyze_expr callback
 
Index: config/i386/i386.c
===================================================================
--- config/i386/i386.c	(revision 120136)
+++ config/i386/i386.c	(working copy)
@@ -13492,7 +13492,7 @@ decide_alignment (int align,
   return desired_align;
 }
 
-/* Return thre smallest power of 2 greater than VAL.  */
+/* Return the smallest power of 2 greater than VAL.  */
 static int
 smallest_pow2_greater_than (int val)
 {
@@ -13510,7 +13510,7 @@ smallest_pow2_greater_than (int val)
    1) Prologue guard: Conditional that jumps up to epilogues for small
       blocks that can be handled by epilogue alone.  This is faster but
       also needed for correctness, since prologue assume the block is larger
-      than the desrired alignment.
+      than the desired alignment.
 
       Optional dynamic check for size and libcall for large
       blocks is emitted here too, with -minline-stringops-dynamically.
@@ -13834,7 +13834,7 @@ promote_duplicated_reg_to_size (rtx val,
 
 /* Expand string clear operation (bzero).  Use i386 string operations when
    profitable.  See expand_movmem comment for explanation of individual
-   steps performd.  */
+   steps performed.  */
 int
 ix86_expand_setmem (rtx dst, rtx count_exp, rtx val_exp, rtx align_exp,
 		    rtx expected_align_exp, rtx expected_size_exp)
Index: config/ia64/ia64.c
===================================================================
--- config/ia64/ia64.c	(revision 120136)
+++ config/ia64/ia64.c	(working copy)
@@ -9182,7 +9182,7 @@ ia64_asm_output_external (FILE *file, tr
   if (TREE_SYMBOL_REFERENCED (DECL_ASSEMBLER_NAME (decl)))
     {
       /* maybe_assemble_visibility will return 1 if the assembler
-	 visibility directive is outputed.  */
+	 visibility directive is output.  */
       int need_visibility = ((*targetm.binds_local_p) (decl)
 			     && maybe_assemble_visibility (decl));
 
Index: cse.c
===================================================================
--- cse.c	(revision 120136)
+++ cse.c	(working copy)
@@ -5791,7 +5791,7 @@ cse_process_notes (rtx x, rtx object)
    Otherwise, DATA->path is filled and the function returns TRUE indicating
    that a path to follow was found.
 
-   If FOLLOW_JUMPS is false, the maximum path lenghth is 1 and the only
+   If FOLLOW_JUMPS is false, the maximum path length is 1 and the only
    block in the path will be FIRST_BB.  */
 
 static bool
@@ -6248,7 +6248,7 @@ cse_main (rtx f ATTRIBUTE_UNUSED, int nr
 	  if (ebb_data.nsets == 0)
 	    continue;
 
-	  /* Get a reasonable extimate for the maximum number of qty's
+	  /* Get a reasonable estimate for the maximum number of qty's
 	     needed for this path.  For this, we take the number of sets
 	     and multiply that by MAX_RECOG_OPERANDS.  */
 	  max_qty = ebb_data.nsets * MAX_RECOG_OPERANDS;
Index: output.h
===================================================================
--- output.h	(revision 120136)
+++ output.h	(working copy)
@@ -204,7 +204,7 @@ extern void assemble_variable (tree, int
    DONT_OUTPUT_DATA is from assemble_variable.  */
 extern void align_variable (tree decl, bool dont_output_data);
 
-/* Queue for outputing something to declare an external symbol to the
+/* Queue for outputting something to declare an external symbol to the
    assembler.  (Most assemblers don't need this, so we normally output
    nothing.)  Do nothing if DECL is not external.  */
 extern void assemble_external (tree);
Index: toplev.c
===================================================================
--- toplev.c	(revision 120136)
+++ toplev.c	(working copy)
@@ -1249,7 +1249,7 @@ print_single_switch (print_switch_fn_typ
 {
   /* The ultrix fprintf returns 0 on success, so compute the result
      we want here since we need it for the following test.  The +1
-     is for the seperator character that will probably be emitted.  */
+     is for the separator character that will probably be emitted.  */
   int len = strlen (text) + 1;
 
   if (pos != 0
Index: tree-affine.h
===================================================================
--- tree-affine.h	(revision 120136)
+++ tree-affine.h	(working copy)
@@ -49,7 +49,7 @@ typedef struct affine_tree_combination
      TYPE, but their sizes must be the same (STRIP_NOPS is applied to the
      elements).
      
-     The coefficients are always sign extened from the precision of TYPE
+     The coefficients are always sign extended from the precision of TYPE
      (regardless of signedness of TYPE).  */
   struct aff_comb_elt elts[MAX_AFF_ELTS];
 
Index: tree-flow.h
===================================================================
--- tree-flow.h	(revision 120136)
+++ tree-flow.h	(working copy)
@@ -288,7 +288,7 @@ struct var_ann_d GTY(())
   unsigned int escape_mask;
 };
 
-/* Contianer for variable annotation used by hashtable for annotations for
+/* Container for variable annotation used by hashtable for annotations for
    static variables.  */
 struct static_var_ann_d GTY(())
 {
Index: tree-ssa-alias.c
===================================================================
--- tree-ssa-alias.c	(revision 120136)
+++ tree-ssa-alias.c	(working copy)
@@ -1710,7 +1710,7 @@ setup_pointers_and_addressables (struct 
 		{
 		  /* The memory partition holding VAR will no longer
 		     contain VAR, and statements referencing it will need
-		     to be udpated.  */
+		     to be updated.  */
 		  if (memory_partition (var))
 		    mark_sym_for_renaming (memory_partition (var));
 
Index: tree-ssa-coalesce.c
===================================================================
--- tree-ssa-coalesce.c	(revision 120136)
+++ tree-ssa-coalesce.c	(working copy)
@@ -182,7 +182,7 @@ coalesce_pair_map_hash (const void *pair
 
 
 /* Equality function for coalesce list hash table.  Compare PAIR1 and PAIR2,
-   returning TRUE if the two pairs are equivilent. */
+   returning TRUE if the two pairs are equivalent.  */
 
 static int 
 coalesce_pair_map_eq (const void *pair1, const void *pair2)
@@ -309,7 +309,7 @@ add_coalesce (coalesce_list_p cl, int p1
 }
 
 
-/* Comparison function to allow qsort to sort P1 and P2 in Ascendiong order.  */
+/* Comparison function to allow qsort to sort P1 and P2 in Ascending order.  */
 
 static int 
 compare_pairs (const void *p1, const void *p2)
@@ -355,7 +355,7 @@ end_coalesce_pair_p (coalesce_pair_itera
 }
 
 
-/* Return the next parttition pair to be visited by ITER.  */
+/* Return the next partition pair to be visited by ITER.  */
 
 static inline coalesce_pair_p
 next_coalesce_pair (coalesce_pair_iterator *iter)
@@ -466,7 +466,7 @@ dump_coalesce_list (FILE *f, coalesce_li
 
 
 /* This represents a conflict graph.  Implemented as an array of bitmaps.  
-   A full matrix isused for conflicts rather than just upper triangular form.
+   A full matrix is used for conflicts rather than just upper triangular form.
    this make sit much simpler and faster to perform conflict merges.  */
 
 typedef struct ssa_conflicts_d
@@ -787,9 +787,9 @@ live_track_clear_base_vars (live_track_p
 
 
 /* Build a conflict graph based on LIVEINFO.  Any partitions which are in the
-   partition view of the var_map liveinfo is based on get entires in the 
+   partition view of the var_map liveinfo is based on get entries in the 
    conflict graph.  Only conflicts between ssa_name partitions with the same 
-   base variableare added.  */
+   base variable are added.  */
 
 static ssa_conflicts_p
 build_ssa_conflict_graph (tree_live_info_p liveinfo)
@@ -1140,7 +1140,7 @@ create_outofssa_var_map (coalesce_list_p
 }
 
 
-/* Attempt to coalesce ssa verisons X and Y together using the partition
+/* Attempt to coalesce ssa versions X and Y together using the partition
    mapping in MAP and checking conflicts in GRAPH.  Output any debug info to
    DEBUG, if it is nun-NULL.  */
 
@@ -1219,8 +1219,8 @@ coalesce_partitions (var_map map, ssa_co
   edge e;
   edge_iterator ei;
 
-  /* First, coalece all the copie across abnormal edges.  These are not placed
-     in the coalesce list becase they do not need to be sorted, and simply 
+  /* First, coalesce all the copies across abnormal edges.  These are not placed
+     in the coalesce list because they do not need to be sorted, and simply 
      consume extra memory/compilation time in large programs.  */
 
   FOR_EACH_BB (bb)
Index: tree-ssa-live.c
===================================================================
--- tree-ssa-live.c	(revision 120136)
+++ tree-ssa-live.c	(working copy)
@@ -560,7 +560,7 @@ delete_tree_live_info (tree_live_info_p 
 
 /* Visit basic block BB and propogate any required live on entry bits from 
    LIVE into the predecessors.  VISITED is the bitmap of visited blocks.  
-   TMP is a temporary work bitmap which is passed in to avoid reallocting
+   TMP is a temporary work bitmap which is passed in to avoid reallocating
    it each time.  */
 
 static void 
@@ -602,7 +602,7 @@ loe_visit_block (tree_live_info_p live, 
 
 
 /* Using LIVE, fill in all the live-on-entry blocks between the defs and uses 
-   of all the vairables.  */
+   of all the variables.  */
 
 static void
 live_worklist (tree_live_info_p live)
@@ -631,7 +631,7 @@ live_worklist (tree_live_info_p live)
 }
 
 
-/* Calulate the initial live on entry vector for SSA_NAME using immediate_use
+/* Calculate the initial live on entry vector for SSA_NAME using immediate_use
    links.  Set the live on entry fields in LIVE.  Def's are marked temporarily
    in the liveout vector.  */
 
Index: tree-ssa-live.h
===================================================================
--- tree-ssa-live.h	(revision 120136)
+++ tree-ssa-live.h	(working copy)
@@ -31,8 +31,8 @@ Boston, MA 02110-1301, USA.  */
 /* Used to create the variable mapping when we go out of SSA form.  
 
    Mapping from an ssa_name to a partition number is maintained, as well as
-   partition number to back to ssa_name. A parition can also be represented
-   by a non-ssa_name variable.  This allows ssa_names and thier partition to 
+   partition number to back to ssa_name. A partition can also be represented
+   by a non-ssa_name variable.  This allows ssa_names and their partition to 
    be coalesced with live on entry compiler variables, as well as eventually
    having real compiler variables assigned to each partition as part of the 
    final stage of going of of ssa.  
@@ -43,7 +43,7 @@ Boston, MA 02110-1301, USA.  */
    partitions.  This allows the coalescer to decide what partitions are 
    interesting to it, and only work with those partitions.  Whenever the view
    is changed, the partition numbers change, but none of the partition groupings
-   change. (ie, it is truly a view since it doesnt change anything)
+   change. (ie, it is truly a view since it doesn't change anything)
 
    The final component of the data structure is the basevar map.  This provides
    a list of all the different base variables which occue in a partition view,
Index: tree-ssa-operands.c
===================================================================
--- tree-ssa-operands.c	(revision 120136)
+++ tree-ssa-operands.c	(working copy)
@@ -468,8 +468,8 @@ ssa_operand_alloc (unsigned size)
       if (size > ssa_operand_mem_size)
         ssa_operand_mem_size = OP_SIZE_3 * sizeof (struct voptype_d);
 
-      /* Fail if there is not enough space.  If thre are this many operands
-	 required, first make sure there isn't a different probem causing this
+      /* Fail if there is not enough space.  If there are this many operands
+	 required, first make sure there isn't a different problem causing this
 	 many operands.  If the decision is that this is OK, then we can 
 	 specially allocate a buffer just for this request.  */
       gcc_assert (size <= ssa_operand_mem_size);
@@ -607,7 +607,7 @@ add_use_op (tree stmt, tree *op, use_opt
 
 
 /* Return a virtual op pointer with NUM elements which are all initialized to OP
-   and are linked into the immeidate uses for STMT.  The new vop is appended
+   and are linked into the immediate uses for STMT.  The new vop is appended
    after PREV.  */
 
 static inline voptype_p
Index: tree-ssa-ter.c
===================================================================
--- tree-ssa-ter.c	(revision 120136)
+++ tree-ssa-ter.c	(working copy)
@@ -80,13 +80,13 @@ Boston, MA 02110-1301, USA.  */
    v_9 = a_2 * n_12
    <...>
 
-   If b_5, b_8 and b_14 are all colaesced together...
+   If b_5, b_8 and b_14 are all coalesced together...
    The expression b_5 + 6 CANNOT replace the use in the statement defining v_9
    because b_8 is in fact killing the value of b_5 since they share a partition
-   and will be assigned the same memory or regster location.
+   and will be assigned the same memory or register location.
    
    TER implements this but stepping through the instructions in a block and
-   tracking potential expressions for replacement, and the paritions they are
+   tracking potential expressions for replacement, and the partitions they are
    dependent on.  Expressions are represented by the SSA_NAME_VERSION of the
    DEF on the LHS of a GIMPLE_MODIFY_STMT and the expression is the RHS.
 
@@ -110,8 +110,8 @@ Boston, MA 02110-1301, USA.  */
    an expression from the partition kill lists when a decision is made whether
    to replace it or not.  This is indexed by ssa version number as well, and
    indicates a partition number.  virtual operands are not tracked individually,
-   but they are summarized by an artifical partition called VIRTUAL_PARTITION.
-   This means a MAY or MUST def will kill *ALL* expressions that are dependant
+   but they are summarized by an artificial partition called VIRTUAL_PARTITION.
+   This means a MAY or MUST def will kill *ALL* expressions that are dependent
    on a virtual operand.
    Note that the EXPR_DECL_UID and this bitmap represent very similar 
    information, but the info in one is not easy to obtain from the other.
@@ -121,11 +121,11 @@ Boston, MA 02110-1301, USA.  */
    longer be valid if a definition into this partition takes place.
 
    PARTITION_IN_USE is simply a bitmap which is used to track which partitions
-   currently have sokmething in their kill list.  This is used at the end of 
+   currently have something in their kill list.  This is used at the end of 
    a block to clear out the KILL_LIST bitmaps at the end of each block.
 
    NEW_REPLACEABLE_DEPENDENCIES is used as a temporary place to store 
-   dependencies which will be reused by the current defintion. ALl the uses
+   dependencies which will be reused by the current definition. ALl the uses
    on an expression are processed before anything else is done. If a use is
    determined to be a replaceable expression AND the current stmt is also going
    to be replaceable, all the dependencies of this replaceable use will be
@@ -161,8 +161,8 @@ typedef struct temp_expr_table_d 
   tree *replaceable_expressions;	/* Replacement expression table.  */
   bitmap *expr_decl_uids;		/* Base uids of exprs.  */
   bitmap *kill_list;			/* Expr's killed by a partition.  */
-  int virtual_partition;		/* Psuedo partition for virtual ops.  */
-  bitmap partition_in_use;		/* Partitions with kill entires.  */
+  int virtual_partition;		/* Pseudo partition for virtual ops.  */
+  bitmap partition_in_use;		/* Partitions with kill entries.  */
   bitmap new_replaceable_dependencies;	/* Holding place for pending dep's.  */
   int *num_in_part;			/* # of ssa_names in a partition.  */
 } *temp_expr_table_p;
@@ -256,7 +256,7 @@ version_to_be_replaced_p (temp_expr_tabl
 }
 
 
-/* Add partition P to the list if partititons VERSION is dependent on.  TAB is 
+/* Add partition P to the list if partitions VERSION is dependent on.  TAB is 
    the expression table */
 
 static inline void
Index: tree-vrp.c
===================================================================
--- tree-vrp.c	(revision 120136)
+++ tree-vrp.c	(working copy)
@@ -626,8 +626,8 @@ compare_values (tree val1, tree val2)
 
       /* If VAL1 is different than VAL2, return +2.
 	 For integer constants we either have already returned -1 or 1
-	 or they are equivalent.  We still might suceed prove something
-	 about non-trivial operands.  */
+	 or they are equivalent.  We still might succeed in proving
+	 something about non-trivial operands.  */
       if (TREE_CODE (val1) != INTEGER_CST
 	  || TREE_CODE (val2) != INTEGER_CST)
 	{
Index: varpool.c
===================================================================
--- varpool.c	(revision 120136)
+++ varpool.c	(working copy)
@@ -40,7 +40,7 @@ Software Foundation, 51 Franklin Street,
     and drives the decision process on what variables and when are
     going to be compiled.
 
-    The varpool nodes are alocated lazilly for declarations
+    The varpool nodes are allocated lazily for declarations
     either by frontend or at callgraph construction time.
     All variables supposed to be output into final file needs to be
     explicitely marked by frontend via VARPOOL_FINALIZE_DECL function.  */



More information about the Gcc-patches mailing list