*** empty log message ***

[r30]

diff --git a/Changes b/Changes
index d572cc8..a497911 100644 (file)
--- a/Changes
+++ b/Changes
@@ -1,3 +1,8 @@
+  6.7.2000 Goetz
+  Fixed bug in _r_ constructors for all four Div operations.
+  Fixed bug in turn_into_tuple: didn't remember the block.
+  Tested transform_node.
+
   5.7.2000 Goetz
   Fixed some testprograms to new semantics of firm.
   Added testprogram global_var_example.

diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c
index ed6ad32..a9938fc 100644 (file)
--- a/ir/ir/ircons.c
+++ b/ir/ir/ircons.c
@@ -359,7 +359,7 @@ new_r_Quot (ir_graph *irg, ir_node *block,
 {
   ir_node *in[3] = {memop, op1, op2};
   ir_node *res;
-  res = new_ir_node (irg, block, op_Quot, mode_T, 2, in);
+  res = new_ir_node (irg, block, op_Quot, mode_T, 3, in);
   res = optimize (res);
   ir_vrfy (res);
   return res;
@@ -371,7 +371,7 @@ new_r_DivMod (ir_graph *irg, ir_node *block,
 {
   ir_node *in[3] = {memop, op1, op2};
   ir_node *res;
-  res = new_ir_node (irg, block, op_DivMod, mode_T, 2, in);
+  res = new_ir_node (irg, block, op_DivMod, mode_T, 3, in);
   res = optimize (res);
   ir_vrfy (res);
   return res;
@@ -383,7 +383,7 @@ new_r_Div (ir_graph *irg, ir_node *block,
 {
   ir_node *in[3] = {memop, op1, op2};
   ir_node *res;
-  res = new_ir_node (irg, block, op_Div, mode_T, 2, in);
+  res = new_ir_node (irg, block, op_Div, mode_T, 3, in);
   res = optimize (res);
   ir_vrfy (res);
   return res;
@@ -395,7 +395,7 @@ new_r_Mod (ir_graph *irg, ir_node *block,
 {
   ir_node *in[3] = {memop, op1, op2};
   ir_node *res;
-  res = new_ir_node (irg, block, op_Mod, mode_T, 2, in);
+  res = new_ir_node (irg, block, op_Mod, mode_T, 3, in);
   res = optimize (res);
   ir_vrfy (res);
   return res;

diff --git a/ir/ir/irflag.c b/ir/ir/irflag.c
index 4bb283a..3ab4c92 100644 (file)
--- a/ir/ir/irflag.c
+++ b/ir/ir/irflag.c
@@ -10,7 +10,7 @@
 
 /* 0 - don't do this optimization
    1 - lets see, if there is a better graph */
-int opt_cse = 0;
+int opt_cse = 1;
 int opt_constant_folding = 1;
 int opt_dead_node_elimination = 0;
 int optimized = 1;

diff --git a/ir/ir/irgmod.c b/ir/ir/irgmod.c
index 4959291..8721103 100644 (file)
--- a/ir/ir/irgmod.c
+++ b/ir/ir/irgmod.c
@@ -21,9 +21,10 @@ turn_into_tuple (ir_node *node, int arity)
   if (get_irn_arity(node) == arity) {
     /* keep old array */
   } else {
-    /* allocate new array, remove old one. */
-    /* !!!??? free old in_array */
+    /* Allocate new array, don't free old in_array, it's on the obstack. */
+    ir_node *block = get_nodes_Block(node);
     node->in = NEW_ARR_D (ir_node *, current_ir_graph->obst, arity+1);
+    set_nodes_Block(node, block);
   }
 }
 

diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c
index f39b23d..5b9aee2 100644 (file)
--- a/ir/ir/iropt.c
+++ b/ir/ir/iropt.c
@@ -529,7 +529,6 @@ equivalent_node (ir_node *n)
 } /* end equivalent_node() */
 
 
-#if 0
 /* tries several [inplace] [optimizing] transformations and returns a
    equivalent node.  The difference to equivalent_node is that these
    transformations _do_ generate new nodes, and thus the old node must
@@ -538,16 +537,18 @@ static ir_node *
 transform_node (ir_node *n)
 {
 
-  ir_node *a, *b;
+  ir_node *a = NULL, *b;
   tarval *ta, *tb;
 
   switch (get_irn_opcode(n)) {
   case iro_DivMod: {
+
     int evaluated = 0;
-    ir_mode *mode = get_irn_mode(a);
+    ir_mode *mode;
 
     a = get_DivMod_left(n);
     b = get_DivMod_right(n);
+    mode = get_irn_mode(a);
 
     if (!(   mode_is_int(get_irn_mode(a))
          && mode_is_int(get_irn_mode(b))))
@@ -585,9 +586,10 @@ transform_node (ir_node *n)
       ir_node *mem = get_DivMod_mem(n);
       turn_into_tuple(n, 4);
       set_Tuple_pred(n, 0, mem);
-      set_Tuple_pred(n, 1, new_Bad());
+      set_Tuple_pred(n, 1, new_Bad());  /* no exception */
       set_Tuple_pred(n, 2, a);
       set_Tuple_pred(n, 3, b);
+      assert(get_nodes_Block(n));
     }
   }
   break;
@@ -666,7 +668,7 @@ transform_node (ir_node *n)
     }
   }
   break;
-  case iro_Eor: {
+  case iro_Eor: { /* @@@ not tested as boolean Eor not allowed any more. */
     a = get_Eor_left(n);
     b = get_Eor_right(n);
 
@@ -674,7 +676,7 @@ transform_node (ir_node *n)
        && (get_irn_op(a) == op_Proj)
         && (get_irn_mode(a) == mode_b)
        && (tarval_classify (computed_value (b)) == 1)
-       && (get_irn_op(get_Proj_pred(a)) == iro_Cmp))
+       && (get_irn_op(get_Proj_pred(a)) == op_Cmp))
       /* The Eor negates a Cmp. The Cmp has the negated result anyways! */
       n = new_r_Proj(current_ir_graph, get_nodes_Block(n), get_Proj_pred(a),
                      mode_b, get_negated_pnc(get_Proj_proj(a)));
@@ -685,13 +687,13 @@ transform_node (ir_node *n)
       n = new_r_Not(current_ir_graph, get_nodes_Block(n), a, mode_b);
   }
   break;
-  case iro_Not: {
+  case iro_Not: { /* @@@ not tested as boolean Eor not allowed any more. */
     a = get_Not_op(n);
 
     if (   (get_irn_mode(n) == mode_b)
        && (get_irn_op(a) == op_Proj)
         && (get_irn_mode(a) == mode_b)
-       && (get_irn_op(get_Proj_pred(a)) == iro_Cmp))
+       && (get_irn_op(get_Proj_pred(a)) == op_Cmp))
       /* We negate a Cmp. The Cmp has the negated result anyways! */
       n = new_r_Proj(current_ir_graph, get_nodes_Block(n), get_Proj_pred(a),
                      mode_b, get_negated_pnc(get_Proj_proj(a)));
@@ -699,8 +701,8 @@ transform_node (ir_node *n)
   break;
   default: ;
   }
+  return n;
 }
