ia32_spec.pl

# This is the specification for the ia32 assembler Firm-operations

# Note on Proj numbers:
# If possible, Nodes should follow these rules for assigning proj numbers:
# "Normal" instructions:
#  0 => result
#  1 => flags
#  2 => memory
# instructions with destination address mode:
#  0 => unused
#  1 => flags
#  2 => memory

$arch = "ia32";

$mode_xmm   = "ia32_mode_float64";
$mode_fp87  = "ia32_mode_E";
$mode_gp    = "ia32_mode_gp";
$mode_flags = "ia32_mode_flags";
$mode_fpcw  = "ia32_mode_fpcw";

%reg_classes = (
	gp => [
		{ name => "edx", encoding => 2, dwarf => 2 },
		{ name => "ecx", encoding => 1, dwarf => 1 },
		{ name => "eax", encoding => 0, dwarf => 0 },
		{ name => "ebx", encoding => 3, dwarf => 3 },
		{ name => "esi", encoding => 6, dwarf => 6 },
		{ name => "edi", encoding => 7, dwarf => 7 },
		{ name => "ebp", encoding => 5, dwarf => 5 },
		{ name => "esp", encoding => 4, dwarf => 4 },
		{ name => "gp_NOREG", type => "virtual" }, # we need a dummy register for NoReg nodes
		{ mode => $mode_gp }
	],
	xmm => [
		{ name => "xmm0", dwarf => 21 },
		{ name => "xmm1", dwarf => 22 },
		{ name => "xmm2", dwarf => 23 },
		{ name => "xmm3", dwarf => 24 },
		{ name => "xmm4", dwarf => 25 },
		{ name => "xmm5", dwarf => 26 },
		{ name => "xmm6", dwarf => 27 },
		{ name => "xmm7", dwarf => 28 },
		{ name => "xmm_NOREG", type => "virtual" }, # we need a dummy register for NoReg nodes
		{ mode => $mode_xmm }
	],
	fp => [
		{ name => "st0", realname => "st",    encoding => 0, dwarf => 11 },
		{ name => "st1", realname => "st(1)", encoding => 1, dwarf => 12 },
		{ name => "st2", realname => "st(2)", encoding => 2, dwarf => 13 },
		{ name => "st3", realname => "st(3)", encoding => 3, dwarf => 14 },
		{ name => "st4", realname => "st(4)", encoding => 4, dwarf => 15 },
		{ name => "st5", realname => "st(5)", encoding => 5, dwarf => 16 },
		{ name => "st6", realname => "st(6)", encoding => 6, dwarf => 17 },
		{ name => "st7", realname => "st(7)", encoding => 7, dwarf => 18 },
		{ name => "fp_NOREG", type => "virtual" }, # we need a dummy register for NoReg nodes
		{ mode => $mode_fp87 }
	],
	fp_cw => [	# the floating point control word
		{ name => "fpcw", dwarf => 37 },
		{ mode => $mode_fpcw, flags => "manual_ra" }
	],
	flags => [
		{ name => "eflags", dwarf => 9 },
		{ mode => "ia32_mode_flags", flags => "manual_ra" }
	],
);

$default_attr_type = "ia32_attr_t";
$default_copy_attr = "ia32_copy_attr";

sub ia32_custom_init_attr {
	my ($constr, $node, $name) = @_;

	my $res = "";
	my $am  = $node->{am};
	if (defined($am)) {
		if ($am eq "source,unary") {
			$res .= "\tset_ia32_am_support(res, ia32_am_unary);";
		} elsif ($am eq "source,binary") {
			$res .= "\tset_ia32_am_support(res, ia32_am_binary);";
		} elsif ($am eq "none") {
			# nothing to do
		} else {
			die("Invalid address mode '$am' specified on op $name");
		}
		if ($am ne "none" && $node->{state} ne "exc_pinned" && $node->{state} ne "pinned") {
			die("AM nodes must have pinned or AM pinned state ($name)");
		}
	}
	return $res;
}
$custom_init_attr_func = \&ia32_custom_init_attr;

