nsz Git - libfirm/blob - ir/be/ia32/ia32_transform.c

   1 #ifdef HAVE_CONFIG_H
   2 #include "config.h"
   3 #endif
   4
   5 #include "irnode_t.h"
   6 #include "irgraph_t.h"
   7 #include "irmode_t.h"
   8 #include "irgmod.h"
   9 #include "iredges.h"
  10 #include "irvrfy.h"
  11 #include "ircons.h"
  12 #include "dbginfo.h"
  13 #include "iropt_t.h"
  14 #include "debug.h"
  15
  16 #include "../benode_t.h"
  17 #include "bearch_ia32_t.h"
  18
  19 #include "ia32_nodes_attr.h"
  20 #include "../arch/archop.h"     /* we need this for Min and Max nodes */
  21 #include "ia32_transform.h"
  22 #include "ia32_new_nodes.h"
  23 #include "ia32_map_regs.h"
  24
  25 #include "gen_ia32_regalloc_if.h"
  26
  27 #define SFP_SIGN "0x80000000"
  28 #define DFP_SIGN "0x8000000000000000"
  29 #define SFP_ABS  "0x7FFFFFFF"
  30 #define DFP_ABS  "0x7FFFFFFFFFFFFFFF"
  31
  32 #define TP_SFP_SIGN "ia32_sfp_sign"
  33 #define TP_DFP_SIGN "ia32_dfp_sign"
  34 #define TP_SFP_ABS  "ia32_sfp_abs"
  35 #define TP_DFP_ABS  "ia32_dfp_abs"
  36
  37 #define ENT_SFP_SIGN "IA32_SFP_SIGN"
  38 #define ENT_DFP_SIGN "IA32_DFP_SIGN"
  39 #define ENT_SFP_ABS  "IA32_SFP_ABS"
  40 #define ENT_DFP_ABS  "IA32_DFP_ABS"
  41
  42 extern ir_op *get_op_Mulh(void);
  43
  44 typedef ir_node *construct_binop_func(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *base, ir_node *index, \
  45                                                                           ir_node *op1, ir_node *op2, ir_node *mem, ir_mode *mode);
  46
  47 typedef ir_node *construct_unop_func(dbg_info *db, ir_graph *irg, ir_node *block, ir_node *base, ir_node *index, \
  48                                                                          ir_node *op, ir_node *mem, ir_mode *mode);
  49
  50 typedef enum {
  51         ia32_SSIGN, ia32_DSIGN, ia32_SABS, ia32_DABS
  52 } ia32_known_const_t;
  53
  54 /****************************************************************************************************
  55  *                  _        _                        __                           _   _
  56  *                 | |      | |                      / _|                         | | (_)
  57  *  _ __   ___   __| | ___  | |_ _ __ __ _ _ __  ___| |_ ___  _ __ _ __ ___   __ _| |_ _  ___  _ __
  58  * | '_ \ / _ \ / _` |/ _ \ | __| '__/ _` | '_ \/ __|  _/ _ \| '__| '_ ` _ \ / _` | __| |/ _ \| '_ \
  59  * | | | | (_) | (_| |  __/ | |_| | | (_| | | | \__ \ || (_) | |  | | | | | | (_| | |_| | (_) | | | |
  60  * |_| |_|\___/ \__,_|\___|  \__|_|  \__,_|_| |_|___/_| \___/|_|  |_| |_| |_|\__,_|\__|_|\___/|_| |_|
  61  *
  62  ****************************************************************************************************/
  63
  64 struct tv_ent {
  65         entity *ent;
  66         tarval *tv;
  67 };
  68
  69 /* Compares two (entity, tarval) combinations */
  70 static int cmp_tv_ent(const void *a, const void *b, size_t len) {
  71         const struct tv_ent *e1 = a;
  72         const struct tv_ent *e2 = b;
  73
  74         return !(e1->tv == e2->tv);
  75 }
  76
  77 /* Generates an entity for a known FP const (used for FP Neg + Abs) */
  78 static char *gen_fp_known_const(ir_mode *mode, ia32_known_const_t kct) {
  79         static set    *const_set = NULL;
  80         struct tv_ent  key;
  81         struct tv_ent *entry;
  82         char          *tp_name;
  83         char          *ent_name;
  84         char          *cnst_str;
  85         ir_type       *tp;
  86         ir_node       *cnst;
  87         ir_graph      *rem;
  88         entity        *ent;
  89
  90         if (! const_set) {
  91                 const_set = new_set(cmp_tv_ent, 10);
  92         }
  93
  94         switch (kct) {
  95                 case ia32_SSIGN:
  96                         tp_name  = TP_SFP_SIGN;
  97                         ent_name = ENT_SFP_SIGN;
  98                         cnst_str = SFP_SIGN;
  99                         break;
 100                 case ia32_DSIGN:
 101                         tp_name  = TP_DFP_SIGN;
 102                         ent_name = ENT_DFP_SIGN;
 103                         cnst_str = DFP_SIGN;
 104                         break;
 105                 case ia32_SABS:
 106                         tp_name  = TP_SFP_ABS;
 107                         ent_name = ENT_SFP_ABS;
 108                         cnst_str = SFP_ABS;
 109                         break;
 110                 case ia32_DABS:
 111                         tp_name  = TP_DFP_ABS;
 112                         ent_name = ENT_DFP_ABS;
 113                         cnst_str = DFP_ABS;
 114                         break;
 115         }
 116
 117
 118         key.tv  = new_tarval_from_str(cnst_str, strlen(cnst_str), mode);
 119         key.ent = NULL;
 120
 121         entry = set_insert(const_set, &key, sizeof(key), HASH_PTR(key.tv));
 122
 123         if (! entry->ent) {
 124                 tp  = new_type_primitive(new_id_from_str(tp_name), mode);
 125                 ent = new_entity(get_glob_type(), new_id_from_str(ent_name), tp);
 126
 127                 set_entity_ld_ident(ent, get_entity_ident(ent));
 128                 set_entity_visibility(ent, visibility_local);
 129                 set_entity_variability(ent, variability_constant);
 130                 set_entity_allocation(ent, allocation_static);
 131
 132                 /* we create a new entity here: It's initialization must resist on the
 133                     const code irg */
 134                 rem = current_ir_graph;
 135                 current_ir_graph = get_const_code_irg();
 136                 cnst = new_Const(mode, key.tv);
 137                 current_ir_graph = rem;
 138
 139                 set_atomic_ent_value(ent, cnst);
 140
 141                 /* set the entry for hashmap */
 142                 entry->ent = ent;
 143         }
 144
 145         return ent_name;
 146 }
 147
 148
 149 #undef is_cnst
 150 #define is_cnst(op) (is_ia32_Const(op) || is_ia32_fConst(op))
 151
 152 /* determine if one operator is an Imm */
 153 static ir_node *get_immediate_op(ir_node *op1, ir_node *op2) {
 154         if (op1)
 155                 return is_cnst(op1) ? op1 : (is_cnst(op2) ? op2 : NULL);
 156         else return is_cnst(op2) ? op2 : NULL;
 157 }
 158
 159 /* determine if one operator is not an Imm */
 160 static ir_node *get_expr_op(ir_node *op1, ir_node *op2) {
 161         return !is_cnst(op1) ? op1 : (!is_cnst(op2) ? op2 : NULL);
 162 }
 163
 164
 165 /**
 166  * Construct a standard binary operation, set AM and immediate if required.
 167  *
 168  * @param env   The transformation environment
 169  * @param op1   The first operand
 170  * @param op2   The second operand
 171  * @param func  The node constructor function
 172  * @return The constructed ia32 node.
 173  */
 174 static ir_node *gen_binop(ia32_transform_env_t *env, ir_node *op1, ir_node *op2, construct_binop_func *func) {
 175         ir_node           *new_op   = NULL;
 176         ir_mode           *mode     = env->mode;
 177         dbg_info          *dbg      = env->dbg;
 178         ir_graph          *irg      = env->irg;
 179         ir_node           *block    = env->block;
 180         firm_dbg_module_t *mod      = env->mod;
 181         ir_node           *noreg_gp = ia32_new_NoReg_gp(env->cg);
 182         ir_node           *noreg_fp = ia32_new_NoReg_fp(env->cg);
 183         ir_node           *nomem    = new_NoMem();
 184         ir_node           *expr_op, *imm_op;
 185
 186
 187         /* check if it's an operation with immediate */
 188         if (is_op_commutative(get_irn_op(env->irn))) {
 189                 imm_op  = get_immediate_op(op1, op2);
 190                 expr_op = get_expr_op(op1, op2);
 191         }
 192         else {
 193                 imm_op  = get_immediate_op(NULL, op2);
 194                 expr_op = get_expr_op(op1, op2);
 195         }
 196
 197         assert((expr_op || imm_op) && "invalid operands");
 198
 199         if (!expr_op) {
 200                 /* We have two consts here: not yet supported */
 201                 imm_op = NULL;
 202         }
 203
 204         if (mode_is_float(mode)) {
 205                 /* floating point operations */
 206                 if (imm_op) {
 207                         new_op = func(dbg, irg, block, noreg_gp, noreg_gp, expr_op, noreg_fp, nomem, mode_T);
 208                         set_ia32_Immop_attr(new_op, imm_op);
 209                         set_ia32_am_support(new_op, ia32_am_None);
 210                 }
 211                 else {
 212                         new_op = func(dbg, irg, block, noreg_gp, noreg_gp, op1, op2, nomem, mode_T);
 213                         set_ia32_am_support(new_op, ia32_am_Source);
 214                 }
 215         }
 216         else {
 217                 /* integer operations */
 218                 if (imm_op) {
 219                         /* This is expr + const */
 220                         new_op = func(dbg, irg, block, noreg_gp, noreg_gp, expr_op, noreg_gp, nomem, mode_T);
 221                         set_ia32_Immop_attr(new_op, imm_op);
 222
 223                         /* set AM support */
 224                         set_ia32_am_support(new_op, ia32_am_Dest);
 225                 }
 226                 else {
 227                         /* This is a normal operation */
 228                         new_op = func(dbg, irg, block, noreg_gp, noreg_gp, op1, op2, nomem, mode_T);
 229
 230                         /* set AM support */
 231                         set_ia32_am_support(new_op, ia32_am_Full);
 232                 }
 233         }
 234
 235         return new_rd_Proj(dbg, irg, block, new_op, mode, 0);
 236 }
 237
 238
 239
 240 /**
 241  * Construct a shift/rotate binary operation, sets AM and immediate if required.
 242  *
 243  * @param env   The transformation environment
 244  * @param op1   The first operand
 245  * @param op2   The second operand
 246  * @param func  The node constructor function
 247  * @return The constructed ia32 node.
 248  */
 249 static ir_node *gen_shift_binop(ia32_transform_env_t *env, ir_node *op1, ir_node *op2, construct_binop_func *func) {
 250         ir_node           *new_op = NULL;
 251         ir_mode           *mode   = env->mode;
 252         dbg_info          *dbg    = env->dbg;
 253         ir_graph          *irg    = env->irg;
 254         ir_node           *block  = env->block;
 255         firm_dbg_module_t *mod    = env->mod;
 256         ir_node           *noreg  = ia32_new_NoReg_gp(env->cg);
 257         ir_node           *nomem  = new_NoMem();
 258         ir_node           *expr_op, *imm_op;
 259         tarval            *tv;
 260
 261         assert(! mode_is_float(mode) && "Shift/Rotate with float not supported");
 262
 263         imm_op  = get_immediate_op(NULL, op2);
 264         expr_op = get_expr_op(op1, op2);
 265
 266         assert((expr_op || imm_op) && "invalid operands");
 267
 268         if (!expr_op) {
 269                 /* We have two consts here: not yet supported */
 270                 imm_op = NULL;
 271         }
 272
 273         /* Limit imm_op within range imm8 */
 274         if (imm_op) {
 275                 tv = get_ia32_Immop_tarval(imm_op);
 276
 277                 if (tv) {
 278                         tv = tarval_mod(tv, new_tarval_from_long(32, mode_Iu));
 279                 }
 280                 else {
 281                         imm_op = NULL;
 282                 }
 283         }
 284
 285         /* integer operations */
 286         if (imm_op) {
 287                 /* This is shift/rot with const */
 288
 289                 new_op = func(dbg, irg, block, noreg, noreg, expr_op, noreg, nomem, mode_T);
 290                 set_ia32_Immop_attr(new_op, imm_op);
 291         }
 292         else {
 293                 /* This is a normal shift/rot */
 294                 new_op = func(dbg, irg, block, noreg, noreg, op1, op2, nomem, mode_T);
 295         }
 296
 297         /* set AM support */
 298         set_ia32_am_support(new_op, ia32_am_Dest);
 299
 300         return new_rd_Proj(dbg, irg, block, new_op, mode, 0);
 301 }
 302
 303
 304 /**
 305  * Construct a standard unary operation, set AM and immediate if required.
 306  *
 307  * @param env   The transformation environment
 308  * @param op    The operand
 309  * @param func  The node constructor function
 310  * @return The constructed ia32 node.
 311  */
 312 static ir_node *gen_unop(ia32_transform_env_t *env, ir_node *op, construct_unop_func *func) {
 313         ir_node           *new_op = NULL;
 314         ir_mode           *mode   = env->mode;
 315         dbg_info          *dbg    = env->dbg;
 316         ir_graph          *irg    = env->irg;
 317         ir_node           *block  = env->block;
 318         ir_node           *noreg  = ia32_new_NoReg_gp(env->cg);
 319         ir_node           *nomem  = new_NoMem();
 320
 321         new_op = func(dbg, irg, block, noreg, noreg, op, nomem, mode_T);
 322
 323         if (mode_is_float(mode)) {
 324                 /* floating point operations don't support implicit store */
 325                 set_ia32_am_support(new_op, ia32_am_None);
 326         }
 327         else {
 328                 set_ia32_am_support(new_op, ia32_am_Dest);
 329         }
 330
 331         return new_rd_Proj(dbg, irg, block, new_op, mode, 0);
 332 }
 333
 334
 335
 336 /**
 337  * Creates an ia32 Add with immediate.
 338  *
 339  * @param env       The transformation environment
 340  * @param expr_op   The expression operator
 341  * @param const_op  The constant
 342  * @return the created ia32 Add node
 343  */
 344 static ir_node *gen_imm_Add(ia32_transform_env_t *env, ir_node *expr_op, ir_node *const_op) {
 345         ir_node                *new_op     = NULL;
 346         tarval                 *tv         = get_ia32_Immop_tarval(const_op);
 347         firm_dbg_module_t      *mod        = env->mod;
 348         dbg_info               *dbg        = env->dbg;
 349         ir_mode                *mode       = env->mode;
 350         ir_graph               *irg        = env->irg;
 351         ir_node                *block      = env->block;
 352         ir_node                *noreg      = ia32_new_NoReg_gp(env->cg);
 353         ir_node                *nomem      = new_NoMem();
 354         int                     normal_add = 1;
 355         tarval_classification_t class_tv, class_negtv;
 356
 357         /* const_op: tarval or SymConst? */
 358         if (tv) {
 359                 /* optimize tarvals */
 360                 class_tv    = classify_tarval(tv);
 361                 class_negtv = classify_tarval(tarval_neg(tv));
 362
 363                 if (class_tv == TV_CLASSIFY_ONE) { /* + 1 == INC */
 364                         DB((env->mod, LEVEL_2, "Add(1) to Inc ... "));
 365                         new_op     = new_rd_ia32_Inc(dbg, irg, block, noreg, noreg, expr_op, nomem, mode_T);
 366                         normal_add = 0;
 367                 }
 368                 else if (class_tv == TV_CLASSIFY_ALL_ONE || class_negtv == TV_CLASSIFY_ONE) { /* + (-1) == DEC */
 369                         DB((mod, LEVEL_2, "Add(-1) to Dec ... "));
 370                         new_op     = new_rd_ia32_Dec(dbg, irg, block, noreg, noreg, expr_op, nomem, mode_T);
 371                         normal_add = 0;
 372                 }
 373         }
 374
 375         if (normal_add) {
 376                 new_op = new_rd_ia32_Add(dbg, irg, block, noreg, noreg, expr_op, noreg, nomem, mode_T);
 377                 set_ia32_Immop_attr(new_op, const_op);
 378         }
 379
 380         return new_op;
 381 }
 382
 383 /**
 384  * Creates an ia32 Add.
 385  *
 386  * @param dbg       firm node dbg
 387  * @param block     the block the new node should belong to
 388  * @param op1       first operator
 389  * @param op2       second operator
 390  * @param mode      node mode
 391  * @return the created ia32 Add node
 392  */
 393 static ir_node *gen_Add(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 394         ir_node  *new_op = NULL;
 395         dbg_info *dbg    = env->dbg;
 396         ir_mode  *mode   = env->mode;
 397         ir_graph *irg    = env->irg;
 398         ir_node  *block  = env->block;
 399         ir_node  *noreg  = ia32_new_NoReg_gp(env->cg);
 400         ir_node  *nomem  = new_NoMem();
 401         ir_node  *expr_op, *imm_op;
 402
 403         imm_op  = get_immediate_op(op1, op2);
 404         expr_op = get_expr_op(op1, op2);
 405
 406         assert((expr_op || imm_op) && "invalid operands");
 407
 408         if (mode_is_float(mode)) {
 409                 return gen_binop(env, op1, op2, new_rd_ia32_fAdd);
 410         }
 411         else {
 412                 /* integer ADD */
 413                 if (!expr_op) {
 414                         /* No expr_op means, that we have two const - one symconst and */
 415                         /* one tarval or another symconst - because this case is not   */
 416                         /* covered by constant folding                                 */
 417
 418                         new_op = new_rd_ia32_Lea(dbg, irg, block, noreg, noreg, mode);
 419                         add_ia32_am_offs(new_op, get_ia32_cnst(op1));
 420                         add_ia32_am_offs(new_op, get_ia32_cnst(op2));
 421
 422                         /* set AM support */
 423                         set_ia32_am_support(new_op, ia32_am_Source);
 424                         set_ia32_op_type(new_op, ia32_AddrModeS);
 425                         set_ia32_am_flavour(new_op, ia32_am_O);
 426
 427                         /* Lea doesn't need a Proj */
 428                         return new_op;
 429                 }
 430                 else if (imm_op) {
 431                         /* This is expr + const */
 432                         new_op = gen_imm_Add(env, expr_op, imm_op);
 433
 434                         /* set AM support */
 435                         set_ia32_am_support(new_op, ia32_am_Dest);
 436                 }
 437                 else {
 438                         /* This is a normal add */
 439                         new_op = new_rd_ia32_Add(dbg, irg, block, noreg, noreg, op1, op2, nomem, mode_T);
 440
 441                         /* set AM support */
 442                         set_ia32_am_support(new_op, ia32_am_Full);
 443                 }
 444         }
 445
 446         return new_rd_Proj(dbg, irg, block, new_op, mode, 0);
 447 }
 448
 449
 450
 451 /**
 452  * Creates an ia32 Mul.
 453  *
 454  * @param dbg       firm node dbg
 455  * @param block     the block the new node should belong to
 456  * @param op1       first operator
 457  * @param op2       second operator
 458  * @param mode      node mode
 459  * @return the created ia32 Mul node
 460  */
 461 ir_node *gen_Mul(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 462         ir_node *new_op;
 463
 464         if (mode_is_float(env->mode)) {
 465                 new_op = gen_binop(env, op1, op2, new_rd_ia32_fMul);
 466         }
 467         else {
 468                 new_op = gen_binop(env, op1, op2, new_rd_ia32_Mul);
 469         }
 470
 471         return new_op;
 472 }
 473
 474
 475
 476 /**
 477  * Creates an ia32 Mulh.
 478  * Note: Mul produces a 64Bit result and Mulh returns the upper 32 bit of
 479  * this result while Mul returns the lower 32 bit.
 480  *
 481  * @param env   The transformation environment
 482  * @param op1   The first operator
 483  * @param op2   The second operator
 484  * @return the created ia32 Mulh node
 485  */
 486 static ir_node *gen_Mulh(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 487         ir_node *proj_EAX, *proj_EDX, *mulh;
 488         ir_node *in[1];
 489
 490         assert(mode_is_float(env->mode) && "Mulh with float not supported");
 491         proj_EAX = gen_binop(env, op1, op2, new_rd_ia32_Mulh);
 492         mulh     = get_Proj_pred(proj_EAX);
 493         proj_EDX = new_rd_Proj(env->dbg, env->irg, env->block, mulh, env->mode, pn_EDX);
 494
 495         /* to be on the save side */
 496         set_Proj_proj(proj_EAX, pn_EAX);
 497
 498         if (get_ia32_cnst(mulh)) {
 499                 /* Mulh with const cannot have AM */
 500                 set_ia32_am_support(mulh, ia32_am_None);
 501         }
 502         else {
 503                 /* Mulh cannot have AM for destination */
 504                 set_ia32_am_support(mulh, ia32_am_Source);
 505         }
 506
 507         in[0] = proj_EAX;
 508
 509         /* keep EAX */
 510         be_new_Keep(&ia32_reg_classes[CLASS_ia32_gp], env->irg, env->block, 1, in);
 511
 512         return proj_EDX;
 513 }
 514
 515
 516
 517 /**
 518  * Creates an ia32 And.
 519  *
 520  * @param env   The transformation environment
 521  * @param op1   The first operator
 522  * @param op2   The second operator
 523  * @return The created ia32 And node
 524  */
 525 static ir_node *gen_And(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 526         if (mode_is_float(env->mode)) {
 527                 return gen_binop(env, op1, op2, new_rd_ia32_fAnd);
 528         }
 529         else {
 530                 return gen_binop(env, op1, op2, new_rd_ia32_And);
 531         }
 532 }
 533
 534
 535
 536 /**
 537  * Creates an ia32 Or.
 538  *
 539  * @param env   The transformation environment
 540  * @param op1   The first operator
 541  * @param op2   The second operator
 542  * @return The created ia32 Or node
 543  */
 544 static ir_node *gen_Or(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 545         if (mode_is_float(env->mode)) {
 546                 return gen_binop(env, op1, op2, new_rd_ia32_fOr);
 547         }
 548         else {
 549                 return gen_binop(env, op1, op2, new_rd_ia32_Or);
 550         }
 551 }
 552
 553
 554
 555 /**
 556  * Creates an ia32 Eor.
 557  *
 558  * @param env   The transformation environment
 559  * @param op1   The first operator
 560  * @param op2   The second operator
 561  * @return The created ia32 Eor node
 562  */
 563 static ir_node *gen_Eor(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 564         if (mode_is_float(env->mode)) {
 565                 return gen_binop(env, op1, op2, new_rd_ia32_fEor);
 566         }
 567         else {
 568                 return gen_binop(env, op1, op2, new_rd_ia32_Eor);
 569         }
 570 }
 571
 572
 573
 574 /**
 575  * Creates an ia32 Max.
 576  *
 577  * @param env      The transformation environment
 578  * @param op1      The first operator
 579  * @param op2      The second operator
 580  * @return the created ia32 Max node
 581  */
 582 static ir_node *gen_Max(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 583         ir_node *new_op;
 584
 585         if (mode_is_float(env->mode)) {
 586                 new_op = gen_binop(env, op1, op2, new_rd_ia32_fMax);
 587         }
 588         else {
 589                 new_op = new_rd_ia32_Max(env->dbg, env->irg, env->block, op1, op2, env->mode);
 590                 set_ia32_am_support(new_op, ia32_am_None);
 591         }
 592
 593         return new_op;
 594 }
 595
 596
 597
 598 /**
 599  * Creates an ia32 Min.
 600  *
 601  * @param env      The transformation environment
 602  * @param op1      The first operator
 603  * @param op2      The second operator
 604  * @return the created ia32 Min node
 605  */
 606 static ir_node *gen_Min(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 607         ir_node *new_op;
 608
 609         if (mode_is_float(env->mode)) {
 610                 new_op = gen_binop(env, op1, op2, new_rd_ia32_fMin);
 611         }
 612         else {
 613                 new_op = new_rd_ia32_Min(env->dbg, env->irg, env->block, op1, op2, env->mode);
 614                 set_ia32_am_support(new_op, ia32_am_None);
 615         }
 616
 617         return new_op;
 618 }
 619
 620
 621
 622 /**
 623  * Creates an ia32 Sub with immediate.
 624  *
 625  * @param env   The transformation environment
 626  * @param op1   The first operator
 627  * @param op2   The second operator
 628  * @return The created ia32 Sub node
 629  */
 630 static ir_node *gen_imm_Sub(ia32_transform_env_t *env, ir_node *expr_op, ir_node *const_op) {
 631         ir_node                *new_op     = NULL;
 632         tarval                 *tv         = get_ia32_Immop_tarval(const_op);
 633         firm_dbg_module_t      *mod        = env->mod;
 634         dbg_info               *dbg        = env->dbg;
 635         ir_mode                *mode       = env->mode;
 636         ir_graph               *irg        = env->irg;
 637         ir_node                *block      = env->block;
 638         ir_node                *noreg      = ia32_new_NoReg_gp(env->cg);
 639         ir_node                *nomem      = new_NoMem();
 640         int                     normal_sub = 1;
 641         tarval_classification_t class_tv, class_negtv;
 642
 643         /* const_op: tarval or SymConst? */
 644         if (tv) {
 645                 /* optimize tarvals */
 646                 class_tv    = classify_tarval(tv);
 647                 class_negtv = classify_tarval(tarval_neg(tv));
 648
 649                 if (class_tv == TV_CLASSIFY_ONE) { /* - 1 == DEC */
 650                         DB((mod, LEVEL_2, "Sub(1) to Dec ... "));
 651                         new_op     = new_rd_ia32_Dec(dbg, irg, block, noreg, noreg, expr_op, nomem, mode_T);
 652                         normal_sub = 0;
 653                 }
 654                 else if (class_negtv == TV_CLASSIFY_ONE) { /* - (-1) == Sub */
 655                         DB((mod, LEVEL_2, "Sub(-1) to Inc ... "));
 656                         new_op     = new_rd_ia32_Inc(dbg, irg, block, noreg, noreg, expr_op, nomem, mode_T);
 657                         normal_sub = 0;
 658                 }
 659         }
 660
 661         if (normal_sub) {
 662                 new_op = new_rd_ia32_Sub(dbg, irg, block, noreg, noreg, expr_op, noreg, nomem, mode_T);
 663                 set_ia32_Immop_attr(new_op, const_op);
 664         }
 665
 666         return new_op;
 667 }
 668
 669 /**
 670  * Creates an ia32 Sub.
 671  *
 672  * @param env   The transformation environment
 673  * @param op1   The first operator
 674  * @param op2   The second operator
 675  * @return The created ia32 Sub node
 676  */
 677 static ir_node *gen_Sub(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 678         ir_node  *new_op = NULL;
 679         dbg_info *dbg    = env->dbg;
 680         ir_mode  *mode   = env->mode;
 681         ir_graph *irg    = env->irg;
 682         ir_node  *block  = env->block;
 683         ir_node  *noreg  = ia32_new_NoReg_gp(env->cg);
 684         ir_node  *nomem  = new_NoMem();
 685         ir_node  *expr_op, *imm_op;
 686
 687         imm_op  = get_immediate_op(NULL, op2);
 688         expr_op = get_expr_op(op1, op2);
 689
 690         assert((expr_op || imm_op) && "invalid operands");
 691
 692         if (mode_is_float(mode)) {
 693                 return gen_binop(env, op1, op2, new_rd_ia32_fSub);
 694         }
 695         else {
 696                 /* integer SUB */
 697                 if (!expr_op) {
 698                         /* No expr_op means, that we have two const - one symconst and */
 699                         /* one tarval or another symconst - because this case is not   */
 700                         /* covered by constant folding                                 */
 701
 702                         new_op = new_rd_ia32_Lea(dbg, irg, block, noreg, noreg, mode);
 703                         add_ia32_am_offs(new_op, get_ia32_cnst(op1));
 704                         sub_ia32_am_offs(new_op, get_ia32_cnst(op2));
 705
 706                         /* set AM support */
 707                         set_ia32_am_support(new_op, ia32_am_Source);
 708                         set_ia32_op_type(new_op, ia32_AddrModeS);
 709                         set_ia32_am_flavour(new_op, ia32_am_O);
 710
 711                         /* Lea doesn't need a Proj */
 712                         return new_op;
 713                 }
 714                 else if (imm_op) {
 715                         /* This is expr - const */
 716                         new_op = gen_imm_Sub(env, expr_op, imm_op);
 717
 718                         /* set AM support */
 719                         set_ia32_am_support(new_op, ia32_am_Dest);
 720                 }
 721                 else {
 722                         /* This is a normal sub */
 723                         new_op = new_rd_ia32_Sub(dbg, irg, block, noreg, noreg, op1, op2, nomem, mode_T);
 724
 725                         /* set AM support */
 726                         set_ia32_am_support(new_op, ia32_am_Full);
 727                 }
 728         }
 729
 730         return new_rd_Proj(dbg, irg, block, new_op, mode, 0);
 731 }
 732
 733
 734
 735 /**
 736  * Generates an ia32 DivMod with additional infrastructure for the
 737  * register allocator if needed.
 738  *
 739  * @param env      The transformation environment
 740  * @param dividend -no comment- :)
 741  * @param divisor  -no comment- :)
 742  * @param dm_flav  flavour_Div/Mod/DivMod
 743  * @return The created ia32 DivMod node
 744  */
 745 static ir_node *generate_DivMod(ia32_transform_env_t *env, ir_node *dividend, ir_node *divisor, ia32_op_flavour_t dm_flav) {
 746         ir_node  *res, *proj;
 747         ir_node  *edx_node, *cltd;
 748         ir_node  *in_keep[1];
 749         dbg_info *dbg   = env->dbg;
 750         ir_graph *irg   = env->irg;
 751         ir_node  *block = env->block;
 752         ir_mode  *mode  = env->mode;
 753         ir_node  *irn   = env->irn;
 754         ir_node  *mem;
 755
 756         switch (dm_flav) {
 757                 case flavour_Div:
 758                         mem = get_Div_mem(irn);
 759                         break;
 760                 case flavour_Mod:
 761                         mem = get_Mod_mem(irn);
 762                         break;
 763                 case flavour_DivMod:
 764                         mem = get_DivMod_mem(irn);
 765                         break;
 766                 default:
 767                         assert(0);
 768         }
 769
 770         if (mode_is_signed(mode)) {
 771                 /* in signed mode, we need to sign extend the dividend */
 772                 cltd     = new_rd_ia32_Cdq(dbg, irg, block, dividend, mode_T);
 773                 dividend = new_rd_Proj(dbg, irg, block, cltd, mode_Is, pn_EAX);
 774                 edx_node = new_rd_Proj(dbg, irg, block, cltd, mode_Is, pn_EDX);
 775         }
 776         else {
 777                 edx_node = new_rd_ia32_Const(dbg, irg, block, mode_Iu);
 778                 set_ia32_Const_type(edx_node, ia32_Const);
 779                 set_ia32_Immop_tarval(edx_node, get_tarval_null(mode_Iu));
 780         }
 781
 782         res = new_rd_ia32_DivMod(dbg, irg, block, dividend, divisor, edx_node, mem, mode);
 783
 784         set_ia32_flavour(res, dm_flav);
 785         set_ia32_n_res(res, 2);
 786
 787         /* Only one proj is used -> We must add a second proj and */
 788         /* connect this one to a Keep node to eat up the second   */
 789         /* destroyed register.                                    */
 790         if (get_irn_n_edges(irn) == 1) {
 791                 proj = get_edge_src_irn(get_irn_out_edge_first(irn));
 792                 assert(is_Proj(proj) && "non-Proj to Div/Mod node");
 793
 794                 if (get_Proj_proj(proj) == pn_DivMod_res_div) {
 795                         in_keep[0] = new_rd_Proj(dbg, irg, block, res, mode_Is, pn_DivMod_res_mod);
 796                 }
 797                 else {
 798                         in_keep[0] = new_rd_Proj(dbg, irg, block, res, mode_Is, pn_DivMod_res_div);
 799                 }
 800
 801                 be_new_Keep(&ia32_reg_classes[CLASS_ia32_gp], irg, block, 1, in_keep);
 802         }
 803
 804         return res;
 805 }
 806
 807
 808 /**
 809  * Wrapper for generate_DivMod. Sets flavour_Mod.
 810  */
 811 static ir_node *gen_Mod(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 812         return generate_DivMod(env, op1, op2, flavour_Mod);
 813 }
 814
 815
 816
 817 /**
 818  * Wrapper for generate_DivMod. Sets flavour_Div.
 819  */
 820 static ir_node *gen_Div(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 821         return generate_DivMod(env, op1, op2, flavour_Div);
 822 }
 823
 824
 825
 826 /**
 827  * Wrapper for generate_DivMod. Sets flavour_DivMod.
 828  */
 829 static ir_node *gen_DivMod(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 830         return generate_DivMod(env, op1, op2, flavour_DivMod);
 831 }
 832
 833
 834
 835 /**
 836  * Creates an ia32 floating Div.
 837  *
 838  * @param env   The transformation environment
 839  * @param op1   The first operator
 840  * @param op2   The second operator
 841  * @return The created ia32 fDiv node
 842  */
 843 static ir_node *gen_Quot(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 844         return gen_binop(env, op1, op2, new_rd_ia32_fDiv);
 845 }
 846
 847
 848
 849 /**
 850  * Creates an ia32 Shl.
 851  *
 852  * @param env   The transformation environment
 853  * @param op1   The first operator
 854  * @param op2   The second operator
 855  * @return The created ia32 Shl node
 856  */
 857 static ir_node *gen_Shl(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 858         return gen_shift_binop(env, op1, op2, new_rd_ia32_Shl);
 859 }
 860
 861
 862
 863 /**
 864  * Creates an ia32 Shr.
 865  *
 866  * @param env   The transformation environment
 867  * @param op1   The first operator
 868  * @param op2   The second operator
 869  * @return The created ia32 Shr node
 870  */
 871 static ir_node *gen_Shr(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 872         return gen_shift_binop(env, op1, op2, new_rd_ia32_Shr);
 873 }
 874
 875
 876
 877 /**
 878  * Creates an ia32 Shrs.
 879  *
 880  * @param env   The transformation environment
 881  * @param op1   The first operator
 882  * @param op2   The second operator
 883  * @return The created ia32 Shrs node
 884  */
 885 static ir_node *gen_Shrs(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 886         return gen_shift_binop(env, op1, op2, new_rd_ia32_Shrs);
 887 }
 888
 889
 890
 891 /**
 892  * Creates an ia32 RotL.
 893  *
 894  * @param env   The transformation environment
 895  * @param op1   The first operator
 896  * @param op2   The second operator
 897  * @return The created ia32 RotL node
 898  */
 899 static ir_node *gen_RotL(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 900         return gen_shift_binop(env, op1, op2, new_rd_ia32_RotL);
 901 }
 902
 903
 904
 905 /**
 906  * Creates an ia32 RotR.
 907  * NOTE: There is no RotR with immediate because this would always be a RotL
 908  *       "imm-mode_size_bits" which can be pre-calculated.
 909  *
 910  * @param env   The transformation environment
 911  * @param op1   The first operator
 912  * @param op2   The second operator
 913  * @return The created ia32 RotR node
 914  */
 915 static ir_node *gen_RotR(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 916         return gen_shift_binop(env, op1, op2, new_rd_ia32_RotR);
 917 }
 918
 919
 920
 921 /**
 922  * Creates an ia32 RotR or RotL (depending on the found pattern).
 923  *
 924  * @param env   The transformation environment
 925  * @param op1   The first operator
 926  * @param op2   The second operator
 927  * @return The created ia32 RotL or RotR node
 928  */
 929 static ir_node *gen_Rot(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 930         ir_node *rotate = NULL;
 931
 932         /* Firm has only Rot (which is a RotL), so we are looking for a right (op2)
 933                  operand "-e+mode_size_bits" (it's an already modified "mode_size_bits-e",
 934                  that means we can create a RotR instead of an Add and a RotL */
 935
 936         if (is_Proj(op2)) {
 937                 ir_node *pred = get_Proj_pred(op2);
 938
 939                 if (is_ia32_Add(pred)) {
 940                         ir_node *pred_pred = get_irn_n(pred, 2);
 941                         tarval  *tv        = get_ia32_Immop_tarval(pred);
 942                         long     bits      = get_mode_size_bits(env->mode);
 943
 944                         if (is_Proj(pred_pred)) {
 945                                 pred_pred = get_Proj_pred(pred_pred);
 946                         }
 947
 948                         if (is_ia32_Minus(pred_pred) &&
 949                                 tarval_is_long(tv)       &&
 950                                 get_tarval_long(tv) == bits)
 951                         {
 952                                 DB((env->mod, LEVEL_1, "RotL into RotR ... "));
 953                                 rotate = gen_RotR(env, op1, get_irn_n(pred_pred, 2));
 954                         }
 955
 956                 }
 957         }
 958
 959         if (!rotate) {
 960                 rotate = gen_RotL(env, op1, op2);
 961         }
 962
 963         return rotate;
 964 }
 965
 966
 967
 968 /**
 969  * Transforms a Conv node.
 970  *
 971  * @param env   The transformation environment
 972  * @param op    The operator
 973  * @return The created ia32 Conv node
 974  */
 975 static ir_node *gen_Conv(ia32_transform_env_t *env, ir_node *op) {
 976         return new_rd_ia32_Conv(env->dbg, env->irg, env->block, op, env->mode);
 977 }
 978
 979
 980
 981 /**
 982  * Transforms a Minus node.
 983  *
 984  * @param env   The transformation environment
 985  * @param op    The operator
 986  * @return The created ia32 Minus node
 987  */
 988 static ir_node *gen_Minus(ia32_transform_env_t *env, ir_node *op) {
 989         char    *name;
 990         ir_node *new_op;
 991         ir_node *noreg_gp = ia32_new_NoReg_gp(env->cg);
 992         ir_node *noreg_fp = ia32_new_NoReg_fp(env->cg);
 993         ir_node *nomem    = new_rd_NoMem(env->irg);
 994         int      size;
 995
 996         if (mode_is_float(env->mode)) {
 997                 new_op = new_rd_ia32_fEor(env->dbg, env->irg, env->block, noreg_gp, noreg_gp, op, noreg_fp, nomem, mode_T);
 998
 999                 size   = get_mode_size_bits(env->mode);
1000                 name   = gen_fp_known_const(env->mode, size == 32 ? ia32_SSIGN : ia32_DSIGN);
1001
1002                 set_ia32_sc(new_op, name);
1003
1004                 new_op = new_rd_Proj(env->dbg, env->irg, env->block, new_op, env->mode, 0);
1005         }
1006         else {
1007                 new_op = gen_unop(env, op, new_rd_ia32_Minus);
1008         }
1009
1010         return new_op;
1011 }
1012
1013
1014
1015 /**
1016  * Transforms a Not node.
1017  *
1018  * @param env   The transformation environment
1019  * @param op    The operator
1020  * @return The created ia32 Not node
1021  */
1022 static ir_node *gen_Not(ia32_transform_env_t *env, ir_node *op) {
1023         ir_node *new_op;
1024
1025         if (mode_is_float(env->mode)) {
1026                 assert(0);
1027         }
1028         else {
1029                 new_op = gen_unop(env, op, new_rd_ia32_Not);
1030         }
1031
1032         return new_op;
1033 }
1034
1035
1036
1037 /**
1038  * Transforms an Abs node.
1039  *
1040  * @param env   The transformation environment
1041  * @param op    The operator
1042  * @return The created ia32 Abs node
1043  */
1044 static ir_node *gen_Abs(ia32_transform_env_t *env, ir_node *op) {
1045         ir_node  *res, *p_eax, *p_edx;
1046         dbg_info *dbg      = env->dbg;
1047         ir_mode  *mode     = env->mode;
1048         ir_graph *irg      = env->irg;
1049         ir_node  *block    = env->block;
1050         ir_node  *noreg_gp = ia32_new_NoReg_gp(env->cg);
1051         ir_node  *noreg_fp = ia32_new_NoReg_fp(env->cg);
1052         ir_node  *nomem    = new_NoMem();
1053         int       size;
1054         char     *name;
1055
1056         if (mode_is_float(mode)) {
1057                 res = new_rd_ia32_fAnd(dbg,irg, block, noreg_gp, noreg_gp, op, noreg_fp, nomem, mode_T);
1058
1059                 size   = get_mode_size_bits(mode);
1060                 name   = gen_fp_known_const(mode, size == 32 ? ia32_SABS : ia32_DABS);
1061
1062                 set_ia32_sc(res, name);
1063
1064                 res = new_rd_Proj(dbg, irg, block, res, mode, 0);
1065         }
1066         else {
1067                 res   = new_rd_ia32_Cdq(dbg, irg, block, op, mode_T);
1068                 p_eax = new_rd_Proj(dbg, irg, block, res, mode, pn_EAX);
1069                 p_edx = new_rd_Proj(dbg, irg, block, res, mode, pn_EDX);
1070                 res   = new_rd_ia32_Eor(dbg, irg, block, noreg_gp, noreg_gp, p_eax, p_edx, nomem, mode_T);
1071                 res   = new_rd_Proj(dbg, irg, block, res, mode, 0);
1072                 res   = new_rd_ia32_Sub(dbg, irg, block, noreg_gp, noreg_gp, res, p_edx, nomem, mode_T);
1073                 res   = new_rd_Proj(dbg, irg, block, res, mode, 0);
1074         }
1075
1076         return res;
1077 }
1078
1079
1080
1081 /**
1082  * Transforms a Load.
1083  *
1084  * @param mod     the debug module
1085  * @param block   the block the new node should belong to
1086  * @param node    the ir Load node
1087  * @param mode    node mode
1088  * @return the created ia32 Load node
1089  */
1090 static ir_node *gen_Load(ia32_transform_env_t *env) {
1091         ir_node *node  = env->irn;
1092         ir_node *noreg = ia32_new_NoReg_gp(env->cg);
1093
1094         if (mode_is_float(env->mode)) {
1095                 return new_rd_ia32_fLoad(env->dbg, env->irg, env->block, get_Load_ptr(node), noreg, get_Load_mem(node), env->mode);
1096         }
1097         return new_rd_ia32_Load(env->dbg, env->irg, env->block, get_Load_ptr(node), noreg, get_Load_mem(node), env->mode);
1098 }
1099
1100
1101
1102 /**
1103  * Transforms a Store.
1104  *
1105  * @param mod     the debug module
1106  * @param block   the block the new node should belong to
1107  * @param node    the ir Store node
1108  * @param mode    node mode
1109  * @return the created ia32 Store node
1110  */
1111 ir_node *gen_Store(ia32_transform_env_t *env) {
1112         ir_node *node  = env->irn;
1113         ir_node *noreg = ia32_new_NoReg_gp(env->cg);
1114
1115         if (mode_is_float(env->mode)) {
1116                 return new_rd_ia32_fStore(env->dbg, env->irg, env->block, get_Store_ptr(node), noreg, get_Store_value(node), get_Store_mem(node), env->mode);
1117         }
1118         return new_rd_ia32_Store(env->dbg, env->irg, env->block, get_Store_ptr(node), noreg, get_Store_value(node), get_Store_mem(node), env->mode);
1119 }
1120
1121
1122
1123 /**
1124  * Transforms a Call and its arguments corresponding to the calling convention.
1125  *
1126  * @param mod     the debug module
1127  * @param block   the block the new node should belong to
1128  * @param node    the ir Call node
1129  * @param dummy   mode doesn't matter
1130  * @return the created ia32 Call node
1131  */
1132 static ir_node *gen_Call(ia32_transform_env_t *env) {
1133 #if 0
1134         const ia32_register_req_t **in_req;
1135         ir_node          **in;
1136         ir_node           *new_call, *sync;
1137         int                i, j, n_new_call_in, ignore = 0;
1138         ia32_attr_t       *attr;
1139         dbg_info          *dbg          = env->dbg;
1140         ir_graph          *irg          = env->irg;
1141         ir_node           *block        = env->block;
1142         ir_node           *call         = env->irn;
1143         ir_node          **stack_param  = NULL;
1144         ir_node          **param        = get_Call_param_arr(call);
1145         ir_node           *call_Mem     = get_Call_mem(call);
1146         unsigned           cc           = get_method_calling_convention(get_Call_type(call));
1147         int                n            = get_Call_n_params(call);
1148         int                stack_idx    = 0;
1149         int                biggest_n    = -1;
1150         int                n_res        = get_method_n_ress(get_Call_type(call));
1151
1152         assert(n_res <= 2 && "method with more than two results not supported");
1153
1154         if (cc & cc_reg_param)
1155                 biggest_n = ia32_get_n_regparam_class(n, param, &ignore, &ignore);
1156
1157         /* remember: biggest_n = x means we can pass (x + 1) parameters in register */
1158
1159         /* do we need to pass arguments on stack? */
1160         if (biggest_n + 1 < n)
1161                 stack_param = xcalloc(n - biggest_n - 1, sizeof(ir_node *));
1162
1163         /* we need at least one in, either for the stack params or the call_Mem */
1164         n_new_call_in = biggest_n + 2;
1165
1166         /* the call has one IN for all stack parameter and one IN for each reg param */
1167         in     = xcalloc(n_new_call_in, sizeof(ir_node *));
1168         in_req = xcalloc(n_new_call_in, sizeof(arch_register_req_t *));
1169
1170         /* loop over all parameters and set the register requirements */
1171         for (i = 0; i <= biggest_n && (cc & cc_reg_param); i++) {
1172                 in_req[i] = ia32_get_RegParam_req(n, param, i, cc);
1173         }
1174         stack_idx = i;
1175
1176         /* create remaining stack parameters */
1177         if (cc & cc_last_on_top) {
1178                 for (i = stack_idx; i < n; i++) {
1179                         /* pass it on stack */
1180                         if (mode_is_float(get_irn_mode(param[i]))) {
1181                                 stack_param[i - stack_idx] = new_rd_ia32_fStackArg(get_irn_dbg_info(param[i]), irg,
1182                                                                                                                 block, call_Mem, param[i], mode_M);
1183                         }
1184                         else {
1185                                 stack_param[i - stack_idx] = new_rd_ia32_StackArg(get_irn_dbg_info(param[i]), irg,
1186                                                                                                                 block, call_Mem, param[i], mode_M);
1187                         }
1188                         /* set the argument number for later lowering */
1189                         set_ia32_pncode(stack_param[i - stack_idx], i - stack_idx);
1190                 }
1191         }
1192         else {
1193                 for (i = n - 1, j = 0; i >= stack_idx; i--, j++) {
1194                         /* pass it on stack */
1195                         if (mode_is_float(get_irn_mode(param[i]))) {
1196                                 stack_param[j] = new_rd_ia32_fStackArg(get_irn_dbg_info(param[i]), irg,
1197                                                                                                                 block, call_Mem, param[i], mode_M);
1198                         }
1199                         else {
1200                                 stack_param[j] = new_rd_ia32_StackArg(get_irn_dbg_info(param[i]), irg,
1201                                                                                                                 block, call_Mem, param[i], mode_M);
1202                         }
1203                         /* set the argument number for later lowering */
1204                         set_ia32_pncode(stack_param[j], j);
1205                 }
1206         }
1207
1208         if (stack_param) {
1209                 sync = new_r_Sync(irg, block, n - biggest_n - 1, stack_param);
1210                 in[n_new_call_in - 1] = sync;
1211         }
1212         else {
1213                 in[n_new_call_in - 1] = call_Mem;
1214         }
1215
1216         /* create the new node */
1217         new_call = new_rd_ia32_Call(dbg, irg, block, n_new_call_in, in);
1218         set_ia32_Immop_attr(new_call, get_Call_ptr(call));
1219
1220         /* set register requirements for in and out */
1221         attr             = get_ia32_attr(new_call);
1222         attr->in_req     = in_req;
1223
1224         set_ia32_n_res(new_call, n_res);
1225
1226         if (n_res > 0) {
1227                 attr->out_req    = xcalloc(n_res, sizeof(ia32_register_req_t *));
1228                 attr->slots      = xcalloc(n_res, sizeof(arch_register_t *));
1229         }
1230
1231         /* two results only appear when a 64bit int result is broken up into two 32bit results */
1232         if (n_res == 1) {
1233                 if (mode_is_float(get_type_mode(get_method_res_type(get_Call_type(call), 0))))
1234                         attr->out_req[0] = &ia32_default_req_ia32_fp_xmm0;
1235                 else
1236                         attr->out_req[0] = &ia32_default_req_ia32_gp_eax;
1237         }
1238         else if (n_res == 2) {
1239                 attr->out_req[0] = &ia32_default_req_ia32_gp_eax;
1240                 attr->out_req[1] = &ia32_default_req_ia32_gp_edx;
1241         }
1242
1243         /* stack parameter has no OUT register */
1244         attr->in_req[n_new_call_in - 1] = &ia32_default_req_none;
1245
1246         return new_call;
1247 #endif
1248 }
1249
1250
1251
1252 /**
1253  * Transforms a Cond -> Proj[b] -> Cmp into a CondJmp or CondJmp_i
1254  *
1255  * @param env   The transformation environment
1256  * @return The transformed node.
1257  */
1258 static ir_node *gen_Cond(ia32_transform_env_t *env) {
1259         dbg_info *dbg      = env->dbg;
1260         ir_graph *irg      = env->irg;
1261         ir_node  *block    = env->block;
1262         ir_node  *node     = env->irn;
1263         ir_node  *sel      = get_Cond_selector(node);
1264         ir_mode  *sel_mode = get_irn_mode(sel);
1265         ir_node  *res      = NULL;
1266         ir_node  *pred     = NULL;
1267         ir_node  *noreg    = ia32_new_NoReg_gp(env->cg);
1268         ir_node  *nomem    = new_NoMem();
1269         ir_node  *cmp_a, *cmp_b, *cnst, *expr;
1270
1271         if (is_Proj(sel) && sel_mode == mode_b) {
1272                 pred  = get_Proj_pred(sel);
1273
1274                 /* get both compare operators */
1275                 cmp_a = get_Cmp_left(pred);
1276                 cmp_b = get_Cmp_right(pred);
1277
1278                 /* check if we can use a CondJmp with immediate */
1279                 cnst = get_immediate_op(cmp_a, cmp_b);
1280                 expr = get_expr_op(cmp_a, cmp_b);
1281
1282                 if (cnst && expr) {
1283                         res = new_rd_ia32_CondJmp(dbg, irg, block, noreg, noreg, expr, noreg, nomem, mode_T);
1284                         set_ia32_Immop_attr(res, cnst);
1285                 }
1286                 else {
1287                         res = new_rd_ia32_CondJmp(dbg, irg, block, noreg, noreg, cmp_a, cmp_b, nomem, mode_T);
1288                 }
1289
1290                 set_ia32_pncode(res, get_Proj_proj(sel));
1291         }
1292         else {
1293                 res = new_rd_ia32_SwitchJmp(dbg, irg, block, noreg, noreg, sel, nomem, mode_T);
1294                 set_ia32_pncode(res, get_Cond_defaultProj(node));
1295         }
1296
1297         return res;
1298 }
1299
1300
1301
1302 /**
1303  * Transform the argument projs from a start node corresponding to the
1304  * calling convention.
1305  * It transforms "Proj Arg x -> ProjT -> Start <- ProjM" into
1306  * "RegParam x   -> ProjT -> Start" OR
1307  * "StackParam x -> ProjM -> Start"
1308  * whether parameter is passed in register or on stack.
1309  *
1310  * @param mod     the debug module
1311  * @param block   the block the nodes should belong to
1312  * @param proj    the ProjT node which points to Start
1313  * @param start   the Start node
1314  * @return Should be always NULL
1315  */
1316 static ir_node *gen_Proj_Start(ia32_transform_env_t *env, ir_node *proj, ir_node *start) {
1317 #if 0
1318         const ia32_register_req_t *temp_req;
1319         const ir_edge_t   *edge;
1320         ir_node           *succ, *irn;
1321         ir_node          **projargs;
1322         ir_mode           *mode;
1323         int                n, i;
1324         unsigned           cc;
1325         ir_node           *proj_M     = get_irg_initial_mem(current_ir_graph);
1326         entity            *irg_ent    = get_irg_entity(current_ir_graph);
1327         ir_type           *tp         = get_entity_type(irg_ent);
1328         int                cur_pn     = 0;
1329         ir_graph          *irg        = env->irg;
1330         ir_node           *block      = env->block;
1331
1332         assert(is_Method_type(tp) && "irg type is not a method");
1333
1334         switch(get_Proj_proj(proj)) {
1335                 case pn_Start_T_args:
1336                         /* We cannot use get_method_n_params here as the function might
1337                            be variadic or one argument is not used. */
1338                         n = get_irn_n_edges(proj);
1339
1340                         /* Allocate memory for all non variadic parameters in advance to be on the save side */
1341                         env->cg->reg_param_req = xcalloc(get_method_n_params(tp), sizeof(ia32_register_req_t *));
1342
1343                         /* we are done here when there are no parameters */
1344                         if (n < 1)
1345                                 break;
1346
1347                         /* temporary remember all proj arg x */
1348                         projargs = xcalloc(n, sizeof(ir_node *));
1349
1350                         i = 0;
1351                         foreach_out_edge((const ir_node *)proj, edge) {
1352                                 succ = get_edge_src_irn(edge);
1353                                 assert(is_Proj(succ) && "non-Proj from a Proj_T (pn_Start_T_args).");
1354                                 projargs[i++] = succ;
1355                         }
1356
1357                         cc = get_method_calling_convention(tp);
1358
1359                         /* loop over all parameters and check whether its a int or float */
1360                         for (i = 0; i < n; i++) {
1361                                 mode   = get_irn_mode(projargs[i]);
1362                                 cur_pn = get_Proj_proj(projargs[i]);
1363
1364                                 if (cc & cc_reg_param) {
1365                                         temp_req = ia32_get_RegParam_req(n, projargs, cur_pn, cc);
1366                                 }
1367                                 else {
1368                                         temp_req = NULL;
1369                                 }
1370
1371                                 if (temp_req) {
1372                                         /* passed in register */
1373                                         env->cg->reg_param_req[cur_pn] = temp_req;
1374                                 }
1375                                 else {
1376                                         /* passed on stack */
1377                                         if (mode_is_float(mode))
1378                                                 irn = new_rd_ia32_fStackParam(get_irn_dbg_info(projargs[i]), irg, block, proj_M, mode);
1379                                         else
1380                                                 irn = new_rd_ia32_StackParam(get_irn_dbg_info(projargs[i]), irg, block, proj_M, mode);
1381
1382                                         set_ia32_pncode(irn, cur_pn);
1383
1384                                         /* kill the old "Proj Arg" and replace with the new stack param */
1385                                         exchange(projargs[i], irn);
1386                                 }
1387                         }
1388
1389                         free(projargs);
1390
1391                         break;
1392                 case pn_Start_P_frame_base:
1393                 case pn_Start_X_initial_exec:
1394                 case pn_Start_M:
1395                 case pn_Start_P_globals:
1396                 case pn_Start_P_value_arg_base:
1397                         break;
1398                 default:
1399                         assert(0 && "unsupported Proj(Start)");
1400         }
1401
1402         return NULL;
1403 #endif
1404 }
1405
1406 /**
1407  * Transform some Proj's (Proj_Proj, Proj_Start, Proj_Cmp, Proj_Cond, Proj_Call).
1408  * All others are ignored.
1409  *
1410  * @param mod     the debug module
1411  * @param block   the block the new node should belong to
1412  * @param node    the ir Proj node
1413  * @param mode    mode of the Proj
1414  * @return The transformed node.
1415  */
1416 static ir_node *gen_Proj(ia32_transform_env_t *env) {
1417         ir_node *new_node  = NULL;
1418         ir_node *pred      = get_Proj_pred(env->irn);
1419
1420         if (env->mode == mode_M)
1421                 return NULL;
1422
1423         if (get_irn_op(pred) == op_Start) {
1424                 new_node = gen_Proj_Start(env, env->irn, pred);
1425         }
1426
1427         return new_node;
1428 }
1429
1430
1431
1432 /*********************************************************
1433  *                  _             _      _
1434  *                 (_)           | |    (_)
1435  *  _ __ ___   __ _ _ _ __     __| |_ __ ___   _____ _ __
1436  * | '_ ` _ \ / _` | | '_ \   / _` | '__| \ \ / / _ \ '__|
1437  * | | | | | | (_| | | | | | | (_| | |  | |\ V /  __/ |
1438  * |_| |_| |_|\__,_|_|_| |_|  \__,_|_|  |_| \_/ \___|_|
1439  *
1440  *********************************************************/
1441
1442
1443
1444 /**
1445  * Transforms the given firm node (and maybe some other related nodes)
1446  * into one or more assembler nodes.
1447  *
1448  * @param node    the firm node
1449  * @param env     the debug module
1450  */
1451 void ia32_transform_node(ir_node *node, void *env) {
1452         ia32_code_gen_t *cgenv = (ia32_code_gen_t *)env;
1453         opcode  code           = get_irn_opcode(node);
1454         ir_node *asm_node      = NULL;
1455         ia32_transform_env_t  tenv;
1456
1457         if (is_Block(node))
1458                 return;
1459
1460         tenv.arch_env = cgenv->arch_env;
1461         tenv.block    = get_nodes_block(node);
1462         tenv.dbg      = get_irn_dbg_info(node);
1463         tenv.irg      = current_ir_graph;
1464         tenv.irn      = node;
1465         tenv.mod      = cgenv->mod;
1466         tenv.mode     = get_irn_mode(node);
1467         tenv.cg       = cgenv;
1468
1469 #define UNOP(a)  case iro_##a: asm_node = gen_##a(&tenv, get_##a##_op(node)); break
1470 #define BINOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_left(node), get_##a##_right(node)); break
1471 #define GEN(a)   case iro_##a: asm_node = gen_##a(&tenv); break
1472 #define IGN(a)   case iro_##a: break
1473 #define BAD(a)   case iro_##a: goto bad
1474
1475         DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
1476
1477         switch (code) {
1478                 BINOP(Add);
1479                 BINOP(Sub);
1480                 BINOP(Mul);
1481                 BINOP(And);
1482                 BINOP(Or);
1483                 BINOP(Eor);
1484
1485                 BINOP(Shl);
1486                 BINOP(Shr);
1487                 BINOP(Shrs);
1488
1489                 BINOP(Quot);
1490
1491                 BINOP(Div);
1492                 BINOP(Mod);
1493                 BINOP(DivMod);
1494
1495                 UNOP(Minus);
1496                 UNOP(Conv);
1497                 UNOP(Abs);
1498                 UNOP(Not);
1499
1500                 GEN(Load);
1501                 GEN(Store);
1502                 GEN(Cond);
1503
1504                 IGN(Proj);
1505                 IGN(Call);
1506                 IGN(Alloc);
1507
1508                 IGN(Block);
1509                 IGN(Start);
1510                 IGN(End);
1511                 IGN(NoMem);
1512                 IGN(Phi);
1513                 IGN(IJmp);
1514                 IGN(Break);
1515                 IGN(Cmp);
1516                 IGN(Unknown);
1517                 /* constant transformation happens earlier */
1518                 IGN(Const);
1519                 IGN(SymConst);
1520
1521                 BAD(Raise);
1522                 BAD(Sel);
1523                 BAD(InstOf);
1524                 BAD(Cast);
1525                 BAD(Free);
1526                 BAD(Sync);
1527                 BAD(Tuple);
1528                 BAD(Id);
1529                 BAD(Bad);
1530                 BAD(Confirm);
1531                 BAD(Filter);
1532                 BAD(CallBegin);
1533                 BAD(EndReg);
1534                 BAD(EndExcept);
1535                 BAD(Mux);
1536                 BAD(CopyB);
1537
1538                 default:
1539                         if (get_irn_op(node) == get_op_Max()) {
1540                                 asm_node = gen_Max(&tenv, get_irn_n(node, 0), get_irn_n(node, 1));
1541                         }
1542                         else if (get_irn_op(node) == get_op_Min()) {
1543                                 asm_node = gen_Min(&tenv, get_irn_n(node, 0), get_irn_n(node, 1));
1544                         }
1545                         else if (get_irn_op(node) == get_op_Mulh()) {
1546                                 asm_node = gen_Mulh(&tenv, get_irn_n(node, 0), get_irn_n(node, 1));
1547                         }
1548                         break;
1549 bad:
1550                 fprintf(stderr, "Not implemented: %s\n", get_irn_opname(node));
1551                 assert(0);
1552         }
1553
1554         if (asm_node) {
1555                 exchange(node, asm_node);
1556                 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1557         }
1558         else {
1559                 DB((tenv.mod, LEVEL_1, "ignored\n"));
1560         }
1561 }