-#endif
 
 /***************** Common Subexpression Elimination *****************/
 
@@ -927,11 +929,10 @@ optimize (ir_node *n)
     /* The AmRoq fiasco returns n here.  Martin's version doesn't. */
   }
 
-#if 0
-  /* Some more constant expression evaluation. */
+  /* Some more constant expression evaluation that does not allow to
+     free the node. */
   if (get_opt_constant_folding())
     n = transform_node (n);
-#endif
 
   /* Remove nodes with dead (Bad) input. */
   n = gigo (n);

diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c
index 36ce229..e2d3074 100644 (file)
--- a/ir/ir/irvrfy.c
+++ b/ir/ir/irvrfy.c
@@ -179,7 +179,7 @@ ir_vrfy (ir_node *n)
           );
     op_is_symmetric = 2;
     break;
-  case iro_DivMod:
+  case iro_DivMod:;
     op1mode = get_irn_mode(in[1]);
     op2mode = get_irn_mode(in[2]);
     op3mode = get_irn_mode(in[3]);

diff --git a/ir/ir/irvrfy.h b/ir/ir/irvrfy.h
index 9ec0740..45fe7eb 100644 (file)
--- a/ir/ir/irvrfy.h
+++ b/ir/ir/irvrfy.h
@@ -13,7 +13,7 @@
 # include "irgraph.h"
 
 /* Tests the types of predecessors of checknode. */
