nsz Git - libfirm/blob - ir/opt/opt_polymorphy.c

   1 /*
   2  * Project:     libFIRM
   3  * File name:   ir/opt/opt_polymorphy
   4  * Purpose:     Optimize polymorphic Sel nodes.
   5  * Author:
   6  * Created:
   7  * CVS-ID:      $Id$
   8  * Copyright:   (c) 2005 Universit\81ät Karlsruhe
   9  * Licence:     This file protected by GPL -  GNU GENERAL PUBLIC LICENSE.
  10  */
  11
  12 #include "irprog_t.h"
  13 #include "entity_t.h"
  14 #include "type_t.h"
  15 #include "irop.h"
  16 #include "irnode_t.h"
  17 #include "ircons.h"
  18
  19 #include "iropt_dbg.h"
  20 #include "irflag_t.h"
  21
  22 /** Return dynamic type of ptr.
  23  *
  24  * If we can deduct the dynamic type from the firm nodes
  25  * by a limited test we return the dynamic type.  Else
  26  * we return unknown_type.
  27  *
  28  * If we find a dynamic type this means that the pointer always points
  29  * to an object of this type during runtime.   We resolved polymorphy.
  30  */
  31 static type *get_dynamic_type(ir_node *ptr) {
  32   ptr = skip_Cast(skip_Proj(ptr));
  33   if (get_irn_op(ptr) == op_Alloc)
  34     return get_Alloc_type(ptr);
  35   return firm_unknown_type;
  36 }
  37
  38 /*
  39  * Transform  Sel(Alloc)[method]
  40  * to SymC[method]
  41  */
  42 ir_node *transform_node_Sel(ir_node *node)
  43 {
  44   entity *ent = get_Sel_entity(node);
  45   ir_node *new_node;
  46
  47   if (get_irp_phase_state() == phase_building) return node;
  48
  49   if (!(get_opt_optimize() && get_opt_dyn_meth_dispatch()))
  50     return node;
  51
  52   if (!is_Method_type(get_entity_type(ent)))
  53     return node;
  54
  55   /* If the entity is a leave in the inheritance tree,
  56      we can replace the Sel by a constant. */
  57   if ((get_irp_phase_state() != phase_building) && (get_entity_n_overwrittenby(ent) == 0)) {
  58     /* In dead code, we might call a leave entity that is a description.
  59        Do not turn the Sel to a SymConst. */
  60     if (get_entity_peculiarity(ent) == peculiarity_description) {
  61       /* We could remove the Call depending on this Sel. */
  62       new_node = node;
  63     } else {
  64       ir_node *rem_block = get_cur_block();
  65       set_cur_block(get_nodes_block(node));
  66       new_node = copy_const_value(get_atomic_ent_value(ent));
  67       set_cur_block(rem_block);
  68       DBG_OPT_POLY_ALLOC(node, new_node);
  69     }
  70
  71     return new_node;
  72   }
  73
  74   /* If we know the dynamic type, we can replace the Sel by a constant. */
  75   ir_node *ptr = get_Sel_ptr(node);      /* The address we select from. */
  76   type *dyn_tp = get_dynamic_type(ptr);  /* The runtime type of ptr. */
  77
  78   if (dyn_tp != firm_unknown_type) {
  79     entity *called_ent;
  80
  81     /* We know which method will be called, no dispatch necessary. */
  82     called_ent = resolve_ent_polymorphy(dyn_tp, ent);
  83     /* called_ent may not be description: has no Address/Const to Call! */
  84     assert(get_entity_peculiarity(called_ent) != peculiarity_description);
  85
  86     ir_node *rem_block = get_cur_block();
  87     set_cur_block(get_nodes_block(node));
  88     new_node = copy_const_value(get_atomic_ent_value(called_ent));
  89     set_cur_block(rem_block);
  90     DBG_OPT_POLY_ALLOC(node, new_node);
  91
  92     return new_node;
  93   }
  94
  95   return node;
  96 }
  97
  98 /* Transform  Load(Sel(Alloc)[constant static entity])
  99  *  to Const[constant static entity value].
 100  *
 101  *  This function returns a node replacing the Proj(Load)[Value].
 102  *  If this is actually called in transform_node, we must build
 103  *  a tuple, or replace the Projs of the load.
 104  *  Therefore we call this optimization in ldstopt.
 105  */
 106 ir_node *transform_node_Load(ir_node *n)
 107 {
 108   if (!(get_opt_optimize() && get_opt_dyn_meth_dispatch()))
 109     return n;
 110
 111   ir_node *field_ptr = get_Load_ptr(n);
 112
 113   if (get_irn_op(field_ptr) != op_Sel) return n;
 114
 115   entity *ent  = get_Sel_entity(field_ptr);
 116   ir_node *new_node;
 117
 118   if ((get_entity_allocation(ent) != allocation_static)    ||
 119       (get_entity_variability(ent) != variability_constant)  )
 120     return n;
 121
 122   /* If the entity is a leave in the inheritance tree,
 123      we can replace the Sel by a constant. */
 124   if ((get_irp_phase_state() != phase_building) && (get_entity_n_overwrittenby(ent) == 0)) {
 125     new_node = copy_const_value(get_atomic_ent_value(ent));
 126     DBG_OPT_POLY_ALLOC(field_ptr, new_node);
 127
 128     return new_node;
 129   }
 130
 131   /* If we know the dynamic type, we can replace the Sel by a constant. */
 132   ir_node *ptr = get_Sel_ptr(field_ptr);      /* The address we select from. */
 133   type *dyn_tp = get_dynamic_type(ptr);  /* The runtime type of ptr. */
 134
 135   if (dyn_tp != firm_unknown_type) {
 136     entity *loaded_ent;
 137
 138     /* We know which method will be called, no dispatch necessary. */
 139     loaded_ent = resolve_ent_polymorphy(dyn_tp, ent);
 140     /* called_ent may not be description: has no Address/Const to Call! */
 141     assert(get_entity_peculiarity(loaded_ent) != peculiarity_description);
 142
 143     new_node = copy_const_value(get_atomic_ent_value(loaded_ent));
 144     DBG_OPT_POLY_ALLOC(field_ptr, new_node);
 145
 146     return new_node;
 147   }
 148
 149   return n;
 150 }