dymokomi/luce-base
Source of release 0.45.0
0.45.0 / src / back / assemble / x86_64 / vector.lucb
#==============================================================================================
#
# vector - SSE and AVX instructions
#
# DESCRIPTION:
# A legacy vector instruction is its mandatory prefix, the opcode map and opcode,
# and ModRM with the destination in the reg field; its `v` twin is the same opcode
# under VEX, with a second source in `vvvv` when it takes three operands. Moves keep
# a store opcode for memory destinations, and under VEX a register move whose source
# alone is past `xmm7` uses it too, so the shorter VEX fits, as GNU `as` does.
# `movd` and `movq` move between general and vector registers, and `cvtsi2sd` and its
# kin convert between them.
#
#==============================================================================================
# mark: The table =============================================================================
extend Encoder:
func vector_forms() -> !:
var room: u8[32]
for row in [("add", 0x58u8), ("mul", 0x59u8), ("sub", 0x5Cu8), ("min", 0x5Du8), ("div", 0x5Eu8), ("max", 0x5Fu8),
("sqrt", 0x51u8)]:
let (name, opcode) = row
for kind in [("ps", 0u8), ("pd", 0x66u8), ("ss", 0xF3u8), ("sd", 0xF2u8)]:
let (suffix, prefix) = kind
let packed_root = name == "sqrt" and (prefix == 0 or prefix == 0x66)
try self.both(try strings.format(room, f"{name}{suffix}"),
form(Family.vector, prefix = prefix, map = 1, opcode = opcode, flags = 0 if packed_root else two_sources))
for row in [("and", 0x54u8), ("andn", 0x55u8), ("or", 0x56u8), ("xor", 0x57u8), ("unpckl", 0x14u8), ("unpckh", 0x15u8),
("shuf", 0xC6u8), ("cmp", 0xC2u8)]:
let (name, opcode) = row
let imm = takes_immediate if opcode == 0xC6 or opcode == 0xC2 else 0
try self.both(try strings.format(room, f"{name}ps"), form(Family.vector, map = 1, opcode = opcode, flags = two_sources | imm))
try self.both(try strings.format(room, f"{name}pd"), form(Family.vector, prefix = 0x66, map = 1, opcode = opcode, flags = two_sources | imm))
for row in vector_table:
let (name, prefix, map, opcode, flags) = row
try self.both(name, form(Family.vector, prefix = prefix, map = map, opcode = opcode, flags = flags))
for row in packed_integer:
let (name, map, opcode) = row
try self.both(name, form(Family.vector, prefix = 0x66, map = map, opcode = opcode, flags = two_sources))
for row in [("movups", 0u8, 0x10u8, 0x11u8), ("movupd", 0x66u8, 0x10u8, 0x11u8), ("movaps", 0u8, 0x28u8, 0x29u8),
("movapd", 0x66u8, 0x28u8, 0x29u8), ("movdqu", 0xF3u8, 0x6Fu8, 0x7Fu8), ("movdqa", 0x66u8, 0x6Fu8, 0x7Fu8),
("movss", 0xF3u8, 0x10u8, 0x11u8), ("movsd", 0xF2u8, 0x10u8, 0x11u8)]:
let (name, prefix, load, store) = row
try self.both(name, form(Family.vector_move, prefix = prefix, map = 1, opcode = load, store = store))
for row in [("psrlw", 0xD1u8, 0x71u8, 2u8), ("psraw", 0xE1u8, 0x71u8, 4u8), ("psllw", 0xF1u8, 0x71u8, 6u8),
("psrld", 0xD2u8, 0x72u8, 2u8), ("psrad", 0xE2u8, 0x72u8, 4u8), ("pslld", 0xF2u8, 0x72u8, 6u8),
("psrlq", 0xD3u8, 0x73u8, 2u8), ("psllq", 0xF3u8, 0x73u8, 6u8), ("psrldq", 0u8, 0x73u8, 3u8),
("pslldq", 0u8, 0x73u8, 7u8)]:
let (name, by_register, by_immediate, k) = row
try self.both(name, form(Family.vector_shift, prefix = 0x66, map = 1, opcode = by_register, store = by_immediate, code = k))
try self.both("movd", form(Family.movd, size = 4))
try self.both("movq", form(Family.movq, size = 8))
for row in [("cvtsi2ss", 0xF3u8), ("cvtsi2sd", 0xF2u8)]:
let (name, prefix) = row
try self.both_wide(name, form(Family.from_integer, prefix = prefix, map = 1, opcode = 0x2A, flags = two_sources))
for row in [("cvtss2si", 0xF3u8, 0x2Du8), ("cvttss2si", 0xF3u8, 0x2Cu8), ("cvtsd2si", 0xF2u8, 0x2Du8),
("cvttsd2si", 0xF2u8, 0x2Cu8)]:
let (name, prefix, opcode) = row
try self.both_wide(name, form(Family.to_integer, prefix = prefix, map = 1, opcode = opcode))
for row in [("pmovmskb", 0x66u8, 0xD7u8), ("movmskps", 0u8, 0x50u8), ("movmskpd", 0x66u8, 0x50u8)]:
let (name, prefix, opcode) = row
try self.both(name, form(Family.mask, prefix = prefix, map = 1, opcode = opcode))
for row in [("vfmadd", 0x98u8), ("vfmsub", 0x9Au8), ("vfnmadd", 0x9Cu8), ("vfnmsub", 0x9Eu8)]:
let (name, base) = row
for operands in [("132", 0u8), ("213", 0x10u8), ("231", 0x20u8)]:
let (order, offset) = operands
for kind in [("ps", 0u8, 0u8), ("pd", 0u8, wide_form), ("ss", 1u8, 0u8), ("sd", 1u8, wide_form)]:
let (suffix, scalar, wide) = kind
try self.add(try strings.format(room, f"{name}{order}{suffix}"),
form(Family.fused, prefix = 0x66, map = 2, opcode = base + offset + scalar, flags = vex_encoded | two_sources | wide))
try self.add("vcvtph2ps", form(Family.vector, prefix = 0x66, map = 2, opcode = 0x13, flags = vex_encoded))
try self.add("vcvtps2ph", form(Family.half_store, prefix = 0x66, map = 3, opcode = 0x1D, flags = vex_encoded | takes_immediate))
## `name` for `f`, and `v` and `name` for its VEX twin.
func both(name: str, f: Form) -> !:
try self.add(name, f)
var room: u8[32]
var twin = f
twin.flags |= vex_encoded
try self.add(try strings.format(room, f"v{name}"), twin)
## `both` for `name` and its `l` and `q` spellings, which name the integer's size.
func both_wide(name: str, f: Form) -> !:
try self.both(name, f)
var room: u8[32]
for row in [("l", 4u8), ("q", 8u8)]:
let (letter, size) = row
var sized = f
sized.size = size
try self.both(try strings.format(room, f"{name}{letter}"), sized)
## Vector operations past the arithmetic: name, mandatory prefix, map, opcode, flags.
let vector_table: (str, u8, u8, u8, u8)[34] = [
("cvtss2sd", 0xF3, 1, 0x5A, two_sources), ("cvtsd2ss", 0xF2, 1, 0x5A, two_sources), ("cvtps2pd", 0, 1, 0x5A, 0), ("cvtpd2ps", 0x66, 1, 0x5A, 0),
("cvtdq2ps", 0, 1, 0x5B, 0), ("cvtps2dq", 0x66, 1, 0x5B, 0), ("cvttps2dq", 0xF3, 1, 0x5B, 0), ("cvtdq2pd", 0xF3, 1, 0xE6, 0),
("cvtpd2dq", 0xF2, 1, 0xE6, 0), ("cvttpd2dq", 0x66, 1, 0xE6, 0), ("ucomiss", 0, 1, 0x2E, 0), ("ucomisd", 0x66, 1, 0x2E, 0),
("comiss", 0, 1, 0x2F, 0), ("comisd", 0x66, 1, 0x2F, 0), ("pshufd", 0x66, 1, 0x70, takes_immediate), ("pshuflw", 0xF2, 1, 0x70, takes_immediate),
("pshufhw", 0xF3, 1, 0x70, takes_immediate), ("movhlps", 0, 1, 0x12, two_sources), ("movlhps", 0, 1, 0x16, two_sources),
("rcpps", 0, 1, 0x53, 0), ("rsqrtps", 0, 1, 0x52, 0), ("pabsb", 0x66, 2, 0x1C, 0), ("pabsw", 0x66, 2, 0x1D, 0), ("pabsd", 0x66, 2, 0x1E, 0),
("ptest", 0x66, 2, 0x17, 0), ("roundps", 0x66, 3, 0x08, takes_immediate), ("roundpd", 0x66, 3, 0x09, takes_immediate),
("roundss", 0x66, 3, 0x0A, takes_immediate | two_sources), ("roundsd", 0x66, 3, 0x0B, takes_immediate | two_sources),
("blendps", 0x66, 3, 0x0C, takes_immediate | two_sources), ("blendpd", 0x66, 3, 0x0D, takes_immediate | two_sources),
("pblendw", 0x66, 3, 0x0E, takes_immediate | two_sources), ("palignr", 0x66, 3, 0x0F, takes_immediate | two_sources),
("insertps", 0x66, 3, 0x21, takes_immediate | two_sources)]
## The packed integer operations of the `66 0F` (map 1) and `66 0F 38` (map 2) maps that
## take two sources: name, map, opcode.
let packed_integer: (str, u8, u8)[56] = [
("punpcklbw", 1, 0x60), ("punpcklwd", 1, 0x61), ("punpckldq", 1, 0x62), ("packsswb", 1, 0x63), ("pcmpgtb", 1, 0x64),
("pcmpgtw", 1, 0x65), ("pcmpgtd", 1, 0x66), ("packuswb", 1, 0x67), ("punpckhbw", 1, 0x68), ("punpckhwd", 1, 0x69),
("punpckhdq", 1, 0x6A), ("packssdw", 1, 0x6B), ("punpcklqdq", 1, 0x6C), ("punpckhqdq", 1, 0x6D), ("pcmpeqb", 1, 0x74),
("pcmpeqw", 1, 0x75), ("pcmpeqd", 1, 0x76), ("paddq", 1, 0xD4), ("pmullw", 1, 0xD5), ("psubusb", 1, 0xD8),
("psubusw", 1, 0xD9), ("pminub", 1, 0xDA), ("pand", 1, 0xDB), ("paddusb", 1, 0xDC), ("paddusw", 1, 0xDD),
("pmaxub", 1, 0xDE), ("pandn", 1, 0xDF), ("pavgb", 1, 0xE0), ("pavgw", 1, 0xE3), ("pmulhuw", 1, 0xE4),
("pmulhw", 1, 0xE5), ("psubsb", 1, 0xE8), ("psubsw", 1, 0xE9), ("pminsw", 1, 0xEA), ("por", 1, 0xEB),
("paddsb", 1, 0xEC), ("paddsw", 1, 0xED), ("pmaxsw", 1, 0xEE), ("pxor", 1, 0xEF), ("pmuludq", 1, 0xF4),
("pmaddwd", 1, 0xF5), ("psadbw", 1, 0xF6), ("psubb", 1, 0xF8), ("psubw", 1, 0xF9), ("psubd", 1, 0xFA),
("psubq", 1, 0xFB), ("paddb", 1, 0xFC), ("paddw", 1, 0xFD), ("paddd", 1, 0xFE), ("pshufb", 2, 0x00),
("pmulld", 2, 0x40), ("pminsd", 2, 0x39), ("pminud", 2, 0x3B), ("pmaxsd", 2, 0x3D), ("pmaxud", 2, 0x3F),
("pcmpeqq", 2, 0x29)]
# mark: Encoding ==============================================================================
## Parts for a vector operation whose ModRM reg is `reg` and rm `rm`, under `x`'s form:
## its prefix, map and opcode, VEX when the form is a `v` one with `second` in `vvvv`.
func vector_parts(x: Instruction*, opcode: u8, reg: u8, rm: Operand, second: u8, long: bool) -> Encoding:
let f = x.form
var e = Encoding.with_modrm(f.map, opcode, reg, rm)
e.operand16 = f.prefix == 0x66
e.repeat = f.prefix if f.prefix == 0xF2 or f.prefix == 0xF3 else 0
e.vex = (f.flags & vex_encoded) != 0
e.vvvv = second
e.long = long
if (f.flags & wide_form) != 0:
e.wide = true
return e
## The operands of a vector operation, after any immediate: the source in rm, the second
## source under VEX, the destination; checked to be vector registers or memory.
func vector_operands(u: state.Unit*, x: Instruction*) -> (Operand, u8, Operand)!:
let f = x.form
let imm: usize = 1 if (f.flags & takes_immediate) != 0 else 0
let vex = (f.flags & vex_encoded) != 0
let three = vex and (f.flags & two_sources) != 0
try expect(u, x, imm + (3 if three else 2))
if imm == 1 and x.at(0).kind != Kind.immediate:
try mismatch(u, x)
let origin = x.at(imm)
let target = x.at(x.count - 1)
var second: u8 = 0
if three:
if not x.at(imm + 1).vector():
try mismatch(u, x)
second = x.at(imm + 1).register.number
if not origin.vector_or_memory() or not target.vector():
try mismatch(u, x)
return (origin, second, target)
## A vector operation: its source into its destination, under VEX with a second source.
func vector(u: state.Unit*, x: Instruction*) -> !:
let (origin, second, target) = try vector_operands(u, x)
var e = vector_parts(x, x.form.opcode, target.register.number, origin, second, target.register.bank == Bank.ymm)
if (x.form.flags & takes_immediate) != 0:
e.with_immediate(1, x.at(0).value)
try finish(u, x, &e)
## A vector move: the load opcode into a register, the store opcode into memory; under
## VEX, a register move from past `xmm7` into a low register through the store opcode.
func vector_move(u: state.Unit*, x: Instruction*) -> !:
let vex = (x.form.flags & vex_encoded) != 0
if x.count == 3 and vex and x.at(0).vector() and x.at(1).vector() and x.at(2).vector():
# `vmovss` and `vmovsd` of registers merge a second source
let origin = x.at(0)
let target = x.at(2)
var e = vector_parts(x, x.form.opcode, target.register.number, origin, x.at(1).register.number, false)
if origin.register.number >= 8 and target.register.number < 8:
e = vector_parts(x, x.form.store, origin.register.number, target, x.at(1).register.number, false)
try finish(u, x, &e)
return
try expect(u, x, 2)
let origin = x.at(0)
let target = x.at(1)
let long = (origin.kind == Kind.register and origin.register.bank == Bank.ymm) or (target.kind == Kind.register and target.register.bank == Bank.ymm)
var e: Encoding = ---
if target.vector() and origin.vector_or_memory():
e = vector_parts(x, x.form.opcode, target.register.number, origin, 0, long)
if vex and origin.vector() and origin.register.number >= 8 and target.register.number < 8:
e = vector_parts(x, x.form.store, origin.register.number, target, 0, long)
elif origin.vector() and target.memory():
e = vector_parts(x, x.form.store, origin.register.number, target, 0, long)
else:
try mismatch(u, x)
try finish(u, x, &e)
## A packed shift: by a vector register or memory, or by an immediate.
func vector_shift(u: state.Unit*, x: Instruction*) -> !:
let vex = (x.form.flags & vex_encoded) != 0
try expect(u, x, 3 if vex else 2)
let target = x.at(x.count - 1)
if not target.vector():
try mismatch(u, x)
var e: Encoding = ---
if x.at(0).kind == Kind.immediate:
let origin = x.at(1) if vex else target
if not origin.vector():
try mismatch(u, x)
e = vector_parts(x, x.form.store, x.form.code, origin, target.register.number if vex else 0, false)
e.with_immediate(1, x.at(0).value)
else:
if x.form.opcode == 0 or not x.at(0).vector_or_memory():
try mismatch(u, x)
e = vector_parts(x, x.form.opcode, target.register.number, x.at(0), x.at(1).register.number if vex else 0, false)
try finish(u, x, &e)
# mark: Between register files ================================================================
## `movd`: four bytes between a general register or memory and a vector register.
func move_double(u: state.Unit*, x: Instruction*) -> !:
try expect(u, x, 2)
let origin = x.at(0)
let target = x.at(1)
var e: Encoding = ---
if target.xmm() and origin.general_or_memory() and (not origin.general() or origin.size() == 4):
e = between(x, 0x6E, target.register.number, origin)
elif origin.xmm() and target.general_or_memory() and (not target.general() or target.size() == 4):
e = between(x, 0x7E, origin.register.number, target)
else:
try mismatch(u, x)
try finish(u, x, &e)
## `movq` with a vector register: eight bytes between general registers, memory and
## vector registers, each direction its own opcode.
func move_quad(u: state.Unit*, x: Instruction*) -> !:
try expect(u, x, 2)
let origin = x.at(0)
let target = x.at(1)
var e: Encoding = ---
if target.xmm() and origin.general() and origin.size() == 8:
e = between(x, 0x6E, target.register.number, origin)
e.wide = true
elif origin.xmm() and target.general() and target.size() == 8:
e = between(x, 0x7E, origin.register.number, target)
e.wide = true
elif target.xmm() and (origin.memory() or origin.xmm()):
e = between(x, 0x7E, target.register.number, origin)
e.operand16 = false
e.repeat = 0xF3
elif origin.xmm() and target.memory():
e = between(x, 0xD6, origin.register.number, target)
else:
try mismatch(u, x)
try finish(u, x, &e)
## Parts of a `66 0F` move between register files.
func between(x: Instruction*, opcode: u8, reg: u8, rm: Operand) -> Encoding:
var e = Encoding.with_modrm(1, opcode, reg, rm)
e.operand16 = true
e.vex = (x.form.flags & vex_encoded) != 0
return e
## `cvtsi2sd` and kin: an integer register or memory into a float.
func from_integer(u: state.Unit*, x: Instruction*) -> !:
let vex = (x.form.flags & vex_encoded) != 0
try expect(u, x, 3 if vex else 2)
let origin = x.at(0)
let target = x.at(x.count - 1)
if not origin.general_or_memory() or not target.xmm() or (origin.general() and origin.size() < 4):
try mismatch(u, x)
let size = x.form.size if x.form.size != 0 else (origin.size() if origin.general() else 4)
var e = vector_parts(x, x.form.opcode, target.register.number, origin, x.at(1).register.number if vex else 0, false)
e.wide = size == 8
try finish(u, x, &e)
## `cvttsd2si` and kin: a float into an integer register.
func to_integer(u: state.Unit*, x: Instruction*) -> !:
try expect(u, x, 2)
let origin = x.at(0)
let target = x.at(1)
if not origin.vector_or_memory() or not target.general() or target.size() < 4:
try mismatch(u, x)
var e = vector_parts(x, x.form.opcode, target.register.number, origin, 0, false)
e.wide = target.size() == 8
try finish(u, x, &e)
## `pmovmskb` and kin: a vector register's sign bits into an integer register.
func mask(u: state.Unit*, x: Instruction*) -> !:
try expect(u, x, 2)
if not x.at(0).vector() or not x.at(1).general() or x.at(1).size() < 4:
try mismatch(u, x)
var e = vector_parts(x, x.form.opcode, x.at(1).register.number, x.at(0), 0, x.at(0).register.bank == Bank.ymm)
e.wide = x.at(1).size() == 8
try finish(u, x, &e)
## `vfmadd231sd` and kin: always VEX, three operands.
func fused(u: state.Unit*, x: Instruction*) -> !:
try vector(u, x)
## `vcvtps2ph`: the source register in the reg field, the destination in rm.
func half_store(u: state.Unit*, x: Instruction*) -> !:
try expect(u, x, 3)
if x.at(0).kind != Kind.immediate or not x.at(1).vector() or not x.at(2).vector_or_memory():
try mismatch(u, x)
var e = vector_parts(x, x.form.opcode, x.at(1).register.number, x.at(2), 0, x.at(1).register.bank == Bank.ymm)
e.with_immediate(1, x.at(0).value)
try finish(u, x, &e)