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  = "x86_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" }
	],
);

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, size);",
	ia32_call_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res, size);\n".
		"\tinit_ia32_call_attributes(res, pop, n_reg_results);",
	ia32_condcode_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res, size);\n".
		"\tinit_ia32_condcode_attributes(res, condition_code);",
	ia32_switch_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res, size);\n".
		"\tinit_ia32_switch_attributes(res, switch_table, table_entity);",
	ia32_copyb_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res, size);\n".
		"\tinit_ia32_copyb_attributes(res, size);",
	ia32_immediate_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res, size);\n".
		"\tinit_ia32_immediate_attributes(res, imm);",
	ia32_x87_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res, size);\n".
		"\tinit_ia32_x87_attributes(res);",
	ia32_return_attr_t =>
		"init_ia32_attributes(res, irn_flags, in_reqs, n_res, size);\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",
	constructors => {
		""     => {
			in_reqs  => [ "gp", "gp", "mem", "gp", "gp" ],
			out_reqs => [ "in_r3 in_r4", "flags", "mem" ],
		},
		"8bit" => {
			in_reqs  => [ "gp", "gp", "mem", "eax ebx ecx edx", "eax ebx ecx edx" ],
			out_reqs => [ "eax ebx ecx edx in_r3 in_r4", "flags", "mem" ],
		},
	},
	ins       => [ "base", "index", "mem", "left", "right" ],
	outs      => [ "res", "flags", "M" ],
	attr      => "x86_insn_size_t size",
	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      => "x86_insn_size_t size, 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" ],
	attr      => "x86_insn_size_t size",
};

my $shiftop = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	constructors => {
		""     => { in_reqs => [ "gp",              "ecx" ] },
		"8bit" => { in_reqs => [ "eax ebx ecx edx", "ecx" ] },
	},
	out_reqs  => [ "in_r0 !in_r1", "flags" ],
	ins       => [ "val", "count" ],
	outs      => [ "res", "flags" ],
	mode      => "first",
	attr      => "x86_insn_size_t size",
};

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" ],
	attr      => "x86_insn_size_t size",
};

my $shiftop_double = {
	irn_flags => [ "modify_flags", "rematerializable" ],
	in_reqs   => [ "gp", "gp", "ecx" ],
	constructors => {
		""  => { out_reqs  => [ "in_r0 !in_r1 !in_r2", "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_r0 in_r1",         "flags" ] },
	},
	ins       => [ "val_high", "val_low", "count" ],
	outs      => [ "res", "flags" ],
	mode      => "first",
	fixed     => "x86_insn_size_t const size = X86_SIZE_32;",
};

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",
	attr      => "x86_insn_size_t size",
};

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",
	attr      => "x86_insn_size_t size",
};

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

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

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",
	attr      => "x86_insn_size_t size",
};

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" ],
	attr      => "x86_insn_size_t size",
};

my $memop = {
	state    => "pinned",
	in_reqs  => [ "mem" ],
	out_reqs => [ "mem" ],
	ins      => [ "mem" ],
	fixed    => "x86_insn_size_t const size = X86_SIZE_32;",
};

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

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",
	attr      => "x86_insn_size_t size",
};

my $funop = {
	irn_flags => [ "rematerializable" ],
	in_reqs   => [ "fp" ],
	out_reqs  => [ "fp" ],
	ins       => [ "value" ],
	fixed     => "x86_insn_size_t const size = X86_SIZE_80;",
};

my $fconstop = {
	op_flags  => [ "constlike" ],
	irn_flags => [ "rematerializable" ],
	out_reqs  => [ "fp" ],
	outs      => [ "res" ],
	fixed     => "x86_insn_size_t const size = X86_SIZE_80;\n"
	            ."\t".$x87sim,
};

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

my $fpopop = {
	op_flags    => [ "keep" ],
	out_reqs    => [ "none" ],
	attrs_equal => "attrs_equal_false",
	attr_type   => "ia32_x87_attr_t",
	attr        => "const arch_register_t *reg",
	init        => "attr->x87.reg = reg;",
	fixed       => "x86_insn_size_t const size = X86_SIZE_80;",
};

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

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

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

