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         ir_graph        *irg = current_ir_graph;
  69         unsigned         size;
  70         unsigned         offset;
  71         ir_mode         *mode;
  72         ir_mode         *addr_mode;
  73         ir_node         *mem;
  74         ir_node         *addr_src;
  75         ir_node         *addr_dst;
  76         ir_node         *block;
  77         ir_type         *tp;
  78
  79         addr_src  = get_CopyB_src(irn);
  80         addr_dst  = get_CopyB_dst(irn);
  81         mem       = get_CopyB_mem(irn);
  82         addr_mode = get_irn_mode(addr_src);
  83         block     = get_nodes_block(irn);
  84
  85         tp   = get_CopyB_type(irn);
  86         size = get_type_size_bytes(tp);
  87
  88         offset     = 0;
  89         while (offset < size) {
  90                 mode = get_ir_mode(mode_bytes);
  91                 for (; offset + mode_bytes <= size; offset += mode_bytes) {
  92                         /* construct offset */
  93                         ir_node *addr_const;
  94                         ir_node *add;
  95                         ir_node *load;
  96                         ir_node *load_res;
  97                         ir_node *load_mem;
  98                         ir_node *store;
  99                         ir_node *store_mem;
 100
 101                         addr_const = new_r_Const_long(irg, block, mode_Iu, offset);
 102                         add        = new_r_Add(irg, block, addr_src, addr_const, addr_mode);
 103
 104                         load     = new_r_Load(irg, block, mem, add, mode);
 105                         load_res = new_r_Proj(irg, block, load, mode, pn_Load_res);
 106                         load_mem = new_r_Proj(irg, block, load, mode_M, pn_Load_M);
 107
 108                         addr_const = new_r_Const_long(irg, block, mode_Iu, offset);
 109                         add        = new_r_Add(irg, block, addr_dst, addr_const, addr_mode);
 110
 111                         store     = new_r_Store(irg, block, mem, add, load_res);
 112                         store_mem = new_r_Proj(irg, block, store, mode_M, pn_Store_M);
 113
 114                         mem = store_mem;
 115                 }
 116
 117                 mode_bytes /= 2;
 118         }
 119
 120         turn_into_tuple(irn, pn_CopyB_max);
 121         set_Tuple_pred(irn, pn_CopyB_M_regular, mem);
 122         set_Tuple_pred(irn, pn_CopyB_X_regular, get_irg_bad(irg));
 123         set_Tuple_pred(irn, pn_CopyB_X_except,  get_irg_bad(irg));
 124         set_Tuple_pred(irn, pn_CopyB_M_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         walk_env_t *env = ctx;
 132         ir_type    *tp;
 133         unsigned   size;
 134         entry_t    *entry;
 135
 136         if (is_Proj(irn)) {
 137                 ir_node *pred = get_Proj_pred(irn);
 138
 139                 if (is_CopyB(pred) && get_Proj_proj(irn) != pn_CopyB_M_regular) {
 140                         /* found an exception Proj: remove it from the list again */
 141                         entry = get_irn_link(pred);
 142                         list_del(&entry->list);
 143                 }
 144                 return;
 145         }
 146
 147         if (! is_CopyB(irn))
 148                 return;
 149
 150         tp = get_CopyB_type(irn);
 151         if (get_type_state(tp) != layout_fixed)
 152                 return;
 153
 154         size = get_type_size_bytes(tp);
 155         if (size > env->max_size)
 156                 return;
 157
 158         /* ok, link it in */
 159         entry = obstack_alloc(&env->obst, sizeof(*entry));
 160         entry->copyb = irn;
 161         INIT_LIST_HEAD(&entry->list);
 162         set_irn_link(irn, entry);
 163         list_add_tail(&entry->list, &env->list);
 164 }
 165
 166 void lower_CopyB(ir_graph *irg, unsigned max_size, unsigned native_mode_bytes)
 167 {
 168         walk_env_t env;
 169         entry_t  *entry;
 170         ir_graph *rem = current_ir_graph;
 171
 172         current_ir_graph = irg;
 173
 174         obstack_init(&env.obst);
 175         env.max_size = max_size;
 176         INIT_LIST_HEAD(&env.list);
 177         irg_walk_graph(irg, NULL, find_copyb_nodes, &env);
 178
 179         list_for_each_entry(entry_t, entry, &env.list, list) {
 180                 lower_copyb_nodes(entry->copyb, native_mode_bytes);
 181         }
 182
 183         obstack_free(&env.obst, NULL);
 184         current_ir_graph = rem;
 185 }