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 "tv.h"
  36 #include "error.h"
  37 #include "lowering.h"
  38
  39 static ir_mode *lowered_mode     = NULL;
  40 static int      lower_direct_cmp = 0;
  41
  42 static ir_node *create_not(dbg_info *dbgi, ir_node *node)
  43 {
  44         ir_graph *irg    = current_ir_graph;
  45         ir_node  *block  = get_nodes_block(node);
  46         tarval   *tv_one = get_tarval_one(lowered_mode);
  47         ir_node  *one    = new_d_Const(dbgi, lowered_mode, tv_one);
  48
  49         return new_rd_Eor(dbgi, irg, block, node, one, lowered_mode);
  50 }
  51
  52 static ir_node *lower_node(ir_node *node)
  53 {
  54         ir_graph *irg   = current_ir_graph;
  55         dbg_info *dbgi  = get_irn_dbg_info(node);
  56         ir_op    *op    = get_irn_op(node);
  57         ir_node  *block = get_nodes_block(node);
  58         ir_node  *res;
  59
  60         assert(get_irn_mode(node) == mode_b);
  61
  62         res = get_irn_link(node);
  63         if(res != NULL)
  64                 return res;
  65
  66         /* TODO: be robust against phi-loops... */
  67         if(op == op_Phi) {
  68                 int       i, arity;
  69                 ir_node **in;
  70                 ir_node  *unknown;
  71
  72                 arity = get_irn_arity(node);
  73                 in    = alloca(arity * sizeof(in[0]));
  74                 unknown = new_Unknown(lowered_mode);
  75                 for(i = 0; i < arity; ++i) {
  76                         in[i] = unknown;
  77                 }
  78                 ir_node *new_phi = new_rd_Phi(dbgi, irg, block, arity, in,
  79                                               lowered_mode);
  80                 set_irn_link(node, new_phi);
  81
  82                 for(i = 0; i < arity; ++i) {
  83                         ir_node *in     = get_irn_n(node, i);
  84                         ir_node *low_in = lower_node(in);
  85
  86                         set_irn_n(new_phi, i, low_in);
  87                 }
  88
  89                 return new_phi;
  90         }
  91
  92         if(op == op_And || op == op_Or || op == op_Eor) {
  93                 int i, arity;
  94                 ir_node *copy = exact_copy(node);
  95
  96                 arity = get_irn_arity(node);
  97                 for(i = 0; i < arity; ++i) {
  98                         ir_node *in     = get_irn_n(node, i);
  99                         ir_node *low_in = lower_node(in);
 100
 101                         set_irn_n(copy, i, low_in);
 102                 }
 103                 set_irn_mode(copy, lowered_mode);
 104                 set_irn_link(node, copy);
 105                 return copy;
 106         }
 107         if(op == op_Not) {
 108                 ir_node *op     = get_Not_op(node);
 109                 ir_node *low_op = lower_node(op);
 110
 111                 res = create_not(dbgi, low_op);
 112                 set_irn_link(node, res);
 113                 return res;
 114         }
 115         if(op == op_Psi) {
 116                 ir_node *cond        = get_Psi_cond(node, 0);
 117                 ir_node *low_cond    = lower_node(cond);
 118                 ir_node *v_true      = get_Psi_val(node, 0);
 119                 ir_node *low_v_true  = lower_node(v_true);
 120                 ir_node *v_false     = get_Psi_default(node);
 121                 ir_node *low_v_false = lower_node(v_false);
 122
 123                 ir_node *and0     = new_rd_And(dbgi, irg, block, cond, low_v_true,
 124                                                lowered_mode);
 125
 126                 ir_node *not_cond = create_not(dbgi, low_cond);
 127
 128                 ir_node *and1     = new_rd_And(dbgi, irg, block, not_cond, low_v_false,
 129                                                lowered_mode);
 130
 131                 ir_node *or       = new_rd_Or(dbgi, irg, block, and0, and1,
 132                                               lowered_mode);
 133
 134                 set_irn_link(node, or);
 135                 return or;
 136         }
 137         if(op == op_Conv) {
 138                 tarval  *tv_one   = get_tarval_one(lowered_mode);
 139                 ir_node *one      = new_d_Const(dbgi, lowered_mode, tv_one);
 140                 tarval  *tv_zero  = get_tarval_null(lowered_mode);
 141                 ir_node *zero     = new_d_Const(dbgi, lowered_mode, tv_zero);
 142                 ir_mode *mode     = get_irn_mode(node);
 143                 tarval  *tv_zeroc = get_tarval_null(mode);
 144                 ir_node *zero_cmp = new_d_Const(dbgi, mode, tv_zeroc);
 145
 146                 ir_node *cmp      = new_rd_Cmp(dbgi, irg, block, node, zero_cmp);
 147                 ir_node *proj     = new_rd_Proj(dbgi, irg, block, cmp, mode_b,
 148                                                 pn_Cmp_Lg);
 149                 ir_node *vals[2]  = { one, zero };
 150                 ir_node *psi      = new_rd_Psi(dbgi, irg, block, 1, &proj, vals,
 151                                                lowered_mode);
 152
 153                 set_irn_link(node, psi);
 154                 return psi;
 155         }
 156         if(op == op_Proj) {
 157                 ir_node *pred  = get_Proj_pred(node);
 158
 159                 assert(!is_Load(pred));
 160                 if(is_Cmp(pred)) {
 161                         ir_mode *mode  = get_irn_mode(pred);
 162                         ir_node *left  = get_Cmp_left(pred);
 163                         ir_node *right = get_Cmp_right(pred);
 164
 165                         if(get_mode_size_bits(mode) < get_mode_size_bits(lowered_mode)
 166                                  || classify_Const(right) == CNST_NULL) {
 167                                 int      pnc      = get_Proj_proj(node);
 168                                 ir_node *res      = NULL;
 169                                 int      need_not = 0;
 170                                 ir_node *a        = NULL;
 171                                 ir_node *b        = NULL;
 172
 173                                 if(pnc == pn_Cmp_Lt) {
 174                                         /* a < b  ->  (a - b) >> 31 */
 175                                         a = left;
 176                                         b = right;
 177                                 } else if(pnc == pn_Cmp_Le) {
 178                                         /* a <= b  -> ((a - b) >> 31) ^ 1 */
 179                                         a        = right;
 180                                         b        = left;
 181                                         need_not = 1;
 182                                 } else if(pnc == pn_Cmp_Gt) {
 183                                         /* a > b   -> (b - a) >> 31 */
 184                                         a = right;
 185                                         b = left;
 186                                 } else if(pnc == pn_Cmp_Ge) {
 187                                         /* a >= b   -> ((a - b) >> 31) ^ 1 */
 188                                         a        = left;
 189                                         b        = right;
 190                                         need_not = 1;
 191                                 }
 192
 193                                 if(a != NULL) {
 194                                         tarval  *tv        = new_tarval_from_long(31, mode_Iu);
 195                                         ir_node *shift_cnt = new_d_Const(dbgi, mode_Iu, tv);
 196
 197                                         if(mode != lowered_mode) {
 198                                                 a = new_rd_Conv(dbgi, irg, block, a, lowered_mode);
 199                                                 b = new_rd_Conv(dbgi, irg, block, b, lowered_mode);
 200                                         }
 201
 202                                         res = new_rd_Sub(dbgi, irg, block, a, b, lowered_mode);
 203                                         res = new_rd_Shr(dbgi, irg, block, res, shift_cnt,
 204                                                          lowered_mode);
 205
 206                                         if(need_not) {
 207                                                 res = create_not(dbgi, res);
 208                                         }
 209                                         set_irn_link(node, res);
 210                                         return res;
 211                                 }
 212                         }
 213
 214                         {
 215                         /* synthesize the 0/1 value */
 216                         tarval  *tv_one  = get_tarval_one(lowered_mode);
 217                         ir_node *one     = new_d_Const(dbgi, lowered_mode, tv_one);
 218                         tarval  *tv_zero = get_tarval_null(lowered_mode);
 219                         ir_node *zero    = new_d_Const(dbgi, lowered_mode, tv_zero);
 220
 221                         ir_node *vals[2] = { one, zero };
 222                         ir_node *psi     = new_rd_Psi(dbgi, irg, block, 1, &node, vals,
 223                                                       lowered_mode);
 224
 225                         set_irn_link(node, psi);
 226                         return psi;
 227                         }
 228                 }
 229
 230                 panic("unexpected projb: %+F (pred: %+F)", node, pred);
 231         }
 232         if(op == op_Const) {
 233                 tarval *tv = get_Const_tarval(node);
 234                 if(tv == get_tarval_b_true()) {
 235                         tarval  *tv_one  = get_tarval_one(lowered_mode);
 236                         res              = new_d_Const(dbgi, lowered_mode, tv_one);
 237                 } else if(tv == get_tarval_b_false()) {
 238                         tarval  *tv_zero = get_tarval_null(lowered_mode);
 239                         res              = new_d_Const(dbgi, lowered_mode, tv_zero);
 240                 } else {
 241                         panic("invalid boolean const %+F", node);
 242                 }
 243                 set_irn_link(node, res);
 244                 return res;
 245         }
 246
 247         panic("didn't expect %+F to have mode_b", node);
 248 }
 249
 250 static ir_node *create_convb(ir_node *node)
 251 {
 252         ir_graph *irg   = current_ir_graph;
 253         ir_node  *block = get_nodes_block(node);
 254         ir_node  *conv  = new_rd_Conv(NULL, irg, block, node, mode_b);
 255
 256         return conv;
 257 }
 258
 259 static void lower_mode_b_walker(ir_node *node, void *env)
 260 {
 261         int i, arity;
 262         (void) env;
 263
 264         arity = get_irn_arity(node);
 265         for(i = 0; i < arity; ++i) {
 266                 ir_node *lowered_in;
 267                 ir_node *in = get_irn_n(node, i);
 268                 if(get_irn_mode(in) != mode_b)
 269                         continue;
 270
 271                 if(! lower_direct_cmp) {
 272                         if(is_Cond(node)
 273                                         || (is_Psi(node) && get_irn_mode(node) != mode_b)) {
 274                                 if(is_Proj(in)) {
 275                                         ir_node *pred = get_Proj_pred(in);
 276                                         if(is_Cmp(pred))
 277                                                 continue;
 278                                 }
 279                         }
 280                 }
 281
 282                 lowered_in = lower_node(in);
 283                 lowered_in = create_convb(lowered_in);
 284                 set_irn_n(node, i, lowered_in);
 285         }
 286 }
 287
 288 static void clear_links(ir_node *node, void *env)
 289 {
 290         (void) env;
 291         set_irn_link(node, NULL);
 292 }
 293
 294 void ir_lower_mode_b(ir_graph *irg, ir_mode *mode, int do_lower_direct_cmp)
 295 {
 296         lowered_mode     = mode;
 297         lower_direct_cmp = do_lower_direct_cmp;
 298         set_using_irn_link(irg);
 299         irg_walk_graph(irg, clear_links, lower_mode_b_walker, NULL);
 300         clear_using_irn_link(irg);
 301 }