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         ir_node *new_op;
1094
1095         if (mode_is_float(env->mode)) {
1096                 new_op = new_rd_ia32_fLoad(env->dbg, env->irg, env->block, get_Load_ptr(node), noreg, get_Load_mem(node), env->mode);
1097         }
1098         else {
1099                 new_op = new_rd_ia32_Load(env->dbg, env->irg, env->block, get_Load_ptr(node), noreg, get_Load_mem(node), env->mode);
1100         }
1101
1102         set_ia32_am_support(new_op, ia32_am_Source);
1103         return new_op;
1104 }
1105
1106
1107
1108 /**
1109  * Transforms a Store.
1110  *
1111  * @param mod     the debug module
1112  * @param block   the block the new node should belong to
1113  * @param node    the ir Store node
1114  * @param mode    node mode
1115  * @return the created ia32 Store node
1116  */
1117 ir_node *gen_Store(ia32_transform_env_t *env) {
1118         ir_node *node  = env->irn;
1119         ir_node *noreg = ia32_new_NoReg_gp(env->cg);
1120         ir_node *new_op;
1121
1122         if (mode_is_float(env->mode)) {
1123                 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);
1124         }
1125         else {
1126                 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);
1127         }
1128
1129         set_ia32_am_support(new_op, ia32_am_Dest);
1130         return new_op;
1131 }
1132
1133
1134
1135 /**
1136  * Transforms a Call and its arguments corresponding to the calling convention.
1137  *
1138  * @param mod     the debug module
1139  * @param block   the block the new node should belong to
1140  * @param node    the ir Call node
1141  * @param dummy   mode doesn't matter
1142  * @return the created ia32 Call node
1143  */
1144 static ir_node *gen_Call(ia32_transform_env_t *env) {
1145 #if 0
1146         const ia32_register_req_t **in_req;
1147         ir_node          **in;
1148         ir_node           *new_call, *sync;
1149         int                i, j, n_new_call_in, ignore = 0;
1150         ia32_attr_t       *attr;
1151         dbg_info          *dbg          = env->dbg;
1152         ir_graph          *irg          = env->irg;
1153         ir_node           *block        = env->block;
1154         ir_node           *call         = env->irn;
1155         ir_node          **stack_param  = NULL;
1156         ir_node          **param        = get_Call_param_arr(call);
1157         ir_node           *call_Mem     = get_Call_mem(call);
1158         unsigned           cc           = get_method_calling_convention(get_Call_type(call));
1159         int                n            = get_Call_n_params(call);
1160         int                stack_idx    = 0;
1161         int                biggest_n    = -1;
1162         int                n_res        = get_method_n_ress(get_Call_type(call));
1163
1164         assert(n_res <= 2 && "method with more than two results not supported");
1165
1166         if (cc & cc_reg_param)
1167                 biggest_n = ia32_get_n_regparam_class(n, param, &ignore, &ignore);
1168
1169         /* remember: biggest_n = x means we can pass (x + 1) parameters in register */
1170
1171         /* do we need to pass arguments on stack? */
1172         if (biggest_n + 1 < n)
1173                 stack_param = xcalloc(n - biggest_n - 1, sizeof(ir_node *));
1174
1175         /* we need at least one in, either for the stack params or the call_Mem */
1176         n_new_call_in = biggest_n + 2;
1177
1178         /* the call has one IN for all stack parameter and one IN for each reg param */
1179         in     = xcalloc(n_new_call_in, sizeof(ir_node *));
1180         in_req = xcalloc(n_new_call_in, sizeof(arch_register_req_t *));
1181
1182         /* loop over all parameters and set the register requirements */
1183         for (i = 0; i <= biggest_n && (cc & cc_reg_param); i++) {
1184                 in_req[i] = ia32_get_RegParam_req(n, param, i, cc);
1185         }
1186         stack_idx = i;
1187
1188         /* create remaining stack parameters */
1189         if (cc & cc_last_on_top) {
1190                 for (i = stack_idx; i < n; i++) {
1191                         /* pass it on stack */
1192                         if (mode_is_float(get_irn_mode(param[i]))) {
1193                                 stack_param[i - stack_idx] = new_rd_ia32_fStackArg(get_irn_dbg_info(param[i]), irg,
1194                                                                                                                 block, call_Mem, param[i], mode_M);
1195                         }
1196                         else {
1197                                 stack_param[i - stack_idx] = new_rd_ia32_StackArg(get_irn_dbg_info(param[i]), irg,
1198                                                                                                                 block, call_Mem, param[i], mode_M);
1199                         }
1200                         /* set the argument number for later lowering */
1201                         set_ia32_pncode(stack_param[i - stack_idx], i - stack_idx);
1202                 }
1203         }
1204         else {
1205                 for (i = n - 1, j = 0; i >= stack_idx; i--, j++) {
1206                         /* pass it on stack */
1207                         if (mode_is_float(get_irn_mode(param[i]))) {
1208                                 stack_param[j] = new_rd_ia32_fStackArg(get_irn_dbg_info(param[i]), irg,
1209                                                                                                                 block, call_Mem, param[i], mode_M);
1210                         }
1211                         else {
1212                                 stack_param[j] = new_rd_ia32_StackArg(get_irn_dbg_info(param[i]), irg,
1213                                                                                                                 block, call_Mem, param[i], mode_M);
1214                         }
1215                         /* set the argument number for later lowering */
1216                         set_ia32_pncode(stack_param[j], j);
1217                 }
1218         }
1219
1220         if (stack_param) {
1221                 sync = new_r_Sync(irg, block, n - biggest_n - 1, stack_param);
1222                 in[n_new_call_in - 1] = sync;
1223         }
1224         else {
1225                 in[n_new_call_in - 1] = call_Mem;
1226         }
1227
1228         /* create the new node */
1229         new_call = new_rd_ia32_Call(dbg, irg, block, n_new_call_in, in);
1230         set_ia32_Immop_attr(new_call, get_Call_ptr(call));
1231
1232         /* set register requirements for in and out */
1233         attr             = get_ia32_attr(new_call);
1234         attr->in_req     = in_req;
1235
1236         set_ia32_n_res(new_call, n_res);
1237
1238         if (n_res > 0) {
1239                 attr->out_req    = xcalloc(n_res, sizeof(ia32_register_req_t *));
1240                 attr->slots      = xcalloc(n_res, sizeof(arch_register_t *));
1241         }
1242
1243         /* two results only appear when a 64bit int result is broken up into two 32bit results */
1244         if (n_res == 1) {
1245                 if (mode_is_float(get_type_mode(get_method_res_type(get_Call_type(call), 0))))
1246                         attr->out_req[0] = &ia32_default_req_ia32_fp_xmm0;
1247                 else
1248                         attr->out_req[0] = &ia32_default_req_ia32_gp_eax;
1249         }
1250         else if (n_res == 2) {
1251                 attr->out_req[0] = &ia32_default_req_ia32_gp_eax;
1252                 attr->out_req[1] = &ia32_default_req_ia32_gp_edx;
1253         }
1254
1255         /* stack parameter has no OUT register */
1256         attr->in_req[n_new_call_in - 1] = &ia32_default_req_none;
1257
1258         return new_call;
1259 #endif
1260 }
1261
1262
1263
1264 /**
1265  * Transforms a Cond -> Proj[b] -> Cmp into a CondJmp or CondJmp_i
1266  *
1267  * @param env   The transformation environment
1268  * @return The transformed node.
1269  */
1270 static ir_node *gen_Cond(ia32_transform_env_t *env) {
1271         dbg_info *dbg      = env->dbg;
1272         ir_graph *irg      = env->irg;
1273         ir_node  *block    = env->block;
1274         ir_node  *node     = env->irn;
1275         ir_node  *sel      = get_Cond_selector(node);
1276         ir_mode  *sel_mode = get_irn_mode(sel);
1277         ir_node  *res      = NULL;
1278         ir_node  *pred     = NULL;
1279         ir_node  *noreg    = ia32_new_NoReg_gp(env->cg);
1280         ir_node  *nomem    = new_NoMem();
1281         ir_node  *cmp_a, *cmp_b, *cnst, *expr;
1282
1283         if (is_Proj(sel) && sel_mode == mode_b) {
1284                 pred  = get_Proj_pred(sel);
1285
1286                 /* get both compare operators */
1287                 cmp_a = get_Cmp_left(pred);
1288                 cmp_b = get_Cmp_right(pred);
1289
1290                 /* check if we can use a CondJmp with immediate */
1291                 cnst = get_immediate_op(cmp_a, cmp_b);
1292                 expr = get_expr_op(cmp_a, cmp_b);
1293
1294                 if (cnst && expr) {
1295                         res = new_rd_ia32_CondJmp(dbg, irg, block, noreg, noreg, expr, noreg, nomem, mode_T);
1296                         set_ia32_Immop_attr(res, cnst);
1297                 }
1298                 else {
1299                         res = new_rd_ia32_CondJmp(dbg, irg, block, noreg, noreg, cmp_a, cmp_b, nomem, mode_T);
1300                 }
1301
1302                 set_ia32_pncode(res, get_Proj_proj(sel));
1303         }
1304         else {
1305                 res = new_rd_ia32_SwitchJmp(dbg, irg, block, noreg, noreg, sel, nomem, mode_T);
1306                 set_ia32_pncode(res, get_Cond_defaultProj(node));
1307         }
1308
1309         return res;
1310 }
1311
1312
1313
1314 /**
1315  * Transform the argument projs from a start node corresponding to the
1316  * calling convention.
1317  * It transforms "Proj Arg x -> ProjT -> Start <- ProjM" into
1318  * "RegParam x   -> ProjT -> Start" OR
1319  * "StackParam x -> ProjM -> Start"
1320  * whether parameter is passed in register or on stack.
1321  *
1322  * @param mod     the debug module
1323  * @param block   the block the nodes should belong to
1324  * @param proj    the ProjT node which points to Start
1325  * @param start   the Start node
1326  * @return Should be always NULL
1327  */
1328 static ir_node *gen_Proj_Start(ia32_transform_env_t *env, ir_node *proj, ir_node *start) {
1329 #if 0
1330         const ia32_register_req_t *temp_req;
1331         const ir_edge_t   *edge;
1332         ir_node           *succ, *irn;
1333         ir_node          **projargs;
1334         ir_mode           *mode;
1335         int                n, i;
1336         unsigned           cc;
1337         ir_node           *proj_M     = get_irg_initial_mem(current_ir_graph);
1338         entity            *irg_ent    = get_irg_entity(current_ir_graph);
1339         ir_type           *tp         = get_entity_type(irg_ent);
1340         int                cur_pn     = 0;
1341         ir_graph          *irg        = env->irg;
1342         ir_node           *block      = env->block;
1343
1344         assert(is_Method_type(tp) && "irg type is not a method");
1345
1346         switch(get_Proj_proj(proj)) {
1347                 case pn_Start_T_args:
1348                         /* We cannot use get_method_n_params here as the function might
1349                            be variadic or one argument is not used. */
1350                         n = get_irn_n_edges(proj);
1351
1352                         /* Allocate memory for all non variadic parameters in advance to be on the save side */
1353                         env->cg->reg_param_req = xcalloc(get_method_n_params(tp), sizeof(ia32_register_req_t *));
1354
1355                         /* we are done here when there are no parameters */
1356                         if (n < 1)
1357                                 break;
1358
1359                         /* temporary remember all proj arg x */
1360                         projargs = xcalloc(n, sizeof(ir_node *));
1361
1362                         i = 0;
1363                         foreach_out_edge((const ir_node *)proj, edge) {
1364                                 succ = get_edge_src_irn(edge);
1365                                 assert(is_Proj(succ) && "non-Proj from a Proj_T (pn_Start_T_args).");
1366                                 projargs[i++] = succ;
1367                         }
1368
1369                         cc = get_method_calling_convention(tp);
1370
1371                         /* loop over all parameters and check whether its a int or float */
1372                         for (i = 0; i < n; i++) {
1373                                 mode   = get_irn_mode(projargs[i]);
1374                                 cur_pn = get_Proj_proj(projargs[i]);
1375
1376                                 if (cc & cc_reg_param) {
1377                                         temp_req = ia32_get_RegParam_req(n, projargs, cur_pn, cc);
1378                                 }
1379                                 else {
1380                                         temp_req = NULL;
1381                                 }
1382
1383                                 if (temp_req) {
1384                                         /* passed in register */
1385                                         env->cg->reg_param_req[cur_pn] = temp_req;
1386                                 }
1387                                 else {
1388                                         /* passed on stack */
1389                                         if (mode_is_float(mode))
1390                                                 irn = new_rd_ia32_fStackParam(get_irn_dbg_info(projargs[i]), irg, block, proj_M, mode);
1391                                         else
1392                                                 irn = new_rd_ia32_StackParam(get_irn_dbg_info(projargs[i]), irg, block, proj_M, mode);
1393
1394                                         set_ia32_pncode(irn, cur_pn);
1395
1396                                         /* kill the old "Proj Arg" and replace with the new stack param */
1397                                         exchange(projargs[i], irn);
1398                                 }
1399                         }
1400
1401                         free(projargs);
1402
1403                         break;
1404                 case pn_Start_P_frame_base:
1405                 case pn_Start_X_initial_exec:
1406                 case pn_Start_M:
1407                 case pn_Start_P_globals:
1408                 case pn_Start_P_value_arg_base:
1409                         break;
1410                 default:
1411                         assert(0 && "unsupported Proj(Start)");
1412         }
1413
1414         return NULL;
1415 #endif
1416 }
1417
1418 /**
1419  * Transform some Proj's (Proj_Proj, Proj_Start, Proj_Cmp, Proj_Cond, Proj_Call).
1420  * All others are ignored.
1421  *
1422  * @param mod     the debug module
1423  * @param block   the block the new node should belong to
1424  * @param node    the ir Proj node
1425  * @param mode    mode of the Proj
1426  * @return The transformed node.
1427  */
1428 static ir_node *gen_Proj(ia32_transform_env_t *env) {
1429         ir_node *new_node  = NULL;
1430         ir_node *pred      = get_Proj_pred(env->irn);
1431
1432         if (env->mode == mode_M)
1433                 return NULL;
1434
1435         if (get_irn_op(pred) == op_Start) {
1436                 new_node = gen_Proj_Start(env, env->irn, pred);
1437         }
1438
1439         return new_node;
1440 }
1441
1442
1443
1444 /*********************************************************
1445  *                  _             _      _
1446  *                 (_)           | |    (_)
1447  *  _ __ ___   __ _ _ _ __     __| |_ __ ___   _____ _ __
1448  * | '_ ` _ \ / _` | | '_ \   / _` | '__| \ \ / / _ \ '__|
1449  * | | | | | | (_| | | | | | | (_| | |  | |\ V /  __/ |
1450  * |_| |_| |_|\__,_|_|_| |_|  \__,_|_|  |_| \_/ \___|_|
1451  *
1452  *********************************************************/
1453
1454
1455
1456 /**
1457  * Transforms the given firm node (and maybe some other related nodes)
1458  * into one or more assembler nodes.
1459  *
1460  * @param node    the firm node
1461  * @param env     the debug module
1462  */
1463 void ia32_transform_node(ir_node *node, void *env) {
1464         ia32_code_gen_t *cgenv = (ia32_code_gen_t *)env;
1465         opcode  code           = get_irn_opcode(node);
1466         ir_node *asm_node      = NULL;
1467         ia32_transform_env_t  tenv;
1468
1469         if (is_Block(node))
1470                 return;
1471
1472         tenv.arch_env = cgenv->arch_env;
1473         tenv.block    = get_nodes_block(node);
1474         tenv.dbg      = get_irn_dbg_info(node);
1475         tenv.irg      = current_ir_graph;
1476         tenv.irn      = node;
1477         tenv.mod      = cgenv->mod;
1478         tenv.mode     = get_irn_mode(node);
1479         tenv.cg       = cgenv;
1480
1481 #define UNOP(a)  case iro_##a: asm_node = gen_##a(&tenv, get_##a##_op(node)); break
1482 #define BINOP(a) case iro_##a: asm_node = gen_##a(&tenv, get_##a##_left(node), get_##a##_right(node)); break
1483 #define GEN(a)   case iro_##a: asm_node = gen_##a(&tenv); break
1484 #define IGN(a)   case iro_##a: break
1485 #define BAD(a)   case iro_##a: goto bad
1486
1487         DBG((tenv.mod, LEVEL_1, "check %+F ... ", node));
1488
1489         switch (code) {
1490                 BINOP(Add);
1491                 BINOP(Sub);
1492                 BINOP(Mul);
1493                 BINOP(And);
1494                 BINOP(Or);
1495                 BINOP(Eor);
1496
1497                 BINOP(Shl);
1498                 BINOP(Shr);
1499                 BINOP(Shrs);
1500
1501                 BINOP(Quot);
1502
1503                 BINOP(Div);
1504                 BINOP(Mod);
1505                 BINOP(DivMod);
1506
1507                 UNOP(Minus);
1508                 UNOP(Conv);
1509                 UNOP(Abs);
1510                 UNOP(Not);
1511
1512                 GEN(Load);
1513                 GEN(Store);
1514                 GEN(Cond);
1515
1516                 IGN(Proj);
1517                 IGN(Call);
1518                 IGN(Alloc);
1519
1520                 IGN(Block);
1521                 IGN(Start);
1522                 IGN(End);
1523                 IGN(NoMem);
1524                 IGN(Phi);
1525                 IGN(IJmp);
1526                 IGN(Break);
1527                 IGN(Cmp);
1528                 IGN(Unknown);
1529                 /* constant transformation happens earlier */
1530                 IGN(Const);
1531                 IGN(SymConst);
1532
1533                 BAD(Raise);
1534                 BAD(Sel);
1535                 BAD(InstOf);
1536                 BAD(Cast);
1537                 BAD(Free);
1538                 BAD(Sync);
1539                 BAD(Tuple);
1540                 BAD(Id);
1541                 BAD(Bad);
1542                 BAD(Confirm);
1543                 BAD(Filter);
1544                 BAD(CallBegin);
1545                 BAD(EndReg);
1546                 BAD(EndExcept);
1547                 BAD(Mux);
1548                 BAD(CopyB);
1549
1550                 default:
1551                         if (get_irn_op(node) == get_op_Max()) {
1552                                 asm_node = gen_Max(&tenv, get_irn_n(node, 0), get_irn_n(node, 1));
1553                         }
1554                         else if (get_irn_op(node) == get_op_Min()) {
1555                                 asm_node = gen_Min(&tenv, get_irn_n(node, 0), get_irn_n(node, 1));
1556                         }
1557                         else if (get_irn_op(node) == get_op_Mulh()) {
1558                                 asm_node = gen_Mulh(&tenv, get_irn_n(node, 0), get_irn_n(node, 1));
1559                         }
1560                         break;
1561 bad:
1562                 fprintf(stderr, "Not implemented: %s\n", get_irn_opname(node));
1563                 assert(0);
1564         }
1565
1566         if (asm_node) {
1567                 exchange(node, asm_node);
1568                 DB((tenv.mod, LEVEL_1, "created node %+F[%p]\n", asm_node, asm_node));
1569         }
1570         else {
1571                 DB((tenv.mod, LEVEL_1, "ignored\n"));
1572         }
1573 }