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

   1 /*
   2  * Copyright (C) 1995-2007 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief       Handling of ia32 specific firm opcodes.
  23  * @author      Christian Wuerdig
  24  * @version     $Id$
  25  *
  26  * This file implements the creation of the achitecture specific firm opcodes
  27  * and the coresponding node constructors for the ia32 assembler irg.
  28  */
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <stdlib.h>
  34
  35 #include "irprog_t.h"
  36 #include "irgraph_t.h"
  37 #include "irnode_t.h"
  38 #include "irmode_t.h"
  39 #include "ircons_t.h"
  40 #include "iropt_t.h"
  41 #include "irop.h"
  42 #include "firm_common_t.h"
  43 #include "irvrfy_t.h"
  44 #include "irprintf.h"
  45 #include "iredges.h"
  46 #include "error.h"
  47 #include "raw_bitset.h"
  48 #include "xmalloc.h"
  49
  50 #include "../bearch_t.h"
  51
  52 #include "bearch_ia32_t.h"
  53 #include "ia32_nodes_attr.h"
  54 #include "ia32_new_nodes.h"
  55 #include "gen_ia32_regalloc_if.h"
  56 #include "gen_ia32_machine.h"
  57
  58 /***********************************************************************************
  59  *      _                                   _       _             __
  60  *     | |                                 (_)     | |           / _|
  61  *   __| |_   _ _ __ ___  _ __   ___ _ __   _ _ __ | |_ ___ _ __| |_ __ _  ___ ___
  62  *  / _` | | | | '_ ` _ \| '_ \ / _ \ '__| | | '_ \| __/ _ \ '__|  _/ _` |/ __/ _ \
  63  * | (_| | |_| | | | | | | |_) |  __/ |    | | | | | ||  __/ |  | || (_| | (_|  __/
  64  *  \__,_|\__,_|_| |_| |_| .__/ \___|_|    |_|_| |_|\__\___|_|  |_| \__,_|\___\___|
  65  *                       | |
  66  *                       |_|
  67  ***********************************************************************************/
  68
  69 /**
  70  * Dumps the register requirements for either in or out.
  71  */
  72 static void dump_reg_req(FILE *F, ir_node *n, const arch_register_req_t **reqs,
  73                          int inout) {
  74         char *dir = inout ? "out" : "in";
  75         int   max = inout ? get_ia32_n_res(n) : get_irn_arity(n);
  76         char  buf[1024];
  77         int   i;
  78
  79         memset(buf, 0, sizeof(buf));
  80
  81         if (reqs) {
  82                 for (i = 0; i < max; i++) {
  83                         fprintf(F, "%sreq #%d =", dir, i);
  84
  85                         if (reqs[i]->type == arch_register_req_type_none) {
  86                                 fprintf(F, " n/a");
  87                         }
  88
  89                         if (reqs[i]->type & arch_register_req_type_normal) {
  90                                 fprintf(F, " %s", reqs[i]->cls->name);
  91                         }
  92
  93                         if (reqs[i]->type & arch_register_req_type_limited) {
  94                                 fprintf(F, " %s",
  95                                         arch_register_req_format(buf, sizeof(buf), reqs[i], n));
  96                         }
  97
  98                         if (reqs[i]->type & arch_register_req_type_should_be_same) {
  99                                 ir_fprintf(F, " same as %+F", get_irn_n(n, reqs[i]->other_same));
 100                         }
 101
 102                         if (reqs[i]->type & arch_register_req_type_should_be_different) {
 103                                 ir_fprintf(F, " different from %+F", get_irn_n(n, reqs[i]->other_different));
 104                         }
 105
 106                         fprintf(F, "\n");
 107                 }
 108
 109                 fprintf(F, "\n");
 110         }
 111         else {
 112                 fprintf(F, "%sreq = N/A\n", dir);
 113         }
 114 }
 115
 116 /**
 117  * Dumper interface for dumping ia32 nodes in vcg.
 118  * @param n        the node to dump
 119  * @param F        the output file
 120  * @param reason   indicates which kind of information should be dumped
 121  * @return 0 on success or != 0 on failure
 122  */
 123 static int ia32_dump_node(ir_node *n, FILE *F, dump_reason_t reason) {
 124         ir_mode     *mode = NULL;
 125         int          bad  = 0;
 126         int          i, n_res, am_flav, flags;
 127         const arch_register_req_t **reqs;
 128         const arch_register_t     **slots;
 129
 130         switch (reason) {
 131                 case dump_node_opcode_txt:
 132                         fprintf(F, "%s", get_irn_opname(n));
 133                         break;
 134
 135                 case dump_node_mode_txt:
 136                         mode = get_irn_mode(n);
 137
 138                         if (is_ia32_Ld(n) || is_ia32_St(n)) {
 139                                 mode = get_ia32_ls_mode(n);
 140                         }
 141
 142                         fprintf(F, "[%s]", mode ? get_mode_name(mode) : "?NOMODE?");
 143                         break;
 144
 145                 case dump_node_nodeattr_txt:
 146                         if (is_ia32_ImmConst(n) || is_ia32_ImmSymConst(n)) {
 147                                 if(is_ia32_ImmSymConst(n)) {
 148                                         ir_entity *ent = get_ia32_Immop_symconst(n);
 149                                         ident *id = get_entity_ld_ident(ent);
 150                                         fprintf(F, "[SymC %s]", get_id_str(id));
 151                                 } else {
 152                                         char buf[128];
 153                                         tarval *tv = get_ia32_Immop_tarval(n);
 154
 155                                         tarval_snprintf(buf, sizeof(buf), tv);
 156                                         fprintf(F, "[%s]", buf);
 157                                 }
 158                         }
 159
 160                         if (! is_ia32_Lea(n)) {
 161                                 if (is_ia32_AddrModeS(n)) {
 162                                         fprintf(F, "[AM S] ");
 163                                 }
 164                                 else if (is_ia32_AddrModeD(n)) {
 165                                         fprintf(F, "[AM D] ");
 166                                 }
 167                         }
 168
 169                         break;
 170
 171                 case dump_node_info_txt:
 172                         n_res = get_ia32_n_res(n);
 173                         fprintf(F, "=== IA32 attr begin ===\n");
 174
 175                         /* dump IN requirements */
 176                         if (get_irn_arity(n) > 0) {
 177                                 reqs = get_ia32_in_req_all(n);
 178                                 dump_reg_req(F, n, reqs, 0);
 179                         }
 180
 181                         /* dump OUT requirements */
 182                         if (n_res > 0) {
 183                                 reqs = get_ia32_out_req_all(n);
 184                                 dump_reg_req(F, n, reqs, 1);
 185                         }
 186
 187                         /* dump assigned registers */
 188                         slots = get_ia32_slots(n);
 189                         if (slots && n_res > 0) {
 190                                 for (i = 0; i < n_res; i++) {
 191                                         const arch_register_t *reg;
 192
 193                                         reg = slots[i];
 194
 195                                         fprintf(F, "reg #%d = %s\n", i, reg ? arch_register_get_name(reg) : "n/a");
 196                                 }
 197                                 fprintf(F, "\n");
 198                         }
 199
 200                         /* dump op type */
 201                         fprintf(F, "op = ");
 202                         switch (get_ia32_op_type(n)) {
 203                                 case ia32_Normal:
 204                                         fprintf(F, "Normal");
 205                                         break;
 206                                 case ia32_AddrModeD:
 207                                         fprintf(F, "AM Dest (Load+Store)");
 208                                         break;
 209                                 case ia32_AddrModeS:
 210                                         fprintf(F, "AM Source (Load)");
 211                                         break;
 212                                 default:
 213                                         fprintf(F, "unknown (%d)", get_ia32_op_type(n));
 214                                         break;
 215                         }
 216                         fprintf(F, "\n");
 217
 218                         /* dump immop type */
 219                         fprintf(F, "immediate = ");
 220                         switch (get_ia32_immop_type(n)) {
 221                                 case ia32_ImmNone:
 222                                         fprintf(F, "None");
 223                                         break;
 224                                 case ia32_ImmConst:
 225                                         fprintf(F, "Const");
 226                                         break;
 227                                 case ia32_ImmSymConst:
 228                                         fprintf(F, "SymConst");
 229                                         break;
 230                                 default:
 231                                         fprintf(F, "unknown (%d)", get_ia32_immop_type(n));
 232                                         break;
 233                         }
 234                         fprintf(F, "\n");
 235
 236                         /* dump supported am */
 237                         fprintf(F, "AM support = ");
 238                         switch (get_ia32_am_support(n)) {
 239                                 case ia32_am_None:
 240                                         fprintf(F, "none");
 241                                         break;
 242                                 case ia32_am_Source:
 243                                         fprintf(F, "source only (Load)");
 244                                         break;
 245                                 case ia32_am_Dest:
 246                                         fprintf(F, "dest only (Load+Store)");
 247                                         break;
 248                                 case ia32_am_Full:
 249                                         fprintf(F, "full");
 250                                         break;
 251                                 default:
 252                                         fprintf(F, "unknown (%d)", get_ia32_am_support(n));
 253                                         break;
 254                         }
 255                         fprintf(F, "\n");
 256
 257                         /* dump am flavour */
 258                         fprintf(F, "AM flavour =");
 259                         am_flav = get_ia32_am_flavour(n);
 260                         if (am_flav == ia32_am_N) {
 261                                 fprintf(F, " none");
 262                         }
 263                         else {
 264                                 if (am_flav & ia32_O) {
 265                                         fprintf(F, " O");
 266                                 }
 267                                 if (am_flav & ia32_B) {
 268                                         fprintf(F, " B");
 269                                 }
 270                                 if (am_flav & ia32_I) {
 271                                         fprintf(F, " I");
 272                                 }
 273                                 if (am_flav & ia32_S) {
 274                                         fprintf(F, " S");
 275                                 }
 276                         }
 277                         fprintf(F, " (%d)\n", am_flav);
 278
 279                         /* dump AM offset */
 280                         if(get_ia32_am_offs_int(n) != 0) {
 281                                 fprintf(F, "AM offset = %d\n", get_ia32_am_offs_int(n));
 282                         }
 283
 284                         /* dump AM symconst */
 285                         if(get_ia32_am_sc(n) != NULL) {
 286                                 ir_entity *ent = get_ia32_am_sc(n);
 287                                 ident *id = get_entity_ld_ident(ent);
 288                                 fprintf(F, "AM symconst = %s\n", get_id_str(id));
 289                         }
 290
 291                         /* dump AM scale */
 292                         fprintf(F, "AM scale = %d\n", get_ia32_am_scale(n));
 293
 294                         /* dump pn code */
 295                         if(is_ia32_SwitchJmp(n)) {
 296                                 fprintf(F, "pn_code = %d\n", get_ia32_pncode(n));
 297                         } else {
 298                                 if(get_ia32_pncode(n) & ia32_pn_Cmp_Unsigned) {
 299                                         int pnc = get_ia32_pncode(n);
 300                                         fprintf(F, "pn_code = %d (%s, unsigned)\n",
 301                                                 pnc, get_pnc_string(pnc & ~ia32_pn_Cmp_Unsigned));
 302                                 } else {
 303                                         fprintf(F, "pn_code = %d (%s)\n", get_ia32_pncode(n),
 304                                                 get_pnc_string(get_ia32_pncode(n)));
 305                                 }
 306                         }
 307
 308                         /* dump n_res */
 309                         fprintf(F, "n_res = %d\n", get_ia32_n_res(n));
 310
 311                         /* dump use_frame */
 312                         fprintf(F, "use_frame = %d\n", is_ia32_use_frame(n));
 313
 314                         /* commutative */
 315                         fprintf(F, "commutative = %d\n", is_ia32_commutative(n));
 316
 317                         /* emit cl */
 318                         fprintf(F, "emit cl instead of ecx = %d\n", is_ia32_emit_cl(n));
 319
 320                         /* got lea */
 321                         fprintf(F, "got loea = %d\n", is_ia32_got_lea(n));
 322
 323                         /* need stackent */
 324                         fprintf(F, "need stackent = %d\n", is_ia32_need_stackent(n));
 325
 326                         /* dump latency */
 327                         fprintf(F, "latency = %d\n", get_ia32_latency(n));
 328
 329                         /* dump flags */
 330                         fprintf(F, "flags =");
 331                         flags = get_ia32_flags(n);
 332                         if (flags == arch_irn_flags_none) {
 333                                 fprintf(F, " none");
 334                         }
 335                         else {
 336                                 if (flags & arch_irn_flags_dont_spill) {
 337                                         fprintf(F, " unspillable");
 338                                 }
 339                                 if (flags & arch_irn_flags_rematerializable) {
 340                                         fprintf(F, " remat");
 341                                 }
 342                                 if (flags & arch_irn_flags_ignore) {
 343                                         fprintf(F, " ignore");
 344                                 }
 345                                 if (flags & arch_irn_flags_modify_sp) {
 346                                         fprintf(F, " modify_sp");
 347                                 }
 348                         }
 349                         fprintf(F, " (%d)\n", flags);
 350
 351                         /* dump frame entity */
 352                         fprintf(F, "frame entity = ");
 353                         if (get_ia32_frame_ent(n)) {
 354                                 ir_fprintf(F, "%+F", get_ia32_frame_ent(n));
 355                         }
 356                         else {
 357                                 fprintf(F, "n/a");
 358                         }
 359                         fprintf(F, "\n");
 360
 361                         /* dump modes */
 362                         fprintf(F, "ls_mode = ");
 363                         if (get_ia32_ls_mode(n)) {
 364                                 ir_fprintf(F, "%+F", get_ia32_ls_mode(n));
 365                         }
 366                         else {
 367                                 fprintf(F, "n/a");
 368                         }
 369                         fprintf(F, "\n");
 370
 371 #ifndef NDEBUG
 372                         /* dump original ir node name */
 373                         fprintf(F, "orig node = ");
 374                         if (get_ia32_orig_node(n)) {
 375                                 fprintf(F, "%s", get_ia32_orig_node(n));
 376                         }
 377                         else {
 378                                 fprintf(F, "n/a");
 379                         }
 380                         fprintf(F, "\n");
 381 #endif /* NDEBUG */
 382
 383                         fprintf(F, "=== IA32 attr end ===\n");
 384                         /* end of: case dump_node_info_txt */
 385                         break;
 386         }
 387
 388         return bad;
 389 }
 390
 391
 392
 393 /***************************************************************************************************
 394  *        _   _                   _       __        _                    _   _               _
 395  *       | | | |                 | |     / /       | |                  | | | |             | |
 396  *   __ _| |_| |_ _ __   ___  ___| |_   / /_ _  ___| |_   _ __ ___   ___| |_| |__   ___   __| |___
 397  *  / _` | __| __| '__| / __|/ _ \ __| / / _` |/ _ \ __| | '_ ` _ \ / _ \ __| '_ \ / _ \ / _` / __|
 398  * | (_| | |_| |_| |    \__ \  __/ |_ / / (_| |  __/ |_  | | | | | |  __/ |_| | | | (_) | (_| \__ \
 399  *  \__,_|\__|\__|_|    |___/\___|\__/_/ \__, |\___|\__| |_| |_| |_|\___|\__|_| |_|\___/ \__,_|___/
 400  *                                        __/ |
 401  *                                       |___/
 402  ***************************************************************************************************/
 403
 404 ia32_attr_t *get_ia32_attr(ir_node *node) {
 405         assert(is_ia32_irn(node) && "need ia32 node to get ia32 attributes");
 406         return (ia32_attr_t *)get_irn_generic_attr(node);
 407 }
 408
 409 const ia32_attr_t *get_ia32_attr_const(const ir_node *node) {
 410         assert(is_ia32_irn(node) && "need ia32 node to get ia32 attributes");
 411         return (const ia32_attr_t*) get_irn_generic_attr_const(node);
 412 }
 413
 414 ia32_x87_attr_t *get_ia32_x87_attr(ir_node *node) {
 415         ia32_attr_t     *attr     = get_ia32_attr(node);
 416         ia32_x87_attr_t *x87_attr = CAST_IA32_ATTR(ia32_x87_attr_t, attr);
 417         return x87_attr;
 418 }
 419
 420 const ia32_x87_attr_t *get_ia32_x87_attr_const(const ir_node *node) {
 421         const ia32_attr_t     *attr     = get_ia32_attr_const(node);
 422         const ia32_x87_attr_t *x87_attr = CONST_CAST_IA32_ATTR(ia32_x87_attr_t, attr);
 423         return x87_attr;
 424 }
 425
 426 /**
 427  * Gets the type of an ia32 node.
 428  */
 429 ia32_op_type_t get_ia32_op_type(const ir_node *node) {
 430         const ia32_attr_t *attr = get_ia32_attr_const(node);
 431         return attr->data.tp;
 432 }
 433
 434 /**
 435  * Sets the type of an ia32 node.
 436  */
 437 void set_ia32_op_type(ir_node *node, ia32_op_type_t tp) {
 438         ia32_attr_t *attr = get_ia32_attr(node);
 439         attr->data.tp     = tp;
 440 }
 441
 442 /**
 443  * Gets the immediate op type of an ia32 node.
 444  */
 445 ia32_immop_type_t get_ia32_immop_type(const ir_node *node) {
 446         const ia32_attr_t *attr = get_ia32_attr_const(node);
 447         return attr->data.imm_tp;
 448 }
 449
 450 /**
 451  * Gets the supported address mode of an ia32 node
 452  */
 453 ia32_am_type_t get_ia32_am_support(const ir_node *node) {
 454         const ia32_attr_t *attr = get_ia32_attr_const(node);
 455         return attr->data.am_support;
 456 }
 457
 458 /**
 459  * Sets the supported address mode of an ia32 node
 460  */
 461 void set_ia32_am_support(ir_node *node, ia32_am_type_t am_tp) {
 462         ia32_attr_t *attr     = get_ia32_attr(node);
 463         attr->data.am_support = am_tp;
 464 }
 465
 466 /**
 467  * Gets the address mode flavour of an ia32 node
 468  */
 469 ia32_am_flavour_t get_ia32_am_flavour(const ir_node *node) {
 470         const ia32_attr_t *attr = get_ia32_attr_const(node);
 471         return attr->data.am_flavour;
 472 }
 473
 474 /**
 475  * Sets the address mode flavour of an ia32 node
 476  */
 477 void set_ia32_am_flavour(ir_node *node, ia32_am_flavour_t am_flavour) {
 478         ia32_attr_t *attr     = get_ia32_attr(node);
 479         attr->data.am_flavour = am_flavour;
 480 }
 481
 482 /**
 483  * Gets the address mode offset as int.
 484  */
 485 int get_ia32_am_offs_int(const ir_node *node) {
 486         const ia32_attr_t *attr = get_ia32_attr_const(node);
 487         return attr->am_offs;
 488 }
 489
 490 /**
 491  * Sets the address mode offset from an int.
 492  */
 493 void set_ia32_am_offs_int(ir_node *node, int offset) {
 494         ia32_attr_t *attr = get_ia32_attr(node);
 495         attr->am_offs = offset;
 496 }
 497
 498 void add_ia32_am_offs_int(ir_node *node, int offset) {
 499         ia32_attr_t *attr = get_ia32_attr(node);
 500         attr->am_offs += offset;
 501 }
 502
 503 /**
 504  * Returns the symconst entity associated to address mode.
 505  */
 506 ir_entity *get_ia32_am_sc(const ir_node *node) {
 507         const ia32_attr_t *attr = get_ia32_attr_const(node);
 508         return attr->am_sc;
 509 }
 510
 511 /**
 512  * Sets the symconst entity associated to address mode.
 513  */
 514 void set_ia32_am_sc(ir_node *node, ir_entity *entity) {
 515         ia32_attr_t *attr = get_ia32_attr(node);
 516         attr->am_sc       = entity;
 517 }
 518
 519 /**
 520  * Sets the sign bit for address mode symconst.
 521  */
 522 void set_ia32_am_sc_sign(ir_node *node) {
 523         ia32_attr_t *attr     = get_ia32_attr(node);
 524         attr->data.am_sc_sign = 1;
 525 }
 526
 527 /**
 528  * Clears the sign bit for address mode symconst.
 529  */
 530 void clear_ia32_am_sc_sign(ir_node *node) {
 531         ia32_attr_t *attr     = get_ia32_attr(node);
 532         attr->data.am_sc_sign = 0;
 533 }
 534
 535 /**
 536  * Returns the sign bit for address mode symconst.
 537  */
 538 int is_ia32_am_sc_sign(const ir_node *node) {
 539         const ia32_attr_t *attr = get_ia32_attr_const(node);
 540         return attr->data.am_sc_sign;
 541 }
 542
 543 /**
 544  * Gets the addr mode const.
 545  */
 546 int get_ia32_am_scale(const ir_node *node) {
 547         const ia32_attr_t *attr = get_ia32_attr_const(node);
 548         return attr->data.am_scale;
 549 }
 550
 551 /**
 552  * Sets the index register scale for address mode.
 553  */
 554 void set_ia32_am_scale(ir_node *node, int scale) {
 555         ia32_attr_t *attr   = get_ia32_attr(node);
 556         attr->data.am_scale = scale;
 557 }
 558
 559 /**
 560  * Return the tarval of an immediate operation or NULL in case of SymConst
 561  */
 562 tarval *get_ia32_Immop_tarval(const ir_node *node) {
 563         const ia32_attr_t *attr = get_ia32_attr_const(node);
 564         assert(attr->data.imm_tp == ia32_ImmConst);
 565     return attr->cnst_val.tv;
 566 }
 567
 568 /**
 569  * Sets the attributes of an immediate operation to the specified tarval
 570  */
 571 void set_ia32_Immop_tarval(ir_node *node, tarval *tv) {
 572         ia32_attr_t *attr = get_ia32_attr(node);
 573         attr->data.imm_tp = ia32_ImmConst;
 574         attr->cnst_val.tv = tv;
 575 }
 576
 577 void set_ia32_Immop_symconst(ir_node *node, ir_entity *entity) {
 578         ia32_attr_t *attr = get_ia32_attr(node);
 579         attr->data.imm_tp = ia32_ImmSymConst;
 580         attr->cnst_val.sc = entity;
 581 }
 582
 583 ir_entity *get_ia32_Immop_symconst(const ir_node *node) {
 584         const ia32_attr_t *attr = get_ia32_attr_const(node);
 585         assert(attr->data.imm_tp == ia32_ImmSymConst);
 586         return attr->cnst_val.sc;
 587 }
 588
 589 /**
 590  * Sets the uses_frame flag.
 591  */
 592 void set_ia32_use_frame(ir_node *node) {
 593         ia32_attr_t *attr    = get_ia32_attr(node);
 594         attr->data.use_frame = 1;
 595 }
 596
 597 /**
 598  * Clears the uses_frame flag.
 599  */
 600 void clear_ia32_use_frame(ir_node *node) {
 601         ia32_attr_t *attr    = get_ia32_attr(node);
 602         attr->data.use_frame = 0;
 603 }
 604
 605 /**
 606  * Gets the uses_frame flag.
 607  */
 608 int is_ia32_use_frame(const ir_node *node) {
 609         const ia32_attr_t *attr = get_ia32_attr_const(node);
 610         return attr->data.use_frame;
 611 }
 612
 613 /**
 614  * Sets node to commutative.
 615  */
 616 void set_ia32_commutative(ir_node *node) {
 617         ia32_attr_t *attr         = get_ia32_attr(node);
 618         attr->data.is_commutative = 1;
 619 }
 620
 621 /**
 622  * Sets node to non-commutative.
 623  */
 624 void clear_ia32_commutative(ir_node *node) {
 625         ia32_attr_t *attr         = get_ia32_attr(node);
 626         attr->data.is_commutative = 0;
 627 }
 628
 629 /**
 630  * Checks if node is commutative.
 631  */
 632 int is_ia32_commutative(const ir_node *node) {
 633         const ia32_attr_t *attr = get_ia32_attr_const(node);
 634         return attr->data.is_commutative;
 635 }
 636
 637 /**
 638  * Sets node emit_cl.
 639  */
 640 void set_ia32_emit_cl(ir_node *node) {
 641         ia32_attr_t *attr  = get_ia32_attr(node);
 642         attr->data.emit_cl = 1;
 643 }
 644
 645 /**
 646  * Clears node emit_cl.
 647  */
 648 void clear_ia32_emit_cl(ir_node *node) {
 649         ia32_attr_t *attr  = get_ia32_attr(node);
 650         attr->data.emit_cl = 0;
 651 }
 652
 653 /**
 654  * Checks if node needs %cl.
 655  */
 656 int is_ia32_emit_cl(const ir_node *node) {
 657         const ia32_attr_t *attr = get_ia32_attr_const(node);
 658         return attr->data.emit_cl;
 659 }
 660
 661 /**
 662  * Sets node got_lea.
 663  */
 664 void set_ia32_got_lea(ir_node *node) {
 665         ia32_attr_t *attr  = get_ia32_attr(node);
 666         attr->data.got_lea = 1;
 667 }
 668
 669 /**
 670  * Clears node got_lea.
 671  */
 672 void clear_ia32_got_lea(ir_node *node) {
 673         ia32_attr_t *attr  = get_ia32_attr(node);
 674         attr->data.got_lea = 0;
 675 }
 676
 677 /**
 678  * Checks if node got lea.
 679  */
 680 int is_ia32_got_lea(const ir_node *node) {
 681         const ia32_attr_t *attr = get_ia32_attr_const(node);
 682         return attr->data.got_lea;
 683 }
 684
 685 void set_ia32_need_stackent(ir_node *node) {
 686         ia32_attr_t *attr     = get_ia32_attr(node);
 687         attr->data.need_stackent = 1;
 688 }
 689
 690 void clear_ia32_need_stackent(ir_node *node) {
 691         ia32_attr_t *attr     = get_ia32_attr(node);
 692         attr->data.need_stackent = 0;
 693 }
 694
 695 int is_ia32_need_stackent(const ir_node *node) {
 696         const ia32_attr_t *attr = get_ia32_attr_const(node);
 697         return attr->data.need_stackent;
 698 }
 699
 700 /**
 701  * Gets the mode of the stored/loaded value (only set for Store/Load)
 702  */
 703 ir_mode *get_ia32_ls_mode(const ir_node *node) {
 704         const ia32_attr_t *attr = get_ia32_attr_const(node);
 705         return attr->ls_mode;
 706 }
 707
 708 /**
 709  * Sets the mode of the stored/loaded value (only set for Store/Load)
 710  */
 711 void set_ia32_ls_mode(ir_node *node, ir_mode *mode) {
 712         ia32_attr_t *attr = get_ia32_attr(node);
 713         attr->ls_mode     = mode;
 714 }
 715
 716 /**
 717  * Gets the frame entity assigned to this node.
 718  */
 719 ir_entity *get_ia32_frame_ent(const ir_node *node) {
 720         const ia32_attr_t *attr = get_ia32_attr_const(node);
 721         return attr->frame_ent;
 722 }
 723
 724 /**
 725  * Sets the frame entity for this node.
 726  */
 727 void set_ia32_frame_ent(ir_node *node, ir_entity *ent) {
 728         ia32_attr_t *attr = get_ia32_attr(node);
 729         attr->frame_ent   = ent;
 730         if(ent != NULL)
 731                 set_ia32_use_frame(node);
 732         else
 733                 clear_ia32_use_frame(node);
 734 }
 735
 736
 737 /**
 738  * Gets the instruction latency.
 739  */
 740 unsigned get_ia32_latency(const ir_node *node) {
 741         const ia32_attr_t *attr = get_ia32_attr_const(node);
 742         return attr->latency;
 743 }
 744
 745 /**
 746 * Sets the instruction latency.
 747 */
 748 void set_ia32_latency(ir_node *node, unsigned latency) {
 749         ia32_attr_t *attr = get_ia32_attr(node);
 750         attr->latency     = latency;
 751 }
 752
 753 /**
 754  * Returns the argument register requirements of an ia32 node.
 755  */
 756 const arch_register_req_t **get_ia32_in_req_all(const ir_node *node) {
 757         const ia32_attr_t *attr = get_ia32_attr_const(node);
 758         return attr->in_req;
 759 }
 760
 761 /**
 762  * Sets the argument register requirements of an ia32 node.
 763  */
 764 void set_ia32_in_req_all(ir_node *node, const arch_register_req_t **reqs) {
 765         ia32_attr_t *attr = get_ia32_attr(node);
 766         attr->in_req      = reqs;
 767 }
 768
 769 /**
 770  * Returns the result register requirements of an ia32 node.
 771  */
 772 const arch_register_req_t **get_ia32_out_req_all(const ir_node *node) {
 773         const ia32_attr_t *attr = get_ia32_attr_const(node);
 774         return attr->out_req;
 775 }
 776
 777 /**
 778  * Sets the result register requirements of an ia32 node.
 779  */
 780 void set_ia32_out_req_all(ir_node *node, const arch_register_req_t **reqs) {
 781         ia32_attr_t *attr = get_ia32_attr(node);
 782         attr->out_req     = reqs;
 783 }
 784
 785 /**
 786  * Returns the argument register requirement at position pos of an ia32 node.
 787  */
 788 const arch_register_req_t *get_ia32_in_req(const ir_node *node, int pos) {
 789         const ia32_attr_t *attr = get_ia32_attr_const(node);
 790         if(attr->in_req == NULL)
 791                 return arch_no_register_req;
 792
 793         return attr->in_req[pos];
 794 }
 795
 796 /**
 797  * Returns the result register requirement at position pos of an ia32 node.
 798  */
 799 const arch_register_req_t *get_ia32_out_req(const ir_node *node, int pos) {
 800         const ia32_attr_t *attr = get_ia32_attr_const(node);
 801         if(attr->out_req == NULL)
 802                 return arch_no_register_req;
 803
 804         return attr->out_req[pos];
 805 }
 806
 807 /**
 808  * Sets the OUT register requirements at position pos.
 809  */
 810 void set_ia32_req_out(ir_node *node, const arch_register_req_t *req, int pos) {
 811         ia32_attr_t *attr  = get_ia32_attr(node);
 812         attr->out_req[pos] = req;
 813 }
 814
 815 /**
 816  * Sets the IN register requirements at position pos.
 817  */
 818 void set_ia32_req_in(ir_node *node, const arch_register_req_t *req, int pos) {
 819         ia32_attr_t *attr = get_ia32_attr(node);
 820         attr->in_req[pos] = req;
 821 }
 822
 823 /**
 824  * Returns the register flag of an ia32 node.
 825  */
 826 arch_irn_flags_t get_ia32_flags(const ir_node *node) {
 827         const ia32_attr_t *attr = get_ia32_attr_const(node);
 828         return attr->data.flags;
 829 }
 830
 831 /**
 832  * Sets the register flag of an ia32 node.
 833  */
 834 void set_ia32_flags(ir_node *node, arch_irn_flags_t flags) {
 835         ia32_attr_t *attr = get_ia32_attr(node);
 836         attr->data.flags  = flags;
 837 }
 838
 839 /**
 840  * Returns the result register slots of an ia32 node.
 841  */
 842 const arch_register_t **get_ia32_slots(const ir_node *node) {
 843         const ia32_attr_t *attr = get_ia32_attr_const(node);
 844         return attr->slots;
 845 }
 846
 847 /**
 848  * Returns the number of results.
 849  */
 850 int get_ia32_n_res(const ir_node *node) {
 851         const ia32_attr_t *attr = get_ia32_attr_const(node);
 852         return ARR_LEN(attr->slots);
 853 }
 854
 855 /**
 856  * Returns the flavour of an ia32 node,
 857  */
 858 ia32_op_flavour_t get_ia32_flavour(const ir_node *node) {
 859         const ia32_attr_t *attr = get_ia32_attr_const(node);
 860         return attr->data.op_flav;
 861 }
 862
 863 /**
 864  * Sets the flavour of an ia32 node to flavour_Div/Mod/DivMod/Mul/Mulh.
 865  */
 866 void set_ia32_flavour(ir_node *node, ia32_op_flavour_t op_flav) {
 867         ia32_attr_t *attr  = get_ia32_attr(node);
 868         attr->data.op_flav = op_flav;
 869 }
 870
 871 /**
 872  * Returns the projnum code.
 873  */
 874 pn_Cmp get_ia32_pncode(const ir_node *node) {
 875         const ia32_attr_t *attr = get_ia32_attr_const(node);
 876         return attr->pn_code;
 877 }
 878
 879 /**
 880  * Sets the projnum code
 881  */
 882 void set_ia32_pncode(ir_node *node, pn_Cmp code) {
 883         ia32_attr_t *attr = get_ia32_attr(node);
 884         attr->pn_code     = code;
 885 }
 886
 887 /**
 888  * Sets the flags for the n'th out.
 889  */
 890 void set_ia32_out_flags(ir_node *node, arch_irn_flags_t flags, int pos) {
 891         ia32_attr_t *attr = get_ia32_attr(node);
 892         assert(pos < ARR_LEN(attr->out_flags) && "Invalid OUT position.");
 893         attr->out_flags[pos] = flags;
 894 }
 895
 896 /**
 897  * Gets the flags for the n'th out.
 898  */
 899 arch_irn_flags_t get_ia32_out_flags(const ir_node *node, int pos) {
 900         const ia32_attr_t *attr = get_ia32_attr_const(node);
 901         assert(pos < ARR_LEN(attr->out_flags) && "Invalid OUT position.");
 902         return attr->out_flags[pos];
 903 }
 904
 905 /**
 906  * Get the list of available execution units.
 907  */
 908 const be_execution_unit_t ***get_ia32_exec_units(const ir_node *node) {
 909         const ia32_attr_t *attr = get_ia32_attr_const(node);
 910         return attr->exec_units;
 911 }
 912
 913 /**
 914  * Get the exception label attribute.
 915  */
 916 unsigned get_ia32_exc_label(const ir_node *node) {
 917         const ia32_attr_t *attr = get_ia32_attr_const(node);
 918         return attr->data.except_label;
 919 }
 920
 921 /**
 922  * Set the exception label attribute.
 923  */
 924 void set_ia32_exc_label(ir_node *node, unsigned flag) {
 925         ia32_attr_t *attr = get_ia32_attr(node);
 926         attr->data.except_label = flag;
 927 }
 928
 929 #ifndef NDEBUG
 930
 931 /**
 932  * Returns the name of the original ir node.
 933  */
 934 const char *get_ia32_orig_node(const ir_node *node) {
 935         const ia32_attr_t *attr = get_ia32_attr_const(node);
 936         return attr->orig_node;
 937 }
 938
 939 /**
 940  * Sets the name of the original ir node.
 941  */
 942 void set_ia32_orig_node(ir_node *node, const char *name) {
 943         ia32_attr_t *attr = get_ia32_attr(node);
 944         attr->orig_node   = name;
 945 }
 946
 947 #endif /* NDEBUG */
 948
 949 /******************************************************************************************************
 950  *                      _       _         _   _           __                  _   _
 951  *                     (_)     | |       | | | |         / _|                | | (_)
 952  *  ___ _ __   ___  ___ _  __ _| |   __ _| |_| |_ _ __  | |_ _   _ _ __   ___| |_ _  ___  _ __    ___
 953  * / __| '_ \ / _ \/ __| |/ _` | |  / _` | __| __| '__| |  _| | | | '_ \ / __| __| |/ _ \| '_ \  / __|
 954  * \__ \ |_) |  __/ (__| | (_| | | | (_| | |_| |_| |    | | | |_| | | | | (__| |_| | (_) | | | | \__ \
 955  * |___/ .__/ \___|\___|_|\__,_|_|  \__,_|\__|\__|_|    |_|  \__,_|_| |_|\___|\__|_|\___/|_| |_| |___/
 956  *     | |
 957  *     |_|
 958  ******************************************************************************************************/
 959
 960 /**
 961  * Copy the attributes from an ia32_Const to an Immop (Add_i, Sub_i, ...) node
 962  */
 963 void copy_ia32_Immop_attr(ir_node *node, ir_node *from) {
 964         ia32_immop_type_t immop_type = get_ia32_immop_type(from);
 965
 966         if(immop_type == ia32_ImmConst) {
 967                 set_ia32_Immop_tarval(node, get_ia32_Immop_tarval(from));
 968         } else if(immop_type == ia32_ImmSymConst) {
 969                 set_ia32_Immop_symconst(node, get_ia32_Immop_symconst(from));
 970         } else {
 971                 ia32_attr_t *attr = get_ia32_attr(node);
 972                 assert(immop_type == ia32_ImmNone);
 973                 attr->data.imm_tp = ia32_ImmNone;
 974         }
 975 }
 976
 977 /**
 978  * Copy the attributes from a Firm Const/SymConst to an ia32_Const
 979  */
 980 void set_ia32_Const_attr(ir_node *ia32_cnst, ir_node *cnst) {
 981         assert(is_ia32_Cnst(ia32_cnst) && "Need ia32_Const to set Const attr");
 982
 983         switch (get_irn_opcode(cnst)) {
 984                 case iro_Const:
 985                         set_ia32_Const_tarval(ia32_cnst, get_Const_tarval(cnst));
 986                         break;
 987                 case iro_SymConst:
 988                         assert(get_SymConst_kind(cnst) == symconst_addr_ent);
 989                         set_ia32_Immop_symconst(ia32_cnst, get_SymConst_entity(cnst));
 990                         break;
 991                 case iro_Unknown:
 992                         assert(0 && "Unknown Const NYI");
 993                         break;
 994                 default:
 995                         assert(0 && "Cannot create ia32_Const for this opcode");
 996         }
 997 }
 998
 999 void set_ia32_Const_tarval(ir_node *ia32_cnst, tarval *tv) {
1000 #if 0
1001         if(mode_is_reference(get_tarval_mode(tv))) {
1002                 if(tarval_is_null(tv)) {
1003                         tv = get_tarval_null(mode_Iu);
1004                 } else {
1005                         long val;
1006                         /* workaround... */
1007                         if(!tarval_is_long(tv))
1008                                 panic("Can't convert reference tarval to mode_Iu at %+F", ia32_cnst);
1009                         val = get_tarval_long(tv);
1010                         tv = new_tarval_from_long(val, mode_Iu);
1011                 }
1012         } else {
1013                 tv = tarval_convert_to(tv, mode_Iu);
1014         }
1015 #else
1016         tv = tarval_convert_to(tv, mode_Iu);
1017 #endif
1018
1019         assert(tv != get_tarval_bad() && tv != get_tarval_undefined()
1020                         && tv != NULL);
1021         set_ia32_Immop_tarval(ia32_cnst, tv);
1022 }
1023
1024
1025 /**
1026  * Sets the AddrMode(S|D) attribute
1027  */
1028 void set_ia32_AddrMode(ir_node *node, char direction) {
1029         ia32_attr_t *attr = get_ia32_attr(node);
1030
1031         switch (direction) {
1032                 case 'D':
1033                         attr->data.tp = ia32_AddrModeD;
1034                         break;
1035                 case 'S':
1036                         attr->data.tp = ia32_AddrModeS;
1037                         break;
1038                 default:
1039                         assert(0 && "wrong AM type");
1040         }
1041 }
1042
1043 /**
1044  * Returns whether or not the node is an immediate operation with Const.
1045  */
1046 int is_ia32_ImmConst(const ir_node *node) {
1047         const ia32_attr_t *attr = get_ia32_attr_const(node);
1048         return (attr->data.imm_tp == ia32_ImmConst);
1049 }
1050
1051 /**
1052  * Returns whether or not the node is an immediate operation with SymConst.
1053  */
1054 int is_ia32_ImmSymConst(const ir_node *node) {
1055         const ia32_attr_t *attr = get_ia32_attr_const(node);
1056         return (attr->data.imm_tp == ia32_ImmSymConst);
1057 }
1058
1059 /**
1060  * Returns whether or not the node is an AddrModeS node.
1061  */
1062 int is_ia32_AddrModeS(const ir_node *node) {
1063         const ia32_attr_t *attr = get_ia32_attr_const(node);
1064         return (attr->data.tp == ia32_AddrModeS);
1065 }
1066
1067 /**
1068  * Returns whether or not the node is an AddrModeD node.
1069  */
1070 int is_ia32_AddrModeD(const ir_node *node) {
1071         const ia32_attr_t *attr = get_ia32_attr_const(node);
1072         return (attr->data.tp == ia32_AddrModeD);
1073 }
1074
1075 /**
1076  * Checks if node is a Load or xLoad/vfLoad.
1077  */
1078 int is_ia32_Ld(const ir_node *node) {
1079         int op = get_ia32_irn_opcode(node);
1080         return op == iro_ia32_Load ||
1081                op == iro_ia32_xLoad ||
1082                op == iro_ia32_vfld ||
1083                op == iro_ia32_fld;
1084 }
1085
1086 /**
1087  * Checks if node is a Store or xStore/vfStore.
1088  */
1089 int is_ia32_St(const ir_node *node) {
1090         int op = get_ia32_irn_opcode(node);
1091         return op == iro_ia32_Store ||
1092                op == iro_ia32_Store8Bit ||
1093                op == iro_ia32_xStore ||
1094                op == iro_ia32_vfst ||
1095                op == iro_ia32_fst ||
1096                op == iro_ia32_fstp;
1097 }
1098
1099 /**
1100  * Checks if node is a Const or xConst/vfConst.
1101  */
1102 int is_ia32_Cnst(const ir_node *node) {
1103         int op = get_ia32_irn_opcode(node);
1104         return op == iro_ia32_Const || op == iro_ia32_xConst || op == iro_ia32_vfConst;
1105 }
1106
1107 /**
1108  * Returns the name of the OUT register at position pos.
1109  */
1110 const char *get_ia32_out_reg_name(const ir_node *node, int pos) {
1111         const ia32_attr_t *attr = get_ia32_attr_const(node);
1112
1113         assert(pos < ARR_LEN(attr->slots) && "Invalid OUT position.");
1114         assert(attr->slots[pos]  && "No register assigned");
1115
1116         return arch_register_get_name(attr->slots[pos]);
1117 }
1118
1119 /**
1120  * Returns the index of the OUT register at position pos within its register class.
1121  */
1122 int get_ia32_out_regnr(const ir_node *node, int pos) {
1123         const ia32_attr_t *attr = get_ia32_attr_const(node);
1124
1125         assert(pos < ARR_LEN(attr->slots) && "Invalid OUT position.");
1126         assert(attr->slots[pos]  && "No register assigned");
1127
1128         return arch_register_get_index(attr->slots[pos]);
1129 }
1130
1131 /**
1132  * Returns the OUT register at position pos.
1133  */
1134 const arch_register_t *get_ia32_out_reg(const ir_node *node, int pos) {
1135         const ia32_attr_t *attr = get_ia32_attr_const(node);
1136
1137         assert(pos < ARR_LEN(attr->slots) && "Invalid OUT position.");
1138         assert(attr->slots[pos]  && "No register assigned");
1139
1140         return attr->slots[pos];
1141 }
1142
1143 /**
1144  * Initializes the nodes attributes.
1145  */
1146 void init_ia32_attributes(ir_node *node, arch_irn_flags_t flags,
1147                           const arch_register_req_t **in_reqs,
1148                           const arch_register_req_t **out_reqs,
1149                           const be_execution_unit_t ***execution_units,
1150                           int n_res, unsigned latency)
1151 {
1152         ir_graph       *irg  = get_irn_irg(node);
1153         struct obstack *obst = get_irg_obstack(irg);
1154         ia32_attr_t    *attr = get_ia32_attr(node);
1155
1156         set_ia32_flags(node, flags);
1157         set_ia32_in_req_all(node, in_reqs);
1158         set_ia32_out_req_all(node, out_reqs);
1159         set_ia32_latency(node, latency);
1160
1161         attr->exec_units  = execution_units;
1162 #ifndef NDEBUG
1163         attr->attr_type  |= IA32_ATTR_ia32_attr_t;
1164 #endif
1165
1166         attr->out_flags = NEW_ARR_D(int, obst, n_res);
1167         memset(attr->out_flags, 0, n_res * sizeof(attr->out_flags[0]));
1168
1169         attr->slots = NEW_ARR_D(const arch_register_t*, obst, n_res);
1170         memset(attr->slots, 0, n_res * sizeof(attr->slots[0]));
1171 }
1172
1173 void
1174 init_ia32_x87_attributes(ir_node *res)
1175 {
1176 #ifndef NDEBUG
1177         ia32_attr_t *attr  = get_ia32_attr(res);
1178         attr->attr_type   |= IA32_ATTR_ia32_x87_attr_t;
1179 #endif
1180 }
1181
1182 void
1183 init_ia32_asm_attributes(ir_node *res)
1184 {
1185 #ifndef NDEBUG
1186         ia32_attr_t *attr  = get_ia32_attr(res);
1187         attr->attr_type   |= IA32_ATTR_ia32_asm_attr_t;
1188 #endif
1189 }
1190
1191 ir_node *get_ia32_result_proj(const ir_node *node)
1192 {
1193         const ir_edge_t *edge;
1194
1195         foreach_out_edge(node, edge) {
1196                 ir_node *proj = get_edge_src_irn(edge);
1197                 if(get_Proj_proj(proj) == 0) {
1198                         return proj;
1199                 }
1200         }
1201         return NULL;
1202 }
1203
1204 /***************************************************************************************
1205  *                  _                            _                   _
1206  *                 | |                          | |                 | |
1207  *  _ __   ___   __| | ___    ___ ___  _ __  ___| |_ _ __ _   _  ___| |_ ___  _ __ ___
1208  * | '_ \ / _ \ / _` |/ _ \  / __/ _ \| '_ \/ __| __| '__| | | |/ __| __/ _ \| '__/ __|
1209  * | | | | (_) | (_| |  __/ | (_| (_) | | | \__ \ |_| |  | |_| | (__| || (_) | |  \__ \
1210  * |_| |_|\___/ \__,_|\___|  \___\___/|_| |_|___/\__|_|   \__,_|\___|\__\___/|_|  |___/
1211  *
1212  ***************************************************************************************/
1213
1214 /* default compare operation to compare attributes */
1215 int ia32_compare_attr(const ia32_attr_t *a, const ia32_attr_t *b) {
1216         if (a->data.tp != b->data.tp
1217                         || a->data.imm_tp != b->data.imm_tp)
1218                 return 1;
1219
1220         if (a->data.imm_tp == ia32_ImmConst
1221                         && a->cnst_val.tv != b->cnst_val.tv)
1222                 return 1;
1223
1224         if (a->data.imm_tp == ia32_ImmSymConst
1225                         && a->cnst_val.sc != b->cnst_val.sc)
1226                 return 1;
1227
1228         if (a->data.am_flavour != b->data.am_flavour
1229             || a->data.am_scale != b->data.am_scale
1230             || a->data.am_sc_sign != b->data.am_sc_sign
1231             || a->am_offs != b->am_offs
1232             || a->am_sc != b->am_sc
1233             || a->ls_mode != b->ls_mode)
1234                 return 1;
1235
1236         if (a->data.use_frame != b->data.use_frame
1237             || a->data.use_frame != b->data.use_frame
1238             || a->frame_ent != b->frame_ent)
1239                 return 1;
1240
1241         if(a->pn_code != b->pn_code)
1242                 return 1;
1243
1244         if (a->data.tp != b->data.tp
1245             || a->data.op_flav != b->data.op_flav)
1246                 return 1;
1247
1248         if (a->data.except_label != b->data.except_label)
1249                 return 1;
1250
1251         return 0;
1252 }
1253
1254 /* copies the ia32 attributes */
1255 static void ia32_copy_attr(const ir_node *old_node, ir_node *new_node)
1256 {
1257         ir_graph          *irg      = get_irn_irg(new_node);
1258         struct obstack    *obst     = get_irg_obstack(irg);
1259         const ia32_attr_t *attr_old = get_ia32_attr_const(old_node);
1260         ia32_attr_t       *attr_new = get_ia32_attr(new_node);
1261
1262         /* copy the attributes */
1263         memcpy(attr_new, attr_old, get_op_attr_size(get_irn_op(old_node)));
1264
1265         /* copy out flags */
1266         attr_new->out_flags =
1267                 DUP_ARR_D(int, obst, attr_old->out_flags);
1268         /* copy register assignments */
1269         attr_new->slots =
1270                 DUP_ARR_D(const arch_register_t*, obst, attr_old->slots);
1271 }
1272
1273 /* Include the generated constructor functions */
1274 #include "gen_ia32_new_nodes.c.inl"
1275
1276 /**
1277  * Registers the ia32_copy_attr function for all ia32 opcodes.
1278  */
1279 void ia32_register_copy_attr_func(void) {
1280         int i;
1281
1282         for (i = get_irp_n_opcodes() - 1; i >= 0; --i) {
1283                 ir_op *op = get_irp_opcode(i);
1284                 if (is_ia32_op(op))
1285                         op->ops.copy_attr = ia32_copy_attr;
1286         }
1287 }