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