nsz Git - libfirm/blob - ir/be/ia32/ia32_spec.pl

   1 # Creation: 2005/10/19
   2 # $Id$
   3 # This is the specification for the ia32 assembler Firm-operations
   4
   5 use File::Basename;
   6
   7 $new_emit_syntax = 1;
   8 my $myname = $0;
   9
  10 # the cpu architecture (ia32, ia64, mips, sparc, ppc, ...)
  11 $arch = "ia32";
  12
  13 # The node description is done as a perl hash initializer with the
  14 # following structure:
  15 #
  16 # %nodes = (
  17 #
  18 # <op-name> => {
  19 #   op_flags  => "N|L|C|X|I|F|Y|H|c|K",
  20 #   irn_flags => "R|N|I|S"
  21 #   arity     => "0|1|2|3 ... |variable|dynamic|any",
  22 #   state     => "floats|pinned|mem_pinned|exc_pinned",
  23 #   args      => [
  24 #                    { type => "type 1", name => "name 1" },
  25 #                    { type => "type 2", name => "name 2" },
  26 #                    ...
  27 #                  ],
  28 #   comment   => "any comment for constructor",
  29 #   reg_req   => { in => [ "reg_class|register" ], out => [ "reg_class|register|in_rX" ] },
  30 #   cmp_attr  => "c source code for comparing node attributes",
  31 #   emit      => "emit code with templates",
  32 #   attr      => "attitional attribute arguments for constructor"
  33 #   init_attr => "emit attribute initialization template"
  34 #   rd_constructor => "c source code which constructs an ir_node"
  35 #   attr_type => "name of the attribute struct",
  36 # },
  37 #
  38 # ... # (all nodes you need to describe)
  39 #
  40 # ); # close the %nodes initializer
  41
  42 # op_flags: flags for the operation, OPTIONAL (default is "N")
  43 # the op_flags correspond to the firm irop_flags:
  44 #   N   irop_flag_none
  45 #   L   irop_flag_labeled
  46 #   C   irop_flag_commutative
  47 #   X   irop_flag_cfopcode
  48 #   I   irop_flag_ip_cfopcode
  49 #   F   irop_flag_fragile
  50 #   Y   irop_flag_forking
  51 #   H   irop_flag_highlevel
  52 #   c   irop_flag_constlike
  53 #   K   irop_flag_keep
  54 #
  55 # irn_flags: special node flags, OPTIONAL (default is 0)
  56 # following irn_flags are supported:
  57 #   R   rematerializeable
  58 #   N   not spillable
  59 #   I   ignore for register allocation
  60 #   S   modifies stack pointer
  61 #
  62 # state: state of the operation, OPTIONAL (default is "floats")
  63 #
  64 # arity: arity of the operation, MUST NOT BE OMITTED
  65 #
  66 # args:  the OPTIONAL arguments of the node constructor (debug, irg and block
  67 #        are always the first 3 arguments and are always autmatically
  68 #        created)
  69 #        If this key is missing the following arguments will be created:
  70 #        for i = 1 .. arity: ir_node *op_i
  71 #        ir_mode *mode
  72 #
  73 # outs:  if a node defines more than one output, the names of the projections
  74 #        nodes having outs having automatically the mode mode_T
  75 #        One can also annotate some flags for each out, additional to irn_flags.
  76 #        They are separated from name with a colon ':', and concatenated by pipe '|'
  77 #        Only I and S are available at the moment (same meaning as in irn_flags).
  78 #        example: [ "frame:I", "stack:I|S", "M" ]
  79 #
  80 # comment: OPTIONAL comment for the node constructor
  81 #
  82 # rd_constructor: for every operation there will be a
  83 #      new_rd_<arch>_<op-name> function with the arguments from above
  84 #      which creates the ir_node corresponding to the defined operation
  85 #      you can either put the complete source code of this function here
  86 #
  87 #      This key is OPTIONAL. If omitted, the following constructor will
  88 #      be created:
  89 #      if (!op_<arch>_<op-name>) assert(0);
  90 #      for i = 1 to arity
  91 #         set in[i] = op_i
  92 #      done
  93 #      res = new_ir_node(db, irg, block, op_<arch>_<op-name>, mode, arity, in)
  94 #      return res
  95 #
  96 # NOTE: rd_constructor and args are only optional if and only if arity is 0,1,2 or 3
  97 #
  98
  99 # register types:
 100 #   0 - no special type
 101 #   1 - caller save (register must be saved by the caller of a function)
 102 #   2 - callee save (register must be saved by the called function)
 103 #   4 - ignore (do not assign this register)
 104 #   8 - emitter can choose an arbitrary register of this class
 105 #  16 - the register is a virtual one
 106 #  32 - register represents a state
 107 # NOTE: Last entry of each class is the largest Firm-Mode a register can hold
 108 %reg_classes = (
 109         gp => [
 110                 { name => "edx", type => 1 },
 111                 { name => "ecx", type => 1 },
 112                 { name => "eax", type => 1 },
 113                 { name => "ebx", type => 2 },
 114                 { name => "esi", type => 2 },
 115                 { name => "edi", type => 2 },
 116                 { name => "ebp", type => 2 },
 117                 { name => "esp", type => 4 },
 118                 { name => "gp_NOREG", type => 4 | 8 | 16 }, # we need a dummy register for NoReg nodes
 119                 { name => "gp_UKNWN", type => 4 | 8 | 16 },  # we need a dummy register for Unknown nodes
 120                 { mode => "mode_Iu" }
 121         ],
 122         mmx => [
 123                 { name => "mm0", type => 4 },
 124                 { name => "mm1", type => 4 },
 125                 { name => "mm2", type => 4 },
 126                 { name => "mm3", type => 4 },
 127                 { name => "mm4", type => 4 },
 128                 { name => "mm5", type => 4 },
 129                 { name => "mm6", type => 4 },
 130                 { name => "mm7", type => 4 },
 131                 { mode => "mode_E", flags => "manual_ra" }
 132         ],
 133         xmm => [
 134                 { name => "xmm0", type => 1 },
 135                 { name => "xmm1", type => 1 },
 136                 { name => "xmm2", type => 1 },
 137                 { name => "xmm3", type => 1 },
 138                 { name => "xmm4", type => 1 },
 139                 { name => "xmm5", type => 1 },
 140                 { name => "xmm6", type => 1 },
 141                 { name => "xmm7", type => 1 },
 142                 { name => "xmm_NOREG", type => 4 | 16 },     # we need a dummy register for NoReg nodes
 143                 { name => "xmm_UKNWN", type => 4 | 8 | 16},  # we need a dummy register for Unknown nodes
 144                 { mode => "mode_E" }
 145         ],
 146         vfp => [
 147                 { name => "vf0", type => 1 | 16 },
 148                 { name => "vf1", type => 1 | 16 },
 149                 { name => "vf2", type => 1 | 16 },
 150                 { name => "vf3", type => 1 | 16 },
 151                 { name => "vf4", type => 1 | 16 },
 152                 { name => "vf5", type => 1 | 16 },
 153                 { name => "vf6", type => 1 | 16 },
 154                 { name => "vf7", type => 1 | 16 },
 155                 { name => "vfp_NOREG", type => 4 | 8 | 16 }, # we need a dummy register for NoReg nodes
 156                 { name => "vfp_UKNWN", type => 4 | 8 | 16 },  # we need a dummy register for Unknown nodes
 157                 { mode => "mode_E" }
 158         ],
 159         st => [
 160                 { name => "st0", realname => "st",    type => 4 },
 161                 { name => "st1", realname => "st(1)", type => 4 },
 162                 { name => "st2", realname => "st(2)", type => 4 },
 163                 { name => "st3", realname => "st(3)", type => 4 },
 164                 { name => "st4", realname => "st(4)", type => 4 },
 165                 { name => "st5", realname => "st(5)", type => 4 },
 166                 { name => "st6", realname => "st(6)", type => 4 },
 167                 { name => "st7", realname => "st(7)", type => 4 },
 168                 { mode => "mode_E", flags => "manual_ra" }
 169         ],
 170         fp_cw => [      # the floating point control word
 171                 { name => "fpcw", type => 4|32 },
 172                 { mode => "mode_fpcw", flags => "manual_ra|state" }
 173         ],
 174         flags => [
 175                 { name => "eflags", type => 0 },
 176                 { mode => "mode_Iu", flags => "manual_ra" }
 177         ],
 178 ); # %reg_classes
 179
 180 %cpu = (
 181         GP     => [ 1, "GP_EAX", "GP_EBX", "GP_ECX", "GP_EDX", "GP_ESI", "GP_EDI", "GP_EBP" ],
 182         SSE    => [ 1, "SSE_XMM0", "SSE_XMM1", "SSE_XMM2", "SSE_XMM3", "SSE_XMM4", "SSE_XMM5", "SSE_XMM6", "SSE_XMM7" ],
 183         VFP    => [ 1, "VFP_VF0", "VFP_VF1", "VFP_VF2", "VFP_VF3", "VFP_VF4", "VFP_VF5", "VFP_VF6", "VFP_VF7" ],
 184         BRANCH => [ 1, "BRANCH1", "BRANCH2" ],
 185 ); # %cpu
 186
 187 %vliw = (
 188         bundle_size       => 1,
 189         bundels_per_cycle => 1
 190 ); # vliw
 191
 192 %emit_templates = (
 193         S0 => "${arch}_emit_source_register(node, 0);",
 194         S1 => "${arch}_emit_source_register(node, 1);",
 195         S2 => "${arch}_emit_source_register(node, 2);",
 196         S3 => "${arch}_emit_source_register(node, 3);",
 197         SB1 => "${arch}_emit_8bit_source_register_or_immediate(node, 1);",
 198         SB2 => "${arch}_emit_8bit_source_register_or_immediate(node, 2);",
 199         SB3 => "${arch}_emit_8bit_source_register_or_immediate(node, 3);",
 200         SI3 => "${arch}_emit_source_register_or_immediate(node, 3);",
 201         D0 => "${arch}_emit_dest_register(node, 0);",
 202         D1 => "${arch}_emit_dest_register(node, 1);",
 203         DB0 => "${arch}_emit_8bit_dest_register(node, 0);",
 204         X0 => "${arch}_emit_x87_register(node, 0);",
 205         X1 => "${arch}_emit_x87_register(node, 1);",
 206         SE => "${arch}_emit_extend_suffix(get_ia32_ls_mode(node));",
 207         ME => "if(get_mode_size_bits(get_ia32_ls_mode(node)) != 32)\n
 208                    ia32_emit_mode_suffix(node);",
 209         M  => "${arch}_emit_mode_suffix(node);",
 210         XM => "${arch}_emit_x87_mode_suffix(node);",
 211         XXM => "${arch}_emit_xmm_mode_suffix(node);",
 212         XSD => "${arch}_emit_xmm_mode_suffix_s(node);",
 213         AM => "${arch}_emit_am(node);",
 214         unop3 => "${arch}_emit_unop(node, 3);",
 215         unop4 => "${arch}_emit_unop(node, 4);",
 216         unop5 => "${arch}_emit_unop(node, 5);",
 217         binop => "${arch}_emit_binop(node);",
 218         x87_binop => "${arch}_emit_x87_binop(node);",
 219         CMP0  => "${arch}_emit_cmp_suffix_node(node, 0);",
 220         CMP3  => "${arch}_emit_cmp_suffix_node(node, 3);",
 221 );
 222
 223 #--------------------------------------------------#
 224 #                        _                         #
 225 #                       (_)                        #
 226 #  _ __   _____      __  _ _ __    ___  _ __  ___  #
 227 # | '_ \ / _ \ \ /\ / / | | '__|  / _ \| '_ \/ __| #
 228 # | | | |  __/\ V  V /  | | |    | (_) | |_) \__ \ #
 229 # |_| |_|\___| \_/\_/   |_|_|     \___/| .__/|___/ #
 230 #                                      | |         #
 231 #                                      |_|         #
 232 #--------------------------------------------------#
 233
 234 $default_op_attr_type = "ia32_op_attr_t";
 235 $default_attr_type    = "ia32_attr_t";
 236 $default_copy_attr    = "ia32_copy_attr";
 237
 238 sub ia32_custom_init_attr {
 239         my $node = shift;
 240         my $name = shift;
 241         my $res = "";
 242
 243         if(defined($node->{modified_flags})) {
 244                 $res .= "\tset_ia32_flags(res, get_ia32_flags(res) | arch_irn_flags_modify_flags);\n";
 245         }
 246         if(defined($node->{am})) {
 247                 my $am = $node->{am};
 248                 if($am eq "source,unary") {
 249                         $res .= "\tset_ia32_am_support(res, ia32_am_Source, ia32_am_unary);";
 250                 } elsif($am eq "source,binary") {
 251                         $res .= "\tset_ia32_am_support(res, ia32_am_Source, ia32_am_binary);";
 252                 } elsif($am eq "dest,unary") {
 253                         $res .= "\tset_ia32_am_support(res, ia32_am_Dest, ia32_am_unary);";
 254                 } elsif($am eq "dest,binary") {
 255                         $res .= "\tset_ia32_am_support(res, ia32_am_Dest, ia32_am_binary);";
 256                 } elsif($am eq "dest,ternary") {
 257                         $res .= "\tset_ia32_am_support(res, ia32_am_Dest, ia32_am_ternary);";
 258                 } elsif($am eq "source,ternary") {
 259                         $res .= "\tset_ia32_am_support(res, ia32_am_Source, ia32_am_ternary);";
 260                 } elsif($am eq "none") {
 261                         # nothing to do
 262                 } else {
 263                         die("Invalid address mode '$am' specified on op $name");
 264                 }
 265                 if($am ne "none") {
 266                         if($node->{state} ne "exc_pinned"
 267                                         and $node->{state} ne "pinned") {
 268                                 die("AM nodes must have pinned or AM pinned state ($name)");
 269                         }
 270                 }
 271         }
 272         return $res;
 273 }
 274 $custom_init_attr_func = \&ia32_custom_init_attr;
 275
 276 %init_attr = (
 277         ia32_attr_t     => "\tinit_ia32_attributes(res, flags, in_reqs, out_reqs, exec_units, n_res);",
 278         ia32_x87_attr_t =>
 279                 "\tinit_ia32_attributes(res, flags, in_reqs, out_reqs, exec_units, n_res);\n".
 280                 "\tinit_ia32_x87_attributes(res);",
 281         ia32_asm_attr_t =>
 282                 "\tinit_ia32_attributes(res, flags, in_reqs, out_reqs, exec_units, n_res);\n".
 283                 "\tinit_ia32_x87_attributes(res);".
 284                 "\tinit_ia32_asm_attributes(res);",
 285         ia32_immediate_attr_t =>
 286                 "\tinit_ia32_attributes(res, flags, in_reqs, out_reqs, exec_units, n_res);\n".
 287                 "\tinit_ia32_immediate_attributes(res, symconst, symconst_sign, offset);",
 288         ia32_copyb_attr_t =>
 289                 "\tinit_ia32_attributes(res, flags, in_reqs, out_reqs, exec_units, n_res);\n".
 290                 "\tinit_ia32_copyb_attributes(res, size);",
 291         ia32_condcode_attr_t =>
 292                 "\tinit_ia32_attributes(res, flags, in_reqs, out_reqs, exec_units, n_res);\n".
 293                 "\tinit_ia32_condcode_attributes(res, pnc);",
 294 );
 295
 296 %compare_attr = (
 297         ia32_attr_t           => "ia32_compare_nodes_attr",
 298         ia32_x87_attr_t       => "ia32_compare_x87_attr",
 299         ia32_asm_attr_t       => "ia32_compare_asm_attr",
 300         ia32_immediate_attr_t => "ia32_compare_immediate_attr",
 301         ia32_copyb_attr_t     => "ia32_compare_copyb_attr",
 302         ia32_condcode_attr_t  => "ia32_compare_condcode_attr",
 303 );
 304
 305 %operands = (
 306 );
 307
 308 $mode_xmm     = "mode_E";
 309 $mode_gp      = "mode_Iu";
 310 $mode_flags   = "mode_Iu";
 311 $mode_fpcw    = "mode_fpcw";
 312 $status_flags = [ "CF", "PF", "AF", "ZF", "SF", "OF" ];
 313 $fpcw_flags   = [ "FP_IM", "FP_DM", "FP_ZM", "FP_OM", "FP_UM", "FP_PM",
 314                   "FP_PC0", "FP_PC1", "FP_RC0", "FP_RC1", "FP_X" ];
 315
 316 %nodes = (
 317
 318 Immediate => {
 319         state     => "pinned",
 320         op_flags  => "c",
 321         irn_flags => "I",
 322         reg_req   => { out => [ "gp_NOREG" ] },
 323         attr      => "ir_entity *symconst, int symconst_sign, long offset",
 324         attr_type => "ia32_immediate_attr_t",
 325         latency   => 0,
 326         mode      => $mode_gp,
 327 },
 328
 329 Asm => {
 330         mode      => "mode_T",
 331         arity     => "variable",
 332         out_arity => "variable",
 333         attr_type => "ia32_asm_attr_t",
 334         attr      => "ident *asm_text, const ia32_asm_reg_t *register_map",
 335         init_attr => "attr->asm_text = asm_text;\n".
 336                      "\tattr->register_map = register_map;\n",
 337         latency   => 10,
 338         modified_flags => 1,
 339 },
 340
 341 ProduceVal => {
 342         op_flags  => "c",
 343         irn_flags => "R",
 344         reg_req   => { out => [ "gp" ] },
 345         emit      => "",
 346         units     => [ ],
 347         latency   => 0,
 348         mode      => $mode_gp,
 349         cmp_attr  => "return 1;",
 350 },
 351
 352 #-----------------------------------------------------------------#
 353 #  _       _                                         _            #
 354 # (_)     | |                                       | |           #
 355 #  _ _ __ | |_ ___  __ _  ___ _ __   _ __   ___   __| | ___  ___  #
 356 # | | '_ \| __/ _ \/ _` |/ _ \ '__| | '_ \ / _ \ / _` |/ _ \/ __| #
 357 # | | | | | ||  __/ (_| |  __/ |    | | | | (_) | (_| |  __/\__ \ #
 358 # |_|_| |_|\__\___|\__, |\___|_|    |_| |_|\___/ \__,_|\___||___/ #
 359 #                   __/ |                                         #
 360 #                  |___/                                          #
 361 #-----------------------------------------------------------------#
 362
 363 # commutative operations
 364
 365 Add => {
 366         irn_flags => "R",
 367         state     => "exc_pinned",
 368         reg_req   => { in  => [ "gp", "gp", "none", "gp", "gp" ],
 369                        out => [ "in_r4 in_r5", "flags", "none" ] },
 370         ins       => [ "base", "index", "mem", "left", "right" ],
 371         outs      => [ "res", "flags", "M" ],
 372         emit      => '. add%M %binop',
 373         am        => "source,binary",
 374         units     => [ "GP" ],
 375         latency   => 1,
 376         mode      => $mode_gp,
 377         modified_flags => $status_flags
 378 },
 379
 380 AddMem => {
 381         irn_flags => "R",
 382         state     => "exc_pinned",
 383         reg_req   => { in => [ "gp", "gp", "none", "gp" ], out => [ "none" ] },
 384         ins       => [ "base", "index", "mem", "val" ],
 385         emit      => ". add%M %SI3, %AM",
 386         units     => [ "GP" ],
 387         latency   => 1,
 388         mode      => "mode_M",
 389         modified_flags => $status_flags
 390 },
 391
 392 AddMem8Bit => {
 393         irn_flags => "R",
 394         state     => "exc_pinned",
 395         reg_req   => { in => [ "gp", "gp", "none", "eax ebx ecx edx" ], out => [ "none" ] },
 396         ins       => [ "base", "index", "mem", "val" ],
 397         emit      => ". add%M %SB3, %AM",
 398         units     => [ "GP" ],
 399         latency   => 1,
 400         mode      => "mode_M",
 401         modified_flags => $status_flags
 402 },
 403
 404 Adc => {
 405         state     => "exc_pinned",
 406         reg_req   => { in => [ "gp", "gp", "none", "gp", "gp", "flags" ],
 407                        out => [ "in_r4 in_r5", "flags", "none" ] },
 408         ins       => [ "base", "index", "mem", "left", "right", "eflags" ],
 409         outs      => [ "res", "flags", "M" ],
 410         emit      => '. adc%M %binop',
 411         am        => "source,binary",
 412         units     => [ "GP" ],
 413         latency   => 1,
 414         mode      => $mode_gp,
 415         modified_flags => $status_flags
 416 },
 417
 418 l_Add => {
 419         op_flags  => "C",
 420         reg_req   => { in => [ "none", "none" ], out => [ "none" ] },
 421         ins       => [ "left", "right" ],
 422 },
 423
 424 l_Adc => {
 425         reg_req   => { in => [ "none", "none", "none" ], out => [ "none" ] },
 426         ins       => [ "left", "right", "eflags" ],
 427 },
 428
 429 Mul => {
 430         # we should not rematrialize this node. It produces 2 results and has
 431         # very strict constrains
 432         state     => "exc_pinned",
 433         reg_req   => { in => [ "gp", "gp", "none", "eax", "gp" ],
 434                        out => [ "eax", "edx", "none" ] },
 435         ins       => [ "base", "index", "mem", "val_high", "val_low" ],
 436         emit      => '. mul%M %unop4',
 437         outs      => [ "res_low", "res_high", "M" ],
 438         am        => "source,binary",
 439         latency   => 10,
 440         units     => [ "GP" ],
 441         modified_flags => $status_flags
 442 },
 443
 444 l_Mul => {
 445         # we should not rematrialize this node. It produces 2 results and has
 446         # very strict constrains
 447         op_flags  => "C",
 448         cmp_attr  => "return 1;",
 449         outs      => [ "EAX", "EDX", "M" ],
 450         arity     => 2
 451 },
 452
 453 IMul => {
 454         irn_flags => "R",
 455         state     => "exc_pinned",
 456         # TODO: adjust out requirements for the 3 operand form
 457         # (no need for should_be_same then)
 458         reg_req   => { in => [ "gp", "gp", "none", "gp", "gp" ],
 459                            out => [ "in_r4 in_r5", "flags", "none" ] },
 460         ins       => [ "base", "index", "mem", "left", "right" ],
 461         outs      => [ "res", "flags", "M" ],
 462         am        => "source,binary",
 463         latency   => 5,
 464         units     => [ "GP" ],
 465         mode      => $mode_gp,
 466         modified_flags => $status_flags
 467 },
 468
 469 IMul1OP => {
 470         irn_flags => "R",
 471         state     => "exc_pinned",
 472         reg_req   => { in => [ "gp", "gp", "none", "eax", "gp" ],
 473                        out => [ "eax", "edx", "none" ] },
 474         ins       => [ "base", "index", "mem", "val_high", "val_low" ],
 475         emit      => '. imul%M %unop4',
 476         outs      => [ "res_low", "res_high", "M" ],
 477         am        => "source,binary",
 478         latency   => 5,
 479         units     => [ "GP" ],
 480         modified_flags => $status_flags
 481 },
 482
 483 l_IMul => {
 484         op_flags  => "C",
 485         cmp_attr  => "return 1;",
 486         outs      => [ "res_low", "res_high", "M" ],
 487         arity     => 2
 488 },
 489
 490 And => {
 491         irn_flags => "R",
 492         state     => "exc_pinned",
 493         reg_req   => { in => [ "gp", "gp", "none", "gp", "gp" ],
 494                            out => [ "in_r4 in_r5", "flags", "none" ] },
 495         ins       => [ "base", "index", "mem", "left", "right" ],
 496         outs      => [ "res", "flags", "M" ],
 497         op_modes  => "commutative | am | immediate | mode_neutral",
 498         am        => "source,binary",
 499         emit      => '. and%M %binop',
 500         units     => [ "GP" ],
 501         latency   => 1,
 502         mode      => $mode_gp,
 503         modified_flags => $status_flags
 504 },
 505
 506 AndMem => {
 507         irn_flags => "R",
 508         state     => "exc_pinned",
 509         reg_req   => { in => [ "gp", "gp", "none", "gp" ], out => [ "none" ] },
 510         ins       => [ "base", "index", "mem", "val" ],
 511         emit      => '. and%M %SI3, %AM',
 512         units     => [ "GP" ],
 513         latency   => 1,
 514         mode      => "mode_M",
 515         modified_flags => $status_flags
 516 },
 517
 518 AndMem8Bit => {
 519         irn_flags => "R",
 520         state     => "exc_pinned",
 521         reg_req   => { in => [ "gp", "gp", "none",  "eax ebx ecx edx" ], out => [ "none" ] },
 522         ins       => [ "base", "index", "mem", "val" ],
 523         emit      => '. and%M %SB3, %AM',
 524         units     => [ "GP" ],
 525         latency   => 1,
 526         mode      => "mode_M",
 527         modified_flags => $status_flags
 528 },
 529
 530 Or => {
 531         irn_flags => "R",
 532         state     => "exc_pinned",
 533         reg_req   => { in => [ "gp", "gp", "none", "gp", "gp" ],
 534                        out => [ "in_r4 in_r5", "flags", "none" ] },
 535         ins       => [ "base", "index", "mem", "left", "right" ],
 536         outs      => [ "res", "flags", "M" ],
 537         am        => "source,binary",
 538         emit      => '. or%M %binop',
 539         units     => [ "GP" ],
 540         latency   => 1,
 541         mode      => $mode_gp,
 542         modified_flags => $status_flags
 543 },
 544
 545 OrMem => {
 546         irn_flags => "R",
 547         state     => "exc_pinned",
 548         reg_req   => { in => [ "gp", "gp", "none", "gp" ], out => [ "none" ] },
 549         ins       => [ "base", "index", "mem", "val" ],
 550         emit      => '. or%M %SI3, %AM',
 551         units     => [ "GP" ],
 552         latency   => 1,
 553         mode      => "mode_M",
 554         modified_flags => $status_flags
 555 },
 556
 557 OrMem8Bit => {
 558         irn_flags => "R",
 559         state     => "exc_pinned",
 560         reg_req   => { in => [ "gp", "gp", "none", "eax ebx ecx edx" ], out => [ "none" ] },
 561         ins       => [ "base", "index", "mem", "val" ],
 562         emit      => '. or%M %SB3, %AM',
 563         units     => [ "GP" ],
 564         latency   => 1,
 565         mode      => "mode_M",
 566         modified_flags => $status_flags
 567 },
 568
 569 Xor => {
 570         irn_flags => "R",
 571         state     => "exc_pinned",
 572         reg_req   => { in => [ "gp", "gp", "none", "gp", "gp" ],
 573                        out => [ "in_r4 in_r5", "flags", "none" ] },
 574         ins       => [ "base", "index", "mem", "left", "right" ],
 575         outs      => [ "res", "flags", "M" ],
 576         am        => "source,binary",
 577         emit      => '. xor%M %binop',
 578         units     => [ "GP" ],
 579         latency   => 1,
 580         mode      => $mode_gp,
 581         modified_flags => $status_flags
 582 },
 583
 584 XorMem => {
 585         irn_flags => "R",
 586         state     => "exc_pinned",
 587         reg_req   => { in => [ "gp", "gp", "none", "gp" ], out => [ "none" ] },
 588         ins       => [ "base", "index", "mem", "val" ],
 589         emit      => '. xor%M %SI3, %AM',
 590         units     => [ "GP" ],
 591         latency   => 1,
 592         mode      => "mode_M",
 593         modified_flags => $status_flags
 594 },
 595
 596 XorMem8Bit => {
 597         irn_flags => "R",
 598         state     => "exc_pinned",
 599         reg_req   => { in => [ "gp", "gp", "none", "eax ebx ecx edx" ], out => [ "none" ] },
 600         ins       => [ "base", "index", "mem", "val" ],
 601         emit      => '. xor%M %SB3, %AM',
 602         units     => [ "GP" ],
 603         latency   => 1,
 604         mode      => "mode_M",
 605         modified_flags => $status_flags
 606 },
 607
 608 # not commutative operations
 609
 610 Sub => {
 611         irn_flags => "R",
 612         state     => "exc_pinned",
 613         reg_req   => { in => [ "gp", "gp", "none", "gp", "gp" ],
 614                        out => [ "in_r4", "flags", "none" ] },
 615         ins       => [ "base", "index", "mem", "left", "right" ],
 616         outs      => [ "res", "flags", "M" ],
 617         am        => "source,binary",
 618         emit      => '. sub%M %binop',
 619         units     => [ "GP" ],
 620         latency   => 1,
 621         mode      => $mode_gp,
 622         modified_flags => $status_flags
 623 },
 624
 625 SubMem => {
 626         irn_flags => "R",
 627         state     => "exc_pinned",
 628         reg_req   => { in => [ "gp", "gp", "none", "gp" ], out => [ "none" ] },
 629         ins       => [ "base", "index", "mem", "val" ],
 630         emit      => '. sub%M %SI3, %AM',
 631         units     => [ "GP" ],
 632         latency   => 1,
 633         mode      => 'mode_M',
 634         modified_flags => $status_flags
 635 },
 636
 637 SubMem8Bit => {
 638         irn_flags => "R",
 639         state     => "exc_pinned",
 640         reg_req   => { in => [ "gp", "gp", "none", "eax ebx ecx edx" ], out => [ "none" ] },
 641         ins       => [ "base", "index", "mem", "val" ],
 642         emit      => '. sub%M %SB3, %AM',
 643         units     => [ "GP" ],
 644         latency   => 1,
 645         mode      => 'mode_M',
 646         modified_flags => $status_flags
 647 },
 648
 649 Sbb => {
 650         state     => "exc_pinned",
 651         reg_req   => { in => [ "gp", "gp", "none", "gp", "gp", "flags" ],
 652                        out => [ "in_r4 !in_r5", "flags", "none" ] },
 653         ins       => [ "base", "index", "mem", "left", "right", "eflags" ],
 654         outs      => [ "res", "flags", "M" ],
 655         am        => "source,binary",
 656         emit      => '. sbb%M %binop',
 657         units     => [ "GP" ],
 658         latency   => 1,
 659         mode      => $mode_gp,
 660         modified_flags => $status_flags
 661 },
 662
 663 l_Sub => {
 664         reg_req   => { in => [ "none", "none" ], out => [ "none" ] },
 665         ins       => [ "left", "right" ],
 666 },
 667
 668 l_Sbb => {
 669         reg_req   => { in => [ "none", "none", "none" ], out => [ "none" ] },
 670         ins       => [ "left", "right", "eflags" ],
 671 },
 672
 673 IDiv => {
 674         op_flags  => "F|L",
 675         state     => "exc_pinned",
 676         reg_req   => { in => [ "gp", "gp", "none", "eax", "edx", "gp" ],
 677                        out => [ "eax", "flags", "none", "edx", "none" ] },
 678         ins       => [ "base", "index", "mem", "left_low", "left_high", "right" ],
 679         outs      => [ "div_res", "flags", "M", "mod_res", "X_exc" ],
 680         am        => "source,ternary",
 681         emit      => ". idiv%M %unop5",
 682         latency   => 25,
 683         units     => [ "GP" ],
 684         modified_flags => $status_flags
 685 },
 686
 687 Div => {
 688         op_flags  => "F|L",
 689         state     => "exc_pinned",
 690         reg_req   => { in => [ "gp", "gp", "none", "eax", "edx", "gp" ],
 691                        out => [ "eax", "flags", "none", "edx", "none" ] },
 692         ins       => [ "base", "index", "mem", "left_low", "left_high", "right" ],
 693         outs      => [ "div_res", "flags", "M", "mod_res", "X_exc" ],
 694         am        => "source,ternary",
 695         emit      => ". div%M %unop5",
 696         latency   => 25,
 697         units     => [ "GP" ],
 698         modified_flags => $status_flags
 699 },
 700
 701 Shl => {
 702         irn_flags => "R",
 703         reg_req   => { in => [ "gp", "ecx" ],
 704                        out => [ "in_r1 !in_r2", "flags" ] },
 705         ins       => [ "val", "count" ],
 706         outs      => [ "res", "flags" ],
 707         emit      => '. shl %SB1, %S0',
 708         units     => [ "GP" ],
 709         latency   => 1,
 710         mode      => $mode_gp,
 711         modified_flags => $status_flags
 712 },
 713
 714 ShlMem => {
 715         irn_flags => "R",
 716         state     => "exc_pinned",
 717         reg_req   => { in => [ "gp", "gp", "none", "ecx" ], out => [ "none" ] },
 718         ins       => [ "base", "index", "mem", "count" ],
 719         emit      => '. shl%M %SB3, %AM',
 720         units     => [ "GP" ],
 721         latency   => 1,
 722         mode      => "mode_M",
 723         modified_flags => $status_flags
 724 },
 725
 726 l_ShlDep => {
 727         cmp_attr => "return 1;",
 728         ins      => [ "val", "count", "dep" ],
 729         arity    => 3
 730 },
 731
 732 ShlD => {
 733         irn_flags => "R",
 734         reg_req   => { in => [ "gp", "gp", "ecx" ],
 735                        out => [ "in_r1 !in_r2 !in_r3", "flags" ] },
 736         ins       => [ "val_high", "val_low", "count" ],
 737         outs      => [ "res", "flags" ],
 738         emit      => ". shld%M %SB2, %S1, %D0",
 739         latency   => 6,
 740         units     => [ "GP" ],
 741         mode      => $mode_gp,
 742         modified_flags => $status_flags
 743 },
 744
 745 l_ShlD => {
 746         cmp_attr  => "return 1;",
 747         ins       => [ "val_high", "val_low", "count" ],
 748         arity     => 3,
 749 },
 750
 751 Shr => {
 752         irn_flags => "R",
 753         reg_req   => { in => [ "gp", "ecx" ],
 754                        out => [ "in_r1 !in_r2", "flags" ] },
 755         ins       => [ "val", "count" ],
 756         outs      => [ "res", "flags" ],
 757         emit      => '. shr %SB1, %S0',
 758         units     => [ "GP" ],
 759         mode      => $mode_gp,
 760         latency   => 1,
 761         modified_flags => $status_flags
 762 },
 763
 764 ShrMem => {
 765         irn_flags => "R",
 766         state     => "exc_pinned",
 767         reg_req   => { in => [ "gp", "gp", "none", "ecx" ], out => [ "none" ] },
 768         ins       => [ "base", "index", "mem", "count" ],
 769         emit      => '. shr%M %SB3, %AM',
 770         units     => [ "GP" ],
 771         mode      => "mode_M",
 772         latency   => 1,
 773         modified_flags => $status_flags
 774 },
 775
 776 l_ShrDep => {
 777         cmp_attr  => "return 1;",
 778         ins       => [ "val", "count", "dep" ],
 779         arity     => 3
 780 },
 781
 782 ShrD => {
 783         irn_flags => "R",
 784         reg_req   => { in => [ "gp", "gp", "ecx" ],
 785                        out => [ "in_r1 !in_r2 !in_r3", "flags" ] },
 786         ins       => [ "val_high", "val_low", "count" ],
 787         outs      => [ "res", "flags" ],
 788         emit      => ". shrd%M %SB2, %S1, %D0",
 789         latency   => 6,
 790         units     => [ "GP" ],
 791         mode      => $mode_gp,
 792         modified_flags => $status_flags
 793 },
 794
 795 l_ShrD => {
 796         cmp_attr  => "return 1;",
 797         arity     => 3,
 798         ins       => [ "val_high", "val_low", "count" ],
 799 },
 800
 801 Sar => {
 802         irn_flags => "R",
 803         reg_req   => { in => [ "gp", "ecx" ],
 804                        out => [ "in_r1 !in_r2", "flags" ] },
 805         ins       => [ "val", "count" ],
 806         outs      => [ "res", "flags" ],
 807         emit      => '. sar %SB1, %S0',
 808         units     => [ "GP" ],
 809         latency   => 1,
 810         mode      => $mode_gp,
 811         modified_flags => $status_flags
 812 },
 813
 814 SarMem => {
 815         irn_flags => "R",
 816         state     => "exc_pinned",
 817         reg_req   => { in => [ "gp", "gp", "none", "ecx" ], out => [ "none" ] },
 818         ins       => [ "base", "index", "mem", "count" ],
 819         emit      => '. sar%M %SB3, %AM',
 820         units     => [ "GP" ],
 821         latency   => 1,
 822         mode      => "mode_M",
 823         modified_flags => $status_flags
 824 },
 825
 826 l_SarDep => {
 827         cmp_attr  => "return 1;",
 828         ins       => [ "val", "count", "dep" ],
 829         arity     => 3
 830 },
 831
 832 Ror => {
 833         irn_flags => "R",
 834         reg_req   => { in => [ "gp", "ecx" ],
 835                        out => [ "in_r1 !in_r2", "flags" ] },
 836         ins       => [ "val", "count" ],
 837         outs      => [ "res", "flags" ],
 838         emit      => '. ror %SB1, %S0',
 839         units     => [ "GP" ],
 840         latency   => 1,
 841         mode      => $mode_gp,
 842         modified_flags => $status_flags
 843 },
 844
 845 RorMem => {
 846         irn_flags => "R",
 847         state     => "exc_pinned",
 848         reg_req   => { in => [ "gp", "gp", "none", "ecx" ], out => [ "none" ] },
 849         ins       => [ "base", "index", "mem", "count" ],
 850         emit      => '. ror%M %SB3, %AM',
 851         units     => [ "GP" ],
 852         latency   => 1,
 853         mode      => "mode_M",
 854         modified_flags => $status_flags
 855 },
 856
 857 Rol => {
 858         irn_flags => "R",
 859         reg_req   => { in => [ "gp", "ecx" ],
 860                        out => [ "in_r1 !in_r2", "flags" ] },
 861         ins       => [ "val", "count" ],
 862         outs      => [ "res", "flags" ],
 863         emit      => '. rol %SB1, %S0',
 864         units     => [ "GP" ],
 865         latency   => 1,
 866         mode      => $mode_gp,
 867         modified_flags => $status_flags
 868 },
 869
 870 RolMem => {
 871         irn_flags => "R",
 872         state     => "exc_pinned",
 873         reg_req   => { in => [ "gp", "gp", "none", "ecx" ], out => [ "none" ] },
 874         ins       => [ "base", "index", "mem", "count" ],
 875         emit      => '. rol%M %SB3, %AM',
 876         units     => [ "GP" ],
 877         latency   => 1,
 878         mode      => "mode_M",
 879         modified_flags => $status_flags
 880 },
 881
 882 # unary operations
 883
 884 Neg => {
 885         irn_flags => "R",
 886         reg_req   => { in => [ "gp" ],
 887                        out => [ "in_r1", "flags" ] },
 888         emit      => '. neg %S0',
 889         ins       => [ "val" ],
 890         outs      => [ "res", "flags" ],
 891         units     => [ "GP" ],
 892         latency   => 1,
 893         mode      => $mode_gp,
 894         modified_flags => $status_flags
 895 },
 896
 897 NegMem => {
 898         irn_flags => "R",
 899         state     => "exc_pinned",
 900         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "none" ] },
 901         ins       => [ "base", "index", "mem" ],
 902         emit      => '. neg%M %AM',
 903         units     => [ "GP" ],
 904         latency   => 1,
 905         mode      => "mode_M",
 906         modified_flags => $status_flags
 907 },
 908
 909 Minus64Bit => {
 910         irn_flags => "R",
 911         reg_req   => { in => [ "gp", "gp" ], out => [ "in_r1", "gp" ] },
 912         outs      => [ "low_res", "high_res" ],
 913         units     => [ "GP" ],
 914         latency   => 3,
 915         modified_flags => $status_flags
 916 },
 917
 918
 919 Inc => {
 920         irn_flags => "R",
 921         reg_req   => { in => [ "gp" ],
 922                        out => [ "in_r1", "flags" ] },
 923         outs      => [ "res", "flags" ],
 924         emit      => '. inc %S0',
 925         units     => [ "GP" ],
 926         mode      => $mode_gp,
 927         latency   => 1,
 928         modified_flags => [ "OF", "SF", "ZF", "AF", "PF" ]
 929 },
 930
 931 IncMem => {
 932         irn_flags => "R",
 933         state     => "exc_pinned",
 934         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "none" ] },
 935         ins       => [ "base", "index", "mem" ],
 936         emit      => '. inc%M %AM',
 937         units     => [ "GP" ],
 938         mode      => "mode_M",
 939         latency   => 1,
 940         modified_flags => [ "OF", "SF", "ZF", "AF", "PF" ]
 941 },
 942
 943 Dec => {
 944         irn_flags => "R",
 945         reg_req   => { in => [ "gp" ],
 946                        out => [ "in_r1", "flags" ] },
 947         outs      => [ "res", "flags" ],
 948         emit      => '. dec %S0',
 949         units     => [ "GP" ],
 950         mode      => $mode_gp,
 951         latency   => 1,
 952         modified_flags => [ "OF", "SF", "ZF", "AF", "PF" ]
 953 },
 954
 955 DecMem => {
 956         irn_flags => "R",
 957         state     => "exc_pinned",
 958         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "none" ] },
 959         ins       => [ "base", "index", "mem" ],
 960         emit      => '. dec%M %AM',
 961         units     => [ "GP" ],
 962         mode      => "mode_M",
 963         latency   => 1,
 964         modified_flags => [ "OF", "SF", "ZF", "AF", "PF" ]
 965 },
 966
 967 Not => {
 968         irn_flags => "R",
 969         reg_req   => { in => [ "gp" ],
 970                        out => [ "in_r1", "flags" ] },
 971         ins       => [ "val" ],
 972         outs      => [ "res", "flags" ],
 973         emit      => '. not %S0',
 974         units     => [ "GP" ],
 975         latency   => 1,
 976         mode      => $mode_gp,
 977         # no flags modified
 978 },
 979
 980 NotMem => {
 981         irn_flags => "R",
 982         state     => "exc_pinned",
 983         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "none" ] },
 984         ins       => [ "base", "index", "mem" ],
 985         emit      => '. not%M %AM',
 986         units     => [ "GP" ],
 987         latency   => 1,
 988         mode      => "mode_M",
 989         # no flags modified
 990 },
 991
 992 Cmc => {
 993         reg_req => { in => [ "flags" ], out => [ "flags" ] },
 994         emit    => '.cmc',
 995         units     => [ "GP" ],
 996         latency   => 1,
 997         mode      => $mode_flags,
 998         modified_flags => $status_flags
 999 },
