becopyopt: Fix typos in comments.

[libfirm] / ir / opt / ircgopt.c

diff --git a/ir/opt/ircgopt.c b/ir/opt/ircgopt.c
index eca8ffb..caef78c 100644 (file)
--- a/ir/opt/ircgopt.c
+++ b/ir/opt/ircgopt.c
@@ -1,20 +1,6 @@
 /*
- * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
- *
  * This file is part of libFirm.
- *
- * This file may be distributed and/or modified under the terms of the
- * GNU General Public License version 2 as published by the Free Software
- * Foundation and appearing in the file LICENSE.GPL included in the
- * packaging of this file.
- *
- * Licensees holding valid libFirm Professional Edition licenses may use
- * this file in accordance with the libFirm Commercial License.
- * Agreement provided with the Software.
- *
- * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
- * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE.
+ * Copyright (C) 2012 University of Karlsruhe.
  */
 
 /**
@@ -22,12 +8,11 @@
  * @brief    Removal of unreachable methods.
  * @author   Hubert Schmid
  * @date     09.06.2002
- * @version  $Id$
  */
 
 /*
  * Entfernen von nicht erreichbaren (aufrufbaren) Methoden. Die Menge
- * der nicht erreichbaren Methoden wird aus der Abschätzung der
+ * der nicht erreichbaren Methoden wird aus der Abschätzung der
  * Aufrufrelation bestimmt.
  */
 #include "config.h"
@@ -45,14 +30,14 @@
 #include "irtools.h"
 #include "irpass.h"
 
-DEBUG_ONLY(static firm_dbg_module_t *dbg);
+DEBUG_ONLY(static firm_dbg_module_t *dbg;)
 
 /**
  * Walker: adds Call operations to a head's link list.
  */
 static void collect_call(ir_node *node, void *env)
 {
-       ir_node *head = env;
+       ir_node *head = (ir_node*)env;
 
        if (is_Call(node)) {
                set_irn_link(node, get_irn_link(head));
@@ -61,10 +46,9 @@ static void collect_call(ir_node *node, void *env)
 }
 
 /* garbage collect methods: mark and remove */
-void gc_irgs(int n_keep, ir_entity ** keep_arr)
+void gc_irgs(size_t n_keep, ir_entity ** keep_arr)
 {
        void * MARK = &MARK; /* @@@ gefaehrlich!!! Aber wir markieren hoechstens zu viele ... */
-       int i;
 
        FIRM_DBG_REGISTER(dbg, "firm.opt.cgopt");
 
@@ -78,14 +62,16 @@ void gc_irgs(int n_keep, ir_entity ** keep_arr)
        /* Mark entities that are alive.  */
        if (n_keep > 0) {
                ir_entity **marked = NEW_ARR_F(ir_entity *, n_keep);
-               for (i = 0; i < n_keep; ++i) {
-                       marked[i] = keep_arr[i];
-                       set_entity_link(marked[i], MARK);
-                       DB((dbg, LEVEL_1, "  method %+F kept alive.\n", marked[i]));
+               size_t    idx;
+
+               for (idx = 0; idx < n_keep; ++idx) {
+                       marked[idx] = keep_arr[idx];
+                       set_entity_link(marked[idx], MARK);
+                       DB((dbg, LEVEL_1, "  method %+F kept alive.\n", marked[idx]));
                }
 
-               for (i = 0; i < ARR_LEN(marked); ++i) {
-                       ir_graph *irg = get_entity_irg(marked[i]);
+               for (idx = 0; idx < ARR_LEN(marked); ++idx) {
+                       ir_graph *irg = get_entity_irg(marked[idx]);
                        ir_node *node;
 
                        if (irg == NULL)
@@ -98,12 +84,10 @@ void gc_irgs(int n_keep, ir_entity ** keep_arr)
                        irg_walk_graph(irg, firm_clear_link, collect_call, node);
 
                        /* iterate calls */
-                       for (node = get_irn_link(node); node; node = get_irn_link(node)) {
-                               int i;
-                               assert(is_Call(node));
-
-                               for (i = get_Call_n_callees(node) - 1; i >= 0; --i) {
-                                       ir_entity *ent = get_Call_callee(node, i);
+                       for (node = (ir_node*)get_irn_link(node); node != NULL;
+                            node = (ir_node*)get_irn_link(node)) {
+                               for (size_t i = get_Call_n_callees(node); i > 0;) {
+                                       ir_entity *ent = get_Call_callee(node, --i);
 
                                        if (get_entity_irg(ent) && get_entity_link(ent) != MARK) {
                                                set_entity_link(ent, MARK);
@@ -120,17 +104,15 @@ void gc_irgs(int n_keep, ir_entity ** keep_arr)
        }
 
        /* clean */
-       for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+       for (size_t i = get_irp_n_irgs(); i-- != 0;) {
                ir_graph  *irg = get_irp_irg(i);
                ir_entity *ent = get_irg_entity(irg);
 
                if (get_entity_link(ent) == MARK)
                        continue;
 
-               DB((dbg, LEVEL_1, "  freeing method %+F\n",     ent));
-               remove_irp_irg(irg);
-
-               remove_class_member(get_entity_owner(ent), ent);
+               DB((dbg, LEVEL_1, "  freeing method %+F\n", ent));
+               free_ir_graph(irg);
        }
 }
 
@@ -140,17 +122,17 @@ void gc_irgs(int n_keep, ir_entity ** keep_arr)
 static void pass_wrapper(void)
 {
     ir_entity **keep_methods;
-    int         arr_len;
+    size_t    arr_len;
 
     /* Analysis that finds the free methods,
        i.e. methods that are dereferenced.
        Optimizes polymorphic calls :-). */
-    cgana(&arr_len, &keep_methods);
+    arr_len = cgana(&keep_methods);
 
     /* Remove methods that are never called. */
     gc_irgs(arr_len, keep_methods);
 
-    free(keep_methods);
+    xfree(keep_methods);
 }
 
 ir_prog_pass_t *gc_irgs_pass(const char *name)