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
  22  * @brief       lowers operations with mode_b. The result is a graph which
  23  *              might still contains some convs from/to mode_b, but no
  24  *              operations are performed on them anymore, they are just there
  25  *              so modes match. A backend can safely skip all mode_b convs.
  26  * @author      Matthias Braun, Christoph Mallon
  27  * @version     $Id$
  28  *
  29  * After this pass the following should hold:
  30  *   - The only inputs with mode_b are for the Cond node or the
  31  *     Sel input of a Mux node.
  32  *   - The only nodes producing mode_b are: Proj(Cmp) and ConvB(X) (where X
  33  *     is some mode that can be converted to the lowered mode).
  34  *     ConvB will usually be implemented by a comparison with 0 producing some
  35  *     flags in the backends. It's debatable wether ConvB(X) is a goode idea.
  36  *     Maybe we should rather introduce a Test node.
  37  * All other former uses should be converted to manipulations with an integer
  38  * mode that was specified in the pass configuration.
  39  */
  40 #include "config.h"
  41
  42 #include <stdlib.h>
  43 #include <stdbool.h>
  44
  45 #include "irnode_t.h"
  46 #include "ircons_t.h"
  47 #include "irflag.h"
  48 #include "irgwalk.h"
  49 #include "irtools.h"
  50 #include "iredges.h"
  51 #include "iropt_t.h"
  52 #include "irgmod.h"
  53 #include "tv.h"
  54 #include "error.h"
  55 #include "lowering.h"
  56 #include "pdeq.h"
  57 #include "irpass_t.h"
  58 #include "util.h"
  59 #include "array.h"
  60
  61 static const lower_mode_b_config_t *config;
  62 static ir_type                     *lowered_type;
  63 static ir_node                    **lowered_nodes;
  64 static ir_node                    **check_later;
  65
  66 /**
  67  * Removes a node if its out-edge count has reached 0.
  68  * temporary hack until we have proper automatic dead code elimination.
  69  */
  70 static void maybe_kill_node(ir_node *node)
  71 {
  72         ir_graph *irg;
  73         int       i, arity;
  74
  75         if (get_irn_n_edges(node) != 0)
  76                 return;
  77
  78         irg = get_irn_irg(node);
  79
  80         assert(!is_Bad(node));
  81
  82         arity = get_irn_arity(node);
  83         for (i = 0; i < arity; ++i) {
  84                 set_irn_n(node, i, new_r_Bad(irg));
  85         }
  86         set_nodes_block(node, new_r_Bad(irg));
  87
  88         edges_node_deleted(node, irg);
  89 }
  90
  91 static ir_node *create_not(dbg_info *dbgi, ir_node *node)
  92 {
  93         ir_node  *block  = get_nodes_block(node);
  94         ir_mode  *mode   = config->lowered_mode;
  95         tarval   *tv_one = get_mode_one(mode);
  96         ir_graph *irg    = get_irn_irg(node);
  97         ir_node  *one    = new_rd_Const(dbgi, irg, tv_one);
  98
  99         return new_rd_Eor(dbgi, block, node, one, mode);
 100 }
 101
 102 static ir_node *create_convb(ir_node *node)
 103 {
 104         ir_node  *block = get_nodes_block(node);
 105         ir_node  *conv  = new_rd_Conv(NULL, block, node, mode_b);
 106
 107         return conv;
 108 }
 109
 110 static ir_type *create_lowered_type(void)
 111 {
 112         if (lowered_type == NULL) {
 113                 lowered_type = new_type_primitive(config->lowered_mode);
 114         }
 115         return lowered_type;
 116 }
 117
 118 ir_node *ir_create_mux_set(ir_node *cond, ir_mode *dest_mode)
 119 {
 120         ir_graph *irg     = get_irn_irg(cond);
 121         ir_node  *block   = get_nodes_block(cond);
 122         tarval   *tv_one  = get_mode_one(dest_mode);
 123         ir_node  *one     = new_r_Const(irg, tv_one);
 124         tarval   *tv_zero = get_mode_null(dest_mode);
 125         ir_node  *zero    = new_r_Const(irg, tv_zero);
 126         ir_node  *set     = new_r_Mux(block, cond, zero, one, dest_mode);
 127         return set;
 128 }
 129
 130 ir_node *ir_create_cond_set(ir_node *cond_value, ir_mode *dest_mode)
 131 {
 132         ir_node  *lower_block = part_block_edges(cond_value);
 133         ir_node  *upper_block = get_nodes_block(cond_value);
 134         ir_graph *irg         = get_irn_irg(cond_value);
 135         ir_node  *cond        = new_r_Cond(upper_block, cond_value);
 136         ir_node  *proj_true   = new_r_Proj(cond, mode_X, pn_Cond_true);
 137         ir_node  *proj_false  = new_r_Proj(cond, mode_X, pn_Cond_false);
 138         ir_node  *in_true[1]  = { proj_true };
 139         ir_node  *in_false[1] = { proj_false };
 140         ir_node  *true_block  = new_r_Block(irg, ARRAY_SIZE(in_true), in_true);
 141         ir_node  *false_block = new_r_Block(irg, ARRAY_SIZE(in_false),in_false);
 142         ir_node  *true_jmp    = new_r_Jmp(true_block);
 143         ir_node  *false_jmp   = new_r_Jmp(false_block);
 144         ir_node  *lower_in[2] = { true_jmp, false_jmp };
 145         ir_node  *one         = new_r_Const(irg, get_mode_one(dest_mode));
 146         ir_node  *zero        = new_r_Const(irg, get_mode_null(dest_mode));
 147         ir_node  *phi_in[2]   = { one, zero };
 148         ir_node  *phi;
 149
 150         set_irn_in(lower_block, ARRAY_SIZE(lower_in), lower_in);
 151         phi = new_r_Phi(lower_block, ARRAY_SIZE(phi_in), phi_in, dest_mode);
 152         assert(get_Block_phis(lower_block) == NULL);
 153         set_Block_phis(lower_block, phi);
 154         set_Phi_next(phi, NULL);
 155
 156         /* make sure we do visit the cond_value later... */
 157         ARR_APP1(ir_node*, check_later, cond_value);
 158
 159         return phi;
 160 }
 161
 162 static void adjust_method_type(ir_type *method_type)
 163 {
 164         int i;
 165         int n_params;
 166         int n_res;
 167
 168         n_params = get_method_n_params(method_type);
 169         for (i = 0; i < n_params; ++i) {
 170                 ir_type *param = get_method_param_type(method_type, i);
 171                 if (get_type_mode(param) == mode_b) {
 172                         set_method_param_type(method_type, i, create_lowered_type());
 173                 }
 174         }
 175
 176         n_res = get_method_n_ress(method_type);
 177         for (i = 0; i < n_res; ++i) {
 178                 ir_type *res_type = get_method_res_type(method_type, i);
 179                 if (get_type_mode(res_type) == mode_b) {
 180                         set_method_res_type(method_type, i, create_lowered_type());
 181                 }
 182         }
 183 }
 184
 185 static ir_node *lower_node(ir_node *node)
 186 {
 187         dbg_info *dbgi  = get_irn_dbg_info(node);
 188         ir_node  *block = get_nodes_block(node);
 189         ir_mode  *mode  = config->lowered_mode;
 190         ir_graph *irg;
 191         ir_node  *res;
 192
 193         res = get_irn_link(node);
 194         if (res != NULL)
 195                 return res;
 196
 197         assert(get_irn_mode(node) == mode_b);
 198
 199         irg = get_irn_irg(node);
 200         switch (get_irn_opcode(node)) {
 201         case iro_Phi: {
 202                 int       i, arity;
 203                 ir_node **in;
 204                 ir_node  *dummy;
 205                 ir_node  *new_phi;
 206
 207                 arity = get_irn_arity(node);
 208                 in    = ALLOCAN(ir_node*, arity);
 209                 dummy = new_r_Dummy(irg, mode);
 210                 for (i = 0; i < arity; ++i) {
 211                         in[i] = dummy;
 212                 }
 213                 new_phi = new_r_Phi(block, arity, in, mode);
 214                 /* FIXME This does not correctly break cycles: The Phi might not be the
 215                  * first in the recursion, so the caller(s) are some yet un-lowered
 216                  * nodes and this Phi might have them (indirectly) as operands, so they
 217                  * would be replaced twice. */
 218                 set_irn_link(node, new_phi);
 219                 ARR_APP1(ir_node*, lowered_nodes, node);
 220
 221                 for (i = 0; i < arity; ++i) {
 222                         ir_node *in     = get_irn_n(node, i);
 223                         ir_node *low_in = lower_node(in);
 224
 225                         set_irn_n(new_phi, i, low_in);
 226                 }
 227
 228                 return new_phi;
 229         }
 230
 231         case iro_And: {
 232                 ir_node *lowered_left  = lower_node(get_And_left(node));
 233                 ir_node *lowered_right = lower_node(get_And_right(node));
 234                 res = new_rd_And(dbgi, block, lowered_left, lowered_right, mode);
 235                 break;
 236         }
 237         case iro_Or: {
 238                 ir_node *lowered_left  = lower_node(get_Or_left(node));
 239                 ir_node *lowered_right = lower_node(get_Or_right(node));
 240                 res = new_rd_Or(dbgi, block, lowered_left, lowered_right, mode);
 241                 break;
 242         }
 243         case iro_Eor: {
 244                 ir_node *lowered_left  = lower_node(get_Eor_left(node));
 245                 ir_node *lowered_right = lower_node(get_Eor_right(node));
 246                 res = new_rd_Eor(dbgi, block, lowered_left, lowered_right, mode);
 247                 break;
 248         }
 249
 250         case iro_Not: {
 251                 ir_node *op     = get_Not_op(node);
 252                 ir_node *low_op = lower_node(op);
 253
 254                 res = create_not(dbgi, low_op);
 255                 break;
 256         }
 257
 258         case iro_Mux: {
 259                 ir_node *cond        = get_Mux_sel(node);
 260                 ir_node *low_cond    = lower_node(cond);
 261                 ir_node *v_true      = get_Mux_true(node);
 262                 ir_node *low_v_true  = lower_node(v_true);
 263                 ir_node *v_false     = get_Mux_false(node);
 264                 ir_node *low_v_false = lower_node(v_false);
 265
 266                 ir_node *and0     = new_rd_And(dbgi, block, low_cond, low_v_true, mode);
 267                 ir_node *not_cond = create_not(dbgi, low_cond);
 268                 ir_node *and1     = new_rd_And(dbgi, block, not_cond, low_v_false, mode);
 269                 res = new_rd_Or(dbgi, block, and0, and1, mode);
 270                 break;
 271         }
 272
 273         case iro_Conv: {
 274                 ir_node *pred     = get_Conv_op(node);
 275                 ir_mode *mode     = get_irn_mode(pred);
 276                 tarval  *tv_zeroc = get_mode_null(mode);
 277                 ir_node *zero_cmp = new_rd_Const(dbgi, irg, tv_zeroc);
 278
 279                 ir_node *cmp      = new_rd_Cmp(dbgi, block, pred, zero_cmp);
 280                 ir_node *proj     = new_rd_Proj(dbgi, cmp, mode_b, pn_Cmp_Lg);
 281                 res = config->create_set(proj);
 282                 break;
 283         }
 284
 285         case iro_Proj: {
 286                 ir_node *pred = get_Proj_pred(node);
 287
 288                 if (is_Cmp(pred)) {
 289                         ir_node *left  = get_Cmp_left(pred);
 290                         ir_node *right = get_Cmp_right(pred);
 291                         ir_mode *cmp_mode  = get_irn_mode(left);
 292
 293                         if ((mode_is_int(cmp_mode) || mode_is_reference(cmp_mode)) &&
 294                             (get_mode_size_bits(cmp_mode) < get_mode_size_bits(mode) ||
 295                             (mode_is_signed(cmp_mode) && is_Const(right) && is_Const_null(right)))) {
 296                                 int      pnc      = get_Proj_proj(node);
 297                                 int      need_not = 0;
 298                                 ir_node *a        = NULL;
 299                                 ir_node *b        = NULL;
 300                                 int      bits;
 301                                 tarval  *tv;
 302                                 ir_node *shift_cnt;
 303
 304                                 if (pnc == pn_Cmp_Lt) {
 305                                         /* a < b  ->  (a - b) >> 31 */
 306                                         a = left;
 307                                         b = right;
 308                                 } else if (pnc == pn_Cmp_Le) {
 309                                         /* a <= b  -> ~(a - b) >> 31 */
 310                                         a        = right;
 311                                         b        = left;
 312                                         need_not = 1;
 313                                 } else if (pnc == pn_Cmp_Gt) {
 314                                         /* a > b   -> (b - a) >> 31 */
 315                                         a = right;
 316                                         b = left;
 317                                 } else if (pnc == pn_Cmp_Ge) {
 318                                         /* a >= b   -> ~(a - b) >> 31 */
 319                                         a        = left;
 320                                         b        = right;
 321                                         need_not = 1;
 322                                 } else {
 323                                         goto synth_zero_one;
 324                                 }
 325
 326                                 bits      = get_mode_size_bits(mode);
 327                                 tv        = new_tarval_from_long(bits-1, mode_Iu);
 328                                 shift_cnt = new_rd_Const(dbgi, irg, tv);
 329
 330                                 if (cmp_mode != mode) {
 331                                         a = new_rd_Conv(dbgi, block, a, mode);
 332                                         b = new_rd_Conv(dbgi, block, b, mode);
 333                                 }
 334
 335                                 res = new_rd_Sub(dbgi, block, a, b, mode);
 336                                 if (need_not) {
 337                                         res = new_rd_Not(dbgi, block, res, mode);
 338                                 }
 339                                 res = new_rd_Shr(dbgi, block, res, shift_cnt, mode);
 340                         } else {
 341                                 /* synthesize the 0/1 value */
 342 synth_zero_one:
 343                                 res = config->create_set(node);
 344                         }
 345                 } else if (is_Proj(pred) && is_Call(get_Proj_pred(pred))) {
 346                         ir_type *type = get_Call_type(get_Proj_pred(pred));
 347                         adjust_method_type(type);
 348                         set_irn_mode(node, mode);
 349                         res = node;
 350                         goto own_replacement;
 351                 } else if (is_Proj(pred) && is_Start(get_Proj_pred(pred))) {
 352                         ir_graph  *irg    = get_irn_irg(node);
 353                         ir_entity *entity = get_irg_entity(irg);
 354                         ir_type   *type   = get_entity_type(entity);
 355                         adjust_method_type(type);
 356                         set_irn_mode(node, mode);
 357                         res = node;
 358                         goto own_replacement;
 359                 } else {
 360                         panic("unexpected projb: %+F (pred: %+F)", node, pred);
 361                 }
 362                 break;
 363         }
 364
 365         case iro_Const: {
 366                 tarval *tv = get_Const_tarval(node);
 367                 if (tv == get_tarval_b_true()) {
 368                         tarval *tv_one = get_mode_one(mode);
 369                         res            = new_rd_Const(dbgi, irg, tv_one);
 370                 } else if (tv == get_tarval_b_false()) {
 371                         tarval *tv_zero = get_mode_null(mode);
 372                         res             = new_rd_Const(dbgi, irg, tv_zero);
 373                 } else {
 374                         panic("invalid boolean const %+F", node);
 375                 }
 376                 break;
 377         }
 378
 379         case iro_Unknown:
 380                 res = new_r_Unknown(irg, mode);
 381                 break;
 382
 383         default:
 384                 panic("didn't expect %+F to have mode_b", node);
 385         }
 386
 387         ARR_APP1(ir_node*, lowered_nodes, node);
 388 own_replacement:
 389         set_irn_link(node, res);
 390         return res;
 391 }
 392
 393 static void lower_mode_b_walker(ir_node *node, void *env)
 394 {
 395         int i, arity;
 396         bool changed = false;
 397
 398         arity = get_irn_arity(node);
 399         for (i = 0; i < arity; ++i) {
 400                 ir_node *lowered_in;
 401                 ir_node *in = get_irn_n(node, i);
 402                 if (get_irn_mode(in) != mode_b)
 403                         continue;
 404
 405                 if (! config->lower_direct_cmp) {
 406                         /* Proj(Cmp) as input for Cond and Mux nodes needs no changes.
 407                            (Mux with mode_b is an exception as it gets replaced by and/or
 408                             anyway so we still lower the inputs then) */
 409                         if (is_Cond(node) ||
 410                             (is_Mux(node) && get_irn_mode(node) != mode_b)) {
 411                                 if (is_Proj(in)) {
 412                                         ir_node *pred = get_Proj_pred(in);
 413                                         if (is_Cmp(pred))
 414                                                 continue;
 415                                 }
 416                         }
 417                 }
 418
 419                 lowered_in = lower_node(in);
 420
 421                 if (is_Call(node)) {
 422                         ir_type *type = get_Call_type(node);
 423                         adjust_method_type(type);
 424                 } else if (is_Cond(node) || (is_Mux(node) && i == 0)) {
 425                         lowered_in = create_convb(lowered_in);
 426                 }
 427                 set_irn_n(node, i, lowered_in);
 428                 changed = true;
 429         }
 430         if (changed) {
 431                 bool *global_changed = env;
 432                 *global_changed = true;
 433                 add_identities(node);
 434         }
 435 }
 436
 437 void ir_lower_mode_b(ir_graph *irg, const lower_mode_b_config_t *nconfig)
 438 {
 439         ir_entity *entity  = get_irg_entity(irg);
 440         ir_type   *type    = get_entity_type(entity);
 441         bool       changed = false;
 442         int        i;
 443         int        n;
 444
 445         config        = nconfig;
 446         lowered_nodes = NEW_ARR_F(ir_node*, 0);
 447         check_later   = NEW_ARR_F(ir_node*, 0);
 448         lowered_type  = NULL;
 449
 450         edges_assure(irg);
 451
 452         /* ensure no optimisation touches muxes anymore */
 453         set_irg_state(irg, IR_GRAPH_STATE_KEEP_MUX | IR_GRAPH_STATE_BCONV_ALLOWED);
 454
 455         ir_reserve_resources(irg, IR_RESOURCE_IRN_LINK);
 456
 457         adjust_method_type(type);
 458
 459         irg_walk_graph(irg, firm_clear_link, NULL, NULL);
 460         irg_walk_graph(irg, lower_mode_b_walker, NULL, &changed);
 461
 462         for (i = 0; i < ARR_LEN(check_later); ++i) {
 463                 ir_node *node = check_later[i];
 464                 irg_walk_core(node, lower_mode_b_walker, NULL, &changed);
 465         }
 466
 467         n = ARR_LEN(lowered_nodes);
 468         for (i = 0; i < n; ++i) {
 469                 ir_node *node = lowered_nodes[i];
 470                 maybe_kill_node(node);
 471         }
 472         DEL_ARR_F(check_later);
 473         DEL_ARR_F(lowered_nodes);
 474
 475         ir_free_resources(irg, IR_RESOURCE_IRN_LINK);
 476
 477         if (changed) {
 478                 set_irg_outs_inconsistent(irg);
 479         }
 480 }