nsz Git - libfirm/blob - ir/be/TEMPLATE/TEMPLATE_transform.c

   1 /*
   2  * Copyright (C) 1995-2008 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   code selection (transform FIRM into TEMPLATE FIRM)
  23  * @version $Id$
  24  */
  25 #include "config.h"
  26
  27 #include "irnode_t.h"
  28 #include "irgraph_t.h"
  29 #include "irmode_t.h"
  30 #include "irgmod.h"
  31 #include "iredges.h"
  32 #include "ircons.h"
  33 #include "iropt_t.h"
  34 #include "debug.h"
  35 #include "error.h"
  36
  37 #include "benode.h"
  38 #include "betranshlp.h"
  39 #include "bearch_TEMPLATE_t.h"
  40
  41 #include "TEMPLATE_nodes_attr.h"
  42 #include "TEMPLATE_transform.h"
  43 #include "TEMPLATE_new_nodes.h"
  44
  45 #include "gen_TEMPLATE_regalloc_if.h"
  46
  47 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  48
  49 typedef ir_node* (*new_binop_func)(dbg_info *dbgi, ir_node *block,
  50                                    ir_node *left, ir_node *right);
  51
  52 static ir_node *transform_binop(ir_node *node, new_binop_func new_func)
  53 {
  54         ir_node  *block     = get_nodes_block(node);
  55         ir_node  *new_block = be_transform_node(block);
  56         dbg_info *dbgi      = get_irn_dbg_info(node);
  57         ir_node  *left      = get_binop_left(node);
  58         ir_node  *new_left  = be_transform_node(left);
  59         ir_node  *right     = get_binop_right(node);
  60         ir_node  *new_right = be_transform_node(right);
  61
  62         return new_func(dbgi, new_block, new_left, new_right);
  63 }
  64
  65 static ir_node *gen_And(ir_node *node)
  66 {
  67         return transform_binop(node, new_bd_TEMPLATE_And);
  68 }
  69
  70 static ir_node *gen_Or(ir_node *node)
  71 {
  72         return transform_binop(node, new_bd_TEMPLATE_Or);
  73 }
  74
  75 static ir_node *gen_Eor(ir_node *node)
  76 {
  77         return transform_binop(node, new_bd_TEMPLATE_Xor);
  78 }
  79
  80 static ir_node *gen_Div(ir_node *node)
  81 {
  82         ir_mode *mode = get_Div_resmode(node);
  83         assert(mode_is_float(mode));
  84         return transform_binop(node, new_bd_TEMPLATE_fDiv);
  85 }
  86
  87 static ir_node *gen_Shl(ir_node *node)
  88 {
  89         ir_mode *mode = get_irn_mode(node);
  90         if (get_mode_modulo_shift(mode) != 32)
  91                 panic("modulo shift!=32 not supported by TEMPLATE backend");
  92         return transform_binop(node, new_bd_TEMPLATE_Shl);
  93 }
  94
  95 static ir_node *gen_Shr(ir_node *node)
  96 {
  97         ir_mode *mode = get_irn_mode(node);
  98         if (get_mode_modulo_shift(mode) != 32)
  99                 panic("modulo shift!=32 not supported by TEMPLATE backend");
 100         return transform_binop(node, new_bd_TEMPLATE_Shr);
 101 }
 102
 103 static ir_node *gen_Add(ir_node *node)
 104 {
 105         ir_mode *mode = get_irn_mode(node);
 106
 107         if (mode_is_float(mode)) {
 108                 return transform_binop(node, new_bd_TEMPLATE_fAdd);
 109         }
 110         return transform_binop(node, new_bd_TEMPLATE_Add);
 111 }
 112
 113 static ir_node *gen_Sub(ir_node *node)
 114 {
 115         ir_mode *mode = get_irn_mode(node);
 116
 117         if (mode_is_float(mode)) {
 118                 return transform_binop(node, new_bd_TEMPLATE_fSub);
 119         }
 120         return transform_binop(node, new_bd_TEMPLATE_Sub);
 121 }
 122
 123 static ir_node *gen_Mul(ir_node *node)
 124 {
 125         ir_mode *mode = get_irn_mode(node);
 126
 127         if (mode_is_float(mode)) {
 128                 return transform_binop(node, new_bd_TEMPLATE_fMul);
 129         }
 130         return transform_binop(node, new_bd_TEMPLATE_Mul);
 131 }
 132
 133
 134 typedef ir_node* (*new_unop_func)(dbg_info *dbgi, ir_node *block, ir_node *op);
 135
 136 static ir_node *transform_unop(ir_node *node, new_unop_func new_func)
 137 {
 138         ir_node  *block     = get_nodes_block(node);
 139         ir_node  *new_block = be_transform_node(block);
 140         dbg_info *dbgi      = get_irn_dbg_info(node);
 141         ir_node  *op        = get_unop_op(node);
 142         ir_node  *new_op    = be_transform_node(op);
 143
 144         return new_func(dbgi, new_block, new_op);
 145 }
 146
 147 static ir_node *gen_Minus(ir_node *node)
 148 {
 149         ir_mode *mode = get_irn_mode(node);
 150
 151         if (mode_is_float(mode)) {
 152                 return transform_unop(node, new_bd_TEMPLATE_fMinus);
 153         }
 154         return transform_unop(node, new_bd_TEMPLATE_Minus);
 155 }
 156
 157 static ir_node *gen_Not(ir_node *node)
 158 {
 159         return transform_unop(node, new_bd_TEMPLATE_Not);
 160 }
 161
 162 static ir_node *gen_Const(ir_node *node)
 163 {
 164         ir_node   *block     = get_nodes_block(node);
 165         ir_node   *new_block = be_transform_node(block);
 166         dbg_info  *dbgi      = get_irn_dbg_info(node);
 167         ir_tarval *value     = get_Const_tarval(node);
 168         ir_node   *result;
 169
 170         result = new_bd_TEMPLATE_Const(dbgi, new_block, value);
 171
 172         return result;
 173 }
 174
 175 static ir_node *gen_Load(ir_node *node)
 176 {
 177         ir_node  *block     = get_nodes_block(node);
 178         ir_node  *new_block = be_transform_node(block);
 179         dbg_info *dbgi      = get_irn_dbg_info(node);
 180         ir_node  *ptr       = get_Load_ptr(node);
 181         ir_node  *new_ptr   = be_transform_node(ptr);
 182         ir_node  *mem       = get_Load_mem(node);
 183         ir_node  *new_mem   = be_transform_node(mem);
 184         ir_mode  *mode      = get_irn_mode(node);
 185
 186         if (mode_is_float(mode)) {
 187                 return new_bd_TEMPLATE_fLoad(dbgi, new_block, new_ptr, new_mem, mode);
 188         }
 189         return new_bd_TEMPLATE_Load(dbgi, new_block, new_ptr, new_mem, mode);
 190 }
 191
 192 static ir_node *gen_Store(ir_node *node)
 193 {
 194         ir_node  *block     = get_nodes_block(node);
 195         ir_node  *new_block = be_transform_node(block);
 196         dbg_info *dbgi      = get_irn_dbg_info(node);
 197         ir_node  *ptr       = get_Store_ptr(node);
 198         ir_node  *new_ptr   = be_transform_node(ptr);
 199         ir_node  *val       = get_Store_value(node);
 200         ir_node  *new_val   = be_transform_node(val);
 201         ir_node  *mem       = get_Store_mem(node);
 202         ir_node  *new_mem   = be_transform_node(mem);
 203         ir_mode  *mode      = get_irn_mode(node);
 204
 205         if (mode_is_float(mode)) {
 206                 return new_bd_TEMPLATE_fStore(dbgi, new_block, new_ptr, new_val, new_mem, mode);
 207         }
 208         return new_bd_TEMPLATE_Store(dbgi, new_block, new_ptr, new_mem, new_val, mode);
 209 }
 210
 211 static ir_node *gen_Jmp(ir_node *node)
 212 {
 213         ir_node  *block     = get_nodes_block(node);
 214         ir_node  *new_block = be_transform_node(block);
 215         dbg_info *dbgi      = get_irn_dbg_info(node);
 216
 217         return new_bd_TEMPLATE_Jmp(dbgi, new_block);
 218 }
 219
 220 /**
 221  * returns true if mode should be stored in a general purpose register
 222  */
 223 static inline bool mode_needs_gp_reg(ir_mode *mode)
 224 {
 225         return mode_is_int(mode) || mode_is_reference(mode);
 226 }
 227
 228 static ir_node *gen_Phi(ir_node *node)
 229 {
 230         const arch_register_req_t *req;
 231         ir_node  *block     = get_nodes_block(node);
 232         ir_node  *new_block = be_transform_node(block);
 233         dbg_info *dbgi      = get_irn_dbg_info(node);
 234         ir_mode  *mode      = get_irn_mode(node);
 235         ir_graph *irg       = get_irn_irg(node);
 236         ir_node  *phi;
 237
 238         if (mode_needs_gp_reg(mode)) {
 239                 mode = mode_Iu;
 240                 req  = TEMPLATE_reg_classes[CLASS_TEMPLATE_gp].class_req;
 241         } else {
 242                 req = arch_no_register_req;
 243         }
 244
 245         phi = new_ir_node(dbgi, irg, new_block, op_Phi, mode, get_irn_arity(node),
 246                           get_irn_in(node)+1);
 247         copy_node_attr(irg, node, phi);
 248         be_duplicate_deps(node, phi);
 249
 250         arch_set_irn_register_req_out(phi, 0, req);
 251         be_enqueue_preds(node);
 252         return phi;
 253 }
 254
 255 static void TEMPLATE_register_transformers(void)
 256 {
 257         be_start_transform_setup();
 258
 259         be_set_transform_function(op_Add,   gen_Add);
 260         be_set_transform_function(op_And,   gen_And);
 261         be_set_transform_function(op_Const, gen_Const);
 262         be_set_transform_function(op_Div,   gen_Div);
 263         be_set_transform_function(op_Eor,   gen_Eor);
 264         be_set_transform_function(op_Jmp,   gen_Jmp);
 265         be_set_transform_function(op_Load,  gen_Load);
 266         be_set_transform_function(op_Minus, gen_Minus);
 267         be_set_transform_function(op_Mul,   gen_Mul);
 268         be_set_transform_function(op_Not,   gen_Not);
 269         be_set_transform_function(op_Or,    gen_Or);
 270         be_set_transform_function(op_Phi,   gen_Phi);
 271         be_set_transform_function(op_Shl,   gen_Shl);
 272         be_set_transform_function(op_Shr,   gen_Shr);
 273         be_set_transform_function(op_Store, gen_Store);
 274         be_set_transform_function(op_Sub,   gen_Sub);
 275 }
 276
 277 /**
 278  * Transform generic IR-nodes into TEMPLATE machine instructions
 279  */
 280 void TEMPLATE_transform_graph(ir_graph *irg)
 281 {
 282         TEMPLATE_register_transformers();
 283         be_transform_graph(irg, NULL);
 284 }
 285
 286 void TEMPLATE_init_transform(void)
 287 {
 288         FIRM_DBG_REGISTER(dbg, "firm.be.TEMPLATE.transform");
 289 }