my $xshiftop = {
	irn_flags => [ "rematerializable" ],
	in_reqs   => [ "xmm", "xmm" ],
	out_reqs  => [ "in_r0 !in_r1" ],
	attr      => "x86_insn_size_t size",
};

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

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

my $noregop = {
	state     => "pinned",
	op_flags  => [ "constlike", "dump_noblock" ],
	irn_flags => [ "not_scheduled" ],
	fixed     => "x86_insn_size_t const size = X86_SIZE_32;",
};

my $fpcwop = {
	op_flags => [ "uses_memory" ],
	state    => "pinned",
	fixed    => "x86_insn_size_t const size = X86_SIZE_16;",
};

my $emmsop = {
	op_flags    => [ "keep" ],
	out_reqs    => [ "none" ],
	attrs_equal => "attrs_equal_false",
	fixed       => "x86_insn_size_t const size = X86_SIZE_32;"
	              ."\t$x87sim",
};

%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,
	fixed    => "x86_insn_size_t const size = X86_SIZE_32;",
},

Add => {
	template => $binop_commutative,
	emit     => "add%M %B",
	encode   => "ia32_enc_binop(node, 0)",
	latency  => 1,
},

AddMem => {
	template => $binop_mem,
	emit     => "add%M %S3, %AM",
	encode   => "ia32_enc_binop_mem(node, 0)",
	latency  => 1,
},

Adc => {
	template => $carry_user_op,
	state    => "exc_pinned",
	in_reqs  => [ "gp", "gp", "mem", "gp", "gp", "flags" ],
	out_reqs => [ "in_r3 in_r4", "flags", "mem" ],
	ins      => [ "base", "index", "mem", "left", "right", "eflags" ],
	outs     => [ "res", "flags", "M" ],
	emit     => "adc%M %B",
	encode   => "ia32_enc_binop(node, 2)",
	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",
	encode   => "ia32_enc_unop(node, 0xF7, 4, n_ia32_Mul_right)",
	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",
	encode   => "ia32_enc_0f_unop_reg(node, 0xAF, n_ia32_IMul_right)",
	latency  => 5,
},

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

IMul1OP => {
	template => $mulop,
	emit     => "imul%M %AS4",
	encode   => "ia32_enc_unop(node, 0xF7, 5, n_ia32_IMul1OP_right)",
	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",
	encode   => "ia32_enc_binop(node, 4)",
	latency  => 1,
},

AndMem => {
	template => $binop_mem,
	emit     => "and%M %S3, %AM",
	encode   => "ia32_enc_binop_mem(node, 4)",
	latency  => 1,
},

Or => {
	template => $binop_commutative,
	emit     => "or%M %B",
	encode   => "ia32_enc_binop(node, 1)",
	latency  => 1,
},

OrMem => {
	template => $binop_mem,
	emit     => "or%M %S3, %AM",
	encode   => "ia32_enc_binop_mem(node, 1)",
	latency  => 1,
},

Xor => {
	template => $binop_commutative,
	emit     => "xor%M %B",
	encode   => "ia32_enc_binop(node, 6)",
	latency  => 1,
},

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

XorMem => {
	template => $binop_mem,
	emit     => "xor%M %S3, %AM",
	encode   => "ia32_enc_binop_mem(node, 6)",
	latency  => 1,
},

Sub => {
	irn_flags => [ "modify_flags", "rematerializable" ],
	state     => "exc_pinned",
	constructors => {
		""     => {
			in_reqs  => [ "gp", "gp", "mem", "gp", "gp" ],
			out_reqs => [ "in_r3", "flags", "mem" ],
		},
		"8bit" => {
			in_reqs  => [ "gp", "gp", "mem", "eax ebx ecx edx", "eax ebx ecx edx" ],
			out_reqs => [ "eax ebx ecx edx in_r3", "flags", "mem" ],
		},
	},
	ins       => [ "base", "index", "mem", "minuend", "subtrahend" ],
	outs      => [ "res", "flags", "M" ],
	am        => "source,binary",
	attr      => "x86_insn_size_t size",
	emit      => "sub%M %B",
	encode    => "ia32_enc_binop(node, 5)",
	latency   => 1,
	mode      => "first",
},

