Remove arch_get_allocatable_regs().

[libfirm] / ir / opt / escape_ana.c

diff --git a/ir/opt/escape_ana.c b/ir/opt/escape_ana.c
index 9d51179..92a6d72 100644 (file)
--- a/ir/opt/escape_ana.c
+++ b/ir/opt/escape_ana.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.
  *
@@ -33,10 +33,9 @@
  *
  * A fast and simple Escape analysis.
  */
+#include "config.h"
 
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
+#include "iroptimize.h"
 
 #include "irgraph_t.h"
 #include "irnode_t.h"
@@ -46,7 +45,7 @@
 #include "analyze_irg_args.h"
 #include "irgmod.h"
 #include "ircons.h"
-#include "escape_ana.h"
+#include "irprintf.h"
 #include "debug.h"
 
 /**
@@ -114,6 +113,30 @@ static int is_method_leaving_raise(ir_node *raise)
   return 0;
 }
 
+/**
+ * returns an Alloc node if the node adr Select
+ * from one
+ */
+static ir_node *is_depend_alloc(ir_node *adr) {
+  ir_node *alloc;
+
+  if (!is_Sel(adr))
+    return NULL;
+
+  /* should be a simple Sel */
+  if (get_Sel_n_indexs(adr) != 0)
+    return NULL;
+
+  alloc = skip_Proj(get_Sel_ptr(adr));
+  if (!is_Alloc(alloc))
+    return NULL;
+
+  /* hmm, we depend on this Alloc */
+  ir_printf("depend alloc %+F\n", alloc);
+
+  return NULL;
+}
+
 /**
  * determine if a value calculated by n "escape", ie
  * is stored somewhere we could not track
@@ -130,6 +153,15 @@ static int can_escape(ir_node *n) {
     switch (get_irn_opcode(succ)) {
     case iro_Store:
       if (get_Store_value(succ) == n) {
+        ir_node *adr = get_Store_ptr(succ);
+
+        /*
+         * if this Alloc depends on another one,
+         * we can enqueue it
+         */
+        if (is_depend_alloc(adr))
+          break;
+
         /*
          * We are storing n. As long as we do not further
          * evaluate things, the pointer 'escape' here
@@ -149,8 +181,7 @@ static int can_escape(ir_node *n) {
       ir_node *ptr = get_Call_ptr(succ);
       ir_entity *ent;
 
-      if (get_irn_op(ptr) == op_SymConst &&
-          get_SymConst_kind(ptr) == symconst_addr_ent) {
+      if (is_SymConst_addr_ent(ptr)) {
         ent = get_SymConst_entity(ptr);
 
         /* we know the called entity */
@@ -163,7 +194,7 @@ static int can_escape(ir_node *n) {
           }
         }
       }
