nsz Git - libfirm/blob - ir/lower/lower_copyb.c

   1 /*
   2  * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief   Lower small CopyB nodes into a series of Load/store
  23  * @author  Michael Beck, Matthias Braun
  24  * @version $Id$
  25  */
  26 #include "config.h"
  27
  28 #include "adt/list.h"
  29 #include "ircons.h"
  30 #include "lowering.h"
  31 #include "irprog_t.h"
  32 #include "irgwalk.h"
  33 #include "irnode_t.h"
  34 #include "type_t.h"
  35 #include "irtools.h"
  36 #include "irgmod.h"
  37 #include "error.h"
  38
  39 typedef struct entry entry_t;
  40 struct entry {
  41         struct list_head list;
  42         ir_node *copyb;
  43 };
  44
  45 typedef struct walk_env {
  46         unsigned         max_size;
  47         struct obstack   obst;              /**< the obstack where data is allocated on */
  48         struct list_head list;              /**< the list of copyb nodes */
  49 } walk_env_t;
  50
  51 static ir_mode *get_ir_mode(unsigned bytes)
  52 {
  53         switch (bytes) {
  54         case 1:  return mode_Bu;
  55         case 2:  return mode_Hu;
  56         case 4:  return mode_Iu;
  57         case 8:  return mode_Lu;
  58         case 16: return mode_LLu;
  59         default:
  60                 panic("unexpected mode size requested in copyb lowering");
  61         }
  62 }
  63
  64 /**
  65  * lower a CopyB node.
  66  */
  67 static void lower_copyb_nodes(ir_node *irn, unsigned mode_bytes)
  68 {
  69         ir_graph        *irg = current_ir_graph;
  70         unsigned         size;
  71         unsigned         offset;
  72         ir_mode         *mode;
  73         ir_mode         *addr_mode;
  74         ir_node         *mem;
  75         ir_node         *addr_src;
  76         ir_node         *addr_dst;
  77         ir_node         *block;
  78         ir_type         *tp;
  79
  80         addr_src  = get_CopyB_src(irn);
  81         addr_dst  = get_CopyB_dst(irn);
  82         mem       = get_CopyB_mem(irn);
  83         addr_mode = get_irn_mode(addr_src);
  84         block     = get_nodes_block(irn);
  85
  86         tp   = get_CopyB_type(irn);
  87         size = get_type_size_bytes(tp);
  88
  89         offset     = 0;
  90         while (offset < size) {
  91                 mode = get_ir_mode(mode_bytes);
  92                 for (; offset + mode_bytes <= size; offset += mode_bytes) {
  93                         /* construct offset */
  94                         ir_node *addr_const;
  95                         ir_node *add;
  96                         ir_node *load;
  97                         ir_node *load_res;
  98                         ir_node *load_mem;
  99                         ir_node *store;
 100                         ir_node *store_mem;
 101
 102                         addr_const = new_r_Const_long(irg, mode_Iu, offset);
 103                         add        = new_r_Add(block, addr_src, addr_const, addr_mode);
 104
 105                         load     = new_r_Load(block, mem, add, mode, cons_none);
 106                         load_res = new_r_Proj(load, mode, pn_Load_res);
 107                         load_mem = new_r_Proj(load, mode_M, pn_Load_M);
 108
 109                         addr_const = new_r_Const_long(irg, mode_Iu, offset);
 110                         add        = new_r_Add(block, addr_dst, addr_const, addr_mode);
 111
 112                         store     = new_r_Store(block, load_mem, add, load_res, cons_none);
 113                         store_mem = new_r_Proj(store, mode_M, pn_Store_M);
 114
 115                         mem = store_mem;
 116                 }
 117
 118                 mode_bytes /= 2;
 119         }
 120
 121         turn_into_tuple(irn, pn_CopyB_max);
 122         set_Tuple_pred(irn, pn_CopyB_M,         mem);
 123         set_Tuple_pred(irn, pn_CopyB_X_regular, get_irg_bad(irg));
 124         set_Tuple_pred(irn, pn_CopyB_X_except,  get_irg_bad(irg));
 125 }
 126
 127 /**
 128  * Post-Walker: find small CopyB nodes.
 129  */
 130 static void find_copyb_nodes(ir_node *irn, void *ctx)
 131 {
 132         walk_env_t *env = (walk_env_t*)ctx;
 133         ir_type    *tp;
 134         unsigned   size;
 135         entry_t    *entry;
 136
 137         if (is_Proj(irn)) {
 138                 ir_node *pred = get_Proj_pred(irn);
 139
 140                 if (is_CopyB(pred) && get_Proj_proj(irn) != pn_CopyB_M) {
 141                         /* found an exception Proj: remove it from the list again */
 142                         entry = (entry_t*)get_irn_link(pred);
 143                         list_del(&entry->list);
 144                 }
 145                 return;
 146         }
 147
 148         if (! is_CopyB(irn))
 149                 return;
 150
 151         tp = get_CopyB_type(irn);
 152         if (get_type_state(tp) != layout_fixed)
 153                 return;
 154
 155         size = get_type_size_bytes(tp);
 156         if (size > env->max_size)
 157                 return;
 158
 159         /* ok, link it in */
 160         entry = OALLOC(&env->obst, entry_t);
 161         entry->copyb = irn;
 162         INIT_LIST_HEAD(&entry->list);
 163         set_irn_link(irn, entry);
 164         list_add_tail(&entry->list, &env->list);
 165 }
 166
 167 void lower_CopyB(ir_graph *irg, unsigned max_size, unsigned native_mode_bytes)
 168 {
 169         walk_env_t env;
 170         entry_t  *entry;
 171         ir_graph *rem = current_ir_graph;
 172
 173         current_ir_graph = irg;
 174
 175         obstack_init(&env.obst);
 176         env.max_size = max_size;
 177         INIT_LIST_HEAD(&env.list);
 178         irg_walk_graph(irg, NULL, find_copyb_nodes, &env);
 179
 180         list_for_each_entry(entry_t, entry, &env.list, list) {
 181                 lower_copyb_nodes(entry->copyb, native_mode_bytes);
 182         }
 183
 184         obstack_free(&env.obst, NULL);
 185         current_ir_graph = rem;
 186 }