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())