-      else if (get_irn_op(ptr) == op_Sel) {
+      else if (is_Sel(ptr)) {
         /* go through all possible callees */
         for (k = get_Call_n_callees(succ) - 1; k >= 0; --k) {
           ent = get_Call_callee(succ, k);
@@ -297,7 +328,7 @@ static void find_allocation_calls(ir_node *call, void *ctx)
   if (! is_Call(call))
     return;
   adr = get_Call_ptr(call);
-  if (! is_SymConst(adr) || get_SymConst_kind(adr) != symconst_addr_ent)
+  if (! is_SymConst_addr_ent(adr))
     return;
   ent = get_SymConst_entity(adr);
   if (! env->callback(ent))
@@ -344,7 +375,7 @@ static void find_allocation_calls(ir_node *call, void *ctx)
  */
 static void transform_allocs(ir_graph *irg, walk_env_t *env)
 {
-  ir_node *alloc, *next, *mem, *sel, *size;
+  ir_node *alloc, *next, *mem, *sel, *size, *blk;
   ir_type *ftp, *atp, *tp;
   ir_entity *ent;
   char name[128];
@@ -358,8 +389,10 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env)
     DBG((dbgHandle, LEVEL_1, "%+F allocation of %+F unused, deleted.\n", irg, alloc));
 
     mem = get_Alloc_mem(alloc);
+       blk = get_nodes_block(alloc);
     turn_into_tuple(alloc, pn_Alloc_max);
     set_Tuple_pred(alloc, pn_Alloc_M, mem);
+    set_Tuple_pred(alloc, pn_Alloc_X_regular, new_r_Jmp(irg, blk));
     set_Tuple_pred(alloc, pn_Alloc_X_except, new_r_Bad(irg));
 
     ++env->nr_deads;
@@ -383,7 +416,7 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env)
 
       if (tv != tarval_bad && tarval_is_long(tv) &&
           get_type_state(atp) == layout_fixed &&
-          get_tarval_long(tv) == get_type_size_bytes(atp)) {
+          (unsigned)get_tarval_long(tv) == get_type_size_bytes(atp)) {
         /* a already lowered type size */
         tp = atp;
       }
@@ -392,10 +425,12 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env)
     if (tp && tp != firm_unknown_type) {
       /* we could determine the type, so we could place it on the frame */
       dbg  = get_irn_dbg_info(alloc);
+      blk  = get_nodes_block(alloc);
 
       DBG((dbgHandle, LEVEL_DEFAULT, "%+F allocation of %+F type %+F placed on frame\n", irg, alloc, tp));
 
       snprintf(name, sizeof(name), "%s_NE_%u", get_entity_name(get_irg_entity(irg)), nr++);
+      name[sizeof(name) - 1] = '\0';
       ent = new_d_entity(ftp, new_id_from_str(name), get_Alloc_type(alloc), dbg);
 
       sel = new_rd_simpleSel(dbg, irg, get_nodes_block(alloc),
@@ -404,6 +439,7 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env)
 
       turn_into_tuple(alloc, pn_Alloc_max);
       set_Tuple_pred(alloc, pn_Alloc_M, mem);
+         set_Tuple_pred(alloc, pn_Alloc_X_regular, new_r_Jmp(irg, blk));
       set_Tuple_pred(alloc, pn_Alloc_X_except, new_r_Bad(irg));
       set_Tuple_pred(alloc, pn_Alloc_res, sel);
 
@@ -438,8 +474,8 @@ static void transform_allocs(ir_graph *irg, walk_env_t *env)
  */
 static void transform_alloc_calls(ir_graph *irg, walk_env_t *env)
 {
-  ir_node *call, *next, *mem, *size;
-  ir_type *ftp, *atp, *tp;
+  ir_node *call, *next, *mem, *blk;
+  ir_type *ftp;
 
   /* kill all dead allocs */
   for (call = env->dead_allocs; call; call = next) {
@@ -448,8 +484,10 @@ static void transform_alloc_calls(ir_graph *irg, walk_env_t *env)
     DBG((dbgHandle, LEVEL_1, "%+F allocation of %+F unused, deleted.\n", irg, call));
 
     mem = get_Call_mem(call);
+       blk = get_nodes_block(call);
     turn_into_tuple(call, pn_Call_max);
     set_Tuple_pred(call, pn_Call_M_regular, mem);
+       set_Tuple_pred(call, pn_Call_X_regular, new_r_Jmp(irg, blk));
     set_Tuple_pred(call, pn_Call_X_except, new_r_Bad(irg));
     set_Tuple_pred(call, pn_Call_T_result, new_r_Bad(irg));
     set_Tuple_pred(call, pn_Call_M_except, mem);
@@ -505,6 +543,7 @@ void escape_analysis(int run_scalar_replace, check_alloc_entity_func callback)
   int i;
   struct obstack obst;
   walk_env_t *env, *elist;
+  (void) run_scalar_replace;
 
   if (get_irp_callee_info_state() != irg_callee_info_consistent) {
     assert(! "need callee info");