def Validate(trie_diffs, bitness):
"""Validate that trie_diffs adds 16 bit shld/shrd in 32bit mode."""
# No instructions should be removed for 32/64 bit DFAs.
# No instructions should be added for 64 bit DFA because it already
# contains 16 bit shld/shrd instructions.
# in 32-bit mode, 16 bit shld/shrd should be added.
# This is of the forms:
# shld|shrd, imm|%cl, reg16, reg16|mem
if bitness == 32:
mnemonics = proof_tools.MnemonicOp('shld') | proof_tools.MnemonicOp(
'shrd')
reg16 = proof_tools.GprOperands(bitness=bitness, operand_size=16)
mem = proof_tools.AllMemoryOperands(bitness=bitness)
imm = proof_tools.ImmOp()
cl = set([proof_tools.Operands(disasms=('%cl', ))])
expected_adds = proof_tools.OpsProd(mnemonics, imm | cl, reg16,
reg16 | mem)
else:
expected_adds = set()
proof_tools.AssertDiffSetEquals(trie_diffs,
expected_adds=expected_adds,
expected_removes=set())
def Validate(trie_diffs, bitness):
"""Validates that all ymm vpminsd variants are added."""
mem = proof_tools.AllMemoryOperands(bitness=bitness)
ymm = proof_tools.AllYMMOperands(bitness)
proof_tools.AssertDiffSetEquals(trie_diffs,
expected_adds=OpsProd(
MnemonicOp('vpminsd'), mem | ymm, ymm,
ymm),
expected_removes=set())
def Validate(trie_diffs, _):
# vzeroall and vzeroupper both disassemble into only the mnemonic with
# no operands. They zero out all of the YMM registers, or just the top
# 128 bits of all YMM registers respectively.
# They should both be added, and no instruction should be removed.
proof_tools.AssertDiffSetEquals(
trie_diffs,
expected_adds=(proof_tools.MnemonicOp('vzeroall')
| proof_tools.MnemonicOp('vzeroupper')),
expected_removes=set())
def Validate(trie_diffs, bitness):
"""Validates that all allowed patterns of MNEMONICS are added."""
expected_adds = set()
for mnemonic in MNEMONICS:
expected_adds.update(
XmmYmmOrMemory3operand(mnemonic_name=mnemonic, bitness=bitness))
proof_tools.AssertDiffSetEquals(trie_diffs,
expected_adds=expected_adds,
expected_removes=set())
def Validate(trie_diffs, bitness):
"""Validate the trie_diffs adds 16 bit cmpxchg to 32bit mode."""
# No instructions should be removed for 32/64 bit DFAs.
# No instructions should be added for 64 bit DFA because it already
# contains 16 bit cmpxchg instruction.
if bitness == 32:
expected_adds = LockedRegWithRegOrMem16bit(mnemonic_name='cmpxchg',
bitness=bitness)
else:
expected_adds = set()
proof_tools.AssertDiffSetEquals(trie_diffs,
expected_adds=expected_adds,
expected_removes=set())
def Validate(trie_diffs, bitness):
"""Validates that all allowed patterns of vbroadcast* are added"""
xmm = proof_tools.AllXMMOperands(bitness)
ymm = proof_tools.AllYMMOperands(bitness)
mem = proof_tools.AllMemoryOperands(bitness)
# vbroadcastf128 and vbroadcastsd work with ymm registers.
# vbroadcastsd can work with xmm or ymm registers.
vbroadcastf128 = proof_tools.OpsProd(
proof_tools.MnemonicOp('vbroadcastf128'), mem, ymm)
vbroadcastsd = proof_tools.OpsProd(proof_tools.MnemonicOp('vbroadcastsd'),
mem, ymm)
vbroadcastss = proof_tools.OpsProd(proof_tools.MnemonicOp('vbroadcastss'),
mem, xmm | ymm)
proof_tools.AssertDiffSetEquals(
trie_diffs,
expected_adds=(vbroadcastf128 | vbroadcastsd | vbroadcastss),
expected_removes=set())
def Validate(trie_diffs, bitness):
"""Validate the trie_diffs adds 16 bit bsr/bsf is added in 32bit mode."""
# No instructions should be removed for 32/64 bit DFAs.
# No instructions should be added for 64 bit DFA because it already
# contains 16 bit bsr/bsf instructions.
# in 32-bit mode, 16 bit bsr/bsf should be added.
# This is of the forms:
# {bsr,bsf} mem16/reg16, reg16
if bitness == 32:
mnemonics = proof_tools.MnemonicOp('bsr') | proof_tools.MnemonicOp(
'bsf')
reg16 = proof_tools.GprOperands(bitness=bitness, operand_size=16)
mem = proof_tools.AllMemoryOperands(bitness=bitness)
expected_adds = proof_tools.OpsProd(mnemonics, reg16 | mem, reg16)
else:
expected_adds = set()
proof_tools.AssertDiffSetEquals(trie_diffs,
expected_adds=expected_adds,
expected_removes=set())
def Validate(trie_diffs, bitness):
"""Validate the trie_diffs adds 16 bit movbe is added in 32bit mode."""
# No instructions should be removed for 32/64 bit DFAs.
# No instructions should be added for 64 bit DFA because it already
# contains 16 bit movbe instructions.
# in 32-bit mode, 16 bit movbe should be added.
# This is of two forms:
# movbe mem, reg16
# or
# movbe reg16, mem
if bitness == 32:
mnemonic = proof_tools.MnemonicOp('movbe')
reg16 = proof_tools.GprOperands(bitness=bitness, operand_size=16)
mem = proof_tools.AllMemoryOperands(bitness=bitness)
expected_adds = (proof_tools.OpsProd(mnemonic, mem, reg16)
| proof_tools.OpsProd(mnemonic, reg16, mem))
else:
expected_adds = set()
proof_tools.AssertDiffSetEquals(trie_diffs,
expected_adds=expected_adds,
expected_removes=set())
def Validate(trie_diffs, bitness):
proof_tools.AssertDiffSetEquals(trie_diffs,
expected_adds=Instructions(bitness),
expected_removes=Instructions(bitness))
def Validate(trie_diffs, bitness):
"""Validates that all crc32w variants are added."""
proof_tools.AssertDiffSetEquals(trie_diffs,
expected_adds=Instructions(bitness),
expected_removes=set())
def Validate(trie_diffs, bitness):
"""Validates that all ymm variants of remaining avx2 promotions are added."""
proof_tools.AssertDiffSetEquals(trie_diffs,
expected_adds=Instructions(bitness),
expected_removes=set())
def Validate(trie_diffs, bitness):
"""Validates that all allowed patterns of the moves are added."""
proof_tools.AssertDiffSetEquals(
trie_diffs,
expected_adds=Avx1XmmYmmMemoryMoves(bitness),
expected_removes=set())
