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 #   latency   => "latency of this operation (can be float)"
  36 #   attr_type => "name of the attribute struct",
  37 # },
  38 #
  39 # ... # (all nodes you need to describe)
  40 #
  41 # ); # close the %nodes initializer
  42
  43 # op_flags: flags for the operation, OPTIONAL (default is "N")
  44 # the op_flags correspond to the firm irop_flags:
  45 #   N   irop_flag_none
  46 #   L   irop_flag_labeled
  47 #   C   irop_flag_commutative
  48 #   X   irop_flag_cfopcode
  49 #   I   irop_flag_ip_cfopcode
  50 #   F   irop_flag_fragile
  51 #   Y   irop_flag_forking
  52 #   H   irop_flag_highlevel
  53 #   c   irop_flag_constlike
  54 #   K   irop_flag_keep
  55 #
  56 # irn_flags: special node flags, OPTIONAL (default is 0)
  57 # following irn_flags are supported:
  58 #   R   rematerializeable
  59 #   N   not spillable
  60 #   I   ignore for register allocation
  61 #   S   modifies stack pointer
  62 #
  63 # state: state of the operation, OPTIONAL (default is "floats")
  64 #
  65 # arity: arity of the operation, MUST NOT BE OMITTED
  66 #
  67 # args:  the OPTIONAL arguments of the node constructor (debug, irg and block
  68 #        are always the first 3 arguments and are always autmatically
  69 #        created)
  70 #        If this key is missing the following arguments will be created:
  71 #        for i = 1 .. arity: ir_node *op_i
  72 #        ir_mode *mode
  73 #
  74 # outs:  if a node defines more than one output, the names of the projections
  75 #        nodes having outs having automatically the mode mode_T
  76 #        One can also annotate some flags for each out, additional to irn_flags.
  77 #        They are separated from name with a colon ':', and concatenated by pipe '|'
  78 #        Only I and S are available at the moment (same meaning as in irn_flags).
  79 #        example: [ "frame:I", "stack:I|S", "M" ]
  80 #
  81 # comment: OPTIONAL comment for the node constructor
  82 #
  83 # rd_constructor: for every operation there will be a
  84 #      new_rd_<arch>_<op-name> function with the arguments from above
  85 #      which creates the ir_node corresponding to the defined operation
  86 #      you can either put the complete source code of this function here
  87 #
  88 #      This key is OPTIONAL. If omitted, the following constructor will
  89 #      be created:
  90 #      if (!op_<arch>_<op-name>) assert(0);
  91 #      for i = 1 to arity
  92 #         set in[i] = op_i
  93 #      done
  94 #      res = new_ir_node(db, irg, block, op_<arch>_<op-name>, mode, arity, in)
  95 #      return res
  96 #
  97 # NOTE: rd_constructor and args are only optional if and only if arity is 0,1,2 or 3
  98 #
  99 # latency: the latency of the operation, default is 1
 100 #
 101
 102 # register types:
 103 #   0 - no special type
 104 #   1 - caller save (register must be saved by the caller of a function)
 105 #   2 - callee save (register must be saved by the called function)
 106 #   4 - ignore (do not assign this register)
 107 #   8 - emitter can choose an arbitrary register of this class
 108 #  16 - the register is a virtual one
 109 #  32 - register represents a state
 110 # NOTE: Last entry of each class is the largest Firm-Mode a register can hold
 111 %reg_classes = (
 112         gp => [
 113                 { name => "eax", type => 1 },
 114                 { name => "edx", type => 1 },
 115                 { name => "ebx", type => 2 },
 116                 { name => "ecx", type => 1 },
 117                 { name => "esi", type => 2 },
 118                 { name => "edi", type => 2 },
 119                 { name => "ebp", type => 2 },
 120                 { name => "esp", type => 4 },
 121                 { name => "gp_NOREG", type => 4 | 8 | 16 }, # we need a dummy register for NoReg nodes
 122                 { name => "gp_UKNWN", type => 4 | 8 | 16 },  # we need a dummy register for Unknown nodes
 123                 { mode => "mode_Iu" }
 124         ],
 125         mmx => [
 126                 { name => "mm0", type => 4 },
 127                 { name => "mm1", type => 4 },
 128                 { name => "mm2", type => 4 },
 129                 { name => "mm3", type => 4 },
 130                 { name => "mm4", type => 4 },
 131                 { name => "mm5", type => 4 },
 132                 { name => "mm6", type => 4 },
 133                 { name => "mm7", type => 4 },
 134                 { mode => "mode_E" }
 135         ],
 136         xmm => [
 137                 { name => "xmm0", type => 1 },
 138                 { name => "xmm1", type => 1 },
 139                 { name => "xmm2", type => 1 },
 140                 { name => "xmm3", type => 1 },
 141                 { name => "xmm4", type => 1 },
 142                 { name => "xmm5", type => 1 },
 143                 { name => "xmm6", type => 1 },
 144                 { name => "xmm7", type => 1 },
 145                 { name => "xmm_NOREG", type => 4 | 16 },     # we need a dummy register for NoReg nodes
 146                 { name => "xmm_UKNWN", type => 4 | 8 | 16},  # we need a dummy register for Unknown nodes
 147                 { mode => "mode_E" }
 148         ],
 149         vfp => [
 150                 { name => "vf0", type => 1 | 16 },
 151                 { name => "vf1", type => 1 | 16 },
 152                 { name => "vf2", type => 1 | 16 },
 153                 { name => "vf3", type => 1 | 16 },
 154                 { name => "vf4", type => 1 | 16 },
 155                 { name => "vf5", type => 1 | 16 },
 156                 { name => "vf6", type => 1 | 16 },
 157                 { name => "vf7", type => 1 | 16 },
 158                 { name => "vfp_NOREG", type => 4 | 8 | 16 }, # we need a dummy register for NoReg nodes
 159                 { name => "vfp_UKNWN", type => 4 | 8 | 16 },  # we need a dummy register for Unknown nodes
 160                 { mode => "mode_E" }
 161         ],
 162         st => [
 163                 { name => "st0", realname => "st",    type => 4 },
 164                 { name => "st1", realname => "st(1)", type => 4 },
 165                 { name => "st2", realname => "st(2)", type => 4 },
 166                 { name => "st3", realname => "st(3)", type => 4 },
 167                 { name => "st4", realname => "st(4)", type => 4 },
 168                 { name => "st5", realname => "st(5)", type => 4 },
 169                 { name => "st6", realname => "st(6)", type => 4 },
 170                 { name => "st7", realname => "st(7)", type => 4 },
 171                 { mode => "mode_E" }
 172         ],
 173         fp_cw => [      # the floating point control word
 174                 { name => "fpcw", type => 4 | 32},
 175                 { mode => "mode_fpcw" }
 176         ],
 177         flags => [
 178                 { name => "eflags", type => 4 },
 179                 { mode => "mode_Iu" }
 180         ],
 181         fp_sw => [
 182                 { name => "fpsw", type => 4 },
 183                 { mode => "mode_Hu" }
 184         ],
 185 ); # %reg_classes
 186
 187 %flags = (
 188         CF  => { reg => "eflags", bit => 0 },
 189         PF  => { reg => "eflags", bit => 2 },
 190         AF  => { reg => "eflags", bit => 4 },
 191         ZF  => { reg => "eflags", bit => 6 },
 192         SF  => { reg => "eflags", bit => 7 },
 193         TF  => { reg => "eflags", bit => 8 },
 194         IF  => { reg => "eflags", bit => 9 },
 195         DF  => { reg => "eflags", bit => 10 },
 196         OF  => { reg => "eflags", bit => 11 },
 197         IOPL0 => { reg => "eflags", bit => 12 },
 198         IOPL1 => { reg => "eflags", bit => 13 },
 199         NT  => { reg => "eflags", bit => 14 },
 200         RF  => { reg => "eflags", bit => 16 },
 201         VM  => { reg => "eflags", bit => 17 },
 202         AC  => { reg => "eflags", bit => 18 },
 203         VIF => { reg => "eflags", bit => 19 },
 204         VIP => { reg => "eflags", bit => 20 },
 205         ID  => { reg => "eflags", bit => 21 },
 206
 207         FP_IE => { reg => "fpsw", bit => 0 },
 208         FP_DE => { reg => "fpsw", bit => 1 },
 209         FP_ZE => { reg => "fpsw", bit => 2 },
 210         FP_OE => { reg => "fpsw", bit => 3 },
 211         FP_UE => { reg => "fpsw", bit => 4 },
 212         FP_PE => { reg => "fpsw", bit => 5 },
 213         FP_SF => { reg => "fpsw", bit => 6 },
 214         FP_ES => { reg => "fpsw", bit => 7 },
 215         FP_C0 => { reg => "fpsw", bit => 8 },
 216         FP_C1 => { reg => "fpsw", bit => 9 },
 217         FP_C2 => { reg => "fpsw", bit => 10 },
 218         FP_TOP0 => { reg => "fpsw", bit => 11 },
 219         FP_TOP1 => { reg => "fpsw", bit => 12 },
 220         FP_TOP2 => { reg => "fpsw", bit => 13 },
 221         FP_C3 => { reg => "fpsw", bit => 14 },
 222         FP_B  => { reg => "fpsw", bit => 15 },
 223
 224         FP_IM => { reg => "fpcw", bit => 0 },
 225         FP_DM => { reg => "fpcw", bit => 1 },
 226         FP_ZM => { reg => "fpcw", bit => 2 },
 227         FP_OM => { reg => "fpcw", bit => 3 },
 228         FP_UM => { reg => "fpcw", bit => 4 },
 229         FP_PM => { reg => "fpcw", bit => 5 },
 230         FP_PC0 => { reg => "fpcw", bit => 8 },
 231         FP_PC1 => { reg => "fpcw", bit => 9 },
 232         FP_RC0 => { reg => "fpcw", bit => 10 },
 233         FP_RC1 => { reg => "fpcw", bit => 11 },
 234         FP_X  => { reg => "fpcw", bit => 12 }
 235 ); # %flags
 236
 237 %cpu = (
 238         GP     => [ 1, "GP_EAX", "GP_EBX", "GP_ECX", "GP_EDX", "GP_ESI", "GP_EDI", "GP_EBP" ],
 239         SSE    => [ 1, "SSE_XMM0", "SSE_XMM1", "SSE_XMM2", "SSE_XMM3", "SSE_XMM4", "SSE_XMM5", "SSE_XMM6", "SSE_XMM7" ],
 240         VFP    => [ 1, "VFP_VF0", "VFP_VF1", "VFP_VF2", "VFP_VF3", "VFP_VF4", "VFP_VF5", "VFP_VF6", "VFP_VF7" ],
 241         BRANCH => [ 1, "BRANCH1", "BRANCH2" ],
 242 ); # %cpu
 243
 244 %vliw = (
 245         bundle_size       => 1,
 246         bundels_per_cycle => 1
 247 ); # vliw
 248
 249 %emit_templates = (
 250         S0 => "${arch}_emit_source_register(env, node, 0);",
 251         S1 => "${arch}_emit_source_register(env, node, 1);",
 252         S2 => "${arch}_emit_source_register(env, node, 2);",
 253         S3 => "${arch}_emit_source_register(env, node, 3);",
 254         S4 => "${arch}_emit_source_register(env, node, 4);",
 255         S5 => "${arch}_emit_source_register(env, node, 5);",
 256         D0 => "${arch}_emit_dest_register(env, node, 0);",
 257         D1 => "${arch}_emit_dest_register(env, node, 1);",
 258         D2 => "${arch}_emit_dest_register(env, node, 2);",
 259         D3 => "${arch}_emit_dest_register(env, node, 3);",
 260         D4 => "${arch}_emit_dest_register(env, node, 4);",
 261         D5 => "${arch}_emit_dest_register(env, node, 5);",
 262         X0 => "${arch}_emit_x87_name(env, node, 0);",
 263         X1 => "${arch}_emit_x87_name(env, node, 1);",
 264         X2 => "${arch}_emit_x87_name(env, node, 2);",
 265         C  => "${arch}_emit_immediate(env, node);",
 266         SE => "${arch}_emit_extend_suffix(env, get_ia32_ls_mode(node));",
 267         ME => "if(get_mode_size_bits(get_ia32_ls_mode(node)) != 32)\n
 268                    ia32_emit_mode_suffix(env, node);",
 269         M  => "${arch}_emit_mode_suffix(env, node);",
 270         XM => "${arch}_emit_x87_mode_suffix(env, node);",
 271         XXM => "${arch}_emit_xmm_mode_suffix(env, node);",
 272         XSD => "${arch}_emit_xmm_mode_suffix_s(env, node);",
 273         AM => "${arch}_emit_am(env, node);",
 274         unop0 => "${arch}_emit_unop(env, node, 0);",
 275         unop1 => "${arch}_emit_unop(env, node, 1);",
 276         unop2 => "${arch}_emit_unop(env, node, 2);",
 277         unop3 => "${arch}_emit_unop(env, node, 3);",
 278         unop4 => "${arch}_emit_unop(env, node, 4);",
 279         DAM0  => "${arch}_emit_am_or_dest_register(env, node, 0);",
 280         DAM1  => "${arch}_emit_am_or_dest_register(env, node, 0);",
 281         binop => "${arch}_emit_binop(env, node);",
 282         x87_binop => "${arch}_emit_x87_binop(env, node);",
 283 );
 284
 285 #--------------------------------------------------#
 286 #                        _                         #
 287 #                       (_)                        #
 288 #  _ __   _____      __  _ _ __    ___  _ __  ___  #
 289 # | '_ \ / _ \ \ /\ / / | | '__|  / _ \| '_ \/ __| #
 290 # | | | |  __/\ V  V /  | | |    | (_) | |_) \__ \ #
 291 # |_| |_|\___| \_/\_/   |_|_|     \___/| .__/|___/ #
 292 #                                      | |         #
 293 #                                      |_|         #
 294 #--------------------------------------------------#
 295
 296 $default_attr_type = "ia32_attr_t";
 297 $default_copy_attr = "ia32_copy_attr";
 298
 299 %init_attr = (
 300         ia32_attr_t     => "\tinit_ia32_attributes(res, flags, in_reqs, out_reqs, exec_units, n_res, latency);",
 301         ia32_x87_attr_t =>
 302                 "\tinit_ia32_attributes(res, flags, in_reqs, out_reqs, exec_units, n_res, latency);\n".
 303                 "\tinit_ia32_x87_attributes(res);",
 304         ia32_asm_attr_t =>
 305                 "\tinit_ia32_attributes(res, flags, in_reqs, out_reqs, exec_units, n_res, latency);\n".
 306                 "\tinit_ia32_x87_attributes(res);".
 307                 "\tinit_ia32_asm_attributes(res);",
 308         ia32_immediate_attr_t =>
 309                 "\tinit_ia32_attributes(res, flags, in_reqs, out_reqs, exec_units, n_res, latency);\n".
 310                 "\tinit_ia32_immediate_attributes(res, symconst, symconst_sign, offset);"
 311 );
 312
 313 %compare_attr = (
 314         ia32_attr_t           => "ia32_compare_nodes_attr",
 315         ia32_x87_attr_t       => "ia32_compare_x87_attr",
 316         ia32_asm_attr_t       => "ia32_compare_asm_attr",
 317         ia32_immediate_attr_t => "ia32_compare_immediate_attr",
 318 );
 319
 320 %operands = (
 321 );
 322
 323 $mode_xmm     = "mode_E";
 324 $mode_gp      = "mode_Iu";
 325 $mode_fpcw    = "mode_fpcw";
 326 $status_flags = [ "CF", "PF", "AF", "ZF", "SF", "OF" ];
 327 $fpcw_flags   = [ "FP_IM", "FP_DM", "FP_ZM", "FP_OM", "FP_UM", "FP_PM",
 328                   "FP_PC0", "FP_PC1", "FP_RC0", "FP_RC1", "FP_X" ];
 329
 330 %nodes = (
 331
 332 Immediate => {
 333         state     => "pinned",
 334         op_flags  => "c",
 335         irn_flags => "I",
 336         reg_req   => { out => [ "gp_NOREG" ] },
 337         attr      => "ir_entity *symconst, int symconst_sign, long offset",
 338         attr_type => "ia32_immediate_attr_t",
 339         mode      => $mode_gp,
 340 },
 341
 342 Asm => {
 343         mode      => "mode_T",
 344         arity     => "variable",
 345         out_arity => "variable",
 346         attr_type => "ia32_asm_attr_t",
 347 },
 348
 349 #-----------------------------------------------------------------#
 350 #  _       _                                         _            #
 351 # (_)     | |                                       | |           #
 352 #  _ _ __ | |_ ___  __ _  ___ _ __   _ __   ___   __| | ___  ___  #
 353 # | | '_ \| __/ _ \/ _` |/ _ \ '__| | '_ \ / _ \ / _` |/ _ \/ __| #
 354 # | | | | | ||  __/ (_| |  __/ |    | | | | (_) | (_| |  __/\__ \ #
 355 # |_|_| |_|\__\___|\__, |\___|_|    |_| |_|\___/ \__,_|\___||___/ #
 356 #                   __/ |                                         #
 357 #                  |___/                                          #
 358 #-----------------------------------------------------------------#
 359
 360 # commutative operations
 361
 362 # NOTE:
 363 # All nodes supporting Addressmode have 5 INs:
 364 # 1 - base    r1 == NoReg in case of no AM or no base
 365 # 2 - index   r2 == NoReg in case of no AM or no index
 366 # 3 - op1     r3 == always present
 367 # 4 - op2     r4 == NoReg in case of immediate operation
 368 # 5 - mem     NoMem in case of no AM otherwise it takes the mem from the Load
 369
 370 Add => {
 371         irn_flags => "R",
 372         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 373         ins       => [ "base", "index", "left", "right", "mem" ],
 374         emit      => '. add%M %binop',
 375         units     => [ "GP" ],
 376         mode      => $mode_gp,
 377         modified_flags => $status_flags
 378 },
 379
 380 Adc => {
 381         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 382         emit      => '. adc%M %binop',
 383         units     => [ "GP" ],
 384         mode      => $mode_gp,
 385         modified_flags => $status_flags
 386 },
 387
 388 Add64Bit => {
 389         irn_flags => "R",
 390         arity     => 4,
 391         reg_req   => { in => [ "gp", "gp", "gp", "gp" ], out => [ "!in", "!in" ] },
 392         emit      => '
 393 . movl %S0, %D0
 394 . movl %S1, %D1
 395 . addl %S2, %D0
 396 . adcl %S3, %D1
 397 ',
 398         outs      => [ "low_res", "high_res" ],
 399         units     => [ "GP" ],
 400         modified_flags => $status_flags
 401 },
 402
 403 l_Add => {
 404         op_flags  => "C",
 405         irn_flags => "R",
 406         cmp_attr  => "return 1;",
 407         arity     => 2,
 408 },
 409
 410 l_Adc => {
 411         op_flags  => "C",
 412         cmp_attr  => "return 1;",
 413         arity     => 2,
 414 },
 415
 416 Mul => {
 417         # we should not rematrialize this node. It produces 2 results and has
 418         # very strict constrains
 419         reg_req   => { in => [ "gp", "gp", "eax", "gp", "none" ], out => [ "eax", "edx", "none" ] },
 420         emit      => '. mul%M %unop3',
 421         outs      => [ "EAX", "EDX", "M" ],
 422         ins       => [ "base", "index", "val_high", "val_low", "mem" ],
 423         latency   => 10,
 424         units     => [ "GP" ],
 425         modified_flags => $status_flags
 426 },
 427
 428 l_Mul => {
 429         # we should not rematrialize this node. It produces 2 results and has
 430         # very strict constrains
 431         op_flags  => "C",
 432         cmp_attr  => "return 1;",
 433         outs      => [ "EAX", "EDX", "M" ],
 434         arity     => 2
 435 },
 436
 437 IMul => {
 438         irn_flags => "R",
 439         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 440         emit      => '. imul%M %binop',
 441         latency   => 5,
 442         units     => [ "GP" ],
 443         mode      => $mode_gp,
 444         modified_flags => $status_flags
 445 },
 446
 447 IMul1OP => {
 448         irn_flags => "R",
 449         reg_req   => { in => [ "gp", "gp", "eax", "gp", "none" ], out => [ "eax", "edx", "none" ] },
 450         emit      => '. imul%M %unop3',
 451         outs      => [ "EAX", "EDX", "M" ],
 452         ins       => [ "base", "index", "val_high", "val_low", "mem" ],
 453         latency   => 5,
 454         units     => [ "GP" ],
 455         modified_flags => $status_flags
 456 },
 457
 458 l_IMul => {
 459         op_flags  => "C",
 460         cmp_attr  => "return 1;",
 461         arity     => 2
 462 },
 463
 464 And => {
 465         irn_flags => "R",
 466         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 467         emit      => '. and%M %binop',
 468         units     => [ "GP" ],
 469         mode      => $mode_gp,
 470         modified_flags => $status_flags
 471 },
 472
 473 Or => {
 474         irn_flags => "R",
 475         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 476         emit      => '. or%M %binop',
 477         units     => [ "GP" ],
 478         mode      => $mode_gp,
 479         modified_flags => $status_flags
 480 },
 481
 482 Xor => {
 483         irn_flags => "R",
 484         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 485         emit      => '. xor%M %binop',
 486         units     => [ "GP" ],
 487         mode      => $mode_gp,
 488         modified_flags => $status_flags
 489 },
 490
 491 l_Xor => {
 492         op_flags  => "C",
 493         cmp_attr  => "return 1;",
 494         arity     => 2,
 495         modified_flags => $status_flags
 496 },
 497
 498 # not commutative operations
 499
 500 Sub => {
 501         irn_flags => "R",
 502         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 503         emit      => '. sub%M %binop',
 504         units     => [ "GP" ],
 505         mode      => $mode_gp,
 506         modified_flags => $status_flags
 507 },
 508
 509 Sbb => {
 510         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none" ], out => [ "in_r3 !in_r4" ] },
 511         emit      => '. sbb%M %binop',
 512         units     => [ "GP" ],
 513         mode      => $mode_gp,
 514         modified_flags => $status_flags
 515 },
 516
 517 Sub64Bit => {
 518         irn_flags => "R",
 519         arity     => 4,
 520         reg_req   => { in => [ "gp", "gp", "gp", "gp" ], out => [ "!in", "!in" ] },
 521         emit      => '
 522 . movl %S0, %D0
 523 . movl %S1, %D1
 524 . subl %S2, %D0
 525 . sbbl %S3, %D1
 526 ',
 527         outs      => [ "low_res", "high_res" ],
 528         units     => [ "GP" ],
 529         modified_flags => $status_flags
 530 },
 531
 532 l_Sub => {
 533         irn_flags => "R",
 534         cmp_attr  => "return 1;",
 535         arity     => 2,
 536 },
 537
 538 l_Sbb => {
 539         cmp_attr  => "return 1;",
 540         arity     => 2,
 541 },
 542
 543 IDiv => {
 544         op_flags  => "F|L",
 545         state     => "exc_pinned",
 546         reg_req   => { in => [ "gp", "gp", "eax", "edx", "gp", "none" ], out => [ "eax", "edx", "none" ] },
 547         attr      => "ia32_op_flavour_t dm_flav",
 548         init_attr => "attr->data.op_flav = dm_flav;",
 549         emit      => ". idiv%M %unop4",
 550         outs      => [ "div_res", "mod_res", "M" ],
 551         latency   => 25,
 552         units     => [ "GP" ],
 553         modified_flags => $status_flags
 554 },
 555
 556 Div => {
 557         op_flags  => "F|L",
 558         state     => "exc_pinned",
 559         reg_req   => { in => [ "gp", "gp", "eax", "edx", "gp", "none" ], out => [ "eax", "edx", "none" ] },
 560         attr      => "ia32_op_flavour_t dm_flav",
 561         init_attr => "attr->data.op_flav = dm_flav;",
 562         emit      => ". div%M %unop4",
 563         outs      => [ "div_res", "mod_res", "M" ],
 564         latency   => 25,
 565         units     => [ "GP" ],
 566         modified_flags => $status_flags
 567 },
 568
 569 Shl => {
 570         irn_flags => "R",
 571         # "in_r3" would be enough as out requirement, but the register allocator
 572         # does strange things then and doesn't respect the constraint for in4
 573         # if the same value is attached to in3 and in4 (if you have "i << i" in C)
 574         reg_req   => { in => [ "gp", "gp", "gp", "ecx", "none" ], out => [ "in_r3 !in_r4" ] },
 575         ins       => [ "base", "index", "left", "right", "mem" ],
 576         emit      => '. shl%M %binop',
 577         units     => [ "GP" ],
 578         mode      => $mode_gp,
 579         modified_flags => $status_flags
 580 },
 581
 582 l_Shl => {
 583         cmp_attr  => "return 1;",
 584         arity     => 2
 585 },
 586
 587 ShlD => {
 588         irn_flags => "R",
 589         # Out requirements is: different from all in
 590         # This is because, out must be different from LowPart and ShiftCount.
 591         # We could say "!ecx !in_r4" but it can occur, that all values live through
 592         # this Shift and the only value dying is the ShiftCount. Then there would be
 593         # a register missing, as result must not be ecx and all other registers are
 594         # occupied. What we should write is "!in_r4 !in_r5", but this is not
 595         # supported (and probably never will). So we create artificial interferences
 596         # of the result with all inputs, so the spiller can always assure a free
 597         # register.
 598         reg_req   => { in => [ "gp", "gp", "gp", "gp", "ecx", "none" ], out => [ "!in" ] },
 599         emit      =>
 600 '
 601 if (get_ia32_immop_type(node) == ia32_ImmNone) {
 602         if (get_ia32_op_type(node) == ia32_AddrModeD) {
 603                 . shld%M %%cl, %S3, %AM
 604         } else {
 605                 . shld%M %%cl, %S3, %S2
 606         }
 607 } else {
 608         if (get_ia32_op_type(node) == ia32_AddrModeD) {
 609                 . shld%M %C, %S3, %AM
 610         } else {
 611                 . shld%M %C, %S3, %S2
 612         }
 613 }
 614 ',
 615         latency   => 6,
 616         units     => [ "GP" ],
 617         mode      => $mode_gp,
 618         modified_flags => $status_flags
 619 },
 620
 621 l_ShlD => {
 622         cmp_attr  => "return 1;",
 623         arity     => 3,
 624 },
 625
 626 Shr => {
 627         irn_flags => "R",
 628         reg_req   => { in => [ "gp", "gp", "gp", "ecx", "none" ], out => [ "in_r3 !in_r4" ] },
 629         emit      => '. shr%M %binop',
 630         units     => [ "GP" ],
 631         mode      => $mode_gp,
 632         modified_flags => $status_flags
 633 },
 634
 635 l_Shr => {
 636         cmp_attr  => "return 1;",
 637         arity     => 2
 638 },
 639
 640 ShrD => {
 641         irn_flags => "R",
 642         # Out requirements is: different from all in
 643         # This is because, out must be different from LowPart and ShiftCount.
 644         # We could say "!ecx !in_r4" but it can occur, that all values live through
 645         # this Shift and the only value dying is the ShiftCount. Then there would be a
 646         # register missing, as result must not be ecx and all other registers are
 647         # occupied. What we should write is "!in_r4 !in_r5", but this is not supported
 648         # (and probably never will). So we create artificial interferences of the result
 649         # with all inputs, so the spiller can always assure a free register.
 650         reg_req   => { in => [ "gp", "gp", "gp", "gp", "ecx", "none" ], out => [ "!in" ] },
 651         emit      => '
 652 if (get_ia32_immop_type(node) == ia32_ImmNone) {
 653         if (get_ia32_op_type(node) == ia32_AddrModeD) {
 654                 . shrd%M %%cl, %S3, %AM
 655         } else {
 656                 . shrd%M %%cl, %S3, %S2
 657         }
 658 } else {
 659         if (get_ia32_op_type(node) == ia32_AddrModeD) {
 660                 . shrd%M %C, %S3, %AM
 661         } else {
 662                 . shrd%M %C, %S3, %S2
 663         }
 664 }
 665 ',
 666         latency   => 6,
 667         units     => [ "GP" ],
 668         mode      => $mode_gp,
 669         modified_flags => $status_flags
 670 },
 671
 672 l_ShrD => {
 673         cmp_attr  => "return 1;",
 674         arity     => 3
 675 },
 676
 677 Sar => {
 678         irn_flags => "R",
 679         reg_req   => { in => [ "gp", "gp", "gp", "ecx", "none" ], out => [ "in_r3 !in_r4" ] },
 680         emit      => '. sar%M %binop',
 681         units     => [ "GP" ],
 682         mode      => $mode_gp,
 683         modified_flags => $status_flags
 684 },
 685
 686 l_Sar => {
 687         cmp_attr  => "return 1;",
 688         arity     => 2
 689 },
 690
 691 Ror => {
 692         irn_flags => "R",
 693         reg_req   => { in => [ "gp", "gp", "gp", "ecx", "none" ], out => [ "in_r3 !in_r4" ] },
 694         emit      => '. ror%M %binop',
 695         units     => [ "GP" ],
 696         mode      => $mode_gp,
 697         modified_flags => $status_flags
 698 },
 699
 700 Rol => {
 701         irn_flags => "R",
 702         reg_req   => { in => [ "gp", "gp", "gp", "ecx", "none" ], out => [ "in_r3 !in_r4" ] },
 703         emit      => '. rol%M %binop',
 704         units     => [ "GP" ],
 705         mode      => $mode_gp,
 706         modified_flags => $status_flags
 707 },
 708
 709 # unary operations
 710
 711 Neg => {
 712         irn_flags => "R",
 713         reg_req   => { in => [ "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 714         emit      => '. neg%M %unop2',
 715         ins       => [ "base", "index", "val", "mem" ],
 716         units     => [ "GP" ],
 717         mode      => $mode_gp,
 718         modified_flags => $status_flags
 719 },
 720
 721 Minus64Bit => {
 722         irn_flags => "R",
 723         reg_req   => { in => [ "gp", "gp", "gp" ], out => [ "!in", "!in" ] },
 724         emit      => '
 725 . movl %S0, %D0
 726 . movl %S0, %D1
 727 . subl %S1, %D0
 728 . sbbl %S2, %D1
 729 ',
 730         outs      => [ "low_res", "high_res" ],
 731         units     => [ "GP" ],
 732         modified_flags => $status_flags
 733 },
 734
 735
 736 l_Neg => {
 737         cmp_attr  => "return 1;",
 738         arity     => 1,
 739 },
 740
 741 Inc => {
 742         irn_flags => "R",
 743         reg_req   => { in => [ "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 744         emit      => '. inc%M %unop2',
 745         units     => [ "GP" ],
 746         mode      => $mode_gp,
 747         modified_flags => [ "OF", "SF", "ZF", "AF", "PF" ]
 748 },
 749
 750 Dec => {
 751         irn_flags => "R",
 752         reg_req   => { in => [ "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 753         emit      => '. dec%M %unop2',
 754         units     => [ "GP" ],
 755         mode      => $mode_gp,
 756         modified_flags => [ "OF", "SF", "ZF", "AF", "PF" ]
 757 },
 758
 759 Not => {
 760         irn_flags => "R",
 761         reg_req   => { in => [ "gp", "gp", "gp", "none" ], out => [ "in_r3" ] },
 762         ins       => [ "base", "index", "val", "mem" ],
 763         emit      => '. not%M %unop2',
 764         units     => [ "GP" ],
 765         mode      => $mode_gp,
 766         modified_flags => []
 767 },
 768
 769 # other operations
 770
 771 CondJmp => {
 772         state     => "pinned",
 773         op_flags  => "L|X|Y",
 774         reg_req   => { in  => [ "gp", "gp", "gp", "gp", "none" ],
 775                        out => [ "none", "none"] },
 776         ins       => [ "base", "index", "left", "right", "mem" ],
 777         outs      => [ "false", "true" ],
 778         attr      => "long pnc",
 779         init_attr => "attr->pn_code = pnc;",
 780         latency   => 3,
 781         units     => [ "BRANCH" ],
 782 },
 783
 784 TestJmp => {
 785         state     => "pinned",
 786         op_flags  => "L|X|Y",
 787         reg_req   => { in  => [ "gp", "gp", "gp", "gp", "none" ],
 788                        out => [ "none", "none" ] },
 789         ins       => [ "base", "index", "left", "right", "mem" ],
 790         outs      => [ "false", "true" ],
 791         attr      => "long pnc",
 792         init_attr => "attr->pn_code = pnc;",
 793         latency   => 3,
 794         units     => [ "BRANCH" ],
 795 },
 796
 797 SwitchJmp => {
 798         state     => "pinned",
 799         op_flags  => "L|X|Y",
 800         reg_req   => { in => [ "gp" ], out => [ "none" ] },
 801         latency   => 3,
 802         units     => [ "BRANCH" ],
 803         mode      => "mode_T",
 804 },
 805
 806 Const => {
 807         op_flags  => "c",
 808         irn_flags => "R",
 809         reg_req   => { out => [ "gp" ] },
 810         units     => [ "GP" ],
 811         mode      => $mode_gp,
 812 },
 813
 814 Unknown_GP => {
 815         state     => "pinned",
 816         op_flags  => "c",
 817         irn_flags => "I",
 818         reg_req   => { out => [ "gp_UKNWN" ] },
 819         units     => [],
 820         emit      => "",
 821         mode      => $mode_gp
 822 },
 823
 824 Unknown_VFP => {
 825         state     => "pinned",
 826         op_flags  => "c",
 827         irn_flags => "I",
 828         reg_req   => { out => [ "vfp_UKNWN" ] },
 829         units     => [],
 830         emit      => "",
 831         mode      => "mode_E",
 832         attr_type => "ia32_x87_attr_t",
 833 },
 834
 835 Unknown_XMM => {
 836         state     => "pinned",
 837         op_flags  => "c",
 838         irn_flags => "I",
 839         reg_req   => { out => [ "xmm_UKNWN" ] },
 840         units     => [],
 841         emit      => "",
 842         mode      => "mode_E"
 843 },
 844
 845 NoReg_GP => {
 846         state     => "pinned",
 847         op_flags  => "c",
 848         irn_flags => "I",
 849         reg_req   => { out => [ "gp_NOREG" ] },
 850         units     => [],
 851         emit      => "",
 852         mode      => $mode_gp
 853 },
 854
 855 NoReg_VFP => {
 856         state     => "pinned",
 857         op_flags  => "c",
 858         irn_flags => "I",
 859         reg_req   => { out => [ "vfp_NOREG" ] },
 860         units     => [],
 861         emit      => "",
 862         mode      => "mode_E",
 863         attr_type => "ia32_x87_attr_t",
 864 },
 865
 866 NoReg_XMM => {
 867         state     => "pinned",
 868         op_flags  => "c",
 869         irn_flags => "I",
 870         reg_req   => { out => [ "xmm_NOREG" ] },
 871         units     => [],
 872         emit      => "",
 873         mode      => "mode_E"
 874 },
 875
 876 ChangeCW => {
 877         state     => "pinned",
 878         op_flags  => "c",
 879         irn_flags => "I",
 880         reg_req   => { out => [ "fp_cw" ] },
 881         mode      => $mode_fpcw,
 882         latency   => 3,
 883         units     => [ "GP" ],
 884         modified_flags => $fpcw_flags
 885 },
 886
 887 FldCW => {
 888         op_flags  => "L|F",
 889         state     => "pinned",
 890         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "fp_cw" ] },
 891         latency   => 5,
 892         emit      => ". fldcw %AM",
 893         mode      => $mode_fpcw,
 894         units     => [ "GP" ],
 895         modified_flags => $fpcw_flags
 896 },
 897
 898 FnstCW => {
 899         op_flags  => "L|F",
 900         state     => "pinned",
 901         reg_req   => { in => [ "gp", "gp", "fp_cw", "none" ], out => [ "none" ] },
 902         latency   => 5,
 903         emit      => ". fnstcw %AM",
 904         mode      => "mode_M",
 905         units     => [ "GP" ],
 906 },
 907
 908 Cltd => {
 909         # we should not rematrialize this node. It produces 2 results and has
 910         # very strict constrains
 911         reg_req   => { in => [ "eax" ], out => [ "edx" ] },
 912         ins       => [ "val" ],
 913         emit      => '. cltd',
 914         mode      => $mode_gp,
 915         units     => [ "GP" ],
 916 },
 917
 918 # Load / Store
 919 #
 920 # Note that we add additional latency values depending on address mode, so a
 921 # lateny of 0 for load is correct
 922
 923 Load => {
 924         op_flags  => "L|F",
 925         state     => "exc_pinned",
 926         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "gp", "none" ] },
 927         ins       => [ "base", "index", "mem" ],
 928         outs      => [ "res", "M" ],
 929         latency   => 0,
 930         emit      => ". mov%SE%ME%.l %AM, %D0",
 931         units     => [ "GP" ],
 932 },
 933
 934 l_Load => {
 935         op_flags  => "L|F",
 936         cmp_attr  => "return 1;",
 937         outs      => [ "res", "M" ],
 938         arity     => 2,
 939 },
 940
 941 l_Store => {
 942         op_flags  => "L|F",
 943         cmp_attr  => "return 1;",
 944         state     => "exc_pinned",
 945         arity     => 3,
 946         mode      => "mode_M",
 947 },
 948
 949 Store => {
 950         op_flags  => "L|F",
 951         state     => "exc_pinned",
 952         reg_req   => { in => [ "gp", "gp", "gp", "none" ], out => [ "none" ] },
 953         ins       => [ "base", "index", "val", "mem" ],
 954         emit      => '. mov%M %binop',
 955         latency   => 2,
 956         units     => [ "GP" ],
 957         mode      => "mode_M",
 958 },
 959
 960 Store8Bit => {
 961         op_flags  => "L|F",
 962         state     => "exc_pinned",
 963         reg_req   => { in => [ "gp", "gp", "eax ebx ecx edx", "none" ], out => ["none" ] },
 964         emit      => '. mov%M %binop',
 965         latency   => 2,
 966         units     => [ "GP" ],
 967         mode      => "mode_M",
 968 },
 969
 970 Lea => {
 971         irn_flags => "R",
 972         reg_req   => { in => [ "gp", "gp" ], out => [ "gp" ] },
 973         emit      => '. leal %AM, %D0',
 974         latency   => 2,
 975         units     => [ "GP" ],
 976         mode      => $mode_gp,
 977         modified_flags => [],
 978 },
 979
 980 Push => {
 981         reg_req   => { in => [ "gp", "gp", "gp", "esp", "none" ], out => [ "esp", "none" ] },
 982         emit      => '. push%M %unop2',
 983         ins       => [ "base", "index", "val", "stack", "mem" ],
 984         outs      => [ "stack:I|S", "M" ],
 985         latency   => 2,
 986         units     => [ "GP" ],
 987         modified_flags => [],
 988 },
 989
 990 Pop => {
 991         reg_req   => { in => [ "gp", "gp", "esp", "none" ], out => [ "esp", "gp", "none" ] },
 992         emit      => '. pop%M %DAM1',
 993         outs      => [ "stack:I|S", "res", "M" ],
 994         ins       => [ "base", "index", "stack", "mem" ],
 995         latency   => 3, # Pop is more expensive than Push on Athlon
 996         units     => [ "GP" ],
 997         modified_flags => [],
 998 },
 999
1000 Enter => {
1001         reg_req   => { in => [ "esp" ], out => [ "ebp", "esp", "none" ] },
1002         emit      => '. enter',
1003         outs      => [ "frame:I", "stack:I|S", "M" ],
1004         latency   => 15,
1005         units     => [ "GP" ],
1006 },
1007
1008 Leave => {
1009         reg_req   => { in => [ "esp", "ebp" ], out => [ "ebp", "esp" ] },
1010         emit      => '. leave',
1011         outs      => [ "frame:I", "stack:I|S" ],
1012         latency   => 3,
1013         units     => [ "GP" ],
1014 },
1015
1016 AddSP => {
1017         irn_flags => "I",
1018         reg_req   => { in => [ "gp", "gp", "esp", "gp", "none" ], out => [ "in_r3", "none" ] },
1019         emit      => '. addl %binop',
1020         outs      => [ "stack:S", "M" ],
1021         units     => [ "GP" ],
1022         modified_flags => $status_flags
1023 },
1024
1025 SubSP => {
1026         irn_flags => "I",
1027         reg_req   => { in => [ "gp", "gp", "esp", "gp", "none" ], out => [ "in_r3", "none" ] },
1028         emit      => '. subl %binop',
1029         outs      => [ "stack:S", "M" ],
1030         units     => [ "GP" ],
1031         modified_flags => $status_flags
1032 },
1033
1034 LdTls => {
1035         irn_flags => "R",
1036         reg_req   => { out => [ "gp" ] },
1037         units     => [ "GP" ],
1038 },
1039
1040 # the int instruction
1041 int => {
1042         reg_req   => { in => [ "none" ], out => [ "none" ] },
1043         mode      => "mode_M",
1044         attr      => "tarval *tv",
1045         init_attr => "\tset_ia32_Immop_tarval(res, tv);",
1046         emit      => '. int %C',
1047         units     => [ "GP" ],
1048         cmp_attr  => "return 1;",
1049 },
1050
1051
1052 #-----------------------------------------------------------------------------#
1053 #   _____ _____ ______    __ _             _                     _            #
1054 #  / ____/ ____|  ____|  / _| |           | |                   | |           #
1055 # | (___| (___ | |__    | |_| | ___   __ _| |_   _ __   ___   __| | ___  ___  #
1056 #  \___ \\___ \|  __|   |  _| |/ _ \ / _` | __| | '_ \ / _ \ / _` |/ _ \/ __| #
1057 #  ____) |___) | |____  | | | | (_) | (_| | |_  | | | | (_) | (_| |  __/\__ \ #
1058 # |_____/_____/|______| |_| |_|\___/ \__,_|\__| |_| |_|\___/ \__,_|\___||___/ #
1059 #-----------------------------------------------------------------------------#
1060
1061 # commutative operations
1062
1063 xAdd => {
1064         irn_flags => "R",
1065         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3" ] },
1066         emit      => '. add%XXM %binop',
1067         latency   => 4,
1068         units     => [ "SSE" ],
1069         mode      => "mode_E",
1070 },
1071
1072 xMul => {
1073         irn_flags => "R",
1074         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3" ] },
1075         emit      => '. mul%XXM %binop',
1076         latency   => 4,
1077         units     => [ "SSE" ],
1078         mode      => "mode_E",
1079 },
1080
1081 xMax => {
1082         irn_flags => "R",
1083         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3" ] },
1084         emit      => '. max%XXM %binop',
1085         latency   => 2,
1086         units     => [ "SSE" ],
1087         mode      => "mode_E",
1088 },
1089
1090 xMin => {
1091         irn_flags => "R",
1092         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3" ] },
1093         emit      => '. min%XXM %binop',
1094         latency   => 2,
1095         units     => [ "SSE" ],
1096         mode      => "mode_E",
1097 },
1098
1099 xAnd => {
1100         irn_flags => "R",
1101         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3" ] },
1102         emit      => '. andp%XSD %binop',
1103         latency   => 3,
1104         units     => [ "SSE" ],
1105         mode      => "mode_E",
1106 },
1107
1108 xOr => {
1109         irn_flags => "R",
1110         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3" ] },
1111         emit      => '. orp%XSD %binop',
1112         units     => [ "SSE" ],
1113         mode      => "mode_E",
1114 },
1115
1116 xXor => {
1117         irn_flags => "R",
1118         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3" ] },
1119         emit      => '. xorp%XSD %binop',
1120         latency   => 3,
1121         units     => [ "SSE" ],
1122         mode      => "mode_E",
1123 },
1124
1125 # not commutative operations
1126
1127 xAndNot => {
1128         irn_flags => "R",
1129         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3 !in_r4" ] },
1130         emit      => '. andnp%XSD %binop',
1131         latency   => 3,
1132         units     => [ "SSE" ],
1133         mode      => "mode_E",
1134 },
1135
1136 xSub => {
1137         irn_flags => "R",
1138         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3" ] },
1139         emit      => '. sub%XXM %binop',
1140         latency   => 4,
1141         units     => [ "SSE" ],
1142         mode      => "mode_E",
1143 },
1144
1145 xDiv => {
1146         irn_flags => "R",
1147         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3 !in_r4", "none" ] },
1148         outs      => [ "res", "M" ],
1149         emit      => '. div%XXM %binop',
1150         latency   => 16,
1151         units     => [ "SSE" ],
1152 },
1153
1154 # other operations
1155
1156 xCmp => {
1157         irn_flags => "R",
1158         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "in_r3 !in_r4" ] },
1159         latency   => 3,
1160         units     => [ "SSE" ],
1161         mode      => "mode_E",
1162 },
1163
1164 xCondJmp => {
1165         state     => "pinned",
1166         op_flags  => "L|X|Y",
1167         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "none", "none" ] },
1168         ins       => [ "base", "index", "left", "right", "mem" ],
1169         outs      => [ "false", "true" ],
1170         attr      => "long pnc",
1171         init_attr => "attr->pn_code = pnc;",
1172         latency   => 5,
1173         units     => [ "SSE" ],
1174 },
1175
1176 xConst => {
1177         op_flags  => "c",
1178         irn_flags => "R",
1179         reg_req   => { out => [ "xmm" ] },
1180         emit      => '. mov%XXM %C, %D0',
1181         latency   => 2,
1182         units     => [ "SSE" ],
1183         mode      => "mode_E",
1184 },
1185
1186 # Load / Store
1187
1188 xLoad => {
1189         op_flags  => "L|F",
1190         state     => "exc_pinned",
1191         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "xmm", "none" ] },
1192         emit      => '. mov%XXM %AM, %D0',
1193         outs      => [ "res", "M" ],
1194         latency   => 2,
1195         units     => [ "SSE" ],
1196 },
1197
1198 xStore => {
1199         op_flags => "L|F",
1200         state    => "exc_pinned",
1201         reg_req  => { in => [ "gp", "gp", "xmm", "none" ] },
1202         emit     => '. mov%XXM %binop',
1203         latency  => 2,
1204         units    => [ "SSE" ],
1205         mode     => "mode_M",
1206 },
1207
1208 xStoreSimple => {
1209         op_flags => "L|F",
1210         state    => "exc_pinned",
1211         reg_req  => { in => [ "gp", "gp", "xmm", "none" ] },
1212         ins      => [ "base", "index", "val", "mem" ],
1213         emit     => '. mov%XXM %S2, %AM',
1214         latency  => 2,
1215         units    => [ "SSE" ],
1216         mode     => "mode_M",
1217 },
1218
1219 CvtSI2SS => {
1220         op_flags => "L|F",
1221         reg_req  => { in => [ "gp", "gp", "gp", "none" ], out => [ "xmm" ] },
1222         emit     => '. cvtsi2ss %D0, %AM',
1223         latency  => 2,
1224         units    => [ "SSE" ],
1225         mode     => $mode_xmm
1226 },
1227
1228 CvtSI2SD => {
1229         op_flags => "L|F",
1230         reg_req  => { in => [ "gp", "gp", "gp", "none" ], out => [ "xmm" ] },
1231         emit     => '. cvtsi2sd %unop2',
1232         latency  => 2,
1233         units    => [ "SSE" ],
1234         mode     => $mode_xmm
1235 },
1236
1237
1238 l_X87toSSE => {
1239         op_flags => "L|F",
1240         cmp_attr => "return 1;",
1241         arity    => 3,
1242 },
1243
1244 l_SSEtoX87 => {
1245         op_flags => "L|F",
1246         cmp_attr => "return 1;",
1247         arity    => 3,
1248 },
1249
1250 GetST0 => {
1251         op_flags => "L|F",
1252         irn_flags => "I",
1253         state    => "pinned",
1254         reg_req  => { in => [ "gp", "gp", "none" ] },
1255         emit     => '. fstp%XM %AM',
1256         latency  => 4,
1257         units    => [ "SSE" ],
1258         mode     => "mode_M",
1259 },
1260
1261 SetST0 => {
1262         op_flags => "L|F",
1263         irn_flags => "I",
1264         state    => "pinned",
1265         reg_req  => { in => [ "gp", "gp", "none" ], out => [ "vf0", "none" ] },
1266         ins      => [ "base", "index", "mem" ],
1267         emit     => '. fld%XM %AM',
1268         outs     => [ "res", "M" ],
1269         latency  => 2,
1270         units     => [ "SSE" ],
1271 },
1272
1273 # CopyB
1274
1275 CopyB => {
1276         op_flags => "F|H",
1277         state    => "pinned",
1278         reg_req  => { in => [ "edi", "esi", "ecx", "none" ], out => [ "edi", "esi", "ecx", "none" ] },
1279         outs     => [ "DST", "SRC", "CNT", "M" ],
1280         units    => [ "GP" ],
1281         modified_flags => [ "DF" ]
1282 },
1283
1284 CopyB_i => {
1285         op_flags => "F|H",
1286         state    => "pinned",
1287         reg_req  => { in => [ "edi", "esi", "none" ], out => [  "edi", "esi", "none" ] },
1288         outs     => [ "DST", "SRC", "M" ],
1289         units    => [ "GP" ],
1290         modified_flags => [ "DF" ]
1291 },
1292
1293 # Conversions
1294
1295 Conv_I2I => {
1296         reg_req  => { in => [ "gp", "gp", "gp", "none" ], out => [ "in_r3", "none" ] },
1297         units    => [ "GP" ],
1298         ins      => [ "base", "index", "val", "mem" ],
1299         mode     => $mode_gp,
1300         modified_flags => $status_flags
1301 },
1302
1303 Conv_I2I8Bit => {
1304         reg_req  => { in => [ "gp", "gp", "eax ebx ecx edx", "none" ], out => [ "in_r3", "none" ] },
1305         ins      => [ "base", "index", "val", "mem" ],
1306         units    => [ "GP" ],
1307         mode     => $mode_gp,
1308         modified_flags => $status_flags
1309 },
1310
1311 Conv_I2FP => {
1312         reg_req  => { in => [ "gp", "gp", "gp", "none" ], out => [ "xmm", "none" ] },
1313         latency  => 10,
1314         units    => [ "SSE" ],
1315         mode     => "mode_E",
1316 },
1317
1318 Conv_FP2I => {
1319         reg_req  => { in => [ "gp", "gp", "xmm", "none" ], out => [ "gp", "none" ] },
1320         latency  => 10,
1321         units    => [ "SSE" ],
1322         mode     => $mode_gp,
1323 },
1324
1325 Conv_FP2FP => {
1326         reg_req  => { in => [ "gp", "gp", "xmm", "none" ], out => [ "xmm", "none" ] },
1327         latency  => 8,
1328         units    => [ "SSE" ],
1329         mode     => "mode_E",
1330 },
1331
1332 CmpCMov => {
1333         irn_flags => "R",
1334         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none", "gp", "gp" ], out => [ "in_r7" ] },
1335         ins       => [ "base", "index", "cmp_left", "cmp_right", "mem", "val_true", "val_false" ],
1336         attr      => "pn_Cmp pn_code",
1337         init_attr => "attr->pn_code = pn_code;",
1338         latency   => 2,
1339         units     => [ "GP" ],
1340         mode      => $mode_gp,
1341 },
1342
1343 TestCMov => {
1344         irn_flags => "R",
1345         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none", "gp", "gp" ], out => [ "in_r7" ] },
1346         ins       => [ "base", "index", "cmp_left", "cmp_right", "mem", "val_true", "val_false" ],
1347         attr      => "pn_Cmp pn_code",
1348         init_attr => "attr->pn_code = pn_code;",
1349         latency   => 2,
1350         units     => [ "GP" ],
1351         mode      => $mode_gp,
1352 },
1353
1354 xCmpCMov => {
1355         irn_flags => "R",
1356         reg_req   => { in => [ "xmm", "xmm", "gp", "gp" ], out => [ "in_r4" ] },
1357         latency   => 5,
1358         units     => [ "SSE" ],
1359         mode      => $mode_gp,
1360 },
1361
1362 vfCmpCMov => {
1363         irn_flags => "R",
1364         reg_req   => { in => [ "vfp", "vfp", "gp", "gp" ], out => [ "in_r4" ] },
1365         latency   => 10,
1366         units     => [ "VFP" ],
1367         mode      => $mode_gp,
1368         attr_type => "ia32_x87_attr_t",
1369 },
1370
1371 CmpSet => {
1372         irn_flags => "R",
1373         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none" ], out => [ "eax ebx ecx edx" ] },
1374         ins       => [ "base", "index", "cmp_left", "cmp_right", "mem" ],
1375         attr      => "pn_Cmp pn_code",
1376         init_attr => "attr->pn_code = pn_code;",
1377         latency   => 2,
1378         units     => [ "GP" ],
1379         mode      => $mode_gp,
1380 },
1381
1382 TestSet => {
1383         irn_flags => "R",
1384         reg_req   => { in => [ "gp", "gp", "gp", "gp", "none" ], out => [ "eax ebx ecx edx" ] },
1385         ins       => [ "base", "index", "cmp_left", "cmp_right", "mem" ],
1386         attr      => "pn_Cmp pn_code",
1387         init_attr => "attr->pn_code = pn_code;",
1388         latency   => 2,
1389         units     => [ "GP" ],
1390         mode      => $mode_gp,
1391 },
1392
1393 xCmpSet => {
1394         irn_flags => "R",
1395         reg_req   => { in => [ "gp", "gp", "xmm", "xmm", "none" ], out => [ "eax ebx ecx edx" ] },
1396         latency   => 5,
1397         units     => [ "SSE" ],
1398         mode      => $mode_gp,
1399 },
1400
1401 vfCmpSet => {
1402         irn_flags => "R",
1403         reg_req   => { in => [ "gp", "gp", "vfp", "vfp", "none" ], out => [ "eax ebx ecx edx" ] },
1404         latency   => 10,
1405         units     => [ "VFP" ],
1406         mode      => $mode_gp,
1407         attr_type => "ia32_x87_attr_t",
1408 },
1409
1410 vfCMov => {
1411         irn_flags => "R",
1412         reg_req   => { in => [ "vfp", "vfp", "vfp", "vfp" ], out => [ "vfp" ] },
1413         latency   => 10,
1414         units     => [ "VFP" ],
1415         mode      => "mode_E",
1416         attr_type => "ia32_x87_attr_t",
1417 },
1418
1419 #----------------------------------------------------------#
1420 #        _      _               _    __ _             _    #
1421 #       (_)    | |             | |  / _| |           | |   #
1422 # __   ___ _ __| |_ _   _  __ _| | | |_| | ___   __ _| |_  #
1423 # \ \ / / | '__| __| | | |/ _` | | |  _| |/ _ \ / _` | __| #
1424 #  \ V /| | |  | |_| |_| | (_| | | | | | | (_) | (_| | |_  #
1425 #   \_/ |_|_|   \__|\__,_|\__,_|_| |_| |_|\___/ \__,_|\__| #
1426 #                 | |                                      #
1427 #  _ __   ___   __| | ___  ___                             #
1428 # | '_ \ / _ \ / _` |/ _ \/ __|                            #
1429 # | | | | (_) | (_| |  __/\__ \                            #
1430 # |_| |_|\___/ \__,_|\___||___/                            #
1431 #----------------------------------------------------------#
1432
1433 vfadd => {
1434         irn_flags => "R",
1435         reg_req   => { in => [ "gp", "gp", "vfp", "vfp", "none", "fpcw" ], out => [ "vfp" ] },
1436         ins       => [ "base", "index", "left", "right", "mem", "fpcw" ],
1437         latency   => 4,
1438         units     => [ "VFP" ],
1439         mode      => "mode_E",
1440         attr_type => "ia32_x87_attr_t",
1441 },
1442
1443 vfmul => {
1444         irn_flags => "R",
1445         reg_req   => { in => [ "gp", "gp", "vfp", "vfp", "none", "fpcw" ], out => [ "vfp" ] },
1446         ins       => [ "base", "index", "left", "right", "mem", "fpcw" ],
1447         latency   => 4,
1448         units     => [ "VFP" ],
1449         mode      => "mode_E",
1450         attr_type => "ia32_x87_attr_t",
1451 },
1452
1453 l_vfmul => {
1454         op_flags  => "C",
1455         cmp_attr  => "return 1;",
1456         arity     => 2,
1457 },
1458
1459 vfsub => {
1460         irn_flags => "R",
1461         reg_req   => { in => [ "gp", "gp", "vfp", "vfp", "none", "fpcw" ], out => [ "vfp" ] },
1462         ins       => [ "base", "index", "left", "right", "mem", "fpcw" ],
1463         latency   => 4,
1464         units     => [ "VFP" ],
1465         mode      => "mode_E",
1466         attr_type => "ia32_x87_attr_t",
1467 },
1468
1469 l_vfsub => {
1470         cmp_attr  => "return 1;",
1471         arity     => 2,
1472 },
1473
1474 vfdiv => {
1475         reg_req   => { in => [ "gp", "gp", "vfp", "vfp", "none", "fpcw" ], out => [ "vfp", "none" ] },
1476         ins       => [ "base", "index", "left", "right", "mem", "fpcw" ],
1477         outs      => [ "res", "M" ],
1478         latency   => 20,
1479         units     => [ "VFP" ],
1480         attr_type => "ia32_x87_attr_t",
1481 },
1482
1483 l_vfdiv => {
1484         cmp_attr  => "return 1;",
1485         outs      => [ "res", "M" ],
1486         arity     => 2,
1487 },
1488
1489 vfprem => {
1490         reg_req   => { in => [ "gp", "gp", "vfp", "vfp", "none", "fpcw" ], out => [ "vfp" ] },
1491         ins       => [ "base", "index", "left", "right", "mem", "fpcw" ],
1492         latency   => 20,
1493         units     => [ "VFP" ],
1494         mode      => "mode_E",
1495         attr_type => "ia32_x87_attr_t",
1496 },
1497
1498 l_vfprem => {
1499         cmp_attr  => "return 1;",
1500         arity     => 2,
1501 },
1502
1503 vfabs => {
1504         irn_flags => "R",
1505         reg_req   => { in => [ "vfp"], out => [ "vfp" ] },
1506         ins       => [ "value" ],
1507         latency   => 2,
1508         units     => [ "VFP" ],
1509         mode      => "mode_E",
1510         attr_type => "ia32_x87_attr_t",
1511 },
1512
1513 vfchs => {
1514         irn_flags => "R",
1515         reg_req   => { in => [ "vfp"], out => [ "vfp" ] },
1516         ins       => [ "value" ],
1517         latency   => 2,
1518         units     => [ "VFP" ],
1519         mode      => "mode_E",
1520         attr_type => "ia32_x87_attr_t",
1521 },
1522
1523 # virtual Load and Store
1524
1525 vfld => {
1526         op_flags  => "L|F",
1527         state     => "exc_pinned",
1528         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "vfp", "none" ] },
1529         ins       => [ "base", "index", "mem" ],
1530         outs      => [ "res", "M" ],
1531         attr      => "ir_mode *store_mode",
1532         init_attr => "attr->attr.ls_mode = store_mode;",
1533         latency   => 2,
1534         units     => [ "VFP" ],
1535         attr_type => "ia32_x87_attr_t",
1536 },
1537
1538 vfst => {
1539         op_flags  => "L|F",
1540         state     => "exc_pinned",
1541         reg_req   => { in => [ "gp", "gp", "vfp", "none" ] },
1542         ins       => [ "base", "index", "val", "mem" ],
1543         attr      => "ir_mode *store_mode",
1544         init_attr => "attr->attr.ls_mode = store_mode;",
1545         latency   => 2,
1546         units     => [ "VFP" ],
1547         mode      => "mode_M",
1548         attr_type => "ia32_x87_attr_t",
1549 },
1550
1551 # Conversions
1552
1553 vfild => {
1554         state     => "exc_pinned",
1555         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "vfp", "none" ] },
1556         outs      => [ "res", "M" ],
1557         ins       => [ "base", "index", "mem" ],
1558         latency   => 4,
1559         units     => [ "VFP" ],
1560         attr_type => "ia32_x87_attr_t",
1561 },
1562
1563 l_vfild => {
1564         cmp_attr  => "return 1;",
1565         outs      => [ "res", "M" ],
1566         arity     => 2,
1567 },
1568
1569 vfist => {
1570         state     => "exc_pinned",
1571         reg_req   => { in => [ "gp", "gp", "vfp", "fpcw", "none" ] },
1572         ins       => [ "base", "index", "val", "fpcw", "mem" ],
1573         latency   => 4,
1574         units     => [ "VFP" ],
1575         mode      => "mode_M",
1576         attr_type => "ia32_x87_attr_t",
1577 },
1578
1579 l_vfist => {
1580         cmp_attr  => "return 1;",
1581         state     => "exc_pinned",
1582         arity     => 3,
1583         mode      => "mode_M",
1584 },
1585
1586
1587 # constants
1588
1589 vfldz => {
1590         irn_flags => "R",
1591         reg_req   => { out => [ "vfp" ] },
1592         latency   => 4,
1593         units     => [ "VFP" ],
1594         mode      => "mode_E",
1595         attr_type => "ia32_x87_attr_t",
1596 },
1597
1598 vfld1 => {
1599         irn_flags => "R",
1600         reg_req   => { out => [ "vfp" ] },
1601         latency   => 4,
1602         units     => [ "VFP" ],
1603         mode      => "mode_E",
1604         attr_type => "ia32_x87_attr_t",
1605 },
1606
1607 vfldpi => {
1608         irn_flags => "R",
1609         reg_req   => { out => [ "vfp" ] },
1610         latency   => 4,
1611         units     => [ "VFP" ],
1612         mode      => "mode_E",
1613         attr_type => "ia32_x87_attr_t",
1614 },
1615
1616 vfldln2 => {
1617         irn_flags => "R",
1618         reg_req   => { out => [ "vfp" ] },
1619         latency   => 4,
1620         units     => [ "VFP" ],
1621         mode      => "mode_E",
1622         attr_type => "ia32_x87_attr_t",
1623 },
1624
1625 vfldlg2 => {
1626         irn_flags => "R",
1627         reg_req   => { out => [ "vfp" ] },
1628         latency   => 4,
1629         units     => [ "VFP" ],
1630         mode      => "mode_E",
1631         attr_type => "ia32_x87_attr_t",
1632 },
1633
1634 vfldl2t => {
1635         irn_flags => "R",
1636         reg_req   => { out => [ "vfp" ] },
1637         latency   => 4,
1638         units     => [ "VFP" ],
1639         mode      => "mode_E",
1640         attr_type => "ia32_x87_attr_t",
1641 },
1642
1643 vfldl2e => {
1644         irn_flags => "R",
1645         reg_req   => { out => [ "vfp" ] },
1646         latency   => 4,
1647         units     => [ "VFP" ],
1648         mode      => "mode_E",
1649         attr_type => "ia32_x87_attr_t",
1650 },
1651
1652 vfConst => {
1653         op_flags  => "c",
1654         irn_flags => "R",
1655         reg_req   => { out => [ "vfp" ] },
1656         latency   => 3,
1657         units     => [ "VFP" ],
1658         mode      => "mode_E",
1659         attr_type => "ia32_x87_attr_t",
1660 },
1661
1662 # other
1663
1664 vfCondJmp => {
1665         state     => "pinned",
1666         op_flags  => "L|X|Y",
1667         reg_req   => { in => [ "vfp", "vfp" ], out => [ "none", "none", "eax" ] },
1668         ins       => [ "left", "right" ],
1669         outs      => [ "false", "true", "temp_reg_eax" ],
1670         attr      => "long pnc",
1671         init_attr => "attr->attr.pn_code = pnc;",
1672         latency   => 10,
1673         units     => [ "VFP" ],
1674         attr_type => "ia32_x87_attr_t",
1675 },
1676
1677 #------------------------------------------------------------------------#
1678 #       ___ _____    __ _             _                     _            #
1679 # __  _( _ )___  |  / _| | ___   __ _| |_   _ __   ___   __| | ___  ___  #
1680 # \ \/ / _ \  / /  | |_| |/ _ \ / _` | __| | '_ \ / _ \ / _` |/ _ \/ __| #
1681 #  >  < (_) |/ /   |  _| | (_) | (_| | |_  | | | | (_) | (_| |  __/\__ \ #
1682 # /_/\_\___//_/    |_| |_|\___/ \__,_|\__| |_| |_|\___/ \__,_|\___||___/ #
1683 #------------------------------------------------------------------------#
1684
1685 # Note: gas is strangely buggy: fdivrp and fdivp as well as fsubrp and fsubp
1686 #       are swapped, we work this around in the emitter...
1687
1688 fadd => {
1689         op_flags  => "R",
1690         rd_constructor => "NONE",
1691         reg_req   => { },
1692         emit      => '. fadd%XM %x87_binop',
1693         attr_type => "ia32_x87_attr_t",
1694 },
1695
1696 faddp => {
1697         op_flags  => "R",
1698         rd_constructor => "NONE",
1699         reg_req   => { },
1700         emit      => '. faddp %x87_binop',
1701         attr_type => "ia32_x87_attr_t",
1702 },
1703
1704 fmul => {
1705         op_flags  => "R",
1706         rd_constructor => "NONE",
1707         reg_req   => { },
1708         emit      => '. fmul%XM %x87_binop',
1709         attr_type => "ia32_x87_attr_t",
1710 },
1711
1712 fmulp => {
1713         op_flags  => "R",
1714         rd_constructor => "NONE",
1715         reg_req   => { },
1716         emit      => '. fmulp %x87_binop',,
1717         attr_type => "ia32_x87_attr_t",
1718 },
1719
1720 fsub => {
1721         op_flags  => "R",
1722         rd_constructor => "NONE",
1723         reg_req   => { },
1724         emit      => '. fsub%XM %x87_binop',
1725         attr_type => "ia32_x87_attr_t",
1726 },
1727
1728 fsubp => {
1729         op_flags  => "R",
1730         rd_constructor => "NONE",
1731         reg_req   => { },
1732 # see note about gas bugs
1733         emit      => '. fsubrp %x87_binop',
1734         attr_type => "ia32_x87_attr_t",
1735 },
1736
1737 fsubr => {
1738         op_flags  => "R",
1739         rd_constructor => "NONE",
1740         irn_flags => "R",
1741         reg_req   => { },
1742         emit      => '. fsubr%XM %x87_binop',
1743         attr_type => "ia32_x87_attr_t",
1744 },
1745
1746 fsubrp => {
1747         op_flags  => "R",
1748         rd_constructor => "NONE",
1749         irn_flags => "R",
1750         reg_req   => { },
1751 # see note about gas bugs
1752         emit      => '. fsubp %x87_binop',
1753         attr_type => "ia32_x87_attr_t",
1754 },
1755
1756 fprem => {
1757         op_flags  => "R",
1758         rd_constructor => "NONE",
1759         reg_req   => { },
1760         emit      => '. fprem1',
1761         attr_type => "ia32_x87_attr_t",
1762 },
1763
1764 # this node is just here, to keep the simulator running
1765 # we can omit this when a fprem simulation function exists
1766 fpremp => {
1767         op_flags  => "R",
1768         rd_constructor => "NONE",
1769         reg_req   => { },
1770         emit      => '. fprem1',
1771         attr_type => "ia32_x87_attr_t",
1772 },
1773
1774 fdiv => {
1775         op_flags  => "R",
1776         rd_constructor => "NONE",
1777         reg_req   => { },
1778         emit      => '. fdiv%XM %x87_binop',
1779         attr_type => "ia32_x87_attr_t",
1780 },
1781
1782 fdivp => {
1783         op_flags  => "R",
1784         rd_constructor => "NONE",
1785         reg_req   => { },
1786 # see note about gas bugs
1787         emit      => '. fdivrp %x87_binop',
1788         attr_type => "ia32_x87_attr_t",
1789 },
1790
1791 fdivr => {
1792         op_flags  => "R",
1793         rd_constructor => "NONE",
1794         reg_req   => { },
1795         emit      => '. fdivr%XM %x87_binop',
1796         attr_type => "ia32_x87_attr_t",
1797 },
1798
1799 fdivrp => {
1800         op_flags  => "R",
1801         rd_constructor => "NONE",
1802         reg_req   => { },
1803 # see note about gas bugs
1804         emit      => '. fdivp %x87_binop',
1805         attr_type => "ia32_x87_attr_t",
1806 },
1807
1808 fabs => {
1809         op_flags  => "R",
1810         rd_constructor => "NONE",
1811         reg_req   => { },
1812         emit      => '. fabs',
1813         attr_type => "ia32_x87_attr_t",
1814 },
1815
1816 fchs => {
1817         op_flags  => "R|K",
1818         rd_constructor => "NONE",
1819         reg_req   => { },
1820         emit      => '. fchs',
1821         attr_type => "ia32_x87_attr_t",
1822 },
1823
1824 # x87 Load and Store
1825
1826 fld => {
1827         rd_constructor => "NONE",
1828         op_flags  => "R|L|F",
1829         state     => "exc_pinned",
1830         reg_req   => { },
1831         emit      => '. fld%XM %AM',
1832         attr_type => "ia32_x87_attr_t",
1833 },
1834
1835 fst => {
1836         rd_constructor => "NONE",
1837         op_flags  => "R|L|F",
1838         state     => "exc_pinned",
1839         reg_req   => { },
1840         emit      => '. fst%XM %AM',
1841         mode      => "mode_M",
1842         attr_type => "ia32_x87_attr_t",
1843 },
1844
1845 fstp => {
1846         rd_constructor => "NONE",
1847         op_flags  => "R|L|F",
1848         state     => "exc_pinned",
1849         reg_req   => { },
1850         emit      => '. fstp%XM %AM',
1851         mode      => "mode_M",
1852         attr_type => "ia32_x87_attr_t",
1853 },
1854
1855 # Conversions
1856
1857 fild => {
1858         op_flags  => "R",
1859         rd_constructor => "NONE",
1860         reg_req   => { },
1861         emit      => '. fild%XM %AM',
1862         attr_type => "ia32_x87_attr_t",
1863 },
1864
1865 fist => {
1866         op_flags  => "R",
1867         state     => "exc_pinned",
1868         rd_constructor => "NONE",
1869         reg_req   => { },
1870         emit      => '. fist%XM %AM',
1871         mode      => "mode_M",
1872         attr_type => "ia32_x87_attr_t",
1873 },
1874
1875 fistp => {
1876         op_flags  => "R",
1877         state     => "exc_pinned",
1878         rd_constructor => "NONE",
1879         reg_req   => { },
1880         emit      => '. fistp%XM %AM',
1881         mode      => "mode_M",
1882         attr_type => "ia32_x87_attr_t",
1883 },
1884
1885 # constants
1886
1887 fldz => {
1888         op_flags  => "R|c|K",
1889         irn_flags  => "R",
1890         reg_req   => { },
1891         emit      => '. fldz',
1892         attr_type => "ia32_x87_attr_t",
1893 },
1894
1895 fld1 => {
1896         op_flags  => "R|c|K",
1897         irn_flags  => "R",
1898         reg_req   => { },
1899         emit      => '. fld1',
1900         attr_type => "ia32_x87_attr_t",
1901 },
1902
1903 fldpi => {
1904         op_flags  => "R|c|K",
1905         irn_flags  => "R",
1906         reg_req   => { },
1907         emit      => '. fldpi',
1908         attr_type => "ia32_x87_attr_t",
1909 },
1910
1911 fldln2 => {
1912         op_flags  => "R|c|K",
1913         irn_flags  => "R",
1914         reg_req   => { },
1915         emit      => '. fldln2',
1916         attr_type => "ia32_x87_attr_t",
1917 },
1918
1919 fldlg2 => {
1920         op_flags  => "R|c|K",
1921         irn_flags  => "R",
1922         reg_req   => { },
1923         emit      => '. fldlg2',
1924         attr_type => "ia32_x87_attr_t",
1925 },
1926
1927 fldl2t => {
1928         op_flags  => "R|c|K",
1929         irn_flags  => "R",
1930         reg_req   => { },
1931         emit      => '. fldll2t',
1932         attr_type => "ia32_x87_attr_t",
1933 },
1934
1935 fldl2e => {
1936         op_flags  => "R|c|K",
1937         irn_flags  => "R",
1938         reg_req   => { },
1939         emit      => '. fldl2e',
1940         attr_type => "ia32_x87_attr_t",
1941 },
1942
1943 # fxch, fpush, fpop
1944 # Note that it is NEVER allowed to do CSE on these nodes
1945 # Moreover, note the virtual register requierements!
1946
1947 fxch => {
1948         op_flags  => "R|K",
1949         reg_req   => { },
1950         cmp_attr  => "return 1;",
1951         emit      => '. fxch %X0',
1952         attr_type => "ia32_x87_attr_t",
1953 },
1954
1955 fpush => {
1956         op_flags  => "R|K",
1957         reg_req   => {},
1958         cmp_attr  => "return 1;",
1959         emit      => '. fld %X0',
1960         attr_type => "ia32_x87_attr_t",
1961 },
1962
1963 fpushCopy => {
1964         op_flags  => "R",
1965         reg_req   => { in => [ "vfp"], out => [ "vfp" ] },
1966         cmp_attr  => "return 1;",
1967         emit      => '. fld %X0',
1968         attr_type => "ia32_x87_attr_t",
1969 },
1970
1971 fpop => {
1972         op_flags  => "R|K",
1973         reg_req   => { },
1974         cmp_attr  => "return 1;",
1975         emit      => '. fstp %X0',
1976         attr_type => "ia32_x87_attr_t",
1977 },
1978
1979 # compare
1980
1981 fcomJmp => {
1982         op_flags  => "L|X|Y",
1983         reg_req   => { },
1984         attr_type => "ia32_x87_attr_t",
1985 },
1986
1987 fcompJmp => {
1988         op_flags  => "L|X|Y",
1989         reg_req   => { },
1990         attr_type => "ia32_x87_attr_t",
1991 },
1992
1993 fcomppJmp => {
1994         op_flags  => "L|X|Y",
1995         reg_req   => { },
1996         attr_type => "ia32_x87_attr_t",
1997 },
1998
1999 fcomrJmp => {
2000         op_flags  => "L|X|Y",
2001         reg_req   => { },
2002         attr_type => "ia32_x87_attr_t",
2003 },
2004
2005 fcomrpJmp => {
2006         op_flags  => "L|X|Y",
2007         reg_req   => { },
2008         attr_type => "ia32_x87_attr_t",
2009 },
2010
2011 fcomrppJmp => {
2012         op_flags  => "L|X|Y",
2013         reg_req   => { },
2014         attr_type => "ia32_x87_attr_t",
2015 },
2016
2017
2018 # -------------------------------------------------------------------------------- #
2019 #  ____ ____  _____                  _                               _             #
2020 # / ___/ ___|| ____| __   _____  ___| |_ ___  _ __   _ __   ___   __| | ___  ___   #
2021 # \___ \___ \|  _|   \ \ / / _ \/ __| __/ _ \| '__| | '_ \ / _ \ / _` |/ _ \/ __|  #
2022 #  ___) |__) | |___   \ V /  __/ (__| || (_) | |    | | | | (_) | (_| |  __/\__ \  #
2023 # |____/____/|_____|   \_/ \___|\___|\__\___/|_|    |_| |_|\___/ \__,_|\___||___/  #
2024 #                                                                                  #
2025 # -------------------------------------------------------------------------------- #
2026
2027
2028 # Spilling and reloading of SSE registers, hardcoded, not generated #
2029
2030 xxLoad => {
2031         op_flags  => "L|F",
2032         state     => "exc_pinned",
2033         reg_req   => { in => [ "gp", "gp", "none" ], out => [ "xmm", "none" ] },
2034         emit      => '. movdqu %D0, %AM',
2035         outs      => [ "res", "M" ],
2036         units     => [ "SSE" ],
2037 },
2038
2039 xxStore => {
2040         op_flags => "L|F",
2041         state    => "exc_pinned",
2042         reg_req  => { in => [ "gp", "gp", "xmm", "none" ] },
2043         emit     => '. movdqu %binop',
2044         units    => [ "SSE" ],
2045         mode     => "mode_M",
2046 },
2047
2048 ); # end of %nodes
2049
2050 # Include the generated SIMD node specification written by the SIMD optimization
2051 $my_script_name = dirname($myname) . "/../ia32/ia32_simd_spec.pl";
2052 unless ($return = do $my_script_name) {
2053         warn "couldn't parse $my_script_name: $@" if $@;
2054         warn "couldn't do $my_script_name: $!"    unless defined $return;
2055         warn "couldn't run $my_script_name"       unless $return;
2056 }