%init_attr = (
	ia32_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res);",
	ia32_call_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res);\n".
		"\tinit_ia32_call_attributes(res, pop, call_tp);",
	ia32_condcode_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res);\n".
		"\tinit_ia32_condcode_attributes(res, condition_code);",
	ia32_switch_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res);\n".
		"\tinit_ia32_switch_attributes(res, switch_table);",
	ia32_copyb_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res);\n".
		"\tinit_ia32_copyb_attributes(res, size);",
	ia32_immediate_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res);\n".
		"\tinit_ia32_immediate_attributes(res, imm);",
	ia32_x87_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res);\n".
		"\tinit_ia32_x87_attributes(res);",
	ia32_climbframe_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res);\n".
		"\tinit_ia32_climbframe_attributes(res, count);",
	ia32_return_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res);\n".
		"\tinit_ia32_return_attributes(res, pop);",
);

my $x87sim = "ia32_request_x87_sim(irg);";

my $binop_commutative = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem", "gp", "gp" ],
	out_reqs  => [ "in_r4 in_r5", "flags", "mem" ],
	ins       => [ "base", "index", "mem", "left", "right" ],
	outs      => [ "res", "flags", "M" ],
	am        => "source,binary",
	mode      => "first",
};

my $binop_flags = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	state     => "exc_pinned",
	constructors => {
		""     => { in_reqs => [ "gp", "gp", "mem", "gp", "gp" ], },
		"8bit" => { in_reqs => [ "gp", "gp", "mem", "eax ebx ecx edx", "eax ebx ecx edx" ], }
	},
	out_reqs  => [ "flags", "none", "mem" ],
	ins       => [ "base", "index", "mem", "left", "right" ],
	outs      => [ "eflags", "unused", "M" ],
	am        => "source,binary",
	attr      => "bool ins_permuted",
	init      => "attr->ins_permuted = ins_permuted;",
	mode      => "first",
};

my $binop_mem = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	state     => "exc_pinned",
	constructors => {
		""     => { in_reqs => [ "gp", "gp", "mem", "gp" ] },
		"8bit" => { in_reqs => [ "gp", "gp", "mem", "eax ebx ecx edx" ] },
	},
	out_reqs  => [ "none", "flags", "mem" ],
	ins       => [ "base", "index", "mem", "val" ],
	outs      => [ "unused", "flags", "M" ],
};

my $shiftop = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	in_reqs   => [ "gp", "ecx" ],
	out_reqs  => [ "in_r1 !in_r2", "flags" ],
	ins       => [ "val", "count" ],
	outs      => [ "res", "flags" ],
	mode      => "first",
};

my $shiftop_mem = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem", "ecx" ],
	out_reqs  => [ "none", "flags", "mem" ],
	ins       => [ "base", "index", "mem", "count" ],
	outs      => [ "unused", "flags", "M" ],
};

my $shiftop_double = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	in_reqs   => [ "gp", "gp", "ecx" ],
	constructors => {
		""  => { out_reqs  => [ "in_r1 !in_r2 !in_r3", "flags" ] },
		# With an immediate shift amount we can swap between ShlD/ShrD and negate
		# the shift amount, if the output gets the same register as the second
		# input.
		imm => { out_reqs  => [ "in_r1 in_r2",         "flags" ] },
	},
	ins       => [ "val_high", "val_low", "count" ],
	outs      => [ "res", "flags" ],
	mode      => "first",
};

my $divop = {
	op_flags  => [ "fragile", "uses_memory" ],
	irn_flags => [ "modify_flags" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem", "gp", "eax", "edx" ],
	out_reqs  => [ "eax", "flags", "mem", "edx", "exec", "exec" ],
	ins       => [ "base", "index", "mem", "divisor", "dividend_low", "dividend_high" ],
	outs      => [ "div_res", "flags", "M", "mod_res", "X_regular", "X_except" ],
	am        => "source,unary",
};

my $mulop = {
	# we should not rematerialize these nodes. They produce 2 results and have
	# very strict constraints
	irn_flags => [ "modify_flags" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem", "eax", "gp" ],
	out_reqs  => [ "eax", "flags", "mem", "edx" ],
	ins       => [ "base", "index", "mem", "left", "right" ],
	outs      => [ "res_low", "flags", "M", "res_high" ],
	am        => "source,binary",
};

my $unop = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	in_reqs   => [ "gp" ],
	out_reqs  => [ "in_r1", "flags" ],
	ins       => [ "val" ],
	outs      => [ "res", "flags" ],
	mode      => "first",
};

my $unop_no_flags = {
	# no flags modified
	irn_flags => [ "rematerializable" ],
	in_reqs   => [ "gp" ],
	out_reqs  => [ "in_r1" ],
	ins       => [ "val" ],
	outs      => [ "res" ],
};

my $unop_from_mem = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem", "gp" ],
	out_reqs  => [ "gp", "flags", "mem" ],
	ins       => [ "base", "index", "mem", "operand" ],
	outs      => [ "res", "flags", "M" ],
	am        => "source,unary",
	mode      => "first",
};

