Use backtracking in find_original_value() for the flags emitter.

[libfirm] / ir / be / beifg_std.c

diff --git a/ir/be/beifg_std.c b/ir/be/beifg_std.c
index eb5b1b7..37a6e25 100644 (file)
--- a/ir/be/beifg_std.c
+++ b/ir/be/beifg_std.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
  *
  * This file is part of libFirm.
  *
@@ -18,14 +18,12 @@
  */
 
 /**
- * @file   beifg_std.c
- * @date   18.11.2005
- * @author Sebastian Hack
- *
- * Copyright (C) 2005 Universitaet Karlsruhe
- * Released under the GPL
+ * @file
+ * @brief   Default ifg implementation.
+ * @author  Sebastian Hack
+ * @date    18.11.2005
+ * @version $Id$
  */
-
 #ifdef HAVE_CONFIG_H
 #include "config.h"
 #endif
@@ -38,19 +36,21 @@
 #include "irnodeset.h"
 #include "irgraph_t.h"
 #include "irgwalk.h"
+#include "irtools.h"
 
+#include "bearch_t.h"
 #include "be_t.h"
 #include "belive_t.h"
 #include "bera.h"
 #include "beifg_t.h"
 #include "bechordal_t.h"
-
-#define MAX(x, y) ((x) > (y) ? (x) : (y))
+#include "beirg_t.h"
+#include "beintlive_t.h"
 
 typedef struct _ifg_std_t ifg_std_t;
 
 struct _ifg_std_t {
-       const be_ifg_impl_t *impl;
+       const be_ifg_impl_t    *impl;
        const be_chordal_env_t *env;
 };
 
@@ -62,27 +62,25 @@ static void ifg_std_free(void *self)
 static int ifg_std_connected(const void *self, const ir_node *a, const ir_node *b)
 {
        const ifg_std_t *ifg = self;
-       be_lv_t *lv = ifg->env->birg->lv;
-       return values_interfere(lv, a, b);
+       return values_interfere(ifg->env->birg, a, b);
 }
 
 typedef struct _nodes_iter_t {
        const be_chordal_env_t *env;
-       struct obstack obst;
-       int n;
-       int curr;
-       ir_node **nodes;
+       struct obstack         obst;
+       int                    n;
+       int                    curr;
+       ir_node                **nodes;
 } nodes_iter_t;
 
 static void nodes_walker(ir_node *bl, void *data)
 {
-       nodes_iter_t *it = data;
+       nodes_iter_t     *it   = data;
        struct list_head *head = get_block_border_head(it->env, bl);
-
-       border_t *b;
+       border_t         *b;
 
        foreach_border_head(head, b) {
-               if(b->is_def && b->is_real) {
+               if (b->is_def && b->is_real) {
                        obstack_ptr_grow(&it->obst, b->irn);
                        it->n++;
                }
@@ -132,11 +130,13 @@ static ir_node *ifg_std_nodes_begin(const void *self, void *iter)
 
 static ir_node *ifg_std_nodes_next(const void *self, void *iter)
 {
+       (void) self;
        return get_next_node(iter);
 }
 
 static void ifg_std_nodes_break(const void *self, void *iter)
 {
+       (void) self;
        node_break(iter, 1);
 }
 
@@ -194,6 +194,7 @@ static void find_neighbours(const ifg_std_t *ifg, adj_iter_t *it, const ir_node
 
 static INLINE void neighbours_break(adj_iter_t *it, int force)
 {
+       (void) force;
        assert(it->valid == 1);
        ir_nodeset_destroy(&it->neighbours);
        it->valid = 0;
@@ -217,11 +218,13 @@ static ir_node *ifg_std_neighbours_begin(const void *self, void *iter, const ir_
 
 static ir_node *ifg_std_neighbours_next(const void *self, void *iter)
 {
+       (void) self;
        return get_next_neighbour(iter);
 }
 
 static void ifg_std_neighbours_break(const void *self, void *iter)
 {
+       (void) self;
        neighbours_break(iter, 1);
 }
 
@@ -327,11 +330,13 @@ static int ifg_std_cliques_begin(const void *self, void *iter, ir_node **buf)
 
 static int ifg_std_cliques_next(const void *self, void *iter)
 {
+       (void) self;
        return get_next_clique(iter);
 }
 
 static void ifg_std_cliques_break(const void *self, void *iter)
 {
+       (void) self;
        free_clique_iter(iter);
 }