SubMem => {
	template => $binop_mem,
	emit     => "sub%M %S3, %AM",
	encode   => "ia32_enc_binop_mem(node, 5)",
	latency  => 1,
},

Sbb => {
	template => $carry_user_op,
	state    => "exc_pinned",
	in_reqs  => [ "gp", "gp", "mem", "gp", "gp", "flags" ],
	out_reqs => [ "in_r3", "flags", "mem" ],
	ins      => [ "base", "index", "mem", "minuend", "subtrahend", "eflags" ],
	outs     => [ "res", "flags", "M" ],
	am       => "source,binary",
	emit     => "sbb%M %B",
	encode   => "ia32_enc_binop(node, 3)",
	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",
	encode   => "ia32_enc_unop(node, 0xF7, 7, n_ia32_IDiv_divisor)",
	latency  => 25,
},

Div => {
	template => $divop,
	emit     => "div%M %AS3",
	encode   => "ia32_enc_unop(node, 0xF7, 6, n_ia32_Div_divisor)",
	latency  => 25,
},

Shl => {
	template => $shiftop,
	emit     => "shl%M %<,S1 %D0",
	encode   => "ia32_enc_shiftop(node, 4)",
	latency  => 1,
},

ShlMem => {
	template => $shiftop_mem,
	emit     => "shl%M %<,S3 %AM",
	encode   => "ia32_enc_shiftop_mem(node, 4)",
	latency  => 1,
},

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

Shr => {
	template => $shiftop,
	emit     => "shr%M %<,S1 %D0",
	encode   => "ia32_enc_shiftop(node, 5)",
	latency  => 1,
},

ShrMem => {
	template => $shiftop_mem,
	emit     => "shr%M %<,S3 %AM",
	encode   => "ia32_enc_shiftop_mem(node, 5)",
	latency  => 1,
},

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

Sar => {
	template => $shiftop,
	emit     => "sar%M %<,S1 %D0",
	encode   => "ia32_enc_shiftop(node, 7)",
	latency  => 1,
},

SarMem => {
	template => $shiftop_mem,
	emit     => "sar%M %<,S3 %AM",
	encode   => "ia32_enc_shiftop_mem(node, 7)",
	latency  => 1,
},

Ror => {
	template => $shiftop,
	emit     => "ror%M %<,S1 %D0",
	encode   => "ia32_enc_shiftop(node, 1)",
	latency  => 1,
},

RorMem => {
	template => $shiftop_mem,
	emit     => "ror%M %<,S3 %AM",
	encode   => "ia32_enc_shiftop_mem(node, 1)",
	latency  => 1,
},

Rol => {
	template => $shiftop,
	emit     => "rol%M %<,S1 %D0",
	encode   => "ia32_enc_shiftop(node, 0)",
	latency  => 1,
},

RolMem => {
	template => $shiftop_mem,
	emit     => "rol%M %<,S3 %AM",
	encode   => "ia32_enc_shiftop_mem(node, 0)",
	latency  => 1,
},

Neg => {
	template => $unop,
	emit     => "neg%M %D0",
	encode   => "ia32_enc_unop(node, 0xF7, 3, n_ia32_Neg_val)",
	latency  => 1,
},

NegMem => {
	template => $unop_mem,
	emit     => "neg%M %AM",
	encode   => "ia32_enc_unop_mem(node, 0xF6, 3)",
	latency  => 1,
},

Minus64 => {
	irn_flags => [ "modify_flags", "rematerializable" ],
	in_reqs   => [ "gp", "gp" ],
	out_reqs  => [ "in_r0", "in_r1" ],
	ins       => [ "low", "high" ],