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         ir_node *noreg = ia32_new_NoReg_gp(env->cg);
 845         ir_node *nomem = new_rd_NoMem(env->irg);
 846         ir_node *new_op;
 847
 848         new_op = new_rd_ia32_fDiv(env->dbg, env->irg, env->block, noreg, noreg, op1, op2, nomem, env->mode);
 849         set_ia32_am_support(new_op, ia32_am_Source);
 850
 851         return new_op;
 852 }
 853
 854
 855
 856 /**
 857  * Creates an ia32 Shl.
 858  *
 859  * @param env   The transformation environment
 860  * @param op1   The first operator
 861  * @param op2   The second operator
 862  * @return The created ia32 Shl node
 863  */
 864 static ir_node *gen_Shl(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 865         return gen_shift_binop(env, op1, op2, new_rd_ia32_Shl);
 866 }
 867
 868
 869
 870 /**
 871  * Creates an ia32 Shr.
 872  *
 873  * @param env   The transformation environment
 874  * @param op1   The first operator
 875  * @param op2   The second operator
 876  * @return The created ia32 Shr node
 877  */
 878 static ir_node *gen_Shr(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 879         return gen_shift_binop(env, op1, op2, new_rd_ia32_Shr);
 880 }
 881
 882
 883
 884 /**
 885  * Creates an ia32 Shrs.
 886  *
 887  * @param env   The transformation environment
 888  * @param op1   The first operator
 889  * @param op2   The second operator
 890  * @return The created ia32 Shrs node
 891  */
 892 static ir_node *gen_Shrs(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 893         return gen_shift_binop(env, op1, op2, new_rd_ia32_Shrs);
 894 }
 895
 896
 897
 898 /**
 899  * Creates an ia32 RotL.
 900  *
 901  * @param env   The transformation environment
 902  * @param op1   The first operator
 903  * @param op2   The second operator
 904  * @return The created ia32 RotL node
 905  */
 906 static ir_node *gen_RotL(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 907         return gen_shift_binop(env, op1, op2, new_rd_ia32_RotL);
 908 }
 909
 910
 911
 912 /**
 913  * Creates an ia32 RotR.
 914  * NOTE: There is no RotR with immediate because this would always be a RotL
 915  *       "imm-mode_size_bits" which can be pre-calculated.
 916  *
 917  * @param env   The transformation environment
 918  * @param op1   The first operator
 919  * @param op2   The second operator
 920  * @return The created ia32 RotR node
 921  */
 922 static ir_node *gen_RotR(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 923         return gen_shift_binop(env, op1, op2, new_rd_ia32_RotR);
 924 }
 925
 926
 927
 928 /**
 929  * Creates an ia32 RotR or RotL (depending on the found pattern).
 930  *
 931  * @param env   The transformation environment
 932  * @param op1   The first operator
 933  * @param op2   The second operator
 934  * @return The created ia32 RotL or RotR node
 935  */
 936 static ir_node *gen_Rot(ia32_transform_env_t *env, ir_node *op1, ir_node *op2) {
 937         ir_node *rotate = NULL;
 938
 939         /* Firm has only Rot (which is a RotL), so we are looking for a right (op2)
 940                  operand "-e+mode_size_bits" (it's an already modified "mode_size_bits-e",
 941                  that means we can create a RotR instead of an Add and a RotL */
 942
 943         if (is_Proj(op2)) {
 944                 ir_node *pred = get_Proj_pred(op2);
 945
 946                 if (is_ia32_Add(pred)) {
 947                         ir_node *pred_pred = get_irn_n(pred, 2);
 948                         tarval  *tv        = get_ia32_Immop_tarval(pred);
 949                         long     bits      = get_mode_size_bits(env->mode);
 950
 951                         if (is_Proj(pred_pred)) {
 952                                 pred_pred = get_Proj_pred(pred_pred);
 953                         }
 954
 955                         if (is_ia32_Minus(pred_pred) &&
 956                                 tarval_is_long(tv)       &&
 957                                 get_tarval_long(tv) == bits)
 958                         {
 959                                 DB((env->mod, LEVEL_1, "RotL into RotR ... "));
 960                                 rotate = gen_RotR(env, op1, get_irn_n(pred_pred, 2));
 961                         }
 962
 963                 }
 964         }
 965
 966         if (!rotate) {
 967                 rotate = gen_RotL(env, op1, op2);
 968         }
 969
 970         return rotate;
 971 }
 972
 973
 974
 975 /**
 976  * Transforms a Conv node.
 977  *
 978  * @param env   The transformation environment
 979  * @param op    The operator
 980  * @return The created ia32 Conv node
 981  */
 982 static ir_node *gen_Conv(ia32_transform_env_t *env, ir_node *op) {
 983         return new_rd_ia32_Conv(env->dbg, env->irg, env->block, op, env->mode);
 984 }
 985
 986
 987
 988 /**
 989  * Transforms a Minus node.
 990  *
 991  * @param env   The transformation environment
 992  * @param op    The operator
 993  * @return The created ia32 Minus node
 994  */
 995 static ir_node *gen_Minus(ia32_transform_env_t *env, ir_node *op) {
 996         char    *name;
 997         ir_node *new_op;
 998         ir_node *noreg_gp = ia32_new_NoReg_gp(env->cg);
 999         ir_node *noreg_fp = ia32_new_NoReg_fp(env->cg);
1000         ir_node *nomem    = new_rd_NoMem(env->irg);
1001         int      size;
1002
1003         if (mode_is_float(env->mode)) {
1004                 new_op = new_rd_ia32_fEor(env->dbg, env->irg, env->block, noreg_gp, noreg_gp, op, noreg_fp, nomem, mode_T);
1005
1006                 size   = get_mode_size_bits(env->mode);
1007                 name   = gen_fp_known_const(env->mode, size == 32 ? ia32_SSIGN : ia32_DSIGN);
1008
1009                 set_ia32_sc(new_op, name);
1010
1011                 new_op = new_rd_Proj(env->dbg, env->irg, env->block, new_op, env->mode, 0);
1012         }
1013         else {
1014                 new_op = gen_unop(env, op, new_rd_ia32_Minus);
1015         }
1016
1017         return new_op;
1018 }
1019
1020
1021
1022 /**
1023  * Transforms a Not node.
1024  *
1025  * @param env   The transformation environment
1026  * @param op    The operator
1027  * @return The created ia32 Not node
1028  */
1029 static ir_node *gen_Not(ia32_transform_env_t *env, ir_node *op) {
1030         ir_node *new_op;
1031
1032         if (mode_is_float(env->mode)) {
1033                 assert(0);
1034         }
1035         else {
1036                 new_op = gen_unop(env, op, new_rd_ia32_Not);
1037         }
1038
1039         return new_op;
1040 }
1041
1042
1043
1044 /**
1045  * Transforms an Abs node.
1046  *
1047  * @param env   The transformation environment
1048  * @param op    The operator
1049  * @return The created ia32 Abs node
1050  */
1051 static ir_node *gen_Abs(ia32_transform_env_t *env, ir_node *op) {
1052         ir_node  *res, *p_eax, *p_edx;
1053         dbg_info *dbg      = env->dbg;
1054         ir_mode  *mode     = env->mode;
1055         ir_graph *irg      = env->irg;
1056         ir_node  *block    = env->block;
1057         ir_node  *noreg_gp = ia32_new_NoReg_gp(env->cg);
1058         ir_node  *noreg_fp = ia32_new_NoReg_fp(env->cg);
1059         ir_node  *nomem    = new_NoMem();
1060         int       size;
1061         char     *name;
1062
1063         if (mode_is_float(mode)) {
1064                 res = new_rd_ia32_fAnd(dbg,irg, block, noreg_gp, noreg_gp, op, noreg_fp, nomem, mode_T);
1065
1066                 size   = get_mode_size_bits(mode);
1067                 name   = gen_fp_known_const(mode, size == 32 ? ia32_SABS : ia32_DABS);
1068
1069                 set_ia32_sc(res, name);
1070
1071                 res = new_rd_Proj(dbg, irg, block, res, mode, 0);
1072         }
1073         else {
1074                 res   = new_rd_ia32_Cdq(dbg, irg, block, op, mode_T);
1075                 p_eax = new_rd_Proj(dbg, irg, block, res, mode, pn_EAX);
1076                 p_edx = new_rd_Proj(dbg, irg, block, res, mode, pn_EDX);
1077                 res   = new_rd_ia32_Eor(dbg, irg, block, noreg_gp, noreg_gp, p_eax, p_edx, nomem, mode_T);
1078                 res   = new_rd_Proj(dbg, irg, block, res, mode, 0);
1079                 res   = new_rd_ia32_Sub(dbg, irg, block, noreg_gp, noreg_gp, res, p_edx, nomem, mode_T);
1080                 res   = new_rd_Proj(dbg, irg, block, res, mode, 0);
1081         }
1082
1083         return res;
1084 }
1085
1086
1087
1088 /**
1089  * Transforms a Load.
1090  *
1091  * @param mod     the debug module
1092  * @param block   the block the new node should belong to
1093  * @param node    the ir Load node
1094  * @param mode    node mode
1095  * @return the created ia32 Load node
1096  */
1097 static ir_node *gen_Load(ia32_transform_env_t *env) {
1098         ir_node *node  = env->irn;
1099         ir_node *noreg = ia32_new_NoReg_gp(env->cg);
1100         ir_node *new_op;
1101
1102         if (mode_is_float(env->mode)) {
1103                 new_op = new_rd_ia32_fLoad(env->dbg, env->irg, env->block, get_Load_ptr(node), noreg, get_Load_mem(node), env->mode);
1104         }
1105         else {
1106                 new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, get_Load_ptr(node), noreg, get_Load_mem(node), env->mode);
1107         }
1108
1109         set_ia32_am_support(new_op, ia32_am_Source);
1110         return new_op;
1111 }
1112
1113
1114
1115 /**
1116  * Transforms a Store.
1117  *
1118  * @param mod     the debug module
1119  * @param block   the block the new node should belong to
1120  * @param node    the ir Store node
1121  * @param mode    node mode
1122  * @return the created ia32 Store node
1123  */
1124 ir_node *gen_Store(ia32_transform_env_t *env) {
1125         ir_node *node  = env->irn;
1126         ir_node *noreg = ia32_new_NoReg_gp(env->cg);
1127         ir_node *new_op;
1128
1129         if (mode_is_float(env->mode)) {
1130                 new_op = 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);
1131         }
1132         else {
1133                 new_op = 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);
1134         }
1135
1136         set_ia32_am_support(new_op, ia32_am_Dest);
1137         return new_op;
1138 }
1139
1140
1141
1142 /**
1143  * Transforms a Call and its arguments corresponding to the calling convention.
1144  *
1145  * @param mod     the debug module
1146  * @param block   the block the new node should belong to
1147  * @param node    the ir Call node
1148  * @param dummy   mode doesn't matter
1149  * @return the created ia32 Call node
1150  */
1151 static ir_node *gen_Call(ia32_transform_env_t *env) {
1152 #if 0
1153         const ia32_register_req_t **in_req;
1154         ir_node          **in;
1155         ir_node           *new_call, *sync;
1156         int                i, j, n_new_call_in, ignore = 0;
1157         ia32_attr_t       *attr;
1158         dbg_info          *dbg          = env->dbg;
1159         ir_graph          *irg          = env->irg;
1160         ir_node           *block        = env->block;
1161         ir_node           *call         = env->irn;
1162         ir_node          **stack_param  = NULL;
1163         ir_node          **param        = get_Call_param_arr(call);
1164         ir_node           *call_Mem     = get_Call_mem(call);
1165         unsigned           cc           = get_method_calling_convention(get_Call_type(call));
1166         int                n            = get_Call_n_params(call);
1167         int                stack_idx    = 0;
1168         int                biggest_n    = -1;
1169         int                n_res        = get_method_n_ress(get_Call_type(call));
1170
1171         assert(n_res <= 2 && "method with more than two results not supported");
1172
1173         if (cc & cc_reg_param)
1174                 biggest_n = ia32_get_n_regparam_class(n, param, &ignore, &ignore);
1175
1176         /* remember: biggest_n = x means we can pass (x + 1) parameters in register */
1177
1178         /* do we need to pass arguments on stack? */
1179         if (biggest_n + 1 < n)
1180                 stack_param = xcalloc(n - biggest_n - 1, sizeof(ir_node *));
1181
1182         /* we need at least one in, either for the stack params or the call_Mem */
1183         n_new_call_in = biggest_n + 2;
1184
1185         /* the call has one IN for all stack parameter and one IN for each reg param */
1186         in     = xcalloc(n_new_call_in, sizeof(ir_node *));
1187         in_req = xcalloc(n_new_call_in, sizeof(arch_register_req_t *));
1188
1189         /* loop over all parameters and set the register requirements */
1190         for (i = 0; i <= biggest_n && (cc & cc_reg_param); i++) {
1191                 in_req[i] = ia32_get_RegParam_req(n, param, i, cc);
1192         }
1193         stack_idx = i;
1194
1195         /* create remaining stack parameters */
1196         if (cc & cc_last_on_top) {
1197                 for (i = stack_idx; i < n; i++) {
1198                         /* pass it on stack */
1199                         if (mode_is_float(get_irn_mode(param[i]))) {
1200                                 stack_param[i - stack_idx] = new_rd_ia32_fStackArg(get_irn_dbg_info(param[i]), irg,
1201                                                                                                                 block, call_Mem, param[i], mode_M);
1202                         }
1203                         else {
1204                                 stack_param[i - stack_idx] = new_rd_ia32_StackArg(get_irn_dbg_info(param[i]), irg,
1205                                                                                                                 block, call_Mem, param[i], mode_M);
1206                         }
1207                         /* set the argument number for later lowering */
1208                         set_ia32_pncode(stack_param[i - stack_idx], i - stack_idx);
1209                 }
1210         }
1211         else {
1212                 for (i = n - 1, j = 0; i >= stack_idx; i--, j++) {
1213                         /* pass it on stack */
1214                         if (mode_is_float(get_irn_mode(param[i]))) {
1215                                 stack_param[j] = new_rd_ia32_fStackArg(get_irn_dbg_info(param[i]), irg,
1216                                                                                                                 block, call_Mem, param[i], mode_M);
1217                         }
1218                         else {
1219                                 stack_param[j] = new_rd_ia32_StackArg(get_irn_dbg_info(param[i]), irg,
1220                                                                                                                 block, call_Mem, param[i], mode_M);
1221                         }
1222                         /* set the argument number for later lowering */
1223                         set_ia32_pncode(stack_param[j], j);
1224                 }
1225         }
1226
1227         if (stack_param) {
1228                 sync = new_r_Sync(irg, block, n - biggest_n - 1, stack_param);
1229                 in[n_new_call_in - 1] = sync;
1230         }
1231         else {
1232                 in[n_new_call_in - 1] = call_Mem;
1233         }
1234
1235         /* create the new node */
1236         new_call = new_rd_ia32_Call(dbg, irg, block, n_new_call_in, in);
1237         set_ia32_Immop_attr(new_call, get_Call_ptr(call));
1238
1239         /* set register requirements for in and out */
1240         attr             = get_ia32_attr(new_call);
1241         attr->in_req     = in_req;
1242
1243         set_ia32_n_res(new_call, n_res);
1244
1245         if (n_res > 0) {
1246                 attr->out_req    = xcalloc(n_res, sizeof(ia32_register_req_t *));
1247                 attr->slots      = xcalloc(n_res, sizeof(arch_register_t *));
1248         }
1249
1250         /* two results only appear when a 64bit int result is broken up into two 32bit results */
1251         if (n_res == 1) {
1252                 if (mode_is_float(get_type_mode(get_method_res_type(get_Call_type(call), 0))))
1253                         attr->out_req[0] = &ia32_default_req_ia32_fp_xmm0;
1254                 else
1255                         attr->out_req[0] = &ia32_default_req_ia32_gp_eax;
1256         }
1257         else if (n_res == 2) {
1258                 attr->out_req[0] = &ia32_default_req_ia32_gp_eax;
1259                 attr->out_req[1] = &ia32_default_req_ia32_gp_edx;
1260         }
1261
1262         /* stack parameter has no OUT register */
1263         attr->in_req[n_new_call_in - 1] = &ia32_default_req_none;
1264
1265         return new_call;
1266 #endif
1267 }
1268
1269
1270
1271 /**
1272  * Transforms a Cond -> Proj[b] -> Cmp into a CondJmp or CondJmp_i
1273  *
1274  * @param env   The transformation environment
1275  * @return The transformed node.
1276  */
1277 static ir_node *gen_Cond(ia32_transform_env_t *env) {
1278         dbg_info *dbg      = env->dbg;
1279         ir_graph *irg      = env->irg;
1280         ir_node  *block    = env->block;
1281         ir_node  *node     = env->irn;
1282         ir_node  *sel      = get_Cond_selector(node);
1283         ir_mode  *sel_mode = get_irn_mode(sel);
1284         ir_node  *res      = NULL;
1285         ir_node  *pred     = NULL;
1286         ir_node  *noreg    = ia32_new_NoReg_gp(env->cg);
1287         ir_node  *nomem    = new_NoMem();
1288         ir_node  *cmp_a, *cmp_b, *cnst, *expr;
1289
1290         if (is_Proj(sel) && sel_mode == mode_b) {
1291                 pred  = get_Proj_pred(sel);
1292
1293                 /* get both compare operators */
1294                 cmp_a = get_Cmp_left(pred);
1295                 cmp_b = get_Cmp_right(pred);
1296
1297                 /* check if we can use a CondJmp with immediate */
1298                 cnst = get_immediate_op(cmp_a, cmp_b);
1299                 expr = get_expr_op(cmp_a, cmp_b);
1300
1301                 if (cnst && expr) {
1302                         res = new_rd_ia32_CondJmp(dbg, irg, block, noreg, noreg, expr, noreg, nomem, mode_T);
1303                         set_ia32_Immop_attr(res, cnst);
1304                 }
1305                 else {
1306                         res = new_rd_ia32_CondJmp(dbg, irg, block, noreg, noreg, cmp_a, cmp_b, nomem, mode_T);
1307                 }
1308
1309                 set_ia32_pncode(res, get_Proj_proj(sel));
1310         }
1311         else {
1312                 res = new_rd_ia32_SwitchJmp(dbg, irg, block, noreg, noreg, sel, nomem, mode_T);
1313                 set_ia32_pncode(res, get_Cond_defaultProj(node));
1314         }
1315
1316         return res;
1317 }
1318
1319
1320
1321 /**
1322  * Transform the argument projs from a start node corresponding to the
1323  * calling convention.
1324  * It transforms "Proj Arg x -> ProjT -> Start <- ProjM" into
1325  * "RegParam x   -> ProjT -> Start" OR
1326  * "StackParam x -> ProjM -> Start"
1327  * whether parameter is passed in register or on stack.
1328  *
1329  * @param mod     the debug module
1330  * @param block   the block the nodes should belong to
1331  * @param proj    the ProjT node which points to Start
1332  * @param start   the Start node
1333  * @return Should be always NULL
1334  */
1335 static ir_node *gen_Proj_Start(ia32_transform_env_t *env, ir_node *proj, ir_node *start) {
1336 #if 0
1337         const ia32_register_req_t *temp_req;
1338         const ir_edge_t   *edge;
1339         ir_node           *succ, *irn;
1340         ir_node          **projargs;
1341         ir_mode           *mode;
1342         int                n, i;
1343         unsigned           cc;
1344         ir_node           *proj_M     = get_irg_initial_mem(current_ir_graph);
1345         entity            *irg_ent    = get_irg_entity(current_ir_graph);
1346         ir_type           *tp         = get_entity_type(irg_ent);
1347         int                cur_pn     = 0;
1348         ir_graph          *irg        = env->irg;
1349         ir_node           *block      = env->block;
1350
1351         assert(is_Method_type(tp) && "irg type is not a method");
1352
1353         switch(get_Proj_proj(proj)) {
1354                 case pn_Start_T_args:
1355                         /* We cannot use get_method_n_params here as the function might
1356                            be variadic or one argument is not used. */
1357                         n = get_irn_n_edges(proj);
1358
1359                         /* Allocate memory for all non variadic parameters in advance to be on the save side */
1360                         env->cg->reg_param_req = xcalloc(get_method_n_params(tp), sizeof(ia32_register_req_t *));
1361
1362                         /* we are done here when there are no parameters */
1363                         if (n < 1)
1364                                 break;
1365
1366                         /* temporary remember all proj arg x */
1367                         projargs = xcalloc(n, sizeof(ir_node *));
1368
1369                         i = 0;
1370                         foreach_out_edge((const ir_node *)proj, edge) {
1371                                 succ = get_edge_src_irn(edge);
1372                                 assert(is_Proj(succ) && "non-Proj from a Proj_T (pn_Start_T_args).");
1373                                 projargs[i++] = succ;
1374                         }
1375
1376                         cc = get_method_calling_convention(tp);
1377
1378                         /* loop over all parameters and check whether its a int or float */
1379                         for (i = 0; i < n; i++) {
1380                                 mode   = get_irn_mode(projargs[i]);
1381                                 cur_pn = get_Proj_proj(projargs[i]);
1382
1383                                 if (cc & cc_reg_param) {
1384                                         temp_req = ia32_get_RegParam_req(n, projargs, cur_pn, cc);
1385                                 }
1386                                 else {
1387                                         temp_req = NULL;
1388                                 }
1389
1390                                 if (temp_req) {
1391                                         /* passed in register */
1392                                         env->cg->reg_param_req[cur_pn] = temp_req;
1393                                 }
1394                                 else {
1395                                         /* passed on stack */
1396                                         if (mode_is_float(mode))
1397                                                 irn = new_rd_ia32_fStackParam(get_irn_dbg_info(projargs[i]), irg, block, proj_M, mode);
1398                                         else
1399                                                 irn = new_rd_ia32_StackParam(get_irn_dbg_info(projargs[i]), irg, block, proj_M, mode);
1400
1401                                         set_ia32_pncode(irn, cur_pn);
1402
1403                                         /* kill the old "Proj Arg" and replace with the new stack param */
1404                                         exchange(projargs[i], irn);
1405                                 }
1406                         }
1407
1408                         free(projargs);
1409
1410                         break;
1411                 case pn_Start_P_frame_base:
1412                 case pn_Start_X_initial_exec:
1413                 case pn_Start_M:
1414                 case pn_Start_P_globals:
1415                 case pn_Start_P_value_arg_base:
1416                         break;
1417                 default:
1418                         assert(0 && "unsupported Proj(Start)");
1419         }
1420
1421         return NULL;
1422 #endif
1423 }
1424
1425 /**
1426  * Transform some Proj's (Proj_Proj, Proj_Start, Proj_Cmp, Proj_Cond, Proj_Call).
1427  * All others are ignored.
1428  *
1429  * @param mod     the debug module
1430  * @param block   the block the new node should belong to
1431  * @param node    the ir Proj node
1432  * @param mode    mode of the Proj
1433  * @return The transformed node.
1434  */
1435 static ir_node *gen_Proj(ia32_transform_env_t *env) {
1436         ir_node *new_node  = NULL;
1437         ir_node *pred      = get_Proj_pred(env->irn);
1438
1439         if (env->mode == mode_M)
1440                 return NULL;
1441
1442         if (get_irn_op(pred) == op_Start) {
1443                 new_node = gen_Proj_Start(env, env->irn, pred);
1444         }
1445
1446         return new_node;
1447 }
1448
1449
1450
1451 /*********************************************************
1452  *                  _             _      _
1453  *                 (_)           | |    (_)
1454  *  _ __ ___   __ _ _ _ __     __| |_ __ ___   _____ _ __
1455  * | '_ ` _ \ / _` | | '_ \   / _` | '__| \ \ / / _ \ '__|
1456  * | | | | | | (_| | | | | | | (_| | |  | |\ V /  __/ |
1457  * |_| |_| |_|\__,_|_|_| |_|  \__,_|_|  |_| \_/ \___|_|
1458  *
1459  *********************************************************/
1460
1461
1462
1463 /**
1464  * Transforms the given firm node (and maybe some other related nodes)
1465  * into one or more assembler nodes.
1466  *
1467  * @param node    the firm node
1468  * @param env     the debug module
1469  */
1470 void ia32_transform_node(ir_node *node, void *env) {
1471         ia32_code_gen_t *cgenv = (ia32_code_gen_t *)env;
1472         opcode  code           = get_irn_opcode(node);
1473         ir_node *asm_node      = NULL;
1474         ia32_transform_env_t  tenv;
1475
1476         if (is_Block(node))
1477                 return;
1478
1479         tenv.arch_env = cgenv->arch_env;
1480         tenv.block    = get_nodes_block(node);
1481         tenv.dbg      = get_irn_dbg_info(node);
1482         tenv.irg      = current_ir_graph;
1483         tenv.irn      = node;
1484         tenv.mod      = cgenv->mod;
1485         tenv.mode     = get_irn_mode(node);
1486         tenv.cg       = cgenv;
1487
1488 #define UNOP(a)  case iro_##a: asm_node = gen_##a(&tenv, get_##a##_op(node)); break
1489 #define BINOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_left(node), get_##a##_right(node)); break
1490 #define GEN(a)   case iro_##a: asm_node = gen_##a(&tenv); break
1491 #define IGN(a)   case iro_##a: break
1492 #define BAD(a)   case iro_##a: goto bad
1493
1494         DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
1495
1496         switch (code) {
1497                 BINOP(Add);
1498                 BINOP(Sub);
1499                 BINOP(Mul);
1500                 BINOP(And);
1501                 BINOP(Or);
1502                 BINOP(Eor);
1503
1504                 BINOP(Shl);
1505                 BINOP(Shr);
1506                 BINOP(Shrs);
1507
1508                 BINOP(Quot);
1509
1510                 BINOP(Div);
1511                 BINOP(Mod);
1512                 BINOP(DivMod);
1513
1514                 UNOP(Minus);
1515                 UNOP(Conv);
1516                 UNOP(Abs);
1517                 UNOP(Not);
1518
1519                 GEN(Load);
1520                 GEN(Store);
1521                 GEN(Cond);
1522
1523                 IGN(Proj);
1524                 IGN(Call);
1525                 IGN(Alloc);
1526
1527                 IGN(Block);
1528                 IGN(Start);
1529                 IGN(End);
1530                 IGN(NoMem);
1531                 IGN(Phi);
1532                 IGN(IJmp);
1533                 IGN(Break);
1534                 IGN(Cmp);
1535                 IGN(Unknown);
1536                 /* constant transformation happens earlier */
1537                 IGN(Const);
1538                 IGN(SymConst);
1539
1540                 BAD(Raise);
1541                 BAD(Sel);
1542                 BAD(InstOf);
1543                 BAD(Cast);
1544                 BAD(Free);
1545                 BAD(Sync);
1546                 BAD(Tuple);
1547                 BAD(Id);
1548                 BAD(Bad);
1549                 BAD(Confirm);
1550                 BAD(Filter);
1551                 BAD(CallBegin);
1552                 BAD(EndReg);
1553                 BAD(EndExcept);
1554                 BAD(Mux);
1555                 BAD(CopyB);
1556
1557                 default:
1558                         if (get_irn_op(node) == get_op_Max()) {
1559                                 asm_node = gen_Max(&tenv, get_irn_n(node, 0), get_irn_n(node, 1));
1560                         }
1561                         else if (get_irn_op(node) == get_op_Min()) {
1562                                 asm_node = gen_Min(&tenv, get_irn_n(node, 0), get_irn_n(node, 1));
1563                         }
1564                         else if (get_irn_op(node) == get_op_Mulh()) {
1565                                 asm_node = gen_Mulh(&tenv, get_irn_n(node, 0), get_irn_n(node, 1));
1566                         }
1567                         break;
1568 bad:
1569                 fprintf(stderr, "Not implemented: %s\n", get_irn_opname(node));
1570                 assert(0);
1571         }
1572
1573         if (asm_node) {
1574                 exchange(node, asm_node);
1575                 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1576         }
1577         else {
1578                 DB((tenv.mod, LEVEL_1, "ignored\n"));
1579         }
1580 }