SB1 => "${arch}_emit_8bit_source_register_or_immediate(node, 1);",
SB2 => "${arch}_emit_8bit_source_register_or_immediate(node, 2);",
SB3 => "${arch}_emit_8bit_source_register_or_immediate(node, 3);",
+ SI1 => "${arch}_emit_source_register_or_immediate(node, 1);",
SI3 => "${arch}_emit_source_register_or_immediate(node, 3);",
D0 => "${arch}_emit_dest_register(node, 0);",
D1 => "${arch}_emit_dest_register(node, 1);",
unop3 => "${arch}_emit_unop(node, 3);",
unop4 => "${arch}_emit_unop(node, 4);",
unop5 => "${arch}_emit_unop(node, 5);",
- DAM0 => "${arch}_emit_am_or_dest_register(node, 0);",
binop => "${arch}_emit_binop(node);",
x87_binop => "${arch}_emit_x87_binop(node);",
CMP0 => "${arch}_emit_cmp_suffix_node(node, 0);",
}
if(defined($node->{am})) {
my $am = $node->{am};
- if($am eq "full,binary") {
- $res .= "\tset_ia32_am_support(res, ia32_am_Full, ia32_am_binary);";
- } elsif($am eq "full,unary") {
- $res .= "\tset_ia32_am_support(res, ia32_am_Full, ia32_am_unary);";
- } elsif($am eq "source,unary") {
+ if($am eq "source,unary") {
$res .= "\tset_ia32_am_support(res, ia32_am_Source, ia32_am_unary);";
} elsif($am eq "source,binary") {
$res .= "\tset_ia32_am_support(res, ia32_am_Source, ia32_am_binary);";
- } elsif($am eq "dest,unary") {
- $res .= "\tset_ia32_am_support(res, ia32_am_Dest, ia32_am_unary);";
- } elsif($am eq "dest,binary") {
- $res .= "\tset_ia32_am_support(res, ia32_am_Dest, ia32_am_binary);";
- } elsif($am eq "dest,ternary") {
- $res .= "\tset_ia32_am_support(res, ia32_am_Dest, ia32_am_ternary);";
} elsif($am eq "source,ternary") {
$res .= "\tset_ia32_am_support(res, ia32_am_Source, ia32_am_ternary);";
} elsif($am eq "none") {
Add => {
irn_flags => "R",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ], out => [ "in_r4 in_r5", "none", "flags" ] },
+ reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ],
+ out => [ "in_r4 in_r5", "flags", "none" ] },
ins => [ "base", "index", "mem", "left", "right" ],
+ outs => [ "res", "flags", "M" ],
emit => '. add%M %binop',
- am => "full,binary",
+ am => "source,binary",
units => [ "GP" ],
latency => 1,
mode => $mode_gp,
Adc => {
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "gp", "gp", "flags" ], out => [ "in_r4 in_r5" ] },
+ reg_req => { in => [ "gp", "gp", "none", "gp", "gp", "flags" ],
+ out => [ "in_r4 in_r5", "flags", "none" ] },
ins => [ "base", "index", "mem", "left", "right", "eflags" ],
+ outs => [ "res", "flags", "M" ],
emit => '. adc%M %binop',
- am => "full,binary",
+ am => "source,binary",
units => [ "GP" ],
latency => 1,
mode => $mode_gp,
# we should not rematrialize this node. It produces 2 results and has
# very strict constrains
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "eax", "gp" ], out => [ "eax", "edx", "none" ] },
+ reg_req => { in => [ "gp", "gp", "none", "eax", "gp" ],
+ out => [ "eax", "edx", "none" ] },
ins => [ "base", "index", "mem", "val_high", "val_low" ],
emit => '. mul%M %unop4',
- outs => [ "EAX", "EDX", "M" ],
+ outs => [ "res_low", "res_high", "M" ],
am => "source,binary",
latency => 10,
units => [ "GP" ],
# TODO: adjust out requirements for the 3 operand form
# (no need for should_be_same then)
reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ],
- out => [ "in_r4 in_r5", "none", "flags" ] },
+ out => [ "in_r4 in_r5", "flags", "none" ] },
ins => [ "base", "index", "mem", "left", "right" ],
- outs => [ "res", "M", "flags" ],
+ outs => [ "res", "flags", "M" ],
am => "source,binary",
latency => 5,
units => [ "GP" ],
IMul1OP => {
irn_flags => "R",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "eax", "gp" ], out => [ "eax", "edx", "none" ] },
+ reg_req => { in => [ "gp", "gp", "none", "eax", "gp" ],
+ out => [ "eax", "edx", "none" ] },
ins => [ "base", "index", "mem", "val_high", "val_low" ],
emit => '. imul%M %unop4',
- outs => [ "EAX", "EDX", "M" ],
+ outs => [ "res_low", "res_high", "M" ],
am => "source,binary",
latency => 5,
units => [ "GP" ],
},
l_IMul => {
- # we should not rematrialize this node. It produces 2 results and has
- # very strict constrains
op_flags => "C",
cmp_attr => "return 1;",
- outs => [ "EAX", "EDX", "M" ],
+ outs => [ "res_low", "res_high", "M" ],
arity => 2
},
And => {
irn_flags => "R",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ], out => [ "in_r4 in_r5" ] },
+ reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ],
+ out => [ "in_r4 in_r5", "flags", "none" ] },
ins => [ "base", "index", "mem", "left", "right" ],
+ outs => [ "res", "flags", "M" ],
op_modes => "commutative | am | immediate | mode_neutral",
- am => "full,binary",
+ am => "source,binary",
emit => '. and%M %binop',
units => [ "GP" ],
latency => 1,
Or => {
irn_flags => "R",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ], out => [ "in_r4 in_r5" ] },
+ reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ],
+ out => [ "in_r4 in_r5", "flags", "none" ] },
ins => [ "base", "index", "mem", "left", "right" ],
- am => "full,binary",
+ outs => [ "res", "flags", "M" ],
+ am => "source,binary",
emit => '. or%M %binop',
units => [ "GP" ],
latency => 1,
Xor => {
irn_flags => "R",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ], out => [ "in_r4 in_r5" ] },
+ reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ],
+ out => [ "in_r4 in_r5", "flags", "none" ] },
ins => [ "base", "index", "mem", "left", "right" ],
- am => "full,binary",
+ outs => [ "res", "flags", "M" ],
+ am => "source,binary",
emit => '. xor%M %binop',
units => [ "GP" ],
latency => 1,
Sub => {
irn_flags => "R",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ], out => [ "in_r4", "none", "flags" ] },
+ reg_req => { in => [ "gp", "gp", "none", "gp", "gp" ],
+ out => [ "in_r4", "flags", "none" ] },
ins => [ "base", "index", "mem", "left", "right" ],
- am => "full,binary",
+ outs => [ "res", "flags", "M" ],
+ am => "source,binary",
emit => '. sub%M %binop',
units => [ "GP" ],
latency => 1,
Sbb => {
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "gp", "gp", "flags" ], out => [ "in_r4 !in_r5" ] },
+ reg_req => { in => [ "gp", "gp", "none", "gp", "gp", "flags" ],
+ out => [ "in_r4 !in_r5", "flags", "none" ] },
ins => [ "base", "index", "mem", "left", "right", "eflags" ],
- am => "full,binary",
+ outs => [ "res", "flags", "M" ],
+ am => "source,binary",
emit => '. sbb%M %binop',
units => [ "GP" ],
latency => 1,
IDiv => {
op_flags => "F|L",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "eax", "edx", "gp" ], out => [ "eax", "none", "none", "edx" ] },
+ reg_req => { in => [ "gp", "gp", "none", "eax", "edx", "gp" ],
+ out => [ "eax", "flags", "none", "edx", "none" ] },
ins => [ "base", "index", "mem", "left_low", "left_high", "right" ],
- outs => [ "div_res", "M", "unused", "mod_res" ],
+ outs => [ "div_res", "flags", "M", "mod_res", "X_exc" ],
am => "source,ternary",
emit => ". idiv%M %unop5",
latency => 25,
Div => {
op_flags => "F|L",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "eax", "edx", "gp" ], out => [ "eax", "none", "none", "edx" ] },
+ reg_req => { in => [ "gp", "gp", "none", "eax", "edx", "gp" ],
+ out => [ "eax", "flags", "none", "edx", "none" ] },
ins => [ "base", "index", "mem", "left_low", "left_high", "right" ],
- outs => [ "div_res", "M", "unused", "mod_res" ],
+ outs => [ "div_res", "flags", "M", "mod_res", "X_exc" ],
am => "source,ternary",
emit => ". div%M %unop5",
latency => 25,
Shl => {
irn_flags => "R",
- reg_req => { in => [ "gp", "ecx" ], out => [ "in_r1 !in_r2" ] },
- ins => [ "left", "right" ],
+ reg_req => { in => [ "gp", "ecx" ],
+ out => [ "in_r1 !in_r2", "flags" ] },
+ ins => [ "val", "count" ],
+ outs => [ "res", "flags" ],
emit => '. shl %SB1, %S0',
units => [ "GP" ],
latency => 1,
},
l_ShlDep => {
- cmp_attr => "return 1;",
- ins => [ "left", "right", "dep" ],
- # value, cnt, dependency
- arity => 3
+ cmp_attr => "return 1;",
+ ins => [ "val", "count", "dep" ],
+ arity => 3
},
ShlD => {
irn_flags => "R",
- reg_req => { in => [ "gp", "gp", "ecx" ], out => [ "in_r1 !in_r2 !in_r3" ] },
- ins => [ "left_high", "left_low", "right" ],
+ reg_req => { in => [ "gp", "gp", "ecx" ],
+ out => [ "in_r1 !in_r2 !in_r3", "flags" ] },
+ ins => [ "val_high", "val_low", "count" ],
+ outs => [ "res", "flags" ],
emit => ". shld%M %SB2, %S1, %D0",
latency => 6,
units => [ "GP" ],
l_ShlD => {
cmp_attr => "return 1;",
- ins => [ "high", "low", "count" ],
+ ins => [ "val_high", "val_low", "count" ],
arity => 3,
},
Shr => {
irn_flags => "R",
- reg_req => { in => [ "gp", "ecx" ], out => [ "in_r1 !in_r2" ] },
+ reg_req => { in => [ "gp", "ecx" ],
+ out => [ "in_r1 !in_r2", "flags" ] },
ins => [ "val", "count" ],
+ outs => [ "res", "flags" ],
emit => '. shr %SB1, %S0',
units => [ "GP" ],
mode => $mode_gp,
l_ShrDep => {
cmp_attr => "return 1;",
- ins => [ "left", "right", "dep" ],
- # value, cnt, dependency
+ ins => [ "val", "count", "dep" ],
arity => 3
},
ShrD => {
irn_flags => "R",
- reg_req => { in => [ "gp", "gp", "ecx" ], out => [ "in_r1 !in_r2 !in_r3" ] },
- ins => [ "left_high", "left_low", "right" ],
+ reg_req => { in => [ "gp", "gp", "ecx" ],
+ out => [ "in_r1 !in_r2 !in_r3", "flags" ] },
+ ins => [ "val_high", "val_low", "count" ],
+ outs => [ "res", "flags" ],
emit => ". shrd%M %SB2, %S1, %D0",
latency => 6,
units => [ "GP" ],
l_ShrD => {
cmp_attr => "return 1;",
arity => 3,
- ins => [ "high", "low", "count" ],
+ ins => [ "val_high", "val_low", "count" ],
},
Sar => {
irn_flags => "R",
- reg_req => { in => [ "gp", "ecx" ], out => [ "in_r1 !in_r2" ] },
+ reg_req => { in => [ "gp", "ecx" ],
+ out => [ "in_r1 !in_r2", "flags" ] },
ins => [ "val", "count" ],
+ outs => [ "res", "flags" ],
emit => '. sar %SB1, %S0',
units => [ "GP" ],
latency => 1,
l_SarDep => {
cmp_attr => "return 1;",
- ins => [ "left", "right", "dep" ],
- # value, cnt, dependency
+ ins => [ "val", "count", "dep" ],
arity => 3
},
Ror => {
irn_flags => "R",
- reg_req => { in => [ "gp", "ecx" ], out => [ "in_r1 !in_r2" ] },
+ reg_req => { in => [ "gp", "ecx" ],
+ out => [ "in_r1 !in_r2", "flags" ] },
ins => [ "val", "count" ],
+ outs => [ "res", "flags" ],
emit => '. ror %SB1, %S0',
units => [ "GP" ],
latency => 1,
Rol => {
irn_flags => "R",
- reg_req => { in => [ "gp", "ecx" ], out => [ "in_r1 !in_r2" ] },
+ reg_req => { in => [ "gp", "ecx" ],
+ out => [ "in_r1 !in_r2", "flags" ] },
ins => [ "val", "count" ],
+ outs => [ "res", "flags" ],
emit => '. rol %SB1, %S0',
units => [ "GP" ],
latency => 1,
Neg => {
irn_flags => "R",
- reg_req => { in => [ "gp" ], out => [ "in_r1" ] },
+ reg_req => { in => [ "gp" ],
+ out => [ "in_r1", "flags" ] },
emit => '. neg %S0',
ins => [ "val" ],
+ outs => [ "res", "flags" ],
units => [ "GP" ],
latency => 1,
mode => $mode_gp,
Inc => {
irn_flags => "R",
- reg_req => { in => [ "gp" ], out => [ "in_r1" ] },
+ reg_req => { in => [ "gp" ],
+ out => [ "in_r1", "flags" ] },
+ outs => [ "res", "flags" ],
emit => '. inc %S0',
units => [ "GP" ],
mode => $mode_gp,
Dec => {
irn_flags => "R",
- reg_req => { in => [ "gp" ], out => [ "in_r1" ] },
+ reg_req => { in => [ "gp" ],
+ out => [ "in_r1", "flags" ] },
+ outs => [ "res", "flags" ],
emit => '. dec %S0',
units => [ "GP" ],
mode => $mode_gp,
Not => {
irn_flags => "R",
- reg_req => { in => [ "gp" ], out => [ "in_r1" ] },
+ reg_req => { in => [ "gp" ],
+ out => [ "in_r1", "flags" ] },
ins => [ "val" ],
+ outs => [ "res", "flags" ],
emit => '. not %S0',
units => [ "GP" ],
latency => 1,
mode => $mode_gp,
+ # no flags modified
},
NotMem => {
units => [ "GP" ],
latency => 1,
mode => "mode_M",
+ # no flags modified
+},
+
+Cmc => {
+ reg_req => { in => [ "flags" ], out => [ "flags" ] },
+ emit => '.cmc',
+ units => [ "GP" ],
+ latency => 1,
+ mode => $mode_flags,
+ modified_flags => $status_flags
+},
+
+Stc => {
+ reg_req => { out => [ "flags" ] },
+ emit => '.stc',
+ units => [ "GP" ],
+ latency => 1,
+ mode => $mode_flags,
+ modified_flags => $status_flags
},
# other operations
mode => $mode_gp,
},
+GetEIP => {
+ op_flags => "c",
+ reg_req => { out => [ "gp" ] },
+ units => [ "GP" ],
+ latency => 5,
+ mode => $mode_gp,
+ modified_flags => $status_flags,
+},
+
Unknown_GP => {
state => "pinned",
op_flags => "c",
Load => {
op_flags => "L|F",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none" ], out => [ "gp", "none" ] },
+ reg_req => { in => [ "gp", "gp", "none" ], out => [ "gp", "none", "none" ] },
ins => [ "base", "index", "mem" ],
- outs => [ "res", "M" ],
+ outs => [ "res", "M", "X_exc" ],
latency => 0,
emit => ". mov%SE%ME%.l %AM, %D0",
units => [ "GP" ],
Store => {
op_flags => "L|F",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "gp" ], out => [ "none" ] },
+ reg_req => { in => [ "gp", "gp", "none", "gp" ], out => [ "none", "none" ] },
ins => [ "base", "index", "mem", "val" ],
+ outs => [ "M", "X_exc" ],
emit => '. mov%M %SI3, %AM',
latency => 2,
units => [ "GP" ],
Store8Bit => {
op_flags => "L|F",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "eax ebx ecx edx" ], out => ["none" ] },
+ reg_req => { in => [ "gp", "gp", "none", "eax ebx ecx edx" ], out => ["none", "none" ] },
ins => [ "base", "index", "mem", "val" ],
+ outs => [ "M", "X_exc" ],
emit => '. mov%M %SB3, %AM',
latency => 2,
units => [ "GP" ],
Push => {
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "esp", "gp" ], out => [ "esp", "none" ] },
+ reg_req => { in => [ "gp", "gp", "none", "gp", "esp" ], out => [ "esp", "none" ] },
ins => [ "base", "index", "mem", "val", "stack" ],
- emit => '. push%M %unop4',
+ emit => '. push%M %unop3',
outs => [ "stack:I|S", "M" ],
am => "source,binary",
latency => 2,
Pop => {
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "esp" ], out => [ "gp", "none", "none", "esp" ] },
- emit => '. pop%M %DAM0',
+ reg_req => { in => [ "none", "esp" ], out => [ "gp", "none", "none", "esp" ] },
+ ins => [ "mem", "stack" ],
outs => [ "res", "M", "unused", "stack:I|S" ],
+ emit => '. pop%M %D0',
+ latency => 3, # Pop is more expensive than Push on Athlon
+ units => [ "GP" ],
+},
+
+PopMem => {
+ state => "exc_pinned",
+ reg_req => { in => [ "gp", "gp", "none", "esp" ], out => [ "none", "none", "none", "esp" ] },
ins => [ "base", "index", "mem", "stack" ],
- am => "dest,unary",
+ outs => [ "unused0", "M", "unused1", "stack:I|S" ],
+ emit => '. pop%M %AM',
latency => 3, # Pop is more expensive than Push on Athlon
units => [ "GP" ],
},
am => "source,binary",
emit => '. addl %binop',
latency => 1,
- outs => [ "stack:S", "M" ],
+ outs => [ "stack:I|S", "M" ],
units => [ "GP" ],
modified_flags => $status_flags
},
modified_flags => $status_flags
},
+RepPrefix => {
+ op_flags => "K",
+ state => "pinned",
+ mode => "mode_M",
+ emit => ". rep",
+ latency => 0,
+},
+
LdTls => {
irn_flags => "R",
reg_req => { out => [ "gp" ] },
# |_____/_____/|______| |_| |_|\___/ \__,_|\__| |_| |_|\___/ \__,_|\___||___/ #
#-----------------------------------------------------------------------------#
+# produces a 0/+0.0
xZero => {
irn_flags => "R",
reg_req => { out => [ "xmm" ] },
mode => "mode_E",
},
+# produces all 1 bits
+xAllOnes => {
+ irn_flags => "R",
+ reg_req => { out => [ "xmm" ] },
+ emit => '. pcmpeqb %D0, %D0',
+ latency => 3,
+ units => [ "SSE" ],
+ mode => "mode_E",
+},
+
+# integer shift left, dword
+xPslld => {
+ irn_flags => "R",
+ reg_req => { in => [ "xmm", "xmm" ], out => [ "in_r1 !in_r2" ] },
+ emit => '. pslld %SI1, %D0',
+ units => [ "SSE" ],
+ mode => "mode_E",
+ latency => 3,
+},
+
+# integer shift left, qword
+xPsllq => {
+ irn_flags => "R",
+ reg_req => { in => [ "xmm", "xmm" ], out => [ "in_r1 !in_r2" ] },
+ emit => '. psllq %SI1, %D0',
+ units => [ "SSE" ],
+ mode => "mode_E",
+ latency => 3,
+},
+
+# integer shift right, dword
+xPsrld => {
+ irn_flags => "R",
+ reg_req => { in => [ "xmm", "xmm" ], out => [ "in_r1 !in_r2" ] },
+ emit => '. psrld %SI1, %D0',
+ units => [ "SSE" ],
+ mode => "mode_E",
+ latency => 1,
+},
+
+# mov from integer to SSE register
+xMovd => {
+ irn_flags => "R",
+ reg_req => { in => [ "gp" ], out => [ "xmm" ] },
+ emit => '. movd %S0, %D0',
+ units => [ "SSE" ],
+ mode => "mode_E",
+ latency => 1,
+},
+
# commutative operations
xAdd => {
xLoad => {
op_flags => "L|F",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none" ], out => [ "xmm", "none" ] },
+ reg_req => { in => [ "gp", "gp", "none" ], out => [ "xmm", "none", "none" ] },
ins => [ "base", "index", "mem" ],
+ outs => [ "res", "M", "X_exc" ],
emit => '. mov%XXM %AM, %D0',
attr => "ir_mode *load_mode",
init_attr => "attr->ls_mode = load_mode;",
- outs => [ "res", "M" ],
latency => 0,
units => [ "SSE" ],
},
xStore => {
op_flags => "L|F",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "xmm" ] },
+ reg_req => { in => [ "gp", "gp", "none", "xmm" ], out => [ "none", "none" ] },
ins => [ "base", "index", "mem", "val" ],
+ outs => [ "M", "X_exc" ],
emit => '. mov%XXM %S3, %AM',
latency => 0,
units => [ "SSE" ],
},
-l_X87toSSE => {
+l_LLtoFloat => {
op_flags => "L|F",
cmp_attr => "return 1;",
- arity => 3,
+ ins => [ "val_high", "val_low" ],
},
-l_SSEtoX87 => {
+l_FloattoLL => {
op_flags => "L|F",
cmp_attr => "return 1;",
- arity => 3,
+ ins => [ "val" ],
+ outs => [ "res_high", "res_low" ],
},
# CopyB
irn_flags => "R",
op_flags => "L|F",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none" ], out => [ "vfp", "none" ] },
+ reg_req => { in => [ "gp", "gp", "none" ], out => [ "vfp", "none", "none" ] },
ins => [ "base", "index", "mem" ],
- outs => [ "res", "M" ],
+ outs => [ "res", "M", "X_exc" ],
attr => "ir_mode *load_mode",
init_attr => "attr->attr.ls_mode = load_mode;",
latency => 2,
irn_flags => "R",
op_flags => "L|F",
state => "exc_pinned",
- reg_req => { in => [ "gp", "gp", "none", "vfp" ] },
+ reg_req => { in => [ "gp", "gp", "none", "vfp" ], out => [ "none", "none" ] },
ins => [ "base", "index", "mem", "val" ],
+ outs => [ "M", "X_exc" ],
attr => "ir_mode *store_mode",
init_attr => "attr->attr.ls_mode = store_mode;",
latency => 2,
FucomFnstsw => {
reg_req => { },
emit => ". fucom %X1\n".
- ". fnstsw",
+ ". fnstsw %%ax",
attr_type => "ia32_x87_attr_t",
latency => 2,
},
FucompFnstsw => {
reg_req => { },
emit => ". fucomp %X1\n".
- ". fnstsw",
+ ". fnstsw %%ax",
attr_type => "ia32_x87_attr_t",
latency => 2,
},
FucomppFnstsw => {
reg_req => { },
emit => ". fucompp\n".
- ". fnstsw",
+ ". fnstsw %%ax",
attr_type => "ia32_x87_attr_t",
latency => 2,
},
FtstFnstsw => {
reg_req => { },
emit => ". ftst\n".
- ". fnstsw",
+ ". fnstsw %%ax",
attr_type => "ia32_x87_attr_t",
latency => 2,
},
$node->{op_attr_init} = $op_attr_init;
}
-print "ok";
+print "";
projects / libfirm / blobdiff