1000
1001 Stc => {
1002         reg_req => { out => [ "flags" ] },
1003         emit    => '.stc',
1004         units     => [ "GP" ],
1005         latency   => 1,
1006         mode      => $mode_flags,
1007         modified_flags => $status_flags
1008 },
1009
1010 # other operations
1011
1012 Cmp => {
1013         irn_flags => "R",
1014         state     => "exc_pinned",
1015         reg_req   => { in => [ "gp", "gp", "none", "gp", "gp" ] , out => [ "flags" ] },
1016         ins       => [ "base", "index", "mem", "left", "right" ],
1017         outs      => [ "eflags" ],
1018         am        => "source,binary",
1019         emit      => '. cmp%M %binop',
1020         attr      => "int ins_permuted, int cmp_unsigned",
1021         init_attr => "attr->data.ins_permuted   = ins_permuted;\n".
1022                      "\tattr->data.cmp_unsigned = cmp_unsigned;\n",
1023         latency   => 1,
1024         units     => [ "GP" ],
1025         mode      => $mode_flags,
1026         modified_flags => $status_flags
1027 },
1028
1029 Cmp8Bit => {
1030         irn_flags => "R",
1031         state     => "exc_pinned",
1032         reg_req   => { in => [ "gp", "gp", "none", "eax ebx ecx edx", "eax ebx ecx edx" ] , out => [ "flags" ] },
1033         ins       => [ "base", "index", "mem", "left", "right" ],
1034         outs      => [ "eflags" ],
1035         am        => "source,binary",
1036         emit      => '. cmpb %binop',
1037         attr      => "int ins_permuted, int cmp_unsigned",
1038         init_attr => "attr->data.ins_permuted   = ins_permuted;\n".
1039                      "\tattr->data.cmp_unsigned = cmp_unsigned;\n",
1040         latency   => 1,
1041         units     => [ "GP" ],
1042         mode      => $mode_flags,
1043         modified_flags => $status_flags
1044 },
1045
1046 Test => {
1047         irn_flags => "R",
1048         state     => "exc_pinned",
1049         reg_req   => { in => [ "gp", "gp", "none", "gp", "gp" ] , out => [ "flags" ] },
1050         ins       => [ "base", "index", "mem", "left", "right" ],
1051         outs      => [ "eflags" ],
1052         am        => "source,binary",
1053         emit      => '. test%M %binop',
1054         attr      => "int ins_permuted, int cmp_unsigned",
1055         init_attr => "attr->data.ins_permuted = ins_permuted;\n".
1056                      "\tattr->data.cmp_unsigned = cmp_unsigned;\n",
1057         latency   => 1,
1058         units     => [ "GP" ],
1059         mode      => $mode_flags,
1060         modified_flags => $status_flags
1061 },
1062
1063 Test8Bit => {
1064         irn_flags => "R",
1065         state     => "exc_pinned",
1066         reg_req   => { in => [ "gp", "gp", "none", "eax ebx ecx edx", "eax ebx ecx edx" ] , out => [ "flags" ] },
1067         ins       => [ "base", "index", "mem", "left", "right" ],
1068         outs      => [ "eflags" ],
1069         am        => "source,binary",
1070         emit      => '. testb %binop',
1071         attr      => "int ins_permuted, int cmp_unsigned",
1072         init_attr => "attr->data.ins_permuted = ins_permuted;\n".
1073                      "\tattr->data.cmp_unsigned = cmp_unsigned;\n",
1074         latency   => 1,
1075         units     => [ "GP" ],
1076         mode      => $mode_flags,
1077         modified_flags => $status_flags
1078 },
1079
1080 Set => {
1081         #irn_flags => "R",
1082         reg_req   => { in => [ "eflags" ], out => [ "eax ebx ecx edx" ] },
1083         ins       => [ "eflags" ],
1084         attr_type => "ia32_condcode_attr_t",
1085         attr      => "pn_Cmp pnc, int ins_permuted",
1086         init_attr => "attr->attr.data.ins_permuted = ins_permuted;\n".
1087                       "\tset_ia32_ls_mode(res, mode_Bu);\n",
1088         emit      => '. set%CMP0 %DB0',
1089         latency   => 1,
1090         units     => [ "GP" ],
1091         mode      => $mode_gp,
1092 },
1093
1094 SetMem => {
1095         #irn_flags => "R",
1096         state     => "exc_pinned",
1097         reg_req   => { in => [ "gp", "gp", "none", "eflags" ], out => [ "none" ] },
1098         ins       => [ "base", "index", "mem","eflags" ],
1099         attr_type => "ia32_condcode_attr_t",
1100         attr      => "pn_Cmp pnc, int ins_permuted",
1101         init_attr => "attr->attr.data.ins_permuted = ins_permuted;\n".
1102                       "\tset_ia32_ls_mode(res, mode_Bu);\n",
1103         emit      => '. set%CMP3 %AM',
1104         latency   => 1,
1105         units     => [ "GP" ],
1106         mode      => 'mode_M',
1107 },
1108
1109 CMov => {
1110         #irn_flags => "R",
1111         # (note: leave the false,true order intact to make it compatible with other
1112         #  ia32_binary ops)
1113         state     => "exc_pinned",
1114         reg_req   => { in => [ "gp", "gp", "none", "gp", "gp", "eflags" ], out => [ "in_r4 in_r5" ] },
1115         ins       => [ "base", "index", "mem", "val_false", "val_true", "eflags" ],
1116         am        => "source,binary",
1117         attr_type => "ia32_condcode_attr_t",
1118         attr      => "int ins_permuted, pn_Cmp pnc",
1119         init_attr => "attr->attr.data.ins_permuted = ins_permuted;",
1120         latency   => 1,
1121         units     => [ "GP" ],
1122         mode      => $mode_gp,
1123 },
1124
1125 Jcc => {
1126         state     => "pinned",
1127         op_flags  => "L|X|Y",
1128         reg_req   => { in  => [ "eflags" ], out => [ "none", "none" ] },
1129         ins       => [ "eflags" ],
1130         outs      => [ "false", "true" ],
1131         attr_type => "ia32_condcode_attr_t",
1132         attr      => "pn_Cmp pnc",
1133         latency   => 2,
1134         units     => [ "BRANCH" ],
1135 },
1136
1137 SwitchJmp => {
1138         state     => "pinned",
1139         op_flags  => "L|X|Y",
1140         reg_req   => { in => [ "gp" ], out => [ "none" ] },
1141         mode      => "mode_T",
1142         attr_type => "ia32_condcode_attr_t",
1143         attr      => "pn_Cmp pnc",
1144         latency   => 3,
1145         units     => [ "BRANCH" ],
1146         modified_flags => $status_flags,
1147 },
1148
1149 IJmp => {
1150         state     => "pinned",
1151         op_flags  => "X",
1152         reg_req   => { in => [ "gp", "gp", "none", "gp" ] },
1153         ins       => [ "base", "index", "mem", "target" ],
1154         am        => "source,unary",
1155         emit      => '. jmp *%unop3',
1156         latency   => 1,
1157         units     => [ "BRANCH" ],
1158         mode      => "mode_X",
1159 },
1160
1161 Const => {
1162         op_flags  => "c",
1163         irn_flags => "R",
1164         reg_req   => { out => [ "gp" ] },
1165         units     => [ "GP" ],
1166         attr      => "ir_entity *symconst, int symconst_sign, long offset",
1167         attr_type => "ia32_immediate_attr_t",
1168         latency   => 1,
1169         mode      => $mode_gp,
1170 },
1171
1172 GetEIP => {
1173         op_flags => "c",
1174         reg_req  => { out => [ "gp" ] },
1175         units    => [ "GP" ],
1176         latency  => 5,
1177         mode     => $mode_gp,
1178         modified_flags => $status_flags,
1179 },
1180
1181 Unknown_GP => {
1182         state     => "pinned",
1183         op_flags  => "c",
1184         irn_flags => "I",
1185         reg_req   => { out => [ "gp_UKNWN" ] },
1186         units     => [],
1187         emit      => "",
1188         latency   => 0,
1189         mode      => $mode_gp
1190 },
1191
1192 Unknown_VFP => {
1193         state     => "pinned",
1194         op_flags  => "c",
1195         irn_flags => "I",
1196         reg_req   => { out => [ "vfp_UKNWN" ] },
1197         units     => [],
1198         emit      => "",
1199         mode      => "mode_E",
1200         latency   => 0,
1201         attr_type => "ia32_x87_attr_t",
1202 },
1203
1204 Unknown_XMM => {
1205         state     => "pinned",
1206         op_flags  => "c",
1207         irn_flags => "I",
1208         reg_req   => { out => [ "xmm_UKNWN" ] },
1209         units     => [],
1210         emit      => "",
1211         latency   => 0,
1212         mode      => "mode_E"
1213 },
1214
1215 NoReg_GP => {
1216         state     => "pinned",
1217         op_flags  => "c",
1218         irn_flags => "I",
1219         reg_req   => { out => [ "gp_NOREG" ] },
1220         units     => [],
1221         emit      => "",
1222         latency   => 0,
1223         mode      => $mode_gp
1224 },
1225
1226 NoReg_VFP => {
1227         state     => "pinned",
1228         op_flags  => "c",
1229         irn_flags => "I",
1230         reg_req   => { out => [ "vfp_NOREG" ] },
1231         units     => [],
1232         emit      => "",
1233         mode      => "mode_E",
1234         latency   => 0,
1235         attr_type => "ia32_x87_attr_t",
1236 },
1237
1238 NoReg_XMM => {
1239         state     => "pinned",
1240         op_flags  => "c",
1241         irn_flags => "I",
1242         reg_req   => { out => [ "xmm_NOREG" ] },
1243         units     => [],
1244         emit      => "",
1245         latency   => 0,
1246         mode      => "mode_E"
1247 },
1248
1249 ChangeCW => {
1250         state     => "pinned",
1251         op_flags  => "c",
1252         irn_flags => "I",
1253         reg_req   => { out => [ "fp_cw" ] },
1254         mode      => $mode_fpcw,
1255         latency   => 3,
1256         units     => [ "GP" ],
1257         modified_flags => $fpcw_flags
1258 },
1259
1260 FldCW => {
1261         op_flags  => "L|F",
1262         state     => "pinned",
1263         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "fp_cw" ] },
1264         ins       => [ "base", "index", "mem" ],
1265         latency   => 5,
1266         emit      => ". fldcw %AM",
1267         mode      => $mode_fpcw,
1268         units     => [ "GP" ],
1269         modified_flags => $fpcw_flags
1270 },
1271
1272 FnstCW => {
1273         op_flags  => "L|F",
1274         state     => "pinned",
1275         reg_req   => { in => [ "gp", "gp", "none", "fp_cw" ], out => [ "none" ] },
1276         ins       => [ "base", "index", "mem", "fpcw" ],
1277         latency   => 5,
1278         emit      => ". fnstcw %AM",
1279         mode      => "mode_M",
1280         units     => [ "GP" ],
1281 },
1282
1283 FnstCWNOP => {
1284         op_flags  => "L|F",
1285         state     => "pinned",
1286         reg_req   => { in => [ "fp_cw" ], out => [ "none" ] },
1287         ins       => [ "fpcw" ],
1288         latency   => 0,
1289         emit      => "",
1290         mode      => "mode_M",
1291 },
1292
1293 Cltd => {
1294         # we should not rematrialize this node. It has very strict constraints.
1295         reg_req   => { in => [ "eax", "edx" ], out => [ "edx" ] },
1296         ins       => [ "val", "globbered" ],
1297         emit      => '. cltd',
1298         latency   => 1,
1299         mode      => $mode_gp,
1300         units     => [ "GP" ],
1301 },
1302
1303 # Load / Store
1304 #
1305 # Note that we add additional latency values depending on address mode, so a
1306 # lateny of 0 for load is correct
1307
1308 Load => {
1309         op_flags  => "L|F",
1310         state     => "exc_pinned",
1311         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "gp", "none", "none" ] },
1312         ins       => [ "base", "index", "mem" ],
1313         outs      => [ "res", "M", "X_exc" ],
1314         latency   => 0,
1315         emit      => ". mov%SE%ME%.l %AM, %D0",
1316         units     => [ "GP" ],
1317 },
1318
1319 l_Load => {
1320         op_flags  => "L|F",
1321         cmp_attr  => "return 1;",
1322         outs      => [ "res", "M" ],
1323         arity     => 2,
1324 },
1325
1326 l_Store => {
1327         op_flags  => "L|F",
1328         cmp_attr  => "return 1;",
1329         state     => "exc_pinned",
1330         arity     => 3,
1331         mode      => "mode_M",
1332 },
1333
1334 Store => {
1335         op_flags  => "L|F",
1336         state     => "exc_pinned",
1337         reg_req   => { in => [ "gp", "gp", "none", "gp" ], out => [ "none", "none" ] },
1338         ins       => [ "base", "index", "mem", "val" ],
1339         outs      => [ "M", "X_exc" ],
1340         emit      => '. mov%M %SI3, %AM',
1341         latency   => 2,
1342         units     => [ "GP" ],
1343         mode      => "mode_M",
1344 },
1345
1346 Store8Bit => {
1347         op_flags  => "L|F",
1348         state     => "exc_pinned",
1349         reg_req   => { in => [ "gp", "gp", "none", "eax ebx ecx edx" ], out => ["none", "none" ] },
1350         ins       => [ "base", "index", "mem", "val" ],
1351         outs      => [ "M", "X_exc" ],
1352         emit      => '. mov%M %SB3, %AM',
1353         latency   => 2,
1354         units     => [ "GP" ],
1355         mode      => "mode_M",
1356 },
1357
1358 Lea => {
1359         irn_flags => "R",
1360         reg_req   => { in => [ "gp", "gp" ], out => [ "gp" ] },
1361         ins       => [ "base", "index" ],
1362         emit      => '. leal %AM, %D0',
1363         latency   => 2,
1364         units     => [ "GP" ],
1365         mode      => $mode_gp,
1366 # lea doesn't modify the flags, but setting this seems advantageous since it
1367 # increases chances that the Lea is transformed back to an Add
1368         modified_flags => 1,
1369 },
1370
1371 Push => {
1372         state     => "exc_pinned",
1373         reg_req   => { in => [ "gp", "gp", "none", "esp", "gp" ], out => [ "esp", "none" ] },
1374         ins       => [ "base", "index", "mem", "val", "stack" ],
1375         emit      => '. push%M %unop4',
1376         outs      => [ "stack:I|S", "M" ],
1377         am        => "source,binary",
1378         latency   => 2,
1379         units     => [ "GP" ],
1380 },
1381
1382 Pop => {
1383         state     => "exc_pinned",
1384         reg_req   => { in => [ "none", "esp" ], out => [ "gp", "none", "none", "esp" ] },
1385         ins       => [ "mem", "stack" ],
1386         outs      => [ "res", "M", "unused", "stack:I|S" ],
1387         emit      => '. pop%M %D0',
1388         latency   => 3, # Pop is more expensive than Push on Athlon
1389         units     => [ "GP" ],
1390 },
1391
1392 PopMem => {
1393         state     => "exc_pinned",
1394         reg_req   => { in => [ "gp", "gp", "none", "esp" ], out => [ "none", "none", "none", "esp" ] },
1395         ins       => [ "base", "index", "mem", "stack" ],
1396         outs      => [ "unused0", "M", "unused1", "stack:I|S" ],
1397         emit      => '. pop%M %AM',
1398         latency   => 3, # Pop is more expensive than Push on Athlon
1399         units     => [ "GP" ],
1400 },
1401
1402 Enter => {
1403         reg_req   => { in => [ "esp" ], out => [ "ebp", "esp", "none" ] },
1404         emit      => '. enter',
1405         outs      => [ "frame:I", "stack:I|S", "M" ],
1406         latency   => 15,
1407         units     => [ "GP" ],
1408 },
1409
1410 Leave => {
1411         reg_req   => { in => [ "esp", "ebp" ], out => [ "ebp", "esp" ] },
1412         emit      => '. leave',
1413         outs      => [ "frame:I", "stack:I|S" ],
1414         latency   => 3,
1415         units     => [ "GP" ],
1416 },
1417
1418 AddSP => {
1419         irn_flags => "I",
1420         state     => "pinned",
1421         reg_req   => { in => [ "gp", "gp", "none", "esp", "gp" ], out => [ "in_r4", "none" ] },
1422         ins       => [ "base", "index", "mem", "stack", "size" ],
1423         am        => "source,binary",
1424         emit      => '. addl %binop',
1425         latency   => 1,
1426         outs      => [ "stack:I|S", "M" ],
1427         units     => [ "GP" ],
1428         modified_flags => $status_flags
1429 },
1430
1431 SubSP => {
1432 #irn_flags => "I",
1433         state     => "pinned",
1434         reg_req   => { in => [ "gp", "gp", "none", "esp", "gp" ], out => [ "in_r4", "gp", "none" ] },
1435         ins       => [ "base", "index", "mem", "stack", "size" ],
1436         am        => "source,binary",
1437         emit      => ". subl %binop\n".
1438                      ". movl %%esp, %D1",
1439         latency   => 2,
1440         outs      => [ "stack:I|S", "addr", "M" ],
1441         units     => [ "GP" ],
1442         modified_flags => $status_flags
1443 },
1444
1445 RepPrefix => {
1446         op_flags  => "K",
1447         state     => "pinned",
1448         mode      => "mode_M",
1449         emit      => ". rep",
1450         latency   => 0,
1451 },
1452
1453 LdTls => {
1454         irn_flags => "R",
1455         reg_req   => { out => [ "gp" ] },
1456         units     => [ "GP" ],
1457         latency   => 1,
1458 },
1459
1460
1461 #-----------------------------------------------------------------------------#
1462 #   _____ _____ ______    __ _             _                     _            #
1463 #  / ____/ ____|  ____|  / _| |           | |                   | |           #
1464 # | (___| (___ | |__    | |_| | ___   __ _| |_   _ __   ___   __| | ___  ___  #
1465 #  \___ \\___ \|  __|   |  _| |/ _ \ / _` | __| | '_ \ / _ \ / _` |/ _ \/ __| #
1466 #  ____) |___) | |____  | | | | (_) | (_| | |_  | | | | (_) | (_| |  __/\__ \ #
1467 # |_____/_____/|______| |_| |_|\___/ \__,_|\__| |_| |_|\___/ \__,_|\___||___/ #
1468 #-----------------------------------------------------------------------------#
1469
1470 xZero => {
1471         irn_flags => "R",
1472         reg_req   => { out => [ "xmm" ] },
1473         emit      => '. xorp%XSD %D0, %D0',
1474         latency   => 3,
1475         units     => [ "SSE" ],
1476         mode      => "mode_E",
1477 },
1478
1479 # commutative operations
1480
1481 xAdd => {
1482         irn_flags => "R",
1483         state     => "exc_pinned",
1484         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "in_r4 in_r5" ] },
1485         ins       => [ "base", "index", "mem", "left", "right" ],
1486         am        => "source,binary",
1487         emit      => '. add%XXM %binop',
1488         latency   => 4,
1489         units     => [ "SSE" ],
1490         mode      => "mode_E",
1491 },
1492
1493 xMul => {
1494         irn_flags => "R",
1495         state     => "exc_pinned",
1496         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "in_r4 in_r5" ] },
1497         ins       => [ "base", "index", "mem", "left", "right" ],
1498         am        => "source,binary",
1499         emit      => '. mul%XXM %binop',
1500         latency   => 4,
1501         units     => [ "SSE" ],
1502         mode      => "mode_E",
1503 },
1504
1505 xMax => {
1506         irn_flags => "R",
1507         state     => "exc_pinned",
1508         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "in_r4 in_r5" ] },
1509         ins       => [ "base", "index", "mem", "left", "right" ],
1510         am        => "source,binary",
1511         emit      => '. max%XXM %binop',
1512         latency   => 2,
1513         units     => [ "SSE" ],
1514         mode      => "mode_E",
1515 },
1516
1517 xMin => {
1518         irn_flags => "R",
1519         state     => "exc_pinned",
1520         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "in_r4 in_r5" ] },
1521         ins       => [ "base", "index", "mem", "left", "right" ],
1522         am        => "source,binary",
1523         emit      => '. min%XXM %binop',
1524         latency   => 2,
1525         units     => [ "SSE" ],
1526         mode      => "mode_E",
1527 },
1528
1529 xAnd => {
1530         irn_flags => "R",
1531         state     => "exc_pinned",
1532         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "in_r4 in_r5" ] },
1533         ins       => [ "base", "index", "mem", "left", "right" ],
1534         am        => "source,binary",
1535         emit      => '. andp%XSD %binop',
1536         latency   => 3,
1537         units     => [ "SSE" ],
1538         mode      => "mode_E",
1539 },
1540
1541 xOr => {
1542         irn_flags => "R",
1543         state     => "exc_pinned",
1544         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "in_r4 in_r5" ] },
1545         ins       => [ "base", "index", "mem", "left", "right" ],
1546         am        => "source,binary",
1547         emit      => '. orp%XSD %binop',
1548         latency   => 3,
1549         units     => [ "SSE" ],
1550         mode      => "mode_E",
1551 },
1552
1553 xXor => {
1554         irn_flags => "R",
1555         state     => "exc_pinned",
1556         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "in_r4 in_r5" ] },
1557         ins       => [ "base", "index", "mem", "left", "right" ],
1558         am        => "source,binary",
1559         emit      => '. xorp%XSD %binop',
1560         latency   => 3,
1561         units     => [ "SSE" ],
1562         mode      => "mode_E",
1563 },
1564
1565 # not commutative operations
1566
1567 xAndNot => {
1568         irn_flags => "R",
1569         state     => "exc_pinned",
1570         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "in_r4 !in_r5" ] },
1571         ins       => [ "base", "index", "mem", "left", "right" ],
1572         am        => "source,binary",
1573         emit      => '. andnp%XSD %binop',
1574         latency   => 3,
1575         units     => [ "SSE" ],
1576         mode      => "mode_E",
1577 },
1578
1579 xSub => {
1580         irn_flags => "R",
1581         state     => "exc_pinned",
1582         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "in_r4" ] },
1583         ins       => [ "base", "index", "mem", "left", "right" ],
1584         am        => "source,binary",
1585         emit      => '. sub%XXM %binop',
1586         latency   => 4,
1587         units     => [ "SSE" ],
1588         mode      => "mode_E",
1589 },
1590
1591 xDiv => {
1592         irn_flags => "R",
1593         state     => "exc_pinned",
1594         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "in_r4 !in_r5", "none" ] },
1595         ins       => [ "base", "index", "mem", "left", "right" ],
1596         am        => "source,binary",
1597         outs      => [ "res", "M" ],
1598         emit      => '. div%XXM %binop',
1599         latency   => 16,
1600         units     => [ "SSE" ],
1601 },
1602
1603 # other operations
1604
1605 Ucomi => {
1606         irn_flags => "R",
1607         state     => "exc_pinned",
1608         reg_req   => { in => [ "gp", "gp", "none", "xmm", "xmm" ], out => [ "eflags" ] },
1609         ins       => [ "base", "index", "mem", "left", "right" ],
1610         outs      => [ "flags" ],
1611         am        => "source,binary",
1612         attr      => "int ins_permuted",
1613         init_attr => "attr->data.ins_permuted = ins_permuted;",
1614         emit      => ' .ucomi%XXM %binop',
1615         latency   => 3,
1616         units     => [ "SSE" ],
1617         mode      => $mode_flags,
1618         modified_flags => 1,
1619 },
1620
1621 # Load / Store
1622
1623 xLoad => {
1624         op_flags  => "L|F",
1625         state     => "exc_pinned",
1626         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "xmm", "none", "none" ] },
1627         ins       => [ "base", "index", "mem" ],
1628         outs      => [ "res", "M", "X_exc" ],
1629         emit      => '. mov%XXM %AM, %D0',
1630         attr      => "ir_mode *load_mode",
1631         init_attr => "attr->ls_mode = load_mode;",
1632         latency   => 0,
1633         units     => [ "SSE" ],
1634 },
1635
1636 xStore => {
1637         op_flags => "L|F",
1638         state    => "exc_pinned",
1639         reg_req  => { in => [ "gp", "gp", "none", "xmm" ], out => [ "none", "none" ] },
1640         ins       => [ "base", "index", "mem", "val" ],
1641         outs      => [ "M", "X_exc" ],
1642         emit     => '. mov%XXM %S3, %AM',
1643         latency  => 0,
1644         units    => [ "SSE" ],
1645         mode     => "mode_M",
1646 },
1647
1648 xStoreSimple => {
1649         op_flags => "L|F",
1650         state    => "exc_pinned",
1651         reg_req  => { in => [ "gp", "gp", "none", "xmm" ] },
1652         ins      => [ "base", "index", "mem", "val" ],
1653         emit     => '. mov%XXM %S3, %AM',
1654         latency  => 0,
1655         units    => [ "SSE" ],
1656         mode     => "mode_M",
1657 },
1658
1659 CvtSI2SS => {
1660         op_flags => "L|F",
1661         state     => "exc_pinned",
1662         reg_req  => { in => [ "gp", "gp", "none", "gp" ], out => [ "xmm" ] },
1663         ins      => [ "base", "index", "mem", "val" ],
1664         am       => "source,unary",
1665         emit     => '. cvtsi2ss %unop3, %D0',
1666         latency  => 2,
1667         units    => [ "SSE" ],
1668         mode     => $mode_xmm
1669 },
1670
1671 CvtSI2SD => {
1672         op_flags => "L|F",
1673         state     => "exc_pinned",
1674         reg_req  => { in => [ "gp", "gp", "none", "gp" ], out => [ "xmm" ] },
1675         ins      => [ "base", "index", "mem", "val" ],
1676         am       => "source,unary",
1677         emit     => '. cvtsi2sd %unop3, %D0',
1678         latency  => 2,
1679         units    => [ "SSE" ],
1680         mode     => $mode_xmm
1681 },
1682
1683
1684 l_LLtoFloat => {
1685         op_flags => "L|F",
1686         cmp_attr => "return 1;",
1687         ins      => [ "val_high", "val_low" ],
1688 },
1689
1690 l_FloattoLL => {
1691         op_flags => "L|F",
1692         cmp_attr => "return 1;",
1693         ins      => [ "val" ],
1694         outs     => [ "res_high", "res_low" ],
1695 },
1696
1697 # CopyB
1698
1699 CopyB => {
1700         op_flags  => "F|H",
1701         state     => "pinned",
1702         reg_req   => { in => [ "edi", "esi", "ecx", "none" ], out => [ "edi", "esi", "ecx", "none" ] },
1703         outs      => [ "DST", "SRC", "CNT", "M" ],
1704         attr_type => "ia32_copyb_attr_t",
1705         attr      => "unsigned size",
1706         units     => [ "GP" ],
1707         latency  => 3,
1708 # we don't care about this flag, so no need to mark this node
1709 #       modified_flags => [ "DF" ]
1710 },
1711
1712 CopyB_i => {
1713         op_flags  => "F|H",
1714         state     => "pinned",
1715         reg_req   => { in => [ "edi", "esi", "none" ], out => [  "edi", "esi", "none" ] },
1716         outs      => [ "DST", "SRC", "M" ],
1717         attr_type => "ia32_copyb_attr_t",
1718         attr      => "unsigned size",
1719         units     => [ "GP" ],
1720         latency  => 3,
1721 # we don't care about this flag, so no need to mark this node
1722 #       modified_flags => [ "DF" ]
1723 },
1724
1725 # Conversions
1726
1727 Conv_I2I => {
1728         state     => "exc_pinned",
1729         reg_req   => { in => [ "gp", "gp", "none", "gp" ], out => [ "gp", "none" ] },
1730         ins       => [ "base", "index", "mem", "val" ],
1731         am        => "source,unary",
1732         units     => [ "GP" ],
1733         latency   => 1,
1734         attr      => "ir_mode *smaller_mode",
1735         init_attr => "attr->ls_mode = smaller_mode;",
1736         mode      => $mode_gp,
1737 },
1738
1739 Conv_I2I8Bit => {
1740         state     => "exc_pinned",
1741         reg_req   => { in => [ "gp", "gp", "none", "eax ebx ecx edx" ], out => [ "gp", "none" ] },
1742         ins       => [ "base", "index", "mem", "val" ],
1743         am        => "source,unary",
1744         units     => [ "GP" ],
1745         latency   => 1,
1746         attr      => "ir_mode *smaller_mode",
1747         init_attr => "attr->ls_mode = smaller_mode;",
1748         mode      => $mode_gp,
1749 },
1750
1751 Conv_I2FP => {
1752         state     => "exc_pinned",
1753         reg_req   => { in => [ "gp", "gp", "none", "gp" ], out => [ "xmm", "none" ] },
1754         ins       => [ "base", "index", "mem", "val" ],
1755         am        => "source,unary",
1756         latency   => 10,
1757         units     => [ "SSE" ],
1758         mode      => "mode_E",
1759 },
1760
1761 Conv_FP2I => {
1762         state     => "exc_pinned",
1763         reg_req   => { in => [ "gp", "gp", "none", "xmm" ], out => [ "gp", "none" ] },
1764         ins       => [ "base", "index", "mem", "val" ],
1765         am        => "source,unary",
1766         latency   => 10,
1767         units     => [ "SSE" ],
1768         mode      => $mode_gp,
1769 },
1770
1771 Conv_FP2FP => {
1772         state     => "exc_pinned",
1773         reg_req   => { in => [ "gp", "gp", "none", "xmm" ], out => [ "xmm", "none" ] },
1774         ins       => [ "base", "index", "mem", "val" ],
1775         am        => "source,unary",
1776         latency   => 8,
1777         units     => [ "SSE" ],
1778         mode      => "mode_E",
1779 },
1780
1781 #----------------------------------------------------------#
1782 #        _      _               _    __ _             _    #
1783 #       (_)    | |             | |  / _| |           | |   #
1784 # __   ___ _ __| |_ _   _  __ _| | | |_| | ___   __ _| |_  #
1785 # \ \ / / | '__| __| | | |/ _` | | |  _| |/ _ \ / _` | __| #
1786 #  \ V /| | |  | |_| |_| | (_| | | | | | | (_) | (_| | |_  #
1787 #   \_/ |_|_|   \__|\__,_|\__,_|_| |_| |_|\___/ \__,_|\__| #
1788 #                 | |                                      #
1789 #  _ __   ___   __| | ___  ___                             #
1790 # | '_ \ / _ \ / _` |/ _ \/ __|                            #
1791 # | | | | (_) | (_| |  __/\__ \                            #
1792 # |_| |_|\___/ \__,_|\___||___/                            #
1793 #----------------------------------------------------------#
1794
1795 # rematerialisation disabled for all float nodes for now, because the fpcw
1796 # handler runs before spilling and we might end up with wrong fpcw then
1797
1798 vfadd => {
1799 #       irn_flags => "R",
1800         state     => "exc_pinned",
1801         reg_req   => { in => [ "gp", "gp", "none", "vfp", "vfp", "fpcw" ], out => [ "vfp" ] },
1802         ins       => [ "base", "index", "mem", "left", "right", "fpcw" ],
1803         am        => "source,binary",
1804         latency   => 4,
1805         units     => [ "VFP" ],
1806         mode      => "mode_E",
1807         attr_type => "ia32_x87_attr_t",
1808 },
1809
1810 vfmul => {
1811 #       irn_flags => "R",
1812         state     => "exc_pinned",
1813         reg_req   => { in => [ "gp", "gp", "none", "vfp", "vfp", "fpcw" ], out => [ "vfp" ] },
1814         ins       => [ "base", "index", "mem", "left", "right", "fpcw" ],
1815         am        => "source,binary",
1816         latency   => 4,
1817         units     => [ "VFP" ],
1818         mode      => "mode_E",
1819         attr_type => "ia32_x87_attr_t",
1820 },
1821
1822 vfsub => {
1823 #       irn_flags => "R",
1824         state     => "exc_pinned",
1825         reg_req   => { in => [ "gp", "gp", "none", "vfp", "vfp", "fpcw" ], out => [ "vfp" ] },
1826         ins       => [ "base", "index", "mem", "left", "right", "fpcw" ],
1827         am        => "source,binary",
1828         latency   => 4,
1829         units     => [ "VFP" ],
1830         mode      => "mode_E",
1831         attr_type => "ia32_x87_attr_t",
1832 },
1833
1834 vfdiv => {
1835         state     => "exc_pinned",
1836         reg_req   => { in => [ "gp", "gp", "none", "vfp", "vfp", "fpcw" ], out => [ "vfp", "none" ] },
1837         ins       => [ "base", "index", "mem", "left", "right", "fpcw" ],
1838         am        => "source,binary",
1839         outs      => [ "res", "M" ],
1840         latency   => 20,
1841         units     => [ "VFP" ],
1842         attr_type => "ia32_x87_attr_t",
1843 },
1844
1845 vfprem => {
1846         reg_req   => { in => [ "vfp", "vfp", "fpcw" ], out => [ "vfp" ] },
1847         ins       => [ "left", "right", "fpcw" ],
1848         latency   => 20,
1849         units     => [ "VFP" ],
1850         mode      => "mode_E",
1851         attr_type => "ia32_x87_attr_t",
1852 },
1853
1854 vfabs => {
1855         irn_flags => "R",
1856         reg_req   => { in => [ "vfp"], out => [ "vfp" ] },
1857         ins       => [ "value" ],
1858         latency   => 2,
1859         units     => [ "VFP" ],
1860         mode      => "mode_E",
1861         attr_type => "ia32_x87_attr_t",
1862 },
1863
1864 vfchs => {
1865         irn_flags => "R",
1866         reg_req   => { in => [ "vfp"], out => [ "vfp" ] },
1867         ins       => [ "value" ],
1868         latency   => 2,
1869         units     => [ "VFP" ],
1870         mode      => "mode_E",
1871         attr_type => "ia32_x87_attr_t",
1872 },
1873
1874 # virtual Load and Store
1875
1876 vfld => {
1877         irn_flags => "R",
1878         op_flags  => "L|F",
1879         state     => "exc_pinned",
1880         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "vfp", "none", "none" ] },
1881         ins       => [ "base", "index", "mem" ],
1882         outs      => [ "res", "M", "X_exc" ],
1883         attr      => "ir_mode *load_mode",
1884         init_attr => "attr->attr.ls_mode = load_mode;",
1885         latency   => 2,
1886         units     => [ "VFP" ],
1887         attr_type => "ia32_x87_attr_t",
1888 },
1889
1890 vfst => {
1891         irn_flags => "R",
1892         op_flags  => "L|F",
1893         state     => "exc_pinned",
1894         reg_req   => { in => [ "gp", "gp", "none", "vfp" ], out => [ "none", "none" ] },
1895         ins       => [ "base", "index", "mem", "val" ],
1896         outs      => [ "M", "X_exc" ],
1897         attr      => "ir_mode *store_mode",
1898         init_attr => "attr->attr.ls_mode = store_mode;",
1899         latency   => 2,
1900         units     => [ "VFP" ],
1901         mode      => "mode_M",
1902         attr_type => "ia32_x87_attr_t",
1903 },
1904
1905 # Conversions
1906
1907 vfild => {
1908         state     => "exc_pinned",
1909         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "vfp", "none" ] },
1910         outs      => [ "res", "M" ],
1911         ins       => [ "base", "index", "mem" ],
1912         latency   => 4,
1913         units     => [ "VFP" ],
1914         attr_type => "ia32_x87_attr_t",
1915 },
1916
1917 l_vfild => {
1918         cmp_attr  => "return 1;",
1919         outs      => [ "res", "M" ],
1920         arity     => 2,
1921 },
1922
1923 vfist => {
1924         state     => "exc_pinned",
1925         reg_req   => { in => [ "gp", "gp", "none", "vfp", "fpcw" ] },
1926         ins       => [ "base", "index", "mem", "val", "fpcw" ],
1927         latency   => 4,
1928         units     => [ "VFP" ],
1929         mode      => "mode_M",
1930         attr_type => "ia32_x87_attr_t",
1931 },
1932
1933 l_vfist => {
1934         cmp_attr  => "return 1;",
1935         state     => "exc_pinned",
1936         arity     => 3,
1937         mode      => "mode_M",
1938 },
1939
1940
1941 # constants
1942
1943 vfldz => {
1944         irn_flags => "R",
1945         reg_req   => { out => [ "vfp" ] },
1946         latency   => 4,
1947         units     => [ "VFP" ],
1948         mode      => "mode_E",
1949         attr_type => "ia32_x87_attr_t",
1950 },
1951
1952 vfld1 => {
1953         irn_flags => "R",
1954         reg_req   => { out => [ "vfp" ] },
1955         latency   => 4,
1956         units     => [ "VFP" ],
1957         mode      => "mode_E",
1958         attr_type => "ia32_x87_attr_t",
1959 },
1960
1961 vfldpi => {
1962         irn_flags => "R",
1963         reg_req   => { out => [ "vfp" ] },
1964         latency   => 4,
1965         units     => [ "VFP" ],
1966         mode      => "mode_E",
1967         attr_type => "ia32_x87_attr_t",
1968 },
1969
1970 vfldln2 => {
1971         irn_flags => "R",
1972         reg_req   => { out => [ "vfp" ] },
1973         latency   => 4,
1974         units     => [ "VFP" ],
1975         mode      => "mode_E",
1976         attr_type => "ia32_x87_attr_t",
1977 },
1978
1979 vfldlg2 => {
1980         irn_flags => "R",
1981         reg_req   => { out => [ "vfp" ] },
1982         latency   => 4,
1983         units     => [ "VFP" ],
1984         mode      => "mode_E",
1985         attr_type => "ia32_x87_attr_t",
1986 },
1987
1988 vfldl2t => {
1989         irn_flags => "R",
1990         reg_req   => { out => [ "vfp" ] },
1991         latency   => 4,
1992         units     => [ "VFP" ],
1993         mode      => "mode_E",
1994         attr_type => "ia32_x87_attr_t",
1995 },
1996
1997 vfldl2e => {
1998         irn_flags => "R",
1999         reg_req   => { out => [ "vfp" ] },
2000         latency   => 4,
2001         units     => [ "VFP" ],
2002         mode      => "mode_E",
2003         attr_type => "ia32_x87_attr_t",
2004 },
2005
2006 # other
2007
2008 vFucomFnstsw => {
2009 # we can't allow to rematerialize this node so we don't have
2010 #  accidently produce Phi(Fucom, Fucom(ins_permuted))
2011 #       irn_flags => "R",
2012         reg_req   => { in => [ "vfp", "vfp" ], out => [ "eax" ] },
2013         ins       => [ "left", "right" ],
2014         outs      => [ "flags" ],
2015         attr      => "int ins_permuted",
2016         init_attr => "attr->attr.data.ins_permuted = ins_permuted;",
2017         latency   => 3,
2018         units     => [ "VFP" ],
2019         attr_type => "ia32_x87_attr_t",
2020         mode      => $mode_gp
2021 },
2022
2023 vFucomi => {
2024         irn_flags => "R",
2025         reg_req   => { in => [ "vfp", "vfp" ], out => [ "eflags" ] },
2026         ins       => [ "left", "right" ],
2027         outs      => [ "flags" ],
2028         attr      => "int ins_permuted",
2029         init_attr => "attr->attr.data.ins_permuted = ins_permuted;",
2030         latency   => 3,
2031         units     => [ "VFP" ],
2032         attr_type => "ia32_x87_attr_t",
2033         mode      => $mode_gp
2034 },
2035
2036 vFtstFnstsw => {
2037 #       irn_flags => "R",
2038         reg_req   => { in => [ "vfp" ], out => [ "eax" ] },
2039         ins       => [ "left" ],
2040         outs      => [ "flags" ],
2041         attr      => "int ins_permuted",
2042         init_attr => "attr->attr.data.ins_permuted = ins_permuted;",
2043         latency   => 3,
2044         units     => [ "VFP" ],
2045         attr_type => "ia32_x87_attr_t",
2046         mode      => $mode_gp
2047 },
2048
2049 Sahf => {
2050         irn_flags => "R",
2051         reg_req   => { in => [ "eax" ], out => [ "eflags" ] },
2052         ins       => [ "val" ],
2053         outs      => [ "flags" ],
2054         emit      => '. sahf',
2055         latency   => 1,
2056         units     => [ "GP" ],
2057         mode      => $mode_flags,
2058 },
2059
2060 #------------------------------------------------------------------------#
2061 #       ___ _____    __ _             _                     _            #
2062 # __  _( _ )___  |  / _| | ___   __ _| |_   _ __   ___   __| | ___  ___  #
2063 # \ \/ / _ \  / /  | |_| |/ _ \ / _` | __| | '_ \ / _ \ / _` |/ _ \/ __| #
2064 #  >  < (_) |/ /   |  _| | (_) | (_| | |_  | | | | (_) | (_| |  __/\__ \ #
2065 # /_/\_\___//_/    |_| |_|\___/ \__,_|\__| |_| |_|\___/ \__,_|\___||___/ #
2066 #------------------------------------------------------------------------#
2067
2068 # Note: gas is strangely buggy: fdivrp and fdivp as well as fsubrp and fsubp
2069 #       are swapped, we work this around in the emitter...
2070
2071 fadd => {
2072         state     => "exc_pinned",
2073         rd_constructor => "NONE",
2074         reg_req   => { },
2075         emit      => '. fadd%XM %x87_binop',
2076         latency   => 4,
2077         attr_type => "ia32_x87_attr_t",
2078 },
2079
2080 faddp => {
2081         state     => "exc_pinned",
2082         rd_constructor => "NONE",
2083         reg_req   => { },
2084         emit      => '. faddp%XM %x87_binop',
2085         latency   => 4,
2086         attr_type => "ia32_x87_attr_t",
2087 },
2088
2089 fmul => {
2090         state     => "exc_pinned",
2091         rd_constructor => "NONE",
2092         reg_req   => { },
2093         emit      => '. fmul%XM %x87_binop',
2094         latency   => 4,
2095         attr_type => "ia32_x87_attr_t",
2096 },
2097
2098 fmulp => {
2099         state     => "exc_pinned",
2100         rd_constructor => "NONE",
2101         reg_req   => { },
2102         emit      => '. fmulp%XM %x87_binop',,
2103         latency   => 4,
2104         attr_type => "ia32_x87_attr_t",
2105 },
2106
2107 fsub => {
2108         state     => "exc_pinned",
2109         rd_constructor => "NONE",
2110         reg_req   => { },
2111         emit      => '. fsub%XM %x87_binop',
2112         latency   => 4,
2113         attr_type => "ia32_x87_attr_t",
2114 },
2115
2116 fsubp => {
2117         state     => "exc_pinned",
2118         rd_constructor => "NONE",
2119         reg_req   => { },
2120 # see note about gas bugs
2121         emit      => '. fsubrp%XM %x87_binop',
2122         latency   => 4,
2123         attr_type => "ia32_x87_attr_t",
2124 },
2125
2126 fsubr => {
2127         state     => "exc_pinned",
2128         rd_constructor => "NONE",
2129         irn_flags => "R",
2130         reg_req   => { },
2131         emit      => '. fsubr%XM %x87_binop',
2132         latency   => 4,
2133         attr_type => "ia32_x87_attr_t",
2134 },
2135
2136 fsubrp => {
2137         state     => "exc_pinned",
2138         rd_constructor => "NONE",
2139         irn_flags => "R",
2140         reg_req   => { },
2141 # see note about gas bugs
2142         emit      => '. fsubp%XM %x87_binop',
2143         latency   => 4,
2144         attr_type => "ia32_x87_attr_t",
2145 },
2146
2147 fprem => {
2148         rd_constructor => "NONE",
2149         reg_req   => { },
2150         emit      => '. fprem1',
2151         latency   => 20,
2152         attr_type => "ia32_x87_attr_t",
2153 },
2154
2155 # this node is just here, to keep the simulator running
2156 # we can omit this when a fprem simulation function exists
2157 fpremp => {
2158         rd_constructor => "NONE",
2159         reg_req   => { },
2160         emit      => '. fprem1\n'.
2161                      '. fstp %X0',
2162         latency   => 20,
2163         attr_type => "ia32_x87_attr_t",
2164 },
2165
2166 fdiv => {
2167         state     => "exc_pinned",
2168         rd_constructor => "NONE",
2169         reg_req   => { },
2170         emit      => '. fdiv%XM %x87_binop',
2171         latency   => 20,
2172         attr_type => "ia32_x87_attr_t",
2173 },
2174
2175 fdivp => {
2176         state     => "exc_pinned",
2177         rd_constructor => "NONE",
2178         reg_req   => { },
2179 # see note about gas bugs
2180         emit      => '. fdivrp%XM %x87_binop',
2181         latency   => 20,
2182         attr_type => "ia32_x87_attr_t",
2183 },
2184
2185 fdivr => {
2186         state     => "exc_pinned",
2187         rd_constructor => "NONE",
2188         reg_req   => { },
2189         emit      => '. fdivr%XM %x87_binop',
2190         latency   => 20,
2191         attr_type => "ia32_x87_attr_t",
2192 },
2193
2194 fdivrp => {
2195         state     => "exc_pinned",
2196         rd_constructor => "NONE",
2197         reg_req   => { },
2198 # see note about gas bugs
2199         emit      => '. fdivp%XM %x87_binop',
2200         latency   => 20,
2201         attr_type => "ia32_x87_attr_t",
2202 },
2203
2204 fabs => {
2205         rd_constructor => "NONE",
2206         reg_req   => { },
2207         emit      => '. fabs',
2208         latency   => 4,
2209         attr_type => "ia32_x87_attr_t",
2210 },
2211
2212 fchs => {
2213         op_flags  => "R|K",
2214         rd_constructor => "NONE",
2215         reg_req   => { },
2216         emit      => '. fchs',
2217         latency   => 4,
2218         attr_type => "ia32_x87_attr_t",
2219 },
2220
2221 # x87 Load and Store
2222
2223 fld => {
2224         rd_constructor => "NONE",
2225         op_flags  => "R|L|F",
2226         state     => "exc_pinned",
2227         reg_req   => { },
2228         emit      => '. fld%XM %AM',
2229         attr_type => "ia32_x87_attr_t",
2230         latency   => 2,
2231 },
2232
2233 fst => {
2234         rd_constructor => "NONE",
2235         op_flags  => "R|L|F",
2236         state     => "exc_pinned",
2237         reg_req   => { },
2238         emit      => '. fst%XM %AM',
2239         mode      => "mode_M",
2240         attr_type => "ia32_x87_attr_t",
2241         latency   => 2,
2242 },
2243
2244 fstp => {
2245         rd_constructor => "NONE",
2246         op_flags  => "R|L|F",
2247         state     => "exc_pinned",
2248         reg_req   => { },
2249         emit      => '. fstp%XM %AM',
2250         mode      => "mode_M",
2251         attr_type => "ia32_x87_attr_t",
2252         latency   => 2,
2253 },
2254
2255 # Conversions
2256
2257 fild => {
2258         state     => "exc_pinned",
2259         rd_constructor => "NONE",
2260         reg_req   => { },
2261         emit      => '. fild%M %AM',
2262         attr_type => "ia32_x87_attr_t",
2263         latency   => 2,
2264 },
2265
2266 fist => {
2267         state     => "exc_pinned",
2268         rd_constructor => "NONE",
2269         reg_req   => { },
2270         emit      => '. fist%M %AM',
2271         mode      => "mode_M",
2272         attr_type => "ia32_x87_attr_t",
2273         latency   => 2,
2274 },
2275
2276 fistp => {
2277         state     => "exc_pinned",
2278         rd_constructor => "NONE",
2279         reg_req   => { },
2280         emit      => '. fistp%M %AM',
2281         mode      => "mode_M",
2282         attr_type => "ia32_x87_attr_t",
2283         latency   => 2,
2284 },
2285
2286 # constants
2287
2288 fldz => {
2289         op_flags  => "R|c|K",
2290         irn_flags => "R",
2291         reg_req   => { out => [ "vfp" ] },
2292         emit      => '. fldz',
2293         attr_type => "ia32_x87_attr_t",
2294         latency   => 2,
2295 },
2296
2297 fld1 => {
2298         op_flags  => "R|c|K",
2299         irn_flags => "R",
2300         reg_req   => { out => [ "vfp" ] },
2301         emit      => '. fld1',
2302         attr_type => "ia32_x87_attr_t",
2303         latency   => 2,
2304 },
2305
2306 fldpi => {
2307         op_flags  => "R|c|K",
2308         irn_flags => "R",
2309         reg_req   => { out => [ "vfp" ] },
2310         emit      => '. fldpi',
2311         attr_type => "ia32_x87_attr_t",
2312         latency   => 2,
2313 },
2314
2315 fldln2 => {
2316         op_flags  => "R|c|K",
2317         irn_flags => "R",
2318         reg_req   => { out => [ "vfp" ] },
2319         emit      => '. fldln2',
2320         attr_type => "ia32_x87_attr_t",
2321         latency   => 2,
2322 },
2323
2324 fldlg2 => {
2325         op_flags  => "R|c|K",
2326         irn_flags => "R",
2327         reg_req   => { out => [ "vfp" ] },
2328         emit      => '. fldlg2',
2329         attr_type => "ia32_x87_attr_t",
2330         latency   => 2,
2331 },
2332
2333 fldl2t => {
2334         op_flags  => "R|c|K",
2335         irn_flags => "R",
2336         reg_req   => { out => [ "vfp" ] },
2337         emit      => '. fldll2t',
2338         attr_type => "ia32_x87_attr_t",
2339         latency   => 2,
2340 },
2341
2342 fldl2e => {
2343         op_flags  => "R|c|K",
2344         irn_flags => "R",
2345         reg_req   => { out => [ "vfp" ] },
2346         emit      => '. fldl2e',
2347         attr_type => "ia32_x87_attr_t",
2348         latency   => 2,
2349 },
2350
2351 # fxch, fpush, fpop
2352 # Note that it is NEVER allowed to do CSE on these nodes
2353 # Moreover, note the virtual register requierements!
2354
2355 fxch => {
2356         op_flags  => "R|K",
2357         reg_req   => { },
2358         cmp_attr  => "return 1;",
2359         emit      => '. fxch %X0',
2360         attr_type => "ia32_x87_attr_t",
2361         mode      => "mode_ANY",
2362         latency   => 1,
2363 },
2364
2365 fpush => {
2366         op_flags  => "R|K",
2367         reg_req   => {},
2368         cmp_attr  => "return 1;",
2369         emit      => '. fld %X0',
2370         attr_type => "ia32_x87_attr_t",
2371         mode      => "mode_ANY",
2372         latency   => 1,
2373 },
2374
2375 fpushCopy => {
2376         reg_req   => { in => [ "vfp"], out => [ "vfp" ] },
2377         cmp_attr  => "return 1;",
2378         emit      => '. fld %X0',
2379         attr_type => "ia32_x87_attr_t",
2380         latency   => 1,
2381 },
2382
2383 fpop => {
2384         op_flags  => "K",
2385         reg_req   => { },
2386         cmp_attr  => "return 1;",
2387         emit      => '. fstp %X0',
2388         attr_type => "ia32_x87_attr_t",
2389         mode      => "mode_ANY",
2390         latency   => 1,
2391 },
2392
2393 ffreep => {
2394         op_flags  => "K",
2395         reg_req   => { },
2396         cmp_attr  => "return 1;",
2397         emit      => '. ffreep %X0',
2398         attr_type => "ia32_x87_attr_t",
2399         mode      => "mode_ANY",
2400         latency   => 1,
2401 },
2402
2403 emms => {
2404         op_flags  => "K",
2405         reg_req   => { },
2406         cmp_attr  => "return 1;",
2407         emit      => '. emms',
2408         attr_type => "ia32_x87_attr_t",
2409         mode      => "mode_ANY",
2410         latency   => 3,
2411 },
2412
2413 femms => {
2414         op_flags  => "K",
2415         reg_req   => { },
2416         cmp_attr  => "return 1;",
2417         emit      => '. femms',
2418         attr_type => "ia32_x87_attr_t",
2419         mode      => "mode_ANY",
2420         latency   => 3,
2421 },
2422
2423 # compare
2424
2425 FucomFnstsw => {
2426         reg_req   => { },
2427         emit      => ". fucom %X1\n".
2428                      ". fnstsw %%ax",
2429         attr_type => "ia32_x87_attr_t",
2430         latency   => 2,
2431 },
2432
2433 FucompFnstsw => {
2434         reg_req   => { },
2435         emit      => ". fucomp %X1\n".
2436                      ". fnstsw %%ax",
2437         attr_type => "ia32_x87_attr_t",
2438         latency   => 2,
2439 },
2440
2441 FucomppFnstsw => {
2442         reg_req   => { },
2443         emit      => ". fucompp\n".
2444                      ". fnstsw %%ax",
2445         attr_type => "ia32_x87_attr_t",
2446         latency   => 2,
2447 },
2448
2449 Fucomi => {
2450         reg_req   => { },
2451         emit      => '. fucomi %X1',
2452         attr_type => "ia32_x87_attr_t",
2453         latency   => 1,
2454 },
2455
2456 Fucompi => {
2457         reg_req   => { },
2458         emit      => '. fucompi %X1',
2459         attr_type => "ia32_x87_attr_t",
2460         latency   => 1,
2461 },
2462
2463 FtstFnstsw => {
2464         reg_req   => { },
2465         emit      => ". ftst\n".
2466                      ". fnstsw %%ax",
2467         attr_type => "ia32_x87_attr_t",
2468         latency   => 2,
2469 },
2470
2471
2472 # -------------------------------------------------------------------------------- #
2473 #  ____ ____  _____                  _                               _             #
2474 # / ___/ ___|| ____| __   _____  ___| |_ ___  _ __   _ __   ___   __| | ___  ___   #
2475 # \___ \___ \|  _|   \ \ / / _ \/ __| __/ _ \| '__| | '_ \ / _ \ / _` |/ _ \/ __|  #
2476 #  ___) |__) | |___   \ V /  __/ (__| || (_) | |    | | | | (_) | (_| |  __/\__ \  #
2477 # |____/____/|_____|   \_/ \___|\___|\__\___/|_|    |_| |_|\___/ \__,_|\___||___/  #
2478 #                                                                                  #
2479 # -------------------------------------------------------------------------------- #
2480
2481
2482 # Spilling and reloading of SSE registers, hardcoded, not generated #
2483
2484 xxLoad => {
2485         op_flags  => "L|F",
2486         state     => "exc_pinned",
2487         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "xmm", "none" ] },
2488         emit      => '. movdqu %D0, %AM',
2489         outs      => [ "res", "M" ],
2490         units     => [ "SSE" ],
2491         latency   => 1,
2492 },
2493
2494 xxStore => {
2495         op_flags => "L|F",
2496         state    => "exc_pinned",
2497         reg_req  => { in => [ "gp", "gp", "none", "xmm" ] },
2498         ins      => [ "base", "index", "mem", "val" ],
2499         emit     => '. movdqu %binop',
2500         units    => [ "SSE" ],
2501         latency   => 1,
2502         mode     => "mode_M",
2503 },
2504
2505 ); # end of %nodes
2506
2507 # Include the generated SIMD node specification written by the SIMD optimization
2508 $my_script_name = dirname($myname) . "/../ia32/ia32_simd_spec.pl";
2509 unless ($return = do $my_script_name) {
2510         warn "couldn't parse $my_script_name: $@" if $@;
2511         warn "couldn't do $my_script_name: $!"    unless defined $return;
2512         warn "couldn't run $my_script_name"       unless $return;
2513 }
2514
2515 # Transform some attributes
2516 foreach my $op (keys(%nodes)) {
2517         my $node         = $nodes{$op};
2518         my $op_attr_init = $node->{op_attr_init};
2519
2520         if(defined($op_attr_init)) {
2521                 $op_attr_init .= "\n\t";
2522         } else {
2523                 $op_attr_init = "";
2524         }
2525
2526         if(!defined($node->{latency})) {
2527                 if($op =~ m/^l_/) {
2528                         $node->{latency} = 0;
2529                 } else {
2530                         die("Latency missing for op $op");
2531                 }
2532         }
2533         $op_attr_init .= "attr->latency = ".$node->{latency} . ";";
2534
2535         $node->{op_attr_init} = $op_attr_init;
2536 }
2537
2538 print "";