nsz Git - libfirm/blob - ir/arch/archop.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  * @brief     architecture dependand IR operations
  23  * @version   $Id$
  24  */
  25 #ifdef HAVE_CONFIG_H
  26 #include "config.h"
  27 #endif
  28
  29 #ifdef HAVE_STRING_H
  30 #include <string.h>
  31 #endif
  32
  33 #include "irprog_t.h"
  34 #include "irgraph_t.h"
  35 #include "irnode_t.h"
  36 #include "irmode_t.h"
  37 #include "ircons_t.h"
  38 #include "iropt_t.h"
  39 #include "firm_common_t.h"
  40 #include "irvrfy_t.h"
  41 #include "iropt_dbg.h"
  42 #include "archop.h"
  43
  44 /* when we need verifying */
  45 #ifdef NDEBUG
  46 # define IRN_VRFY_IRG(res, irg)
  47 #else
  48 # define IRN_VRFY_IRG(res, irg)  irn_vrfy_irg(res, irg)
  49 #endif
  50
  51 /** current settings */
  52 static arch_ops_info settings;
  53
  54 /** default settings */
  55 static const arch_ops_info default_settings = {
  56   ARCH_OPS_NONE,
  57   0
  58 };
  59
  60 /** The Min operation */
  61 ir_op *op_Min = NULL;
  62
  63 /** The Max operation */
  64 ir_op *op_Max = NULL;
  65
  66 ir_op *get_op_Min(void)  { return op_Min; }
  67 ir_op *get_op_Max(void)  { return op_Max; }
  68
  69 /*
  70  * construct a Min: Min(a,b) = a < b ? a : b
  71  */
  72 ir_node *
  73 new_rd_Min(dbg_info *db, ir_graph *irg, ir_node *block,
  74        ir_node *op1, ir_node *op2, ir_mode *mode)
  75 {
  76   ir_node *in[2];
  77   ir_node *res;
  78
  79   if (! op_Min) {
  80     assert(0);
  81     return NULL;
  82   }
  83
  84   in[0] = op1;
  85   in[1] = op2;
  86   res = new_ir_node(db, irg, block, op_Min, mode, 2, in);
  87   res = optimize_node(res);
  88   IRN_VRFY_IRG(res, irg);
  89   return res;
  90 }
  91
  92 /*
  93  * construct a Max: Max(a,b) = a > b ? a : b
  94  */
  95 ir_node *
  96 new_rd_Max(dbg_info *db, ir_graph *irg, ir_node *block,
  97        ir_node *op1, ir_node *op2, ir_mode *mode)
  98 {
  99   ir_node *in[2];
 100   ir_node *res;
 101
 102   if (! op_Max) {
 103     assert(0);
 104     return NULL;
 105   }
 106
 107   in[0] = op1;
 108   in[1] = op2;
 109   res = new_ir_node(db, irg, block, op_Max, mode, 2, in);
 110   res = optimize_node(res);
 111   IRN_VRFY_IRG(res, irg);
 112   return res;
 113 }
 114
 115 ir_node *
 116 new_r_Min(ir_graph *irg, ir_node *block,
 117        ir_node *op1, ir_node *op2, ir_mode *mode) {
 118   return new_rd_Min(NULL, irg, block, op1, op2, mode);
 119 }
 120
 121 ir_node *
 122 new_r_Max(ir_graph *irg, ir_node *block,
 123        ir_node *op1, ir_node *op2, ir_mode *mode) {
 124   return new_rd_Max(NULL, irg, block, op1, op2, mode);
 125 }
 126
 127 ir_node *
 128 new_d_Min(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) {
 129   return new_rd_Min(db, current_ir_graph, current_ir_graph->current_block,
 130                op1, op2, mode);
 131 }
 132
 133 ir_node *
 134 new_d_Max(dbg_info *db, ir_node *op1, ir_node *op2, ir_mode *mode) {
 135   return new_rd_Max(db, current_ir_graph, current_ir_graph->current_block,
 136                op1, op2, mode);
 137 }
 138
 139 ir_node *
 140 new_Min(ir_node *op1, ir_node *op2, ir_mode *mode) {
 141   return new_d_Min(NULL, op1, op2, mode);
 142 }
 143
 144 ir_node *
 145 new_Max(ir_node *op1, ir_node *op2, ir_mode *mode) {
 146   return new_d_Max(NULL, op1, op2, mode);
 147 }
 148
 149 /* optimizations */
 150
 151 /**
 152  * return the value of a Min
 153  */
 154 static tarval *computed_value_Min(ir_node *n)
 155 {
 156   ir_node *a = get_binop_left(n);
 157   ir_node *b = get_binop_right(n);
 158
 159   tarval *ta = value_of(a);
 160   tarval *tb = value_of(b);
 161
 162   if ((ta != tarval_bad) && (tb != tarval_bad) && (get_irn_mode(a) == get_irn_mode(b))) {
 163     pn_Cmp res = tarval_cmp(ta, tb);
 164
 165     /* beware: there might be Unordered tarvals here, in that
 166      * case let the backend decide, do NOT optimize */
 167     if (res == pn_Cmp_Lt)
 168       return ta;
 169     if (res == pn_Cmp_Gt || res == pn_Cmp_Eq)
 170       return tb;
 171   }
 172   return tarval_bad;
 173 }
 174
 175 /**
 176  * return the value of a Max
 177  */
 178 static tarval *computed_value_Max(ir_node *n)
 179 {
 180   ir_node *a = get_binop_left(n);
 181   ir_node *b = get_binop_right(n);
 182
 183   tarval *ta = value_of(a);
 184   tarval *tb = value_of(b);
 185
 186   if ((ta != tarval_bad) && (tb != tarval_bad) && (get_irn_mode(a) == get_irn_mode(b))) {
 187     pn_Cmp res = tarval_cmp(ta, tb);
 188
 189     /* beware: there might be Unordered tarvals here, in that
 190      * case let the backend decide, do NOT optimize */
 191     if (res == pn_Cmp_Gt)
 192       return ta;
 193     if (res == pn_Cmp_Lt || res == pn_Cmp_Eq)
 194       return tb;
 195   }
 196   return tarval_bad;
 197 }
 198
 199 /**
 200  * Returns an equivalent node for a Min/Max node.
 201  * We do not allow Exceptions in our Min/Max, so there will be always
 202  * an result.
 203  * The problem is Min(NaN, NaN) == NaN ???.
 204  */
 205 static ir_node *equivalent_node_MinMax(ir_node *n)
 206 {
 207   ir_node *a, *b;
 208
 209   if (settings.minmax_handle_NaN == 0 && mode_is_float(get_irn_mode(n)))
 210     return n;
 211
 212   a = get_binop_left(n);
 213   b = get_binop_right(n);
 214
 215   if (a == b) {
 216     DBG_OPT_ALGSIM0(n, a, FS_OPT_MIN_MAX_EQ);
 217     return a;
 218   }
 219
 220   return n;
 221 }
 222
 223 #define equivalent_node_Min equivalent_node_MinMax
 224 #define equivalent_node_Max equivalent_node_MinMax
 225
 226 /*
 227  * Create Min and Max from Mux nodes
 228  */
 229 ir_node *arch_transform_node_Mux(ir_node *n)
 230 {
 231   if (settings.enabled_ops & ARCH_OPS_MINMAX) {
 232     ir_node *oldn = n, *cmp, *proj = get_Mux_sel(n);
 233     long proj_nr;
 234
 235     if (get_irn_op(proj) != op_Proj)
 236       return n;
 237
 238     cmp = get_Proj_pred(proj);
 239     if (get_irn_op(cmp) == op_Cmp) {
 240       ir_node *a = get_Cmp_left(cmp);
 241       ir_node *b = get_Cmp_right(cmp);
 242       ir_node *t = get_Mux_true(n);
 243       ir_node *f = get_Mux_false(n);
 244
 245       proj_nr = get_Proj_proj(proj);
 246
 247       if (proj_nr == pn_Cmp_Lt || proj_nr == pn_Cmp_Le) {
 248         if (a == t && b == f) {
 249           /* a </<= b ? a : b  ==>  Min(a,b) */
 250           n = new_rd_Min(get_irn_dbg_info(n),
 251                 current_ir_graph,
 252                 get_nodes_block(n),
 253                 a, b,
 254                 get_irn_mode(n));
 255
 256           DBG_OPT_ALGSIM1(oldn, cmp, proj, n, FS_OPT_MUX_TO_MIN);
 257           return n;
 258         }
 259         else if (a == f && b == t) {
 260           /* a </<= b ? b : a  ==>  Max(a,b) */
 261           n = new_rd_Max(get_irn_dbg_info(n),
 262                 current_ir_graph,
 263                 get_nodes_block(n),
 264                 a, b,
 265                 get_irn_mode(n));
 266
 267           DBG_OPT_ALGSIM1(oldn, cmp, proj, n, FS_OPT_MUX_TO_MAX);
 268           return n;
 269         }
 270       }
 271       else if (proj_nr == pn_Cmp_Gt || proj_nr == pn_Cmp_Ge) {
 272         if (a == t && b == f) {
 273           /* a >/>= b ? a : b  ==>  Max(a,b) */
 274           n = new_rd_Max(get_irn_dbg_info(n),
 275                 current_ir_graph,
 276                 get_nodes_block(n),
 277                 a, b,
 278                 get_irn_mode(n));
 279
 280           DBG_OPT_ALGSIM1(oldn, cmp, proj, n, FS_OPT_MUX_TO_MAX);
 281           return n;
 282         }
 283         else if (a == f && b == t) {
 284           /* a >/>= b ? b : a  ==>  Min(a,b) */
 285           n = new_rd_Min(get_irn_dbg_info(n),
 286                 current_ir_graph,
 287                 get_nodes_block(n),
 288                 a, b,
 289                 get_irn_mode(n));
 290
 291           DBG_OPT_ALGSIM1(oldn, cmp, proj, n, FS_OPT_MUX_TO_MIN);
 292           return n;
 293         }
 294       }
 295     }
 296   }
 297   return n;
 298 }
 299
 300 /**
 301  * verify a MinMax node
 302  */
 303 static int verify_node_MinMax(ir_node *n, ir_graph *irg) {
 304   ir_mode *mymode  = get_irn_mode(n);
 305   ir_mode *op1mode = get_irn_mode(get_binop_left(n));
 306   ir_mode *op2mode = get_irn_mode(get_binop_right(n));
 307   (void) irg;
 308
 309   ASSERT_AND_RET(
 310     /* MinMax: BB x numP x numP --> numP */
 311     op1mode == mymode &&
 312     op2mode == mymode &&
 313     mode_is_numP(mymode),
 314     "Min or Max node", 0
 315   );
 316   return 1;
 317 }
 318
 319 /*
 320  * initialize the ops.
 321  */
 322 void firm_archops_init(const arch_ops_info *info)
 323 {
 324   ir_op_ops ops;
 325
 326   if (! info)
 327     info = &default_settings;
 328
 329   memcpy(&settings, info, sizeof(settings));
 330
 331   if (info->enabled_ops & ARCH_OPS_MINMAX) {
 332     memset(&ops, 0, sizeof(ops));
 333
 334     ops.computed_value  = computed_value_Min;
 335     ops.equivalent_node = equivalent_node_Min;
 336     ops.verify_node     = verify_node_MinMax;
 337
 338     op_Min = new_ir_op(get_next_ir_opcode(), "Min",  op_pin_state_floats, irop_flag_commutative, oparity_binary, 0, 0, &ops);
 339
 340     ops.computed_value  = computed_value_Max;
 341     ops.equivalent_node = equivalent_node_Max;
 342     ops.verify_node     = verify_node_MinMax;
 343
 344     op_Max = new_ir_op(get_next_ir_opcode(), "Max",  op_pin_state_floats, irop_flag_commutative, oparity_binary, 0, 0, &ops);
 345   }
 346 }