nsz Git - libfirm/blob - ir/lower/lower_mode_b.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        lowers operations with mode_b. The result is a graph which
  22  *              might still contains some convs from/to mode_b, but no
  23  *              operations are performed on them anymore, they are just there
  24  *              so modes match. A backend can safely skip all mode_b convs.
  25  * @author      Matthias Braun, Christoph Mallon
  26  * @version     $Id$
  27  */
  28 #ifdef HAVE_CONFIG_H
  29 #include "config.h"
  30 #endif
  31
  32 #include <stdlib.h>
  33
  34 #include "irnode_t.h"
  35 #include "ircons_t.h"
  36 #include "irgwalk.h"
  37 #include "irtools.h"
  38 #include "iredges.h"
  39 #include "iropt_t.h"
  40 #include "tv.h"
  41 #include "error.h"
  42 #include "lowering.h"
  43 #include "pdeq.h"
  44
  45 static lower_mode_b_config_t  config;
  46 static ir_type               *lowered_type  = NULL;
  47 static pdeq                  *lowered_nodes = NULL;
  48
  49 /**
  50  * Removes a node if its out-edge count has reached 0.
  51  * temporary hack until we have proper automatic dead code elimination.
  52  */
  53 static void maybe_kill_node(ir_node *node)
  54 {
  55         ir_graph *irg;
  56         int       i, arity;
  57
  58         if(get_irn_n_edges(node) != 0)
  59                 return;
  60
  61         irg = get_irn_irg(node);
  62
  63         assert(!is_Bad(node));
  64
  65         arity = get_irn_arity(node);
  66         for (i = 0; i < arity; ++i) {
  67                 set_irn_n(node, i, new_Bad());
  68         }
  69         set_nodes_block(node, new_Bad());
  70
  71         edges_node_deleted(node, irg);
  72 }
  73
  74 static ir_node *create_not(dbg_info *dbgi, ir_node *node)
  75 {
  76         ir_graph *irg    = current_ir_graph;
  77         ir_node  *block  = get_nodes_block(node);
  78         ir_mode  *mode   = config.lowered_mode;
  79         tarval   *tv_one = get_tarval_one(mode);
  80         ir_node  *one    = new_d_Const(dbgi, mode, tv_one);
  81
  82         return new_rd_Eor(dbgi, irg, block, node, one, mode);
  83 }
  84
  85 static ir_node *create_convb(ir_node *node)
  86 {
  87         ir_graph *irg   = current_ir_graph;
  88         ir_node  *block = get_nodes_block(node);
  89         ir_node  *conv  = new_rd_Conv(NULL, irg, block, node, mode_b);
  90
  91         return conv;
  92 }
  93
  94 static ir_type *create_lowered_type(void)
  95 {
  96         if(lowered_type == NULL) {
  97                 lowered_type = new_type_primitive(new_id_from_str("__lowered_mode_b"),
  98                                                   config.lowered_mode);
  99         }
 100         return lowered_type;
 101 }
 102
 103 /**
 104  * creates a "set" node that produces a 0 or 1 based on a Cmp result
 105  */
 106 static ir_node *create_set(ir_node *node)
 107 {
 108         ir_graph *irg     = current_ir_graph;
 109         dbg_info *dbgi    = get_irn_dbg_info(node);
 110         ir_mode  *mode    = config.lowered_set_mode;
 111         tarval   *tv_one  = get_tarval_one(mode);
 112         ir_node  *one     = new_d_Const(dbgi, mode, tv_one);
 113         ir_node  *block   = get_nodes_block(node);
 114         tarval   *tv_zero = get_tarval_null(mode);
 115         ir_node  *zero    = new_d_Const(dbgi, mode, tv_zero);
 116
 117         ir_node *vals[2]  = { one, zero };
 118         ir_node *set      = new_rd_Psi(dbgi, irg, block, 1, &node, vals, mode);
 119
 120         if(mode != config.lowered_mode) {
 121                 set = new_r_Conv(irg, block, set, config.lowered_mode);
 122         }
 123
 124         return set;
 125 }
 126
 127 static void adjust_method_type(ir_type *method_type)
 128 {
 129         int i;
 130         int n_params;
 131         int n_res;
 132
 133         n_params = get_method_n_params(method_type);
 134         for(i = 0; i < n_params; ++i) {
 135                 ir_type *param = get_method_param_type(method_type, i);
 136                 if(get_type_mode(param) == mode_b) {
 137                         set_method_param_type(method_type, i, create_lowered_type());
 138                 }
 139         }
 140
 141         n_res = get_method_n_ress(method_type);
 142         for(i = 0; i < n_res; ++i) {
 143                 ir_type *res_type = get_method_res_type(method_type, i);
 144                 if(get_type_mode(res_type) == mode_b) {
 145                         set_method_res_type(method_type, i, create_lowered_type());
 146                 }
 147         }
 148 }
 149
 150 static ir_node *lower_node(ir_node *node)
 151 {
 152         ir_graph *irg   = current_ir_graph;
 153         dbg_info *dbgi  = get_irn_dbg_info(node);
 154         ir_op    *op    = get_irn_op(node);
 155         ir_node  *block = get_nodes_block(node);
 156         ir_mode *mode   = config.lowered_mode;
 157         ir_node  *res;
 158
 159         assert(get_irn_mode(node) == mode_b);
 160
 161         res = get_irn_link(node);
 162         if(res != NULL)
 163                 return res;
 164
 165         /* TODO: be robust against phi-loops... */
 166         if(op == op_Phi) {
 167                 int       i, arity;
 168                 ir_node **in;
 169                 ir_node  *unknown, *new_phi;
 170
 171                 arity = get_irn_arity(node);
 172                 in    = alloca(arity * sizeof(in[0]));
 173                 unknown = new_Unknown(config.lowered_mode);
 174                 for(i = 0; i < arity; ++i) {
 175                         in[i] = unknown;
 176                 }
 177                 new_phi = new_r_Phi(irg, block, arity, in, config.lowered_mode);
 178                 set_irn_link(node, new_phi);
 179                 pdeq_putr(lowered_nodes, node);
 180
 181                 for(i = 0; i < arity; ++i) {
 182                         ir_node *in     = get_irn_n(node, i);
 183                         ir_node *low_in = lower_node(in);
 184
 185                         set_irn_n(new_phi, i, low_in);
 186                 }
 187
 188                 return new_phi;
 189         }
 190
 191         if(op == op_And || op == op_Or || op == op_Eor) {
 192                 int i, arity;
 193                 ir_node *copy = exact_copy(node);
 194
 195                 arity = get_irn_arity(node);
 196                 for(i = 0; i < arity; ++i) {
 197                         ir_node *in     = get_irn_n(node, i);
 198                         ir_node *low_in = lower_node(in);
 199
 200                         set_irn_n(copy, i, low_in);
 201                 }
 202                 set_irn_mode(copy, config.lowered_mode);
 203
 204                 set_irn_link(node, copy);
 205                 pdeq_putr(lowered_nodes, node);
 206                 return copy;
 207         }
 208         if(op == op_Not) {
 209                 ir_node *op     = get_Not_op(node);
 210                 ir_node *low_op = lower_node(op);
 211
 212                 res = create_not(dbgi, low_op);
 213                 set_irn_link(node, res);
 214                 pdeq_putr(lowered_nodes, node);
 215                 return res;
 216         }
 217         if(op == op_Psi) {
 218                 ir_node *cond        = get_Psi_cond(node, 0);
 219                 ir_node *low_cond    = lower_node(cond);
 220                 ir_node *v_true      = get_Psi_val(node, 0);
 221                 ir_node *low_v_true  = lower_node(v_true);
 222                 ir_node *v_false     = get_Psi_default(node);
 223                 ir_node *low_v_false = lower_node(v_false);
 224
 225                 ir_node *and0     = new_rd_And(dbgi, irg, block, low_cond, low_v_true,
 226                                                mode);
 227
 228                 ir_node *not_cond = create_not(dbgi, low_cond);
 229
 230                 ir_node *and1     = new_rd_And(dbgi, irg, block, not_cond, low_v_false,
 231                                                mode);
 232
 233                 ir_node *or       = new_rd_Or(dbgi, irg, block, and0, and1,
 234                                               mode);
 235
 236                 set_irn_link(node, or);
 237                 pdeq_putr(lowered_nodes, node);
 238                 return or;
 239         }
 240         if(op == op_Conv) {
 241                 ir_node *pred     = get_Conv_op(node);
 242                 ir_mode *mode     = get_irn_mode(pred);
 243                 tarval  *tv_zeroc = get_tarval_null(mode);
 244                 ir_node *zero_cmp = new_d_Const(dbgi, mode, tv_zeroc);
 245                 ir_node *set;
 246
 247                 ir_node *cmp      = new_rd_Cmp(dbgi, irg, block, pred, zero_cmp);
 248                 ir_node *proj     = new_rd_Proj(dbgi, irg, block, cmp, mode_b,
 249                                                 pn_Cmp_Lg);
 250                 set = create_set(proj);
 251
 252                 set_irn_link(node, set);
 253                 pdeq_putr(lowered_nodes, node);
 254                 return set;
 255         }
 256         if(op == op_Proj) {
 257                 ir_node *pred = get_Proj_pred(node);
 258
 259                 if(is_Cmp(pred)) {
 260                         ir_node *left  = get_Cmp_left(pred);
 261                         ir_node *right = get_Cmp_right(pred);
 262                         ir_mode *cmp_mode  = get_irn_mode(left);
 263                         ir_node *set;
 264
 265                         if ((mode_is_int(cmp_mode) || mode_is_reference(cmp_mode)) && (
 266                                                 get_mode_size_bits(cmp_mode) < get_mode_size_bits(mode) ||
 267                                                 (mode_is_signed(cmp_mode) && is_Const(right) && is_Const_null(right))
 268                                         )) {
 269                                 int      pnc      = get_Proj_proj(node);
 270                                 int      need_not = 0;
 271                                 ir_node *a        = NULL;
 272                                 ir_node *b        = NULL;
 273
 274                                 if(pnc == pn_Cmp_Lt) {
 275                                         /* a < b  ->  (a - b) >> 31 */
 276                                         a = left;
 277                                         b = right;
 278                                 } else if(pnc == pn_Cmp_Le) {
 279                                         /* a <= b  -> ~(a - b) >> 31 */
 280                                         a        = right;
 281                                         b        = left;
 282                                         need_not = 1;
 283                                 } else if(pnc == pn_Cmp_Gt) {
 284                                         /* a > b   -> (b - a) >> 31 */
 285                                         a = right;
 286                                         b = left;
 287                                 } else if(pnc == pn_Cmp_Ge) {
 288                                         /* a >= b   -> ~(a - b) >> 31 */
 289                                         a        = left;
 290                                         b        = right;
 291                                         need_not = 1;
 292                                 }
 293
 294                                 if(a != NULL) {
 295                                         int      bits      = get_mode_size_bits(mode);
 296                                         tarval  *tv        = new_tarval_from_long(bits-1, mode_Iu);
 297                                         ir_node *shift_cnt = new_d_Const(dbgi, mode_Iu, tv);
 298
 299                                         if(cmp_mode != mode) {
 300                                                 a = new_rd_Conv(dbgi, irg, block, a, mode);
 301                                                 b = new_rd_Conv(dbgi, irg, block, b, mode);
 302                                         }
 303
 304                                         res = new_rd_Sub(dbgi, irg, block, a, b, mode);
 305                                         if(need_not) {
 306                                                 res = new_rd_Not(dbgi, irg, block, res, mode);
 307                                         }
 308                                         res = new_rd_Shr(dbgi, irg, block, res, shift_cnt, mode);
 309
 310                                         set_irn_link(node, res);
 311                                         pdeq_putr(lowered_nodes, node);
 312                                         return res;
 313                                 }
 314                         }
 315
 316                         /* synthesize the 0/1 value */
 317                         set = create_set(node);
 318                         set_irn_link(node, set);
 319                         pdeq_putr(lowered_nodes, node);
 320                         return set;
 321                 } else if(is_Proj(pred) && is_Call(get_Proj_pred(pred))) {
 322                         ir_type   *type   = get_Call_type(get_Proj_pred(pred));
 323                         adjust_method_type(type);
 324                         set_irn_mode(node, mode);
 325                         return node;
 326                 } else if(is_Proj(pred) && is_Start(get_Proj_pred(pred))) {
 327                         ir_entity *entity = get_irg_entity(irg);
 328                         ir_type   *type   = get_entity_type(entity);
 329                         adjust_method_type(type);
 330                         set_irn_mode(node, mode);
 331                         return node;
 332                 }
 333
 334                 panic("unexpected projb: %+F (pred: %+F)", node, pred);
 335         }
 336         if(op == op_Const) {
 337                 tarval *tv = get_Const_tarval(node);
 338                 if(tv == get_tarval_b_true()) {
 339                         tarval  *tv_one  = get_tarval_one(mode);
 340                         res              = new_d_Const(dbgi, mode, tv_one);
 341                 } else if(tv == get_tarval_b_false()) {
 342                         tarval  *tv_zero = get_tarval_null(mode);
 343                         res              = new_d_Const(dbgi, mode, tv_zero);
 344                 } else {
 345                         panic("invalid boolean const %+F", node);
 346                 }
 347                 set_irn_link(node, res);
 348                 pdeq_putr(lowered_nodes, node);
 349                 return res;
 350         }
 351         if (op == op_Unknown) {
 352                 return new_Unknown(config.lowered_mode);
 353         }
 354
 355         panic("didn't expect %+F to have mode_b", node);
 356 }
 357
 358 static void lower_mode_b_walker(ir_node *node, void *env)
 359 {
 360         int i, arity;
 361         int changed = 0;
 362         (void) env;
 363
 364         arity = get_irn_arity(node);
 365         for(i = 0; i < arity; ++i) {
 366                 ir_node *lowered_in;
 367                 ir_node *in = get_irn_n(node, i);
 368                 if(get_irn_mode(in) != mode_b)
 369                         continue;
 370
 371                 if(! config.lower_direct_cmp) {
 372                         if(is_Cond(node)
 373                                         || (is_Psi(node) && get_irn_mode(node) != mode_b)) {
 374                                 if(is_Proj(in)) {
 375                                         ir_node *pred = get_Proj_pred(in);
 376                                         if(is_Cmp(pred))
 377                                                 continue;
 378                                 }
 379                         }
 380                 }
 381
 382                 lowered_in = lower_node(in);
 383
 384                 if(is_Return(node)) {
 385                         ir_entity *entity = get_irg_entity(current_ir_graph);
 386                         ir_type   *type   = get_entity_type(entity);
 387                         adjust_method_type(type);
 388                 } else if(is_Call(node)) {
 389                         ir_type *type = get_Call_type(node);
 390                         adjust_method_type(type);
 391                 } else {
 392                         lowered_in = create_convb(lowered_in);
 393                 }
 394                 set_irn_n(node, i, lowered_in);
 395                 changed = 1;
 396         }
 397         if(changed) {
 398                 add_identities(current_ir_graph->value_table, node);
 399         }
 400 }
 401
 402 static void clear_links(ir_node *node, void *env)
 403 {
 404         (void) env;
 405         set_irn_link(node, NULL);
 406 }
 407
 408 void ir_lower_mode_b(ir_graph *irg, const lower_mode_b_config_t *nconfig)
 409 {
 410         config        = *nconfig;
 411         lowered_nodes = new_pdeq();
 412         set_using_irn_link(irg);
 413
 414         irg_walk_graph(irg, clear_links, NULL, NULL);
 415         irg_walk_graph(irg, lower_mode_b_walker, NULL, NULL);
 416
 417         while(!pdeq_empty(lowered_nodes)) {
 418                 ir_node *node = (ir_node*) pdeq_getr(lowered_nodes);
 419                 maybe_kill_node(node);
 420         }
 421         del_pdeq(lowered_nodes);
 422
 423         clear_using_irn_link(irg);
 424 }