comments

[r6009]

diff --git a/ir/adt/pdeq.h b/ir/adt/pdeq.h
index 0f3d8cf..583fda8 100644 (file)
--- a/ir/adt/pdeq.h
+++ b/ir/adt/pdeq.h
@@ -121,7 +121,7 @@ void **pdeq_copyl(pdeq *qp, const void **dst);
 void **pdeq_copyr(pdeq *qp, const void **dst);
 
 /**
- * Add a pointer to the left site of a double ended pointer list.
+ * Add a pointer to the left side of a double ended pointer list.
  *
  * @param dq  The list to add a pointer to.
  * @param x   The pointer element to be added
@@ -131,7 +131,7 @@ void **pdeq_copyr(pdeq *qp, const void **dst);
 pdeq *pdeq_putl(pdeq *dq, const void *x);
 
 /**
- * Add a pointer to the right site of a double ended pointer list.
+ * Add a pointer to the right side of a double ended pointer list.
  *
  * @param dq  The list to add a pointer to.
  * @param x   The pointer element to be added

diff --git a/ir/adt/pset.h b/ir/adt/pset.h
index 6e06bde..ad1931c 100644 (file)
--- a/ir/adt/pset.h
+++ b/ir/adt/pset.h
@@ -149,6 +149,7 @@ pset_entry *pset_hinsert (pset *pset, const void *key, unsigned hash);
  *
  * @remark
  *    The current implementation did not allow to remove non-existing elements.
+ *    @@@ so, does it do now?
  *    Further, it is allowed to remove elements during an iteration
  *    including the current one.
  */

diff --git a/ir/ana/callgraph.c b/ir/ana/callgraph.c
index ab3fb3e..13b6f44 100644 (file)
--- a/ir/ana/callgraph.c
+++ b/ir/ana/callgraph.c
@@ -145,7 +145,7 @@ int get_irg_callee_loop_depth(ir_graph *irg, int pos) {
 
 
 
-double get_irg_callee_execution_freqency(ir_graph *irg, int pos) {
+double get_irg_callee_execution_frequency(ir_graph *irg, int pos) {
   ir_node **arr = ((ana_entry *)irg->callees[pos])->call_list;
   int i, n_Calls = ARR_LEN(arr);
   double freq = 0;
@@ -156,18 +156,18 @@ double get_irg_callee_execution_freqency(ir_graph *irg, int pos) {
   return freq;
 }
 
-double get_irg_callee_method_execution_freqency(ir_graph *irg, int pos) {
-  double call_freq = get_irg_callee_execution_freqency(irg, pos);
+double get_irg_callee_method_execution_frequency(ir_graph *irg, int pos) {
+  double call_freq = get_irg_callee_execution_frequency(irg, pos);
   double meth_freq = get_irg_method_execution_frequency(irg);
   return call_freq * meth_freq;
 }
 
 
-double get_irg_caller_method_execution_freqency(ir_graph *irg, int pos) {
+double get_irg_caller_method_execution_frequency(ir_graph *irg, int pos) {
   ir_graph *caller     = get_irg_caller(irg, pos);
   int       pos_callee = reverse_pos(irg, pos);
 
-  return get_irg_callee_method_execution_freqency(caller, pos_callee);
+  return get_irg_callee_method_execution_frequency(caller, pos_callee);
 }
 
 
@@ -1118,8 +1118,8 @@ static void compute_rec_depth (ir_graph *irg, void *env) {
 
 
 /* ----------------------------------------------------------------------------------- */
-/* Another algorithm to compute the execution freqency of methods ignoring recursions. */
-/* Walk the callgraph.  Ignore backedges.  Use sum of execution freqencies of Call     */
+/* Another algorithm to compute the execution frequency of methods ignoring recursions. */
+/* Walk the callgraph.  Ignore backedges.  Use sum of execution frequencies of Call     */
 /* nodes to evaluate a callgraph edge.                                                 */
 /* ----------------------------------------------------------------------------------- */
 
@@ -1155,12 +1155,12 @@ static void compute_method_execution_frequency (ir_graph *irg, void *env) {
   }
   mark_cg_irg_visited(irg);
 
-  /* Compute the new freqency. */
+  /* Compute the new frequency. */
   freq = 0;
   found_edge = 0;
   for (i = 0; i < n_callers; i++) {
     if (! is_irg_caller_backedge(irg, i)) {
-      double edge_freq = get_irg_caller_method_execution_freqency(irg, i);
+      double edge_freq = get_irg_caller_method_execution_frequency(irg, i);
       assert(edge_freq >= 0);
       freq += edge_freq;
       found_edge = 1;

diff --git a/ir/ana/callgraph.h b/ir/ana/callgraph.h
index e97d2d0..514d749 100644 (file)
--- a/ir/ana/callgraph.h
+++ b/ir/ana/callgraph.h
@@ -100,8 +100,8 @@ void find_callgraph_recursions(void);
  *     path from main().
  *   - The recursion depth.  The maximal number of recursions passed
  *     on all paths reaching this method.
- *   - The execution freqency.  As loop depth, but the edge weight is the sum
- *     of the execution freqencies of all Calls along the edge.
+ *   - The execution frequency.  As loop depth, but the edge weight is the sum
+ *     of the execution frequencies of all Calls along the edge.
  **/
 void compute_performance_estimates(void);
 

diff --git a/ir/ana/cgana.c b/ir/ana/cgana.c
index f3d7675..b31d070 100644 (file)
--- a/ir/ana/cgana.c
+++ b/ir/ana/cgana.c
@@ -71,7 +71,7 @@ static eset *entities = NULL;
 /*--------------------------------------------------------------------------*/
 
 /** Returns the entity that contains the implementation of the inherited
-    entity if available, else returns the entity passed. */
+ *  entity if available, else returns the entity passed. */
 static entity *get_inherited_methods_implementation(entity *inh_meth) {
   assert(get_atomic_ent_value(inh_meth) && "constant entity without value");
   assert((get_irn_op(get_atomic_ent_value(inh_meth)) == op_SymConst) &&