my $unop_mem = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem" ],
	out_reqs  => [ "none", "flags", "mem" ],
	ins       => [ "base", "index", "mem" ],
	outs      => [ "unused", "flags", "M" ],
};

my $memop = {
	state    => "pinned",
	in_reqs  => [ "mem" ],
	out_reqs => [ "mem" ],
	ins      => [ "mem" ],
};

my $prefetchop = {
	op_flags  => [ "uses_memory" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem" ],
	out_reqs  => [ "mem" ],
	ins       => [ "base", "index", "mem" ],
	outs      => [ "M" ],
};

my $fbinop = {
#	irn_flags => [ "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem", "fp", "fp", "fpcw" ],
	out_reqs  => [ "fp", "none", "mem" ],
	ins       => [ "base", "index", "mem", "left", "right", "fpcw" ],
	outs      => [ "res", "dummy", "M" ],
	am        => "source,binary",
	mode      => "first",
	attr_type => "ia32_x87_attr_t",
};

my $funop = {
	irn_flags => [ "rematerializable" ],
	in_reqs   => [ "fp" ],
	out_reqs  => [ "fp" ],
	ins       => [ "value" ],
	init      => "attr->ls_mode = ia32_mode_E;",
};

my $fconstop = {
	op_flags  => [ "constlike" ],
	irn_flags => [ "rematerializable" ],
	out_reqs  => [ "fp" ],
	outs      => [ "res" ],
	init      => "attr->ls_mode = ia32_mode_E;",
	fixed     => $x87sim,
};

my $valueop = {
	op_flags  => [ "constlike" ],
	irn_flags => [ "rematerializable" ],
	out_reqs  => [ "gp" ],
	outs      => [ "res" ],
};

my $fpopop = {
	op_flags    => [ "keep" ],
	out_reqs    => [ "none" ],
	attrs_equal => "attrs_equal_false",
	attr_type   => "ia32_x87_attr_t",
};

my $xbinop = {
	irn_flags => [ "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem", "xmm", "xmm" ],
	out_reqs  => [ "in_r4 !in_r5", "flags", "mem" ],
	ins       => [ "base", "index", "mem", "left", "right" ],
	outs      => [ "res", "flags", "M" ],
	am        => "source,binary",
	mode      => "first",
};

my $xbinop_commutative = {
	irn_flags => [ "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem", "xmm", "xmm" ],
	out_reqs  => [ "in_r4 in_r5", "flags", "mem" ],
	ins       => [ "base", "index", "mem", "left", "right" ],
	outs      => [ "res", "flags", "M" ],
	am        => "source,binary",
	mode      => "first",
};

my $xconv_i2f = {
	state    => "exc_pinned",
	in_reqs  => [ "gp", "gp", "mem", "gp" ],
	out_reqs => [ "xmm" ],
	ins      => [ "base", "index", "mem", "val" ],
	am       => "source,unary",
};

my $xshiftop = {
	irn_flags => [ "rematerializable" ],
	in_reqs   => [ "xmm", "xmm" ],
	out_reqs  => [ "in_r1 !in_r2" ],
};

my $xvalueop = {
	op_flags  => [ "constlike" ],
	irn_flags => [ "rematerializable" ],
	out_reqs  => [ "xmm" ],
	outs      => [ "res" ],
};

my $carry_user_op = {
	irn_flags => [ "modify_flags" ],
	attr_type => "ia32_condcode_attr_t",
	fixed     => "x86_condition_code_t condition_code = x86_cc_carry;",
};

my $noregop = {
	state     => "pinned",
	op_flags  => [ "constlike", "dump_noblock" ],
	irn_flags => [ "not_scheduled" ],
};

%nodes = (

Immediate => {
	state     => "pinned",
	op_flags  => [ "constlike" ],
	irn_flags => [ "not_scheduled" ],
	out_reqs  => [ "gp_NOREG:I" ],
	attr      => "const x86_imm32_t *imm",
	attr_type => "ia32_immediate_attr_t",
	hash_func => "ia32_hash_Immediate",
	latency   => 0,
},

Add => {
	template => $binop_commutative,
	emit     => "add%M %B",
	latency  => 1,
},

AddMem => {
	template => $binop_mem,
	emit     => "add%M %#S3, %AM",
	latency  => 1,
},

Adc => {
	template => $carry_user_op,
	state    => "exc_pinned",
	in_reqs  => [ "gp", "gp", "mem", "gp", "gp", "flags" ],
	out_reqs => [ "in_r4 in_r5", "flags", "mem" ],
	ins      => [ "base", "index", "mem", "left", "right", "eflags" ],
	outs     => [ "res", "flags", "M" ],
	emit     => "adc%M %B",
	am       => "source,binary",
	latency  => 1,
	mode     => "first",
},

l_Add => {
	ins       => [ "left", "right" ],
	outs      => [ "res", "flags" ],
	attr_type => "",
	dump_func => "NULL",
},

l_Adc => {
	ins       => [ "left", "right", "eflags" ],
	attr_type => "",
	dump_func => "NULL",
},

Mul => {
	template => $mulop,
	emit     => "mul%M %AS4",
	latency  => 10,
},

l_Mul => {
	ins       => [ "left", "right" ],
	outs      => [ "res_low", "flags", "M", "res_high" ],
	attr_type => "",
	dump_func => "NULL",
},

IMul => {
	template => $binop_commutative,
	emit     => "imul%M %B",
	latency  => 5,
},

IMulImm => {
	template => $binop_commutative,
	out_reqs => [ "gp", "flags", "mem" ],
	emit     => "imul%M %#S4, %#AS3, %#D0",
	latency  => 5,
},

IMul1OP => {
	template => $mulop,
	emit     => "imul%M %AS4",
	latency  => 5,
},

l_IMul => {
	ins       => [ "left", "right" ],
	outs      => [ "res_low", "flags", "M", "res_high" ],
	attr_type => "",
	dump_func => "NULL",
},

And => {
	template => $binop_commutative,
	emit     => "and%M %B",
	latency  => 1,
},

AndMem => {
	template => $binop_mem,
	emit     => "and%M %#S3, %AM",
	latency  => 1,
},

Or => {
	template => $binop_commutative,
	emit     => "or%M %B",
	latency  => 1,
},

OrMem => {
	template => $binop_mem,
	emit     => "or%M %#S3, %AM",
	latency  => 1,
},

Xor => {
	template => $binop_commutative,
	emit     => "xor%M %B",
	latency  => 1,
},

Xor0 => {
	op_flags  => [ "constlike" ],
	irn_flags => [ "modify_flags", "rematerializable" ],
	out_reqs  => [ "gp", "flags" ],
	outs      => [ "res", "flags" ],
	emit      => "xor%M %D0, %D0",
	latency   => 1,
	mode      => "first",
},

XorMem => {
	template => $binop_mem,
	emit     => "xor%M %#S3, %AM",
	latency  => 1,
},

Sub => {
	irn_flags => [ "modify_flags", "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem", "gp", "gp" ],
	out_reqs  => [ "in_r4", "flags", "mem" ],
	ins       => [ "base", "index", "mem", "minuend", "subtrahend" ],
	outs      => [ "res", "flags", "M" ],
	am        => "source,binary",
	emit      => "sub%M %B",
	latency   => 1,
	mode      => "first",
},

SubMem => {
	template => $binop_mem,
	emit     => "sub%M %#S3, %AM",
	latency  => 1,
},

Sbb => {
	template => $carry_user_op,
	state    => "exc_pinned",
	in_reqs  => [ "gp", "gp", "mem", "gp", "gp", "flags" ],
	out_reqs => [ "in_r4", "flags", "mem" ],
	ins      => [ "base", "index", "mem", "minuend", "subtrahend", "eflags" ],
	outs     => [ "res", "flags", "M" ],
	am       => "source,binary",
	emit     => "sbb%M %B",
	latency  => 1,
	mode     => "first",
},

Sbb0 => {
	template => $carry_user_op,
	# Spiller currently fails when rematerializing flag consumers
	# irn_flags => [ "modify_flags", "rematerializable" ],
	in_reqs  => [ "flags" ],
	out_reqs => [ "gp", "flags" ],
	outs     => [ "res", "flags" ],
	emit     => "sbb%M %D0, %D0",
	latency  => 1,
	mode     => "first",
},

l_Sub => {
	ins       => [ "minuend", "subtrahend" ],
	outs      => [ "res", "flags" ],
	attr_type => "",
	dump_func => "NULL",
},

l_Sbb => {
	ins       => [ "minuend", "subtrahend", "eflags" ],
	attr_type => "",
	dump_func => "NULL",
},

IDiv => {
	template => $divop,
	emit     => "idiv%M %AS3",
	latency  => 25,
},

Div => {
	template => $divop,
	emit     => "div%M %AS3",
	latency  => 25,
},

Shl => {
	template => $shiftop,
	emit     => "shl%M %<,S1 %D0",
	latency  => 1,
},

ShlMem => {
	template => $shiftop_mem,
	emit     => "shl%M %<,S3 %AM",
	latency  => 1,
},

ShlD => {
	template => $shiftop_double,
	emit     => "shld%M %<S2, %S1, %D0",
	latency  => 6,
},

Shr => {
	template => $shiftop,
	emit     => "shr%M %<,S1 %D0",
	latency  => 1,
},

ShrMem => {
	template => $shiftop_mem,
	emit     => "shr%M %<,S3 %AM",
	latency  => 1,
},

ShrD => {
	template => $shiftop_double,
	emit     => "shrd%M %<S2, %S1, %D0",
	latency  => 6,
},

Sar => {
	template => $shiftop,
	emit     => "sar%M %<,S1 %D0",
	latency  => 1,
},

SarMem => {
	template => $shiftop_mem,
	emit     => "sar%M %<,S3 %AM",
	latency  => 1,
},

Ror => {
	template => $shiftop,
	emit     => "ror%M %<,S1 %D0",
	latency  => 1,
},

RorMem => {
	template => $shiftop_mem,
	emit     => "ror%M %<,S3 %AM",
	latency  => 1,
},

Rol => {
	template => $shiftop,
	emit     => "rol%M %<,S1 %#D0",
	latency  => 1,
},

RolMem => {
	template => $shiftop_mem,
	emit     => "rol%M %<,S3 %AM",
	latency  => 1,
},

Neg => {
	template => $unop,
	emit     => "neg%M %D0",
	latency  => 1,
},

NegMem => {
	template => $unop_mem,
	emit     => "neg%M %AM",
	latency  => 1,
},

Minus64 => {
	irn_flags => [ "modify_flags", "rematerializable" ],
	in_reqs   => [ "gp", "gp" ],
	out_reqs  => [ "in_r1", "in_r2" ],
	ins       => [ "low", "high" ],
	outs      => [ "res_low", "res_high" ],
	latency   => 3,
},

l_Minus64 => {
	ins       => [ "low", "high" ],
	outs      => [ "res_low", "res_high" ],
	attr_type => "",
	dump_func => "NULL",
},

Inc => {
	template => $unop,
	emit     => "inc%M %D0",
	latency  => 1,
},

IncMem => {
	template => $unop_mem,
	emit     => "inc%M %AM",
	latency  => 1,
},

Dec => {
	template => $unop,
	emit     => "dec%M %D0",
	latency  => 1,
},

DecMem => {
	template => $unop_mem,
	emit     => "dec%M %AM",
	latency  => 1,
},

Not => {
	template => $unop_no_flags,
	emit     => "not%M %D0",
	latency  => 1,
},

NotMem => {
	irn_flags => [ "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem" ],
	out_reqs  => [ "none", "none", "mem" ],
	ins       => [ "base", "index", "mem" ],
	outs      => [ "unused0", "unused1", "M" ],
	emit      => "not%M %AM",
	latency   => 1,
	# no flags modified
},

Cmc => {
	template => $carry_user_op,
	in_reqs  => [ "flags" ],
	out_reqs => [ "flags" ],
	emit     => "cmc",
	latency  => 1,
},

Stc => {
	irn_flags => [ "modify_flags" ],
	out_reqs  => [ "flags" ],
	emit      => "stc",
	latency   => 1,
},

Cmp => {
	template => $binop_flags,
	emit     => "cmp%M %B",
	latency  => 1,
},

XorHighLow => {
	irn_flags => [ "modify_flags", "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "eax ebx ecx edx" ],
	out_reqs  => [ "in_r1", "flags" ],
	emit      => "xorb %>D0, %<D0",
	ins       => [ "value" ],
	outs      => [ "res", "flags" ],
	latency   => 1,
},

Test => {
	template => $binop_flags,
	emit     => "test%M %B",
	latency  => 1,
},

Setcc => {
	#irn_flags => [ "rematerializable" ],
	in_reqs   => [ "eflags" ],
	out_reqs  => [ "eax ebx ecx edx" ],
	ins       => [ "eflags" ],
	outs      => [ "res" ],
	attr_type => "ia32_condcode_attr_t",
	attr      => "x86_condition_code_t condition_code",
	# The way we handle Setcc with float nodes (potentially) destroys the flags
	# (when we emit the setX; setp; orb and the setX;setnp;andb sequences)
	init      => "set_ia32_ls_mode(res, mode_Bu);\n".
	             "\tif (condition_code & x86_cc_additional_float_cases) {\n".
	             "\t\tarch_add_irn_flags(res, arch_irn_flag_modify_flags);\n".
	             "\t\t/* attr->latency = 3; */\n".
	             "\t}\n",
	latency   => 1,
},

SetccMem => {
	#irn_flags => [ "rematerializable" ],
	state     => "exc_pinned",
	in_reqs   => [ "gp", "gp", "mem", "eflags" ],
	out_reqs  => [ "mem" ],
	ins       => [ "base", "index", "mem","eflags" ],
	attr_type => "ia32_condcode_attr_t",
	attr      => "x86_condition_code_t condition_code",
	init      => "set_ia32_ls_mode(res, mode_Bu);\n",
	emit      => "set%P3 %AM",
	latency   => 1,
},

CMovcc => {
	#irn_flags => [ "rematerializable" ],
	state     => "exc_pinned",
	# (note: leave the false,true order intact to make it compatible with other
	#  ia32_binary ops)
	in_reqs   => [ "gp", "gp", "mem", "gp", "gp", "eflags" ],
	out_reqs  => [ "in_r4 in_r5", "none", "mem" ],
	ins       => [ "base", "index", "mem", "val_false", "val_true", "eflags" ],
	outs      => [ "res", "unused", "M" ],
	am        => "source,binary",
	attr_type => "ia32_condcode_attr_t",
	attr      => "x86_condition_code_t condition_code",
	emit      => "cmov%P5 %#AS4, %#D0",
	latency   => 1,
	mode      => "first",
},

Jcc => {
	state     => "pinned",
	op_flags  => [ "cfopcode", "forking" ],
	in_reqs   => [ "eflags" ],
	out_reqs  => [ "exec", "exec" ],
	ins       => [ "eflags" ],
	outs      => [ "false", "true" ],
	attr_type => "ia32_condcode_attr_t",
	attr      => "x86_condition_code_t condition_code",
	latency   => 2,
},

SwitchJmp => {
	state     => "pinned",
	op_flags  => [ "cfopcode", "forking" ],
	in_reqs   => [ "gp", "gp" ],
	ins       => [ "base", "index" ],
	out_reqs  => "...",
	attr_type => "ia32_switch_attr_t",
	attr      => "const ir_switch_table *switch_table",
	latency   => 2,
},

Jmp => {