-void ir_vrfy (struct ir_node *checknode);
+void ir_vrfy (ir_node *checknode);
 
 /* Calls ir_vrfy for each node in irg. */
 void vrfy_graph (ir_graph *irg);

diff --git a/testprograms/const_eval_example.c b/testprograms/const_eval_example.c
index 3ae9f35..b3ba444 100644 (file)
--- a/testprograms/const_eval_example.c
+++ b/testprograms/const_eval_example.c
@@ -43,19 +43,28 @@ main(void)
 
   irg = new_ir_graph (ent, 4);
 
-  a = new_Const (mode_i, tarval_from_long (mode_i, 5));
-  b = new_Const (mode_i, tarval_from_long (mode_i, 7));
+  a = new_Const (mode_i, tarval_from_long (mode_i, 7));
+  b = new_Const (mode_i, tarval_from_long (mode_i, 5));
 
   x = new_Jmp ();
   mature_block (irg->current_block);
 
+  /*  To test const eval on DivMod
+  c = new_DivMod(get_store(), a, b);
+  set_store(new_Proj(c, mode_M, 0));
+  d = new_Proj(c, mode_i, 3);
+  c = new_Proj(c, mode_i, 2);
+  */
+
+
+  /*
   c = new_Add (new_Const (mode_i, tarval_from_long (mode_i, 5)),
               new_Const (mode_i, tarval_from_long (mode_i, 7)),
               mode_i);
   d = new_Add (new_Const (mode_i, tarval_from_long (mode_i, 7)),
               new_Const (mode_i, tarval_from_long (mode_i, 5)),
               mode_i);
-
+  */
   {
      ir_node *in[2];
      in[0] = c;

diff --git a/testprograms/dead_block_example.c b/testprograms/dead_block_example.c
index 2c1ad05..a5ad8b6 100644 (file)
--- a/testprograms/dead_block_example.c
+++ b/testprograms/dead_block_example.c
@@ -54,11 +54,6 @@ int main(int argc, char **argv)
 
   /* init library */
   init_firm ();
-  set_opt_constant_folding (1);
-  set_optimize(1);
-  set_opt_cse(1);
-  set_opt_dead_node_elimination(1);
-
 
   /* FIRM was designed for oo languages where all methods belong to a class.
    * For imperative languages like C we view a file as a large class containing

diff --git a/testprograms/if_example.c b/testprograms/if_example.c
index caaddab..e20ad23 100644 (file)
--- a/testprograms/if_example.c
+++ b/testprograms/if_example.c
@@ -14,14 +14,12 @@
 ***
 ***  Doesn't work for some reason!!!!
 ***
-***  main() {
-***    int a = 0;
+***  int main(int a) {
 ***    int b = 2;
-***    if ( a == a )  // a constant condition would be eliminated,
-***                   // a realistic condition would no more be a small example
+***    if ( a == b )
 ***      { a := a - 2; }
 ***
-***    // return a, bla; // das ist hier kein korrekter graph
+***    return a;
 ***  }
 **/
 
@@ -31,9 +29,9 @@ main(void)
   ir_graph *irg;
   type_class *owner;
   entity *ent;
-  type_method *proc_main; /* typeinformation for the method main */
+  type_method *proc_main; /* type information for the method main */
   type_primitive *typ;
-  ir_node *x, *r, *t, *f, *a;
+  ir_node *x, *r, *t, *f, *a, *cmp;
   int a_pos, b_pos;
   FILE *outfile;
 
@@ -43,25 +41,20 @@ main(void)
 
 #define CLASSNAME "IF_EXAMPLE"
 #define METHODNAME "main"
-#define NRARGS 0
-#define NRES 2
+#define NRARGS 1
+#define NRES 1
 
-  owner = new_type_class (id_from_str (CLASSNAME, strlen(CLASSNAME)));
-  proc_main = new_type_method(id_from_str(METHODNAME, strlen(METHODNAME)), NRARGS, NRES);
+  owner = get_glob_type();
+  proc_main = new_type_method(id_from_str(METHODNAME, strlen(METHODNAME)),
+                             NRARGS, NRES);
   ent = new_entity ((type *)owner,
                     id_from_str (METHODNAME, strlen(METHODNAME)),
                     (type *)proc_main);
 
-#define RES_NAME "res1"
+#define RES_NAME "int"
   typ = new_type_primitive(ID_FROM_STR(RES_NAME, strlen(RES_NAME)), mode_i);
+  set_method_param_type(proc_main, 0, (type*)typ);
   set_method_res_type(proc_main, 0, (type*)typ);
-#undef RES_NAME
-
-#define RES_NAME "res2"
-  typ = new_type_primitive(ID_FROM_STR(RES_NAME, strlen(RES_NAME)), mode_i);
-  set_method_res_type(proc_main, 1, (type*)typ);
-#undef RES_NAME
-
 
   /* Generates start and end blocks and nodes and a first, initial block */
   irg = new_ir_graph (ent, 1);
@@ -71,21 +64,20 @@ main(void)
   b_pos = 1;
 
   /* Generate the constant */
-  set_value (a_pos, new_Const (mode_i, tarval_from_long (mode_i, 0)));
+  set_value (a_pos, new_Proj (get_irg_args(irg), mode_i, 0));
+  /*set_value (a_pos, new_Const (mode_i, tarval_from_long (mode_i, 0)));*/
   set_value (b_pos, new_Const (mode_i, tarval_from_long (mode_i, 2)));
   mature_block (irg->current_block);
 
   /* Generate a conditional branch */
-  x = new_Cond (new_Proj(new_Cmp(get_value(a_pos, mode_i),
-                                 get_value(a_pos, mode_i)),
-                         mode_b, Eq));
+  cmp = new_Cmp(get_value(a_pos, mode_i), get_value(b_pos, mode_i));
+  x = new_Cond (new_Proj(cmp, mode_b, Eq));
   f = new_Proj (x, mode_X, 0);
   t = new_Proj (x, mode_X, 1);
 
   /* generate and fill the then block */
   r = new_Block ();
   add_in_edge (r, t);
-  // mature_block (r);
   a = new_Sub(get_value(a_pos, mode_i),
               new_Const (mode_i, tarval_from_long (mode_i, 2)),
              mode_i);
@@ -100,13 +92,11 @@ main(void)
   add_in_edge (r, x);
   mature_block (r);
   {
-     ir_node *in[3], *store ;
+     ir_node *in[1], *store ;
      in[0] = get_value (a_pos, mode_i);
-     in[1] = a;
-     in[2] = get_value (b_pos, mode_i);
      store = get_store();
 
-     x = new_Return (store, 2, in);
+     x = new_Return (store, 1, in);
   }
 
   /* finalize the end block generated in new_ir_graph() */

diff --git a/testprograms/oo_program_example.c b/testprograms/oo_program_example.c
index 7365d53..aba9308 100644 (file)
--- a/testprograms/oo_program_example.c
+++ b/testprograms/oo_program_example.c
@@ -137,6 +137,7 @@ main(void)
   mature_block (main_irg->end_block);
 
   printf("\nDone building the graph.\n");
+  vrfy_graph(main_irg);
   printf("Dumping the graph and a type graph.\n");
   dump_ir_block_graph (main_irg);
   dump_type_graph(main_irg);
@@ -167,6 +168,7 @@ main(void)
   mature_block (set_a_irg->end_block);
 
   printf("\nDone building the graph.\n");
+  vrfy_graph(set_a_irg);
   printf("Dumping the graph and a type graph.\n");
   dump_ir_block_graph (set_a_irg);
   dump_type_graph(set_a_irg);